pungi/tests/test_ostree_installer_phase.py

865 lines
31 KiB
Python
Raw Permalink Normal View History

# -*- coding: utf-8 -*-
import mock
import os
from kobo.shortcuts import force_list
from tests import helpers
from pungi.phases import ostree_installer as ostree
from six.moves import shlex_quote
LOG_PATH = "logs/x86_64/Everything/ostree_installer-1"
class OstreeInstallerPhaseTest(helpers.PungiTestCase):
@mock.patch("pungi.phases.ostree_installer.ThreadPool")
def test_run(self, ThreadPool):
cfg = helpers.IterableMock()
compose = helpers.DummyCompose(
self.topdir,
{
"ostree_installer": [("^Everything$", {"x86_64": cfg})],
"runroot": True,
"translate_paths": [(self.topdir + "/work", "http://example.com/work")],
},
)
pool = ThreadPool.return_value
phase = ostree.OstreeInstallerPhase(
compose, mock.Mock(), self._make_pkgset_phase(["p1", "p2"])
)
phase.run()
self.assertEqual(len(pool.add.call_args_list), 1)
self.assertEqual(
pool.add.call_args_list[0][0][0].baseurls,
[
"http://example.com/work/$basearch/repo/p1",
"http://example.com/work/$basearch/repo/p2",
],
)
self.assertEqual(
pool.queue_put.call_args_list,
[mock.call((compose, compose.variants["Everything"], "x86_64", cfg))],
)
@mock.patch("pungi.phases.ostree_installer.ThreadPool")
def test_skip_without_config(self, ThreadPool):
compose = helpers.DummyCompose(self.topdir, {})
compose.just_phases = None
compose.skip_phases = []
phase = ostree.OstreeInstallerPhase(compose, mock.Mock())
self.assertTrue(phase.skip())
def test_validate_conflict_with_buildinstall(self):
compose = helpers.DummyCompose(
self.topdir, {"ostree_installer": [("^Server$", {"x86_64": mock.Mock()})]}
)
skipmock = mock.Mock()
skipmock.skip.return_value = False
phase = ostree.OstreeInstallerPhase(compose, skipmock)
with self.assertRaises(ValueError) as ctx:
phase.validate()
self.assertEqual(
str(ctx.exception),
"Can not generate ostree installer for Server.x86_64:"
" it has buildinstall running already and the files"
" would clash.",
)
def test_validate_buildinstall_skipped(self):
compose = helpers.DummyCompose(
self.topdir, {"ostree_installer": [("^Server$", {"x86_64": mock.Mock()})]}
)
phase = ostree.OstreeInstallerPhase(compose, mock.Mock(_skipped=True))
phase.validate()
def test_validate_overwrite_enabled(self):
compose = helpers.DummyCompose(
self.topdir,
{
"ostree_installer_overwrite": True,
"ostree_installer": [("^Server$", {"x86_64": mock.Mock()})],
},
)
phase = ostree.OstreeInstallerPhase(compose, mock.Mock(_skipped=False))
phase.validate()
class OstreeThreadTest(helpers.PungiTestCase):
def setUp(self):
super(OstreeThreadTest, self).setUp()
self.compose = helpers.DummyCompose(
self.topdir,
{
"release_name": "Fedora",
"release_version": "Rawhide",
"koji_profile": "koji",
"koji_cache": "/tmp",
"runroot_tag": "rrt",
"image_volid_formats": ["{release_short}-{variant}-{arch}"],
"translate_paths": [(self.topdir + "/work", "http://example.com/work")],
},
)
def assertImageAdded(self, compose, ImageCls, iso):
image = ImageCls.return_value
self.assertEqual(image.path, "Everything/x86_64/iso/image-name")
self.assertEqual(image.mtime, 13579)
self.assertEqual(image.size, 1024)
self.assertEqual(image.arch, "x86_64")
self.assertEqual(image.type, "dvd-ostree")
self.assertEqual(image.format, "iso")
self.assertEqual(image.disc_number, 1)
self.assertEqual(image.disc_count, 1)
self.assertEqual(image.bootable, True)
self.assertEqual(image.implant_md5, iso.get_implanted_md5.return_value)
self.assertEqual(
compose.im.add.mock_calls, [mock.call("Everything", "x86_64", image)]
)
def assertRunrootCall(
self,
koji,
sources,
release,
isfinal=False,
extra=[],
extra_pkgs=[],
weight=None,
):
lorax_cmd = [
"lorax",
"--product=Fedora",
"--version=Rawhide",
"--release=%s" % release,
]
for s in force_list(sources):
lorax_cmd.append(shlex_quote("--source=%s" % s))
lorax_cmd.append("--variant=Everything")
lorax_cmd.append("--nomacboot")
if isfinal:
lorax_cmd.append("--isfinal")
lorax_cmd.append("--buildarch=x86_64")
lorax_cmd.append("--volid=test-Everything-x86_64")
if extra:
lorax_cmd.extend(extra)
outdir = self.topdir + "/work/x86_64/Everything/ostree_installer"
lorax_cmd.append(outdir)
self.assertEqual(
koji.get_runroot_cmd.call_args_list,
[
mock.call(
"rrt",
"x86_64",
"rm -rf %s && %s" % (outdir, " ".join(lorax_cmd)),
channel=None,
mounts=[self.topdir],
packages=["pungi", "lorax", "ostree"] + extra_pkgs,
use_shell=True,
weight=weight,
chown_paths=[outdir],
)
],
)
self.assertEqual(
koji.run_runroot_cmd.call_args_list,
[
mock.call(
koji.get_runroot_cmd.return_value,
log_file=os.path.join(self.topdir, LOG_PATH, "runroot.log"),
)
],
)
def assertIsoLinked(self, link, get_file_size, get_mtime, final_iso_path):
self.assertEqual(
link.call_args_list,
[
mock.call(
self.topdir
+ "/work/x86_64/Everything/ostree_installer/images/boot.iso",
final_iso_path,
)
],
)
self.assertEqual(get_file_size.call_args_list, [mock.call(final_iso_path)])
self.assertEqual(get_mtime.call_args_list, [mock.call(final_iso_path)])
def assertAllCopied(self, copy_all):
self.assertEqual(
self.compose.get_image_name.call_args_list,
[
mock.call(
"x86_64", self.compose.variants["Everything"], disc_type="ostree"
)
],
)
self.assertTrue(os.path.isdir(self.topdir + "/work/x86_64/Everything/"))
self.assertFalse(
os.path.isdir(self.topdir + "/work/x86_64/Everything/ostree_installer")
)
self.assertEqual(
copy_all.call_args_list,
[
mock.call(
"{0}/work/x86_64/Everything/ostree_installer".format(self.topdir),
"{0}/compose/Everything/x86_64/os".format(self.topdir),
)
],
)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_run(
self, KojiWrapper, link, iso, get_file_size, get_mtime, ImageCls, copy_all
):
self.compose.supported = False
pool = mock.Mock()
cfg = {
"repo": "Everything", # this variant-type repo is deprecated, in result will be replaced with default repo # noqa: E501
"release": "20160321.n.0",
}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"task_id": 1234,
"retcode": 0,
"output": "Foo bar\n",
}
get_file_size.return_value = 1024
get_mtime.return_value = 13579
final_iso_path = self.topdir + "/compose/Everything/x86_64/iso/image-name"
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
self.assertRunrootCall(
koji,
[
"http://example.com/repo/1",
"http://example.com/work/$basearch/comps_repo_Everything",
],
cfg["release"],
extra=["--logfile=%s/%s/lorax.log" % (self.topdir, LOG_PATH)],
)
self.assertIsoLinked(link, get_file_size, get_mtime, final_iso_path)
self.assertImageAdded(self.compose, ImageCls, iso)
self.assertAllCopied(copy_all)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
@mock.patch("pungi.phases.ostree_installer.move_all")
def test_run_koji_plugin(
self,
move_all,
KojiWrapper,
link,
iso,
get_file_size,
get_mtime,
ImageCls,
copy_all,
):
self.compose.supported = False
self.compose.conf["ostree_installer_use_koji_plugin"] = True
pool = mock.Mock()
cfg = {
"repo": "Everything", # this variant-type repo is deprecated, in result will be replaced with default repo # noqa: E501
"release": "20160321.n.0",
}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"task_id": 1234,
"retcode": 0,
"output": "Foo bar\n",
}
get_file_size.return_value = 1024
get_mtime.return_value = 13579
final_iso_path = self.topdir + "/compose/Everything/x86_64/iso/image-name"
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
args = {
"product": "Fedora",
"version": "Rawhide",
"release": "20160321.n.0",
"sources": [
"http://example.com/repo/1",
"http://example.com/work/$basearch/comps_repo_Everything",
],
"variant": "Everything",
"nomacboot": True,
"volid": "test-Everything-x86_64",
"buildarch": "x86_64",
"installpkgs": None,
"add-template": [],
"add-arch-template": [],
"add-template-var": None,
"add-arch-template-var": None,
"rootfs-size": None,
"isfinal": False,
"outputdir": self.topdir + "/work/x86_64/Everything/ostree_installer",
}
self.assertEqual(
koji.get_pungi_buildinstall_cmd.mock_calls,
[
mock.call(
"rrt",
"x86_64",
args,
channel=None,
packages=["pungi", "lorax", "ostree"],
mounts=[self.topdir],
weight=None,
chown_uid=os.getuid(),
)
],
)
self.assertEqual(
koji.run_runroot_cmd.mock_calls,
[
mock.call(
koji.get_pungi_buildinstall_cmd.return_value,
log_file=os.path.join(self.topdir, LOG_PATH, "runroot.log"),
)
],
)
self.assertEqual(
move_all.mock_calls,
[
mock.call(
self.topdir + "/work/x86_64/Everything/ostree_installer/results",
self.topdir + "/work/x86_64/Everything/ostree_installer",
rm_src_dir=True,
),
mock.call(
self.topdir + "/work/x86_64/Everything/ostree_installer/logs",
os.path.join(self.topdir, LOG_PATH),
rm_src_dir=True,
),
],
)
self.assertIsoLinked(link, get_file_size, get_mtime, final_iso_path)
self.assertImageAdded(self.compose, ImageCls, iso)
self.assertAllCopied(copy_all)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_run_external_source(
self, KojiWrapper, link, iso, get_file_size, get_mtime, ImageCls, copy_all
):
pool = mock.Mock()
cfg = {
"repo": "http://example.com/repo/$arch/",
"release": "20160321.n.0",
}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"task_id": 1234,
"retcode": 0,
"output": "Foo bar\n",
}
get_file_size.return_value = 1024
get_mtime.return_value = 13579
final_iso_path = self.topdir + "/compose/Everything/x86_64/iso/image-name"
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
self.assertRunrootCall(
koji,
(
"http://example.com/repo/x86_64/",
"http://example.com/repo/1",
"http://example.com/work/$basearch/comps_repo_Everything",
),
cfg["release"],
isfinal=True,
extra=["--logfile=%s/%s/lorax.log" % (self.topdir, LOG_PATH)],
)
self.assertIsoLinked(link, get_file_size, get_mtime, final_iso_path)
self.assertImageAdded(self.compose, ImageCls, iso)
self.assertAllCopied(copy_all)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_run_with_repo_key(
self, KojiWrapper, link, iso, get_file_size, get_mtime, ImageCls, copy_all
):
pool = mock.Mock()
cfg = {
"release": "20160321.n.0",
"repo": [
"Everything", # this variant-type repo is deprecated, in result will be replaced with default repo # noqa: E501
"https://example.com/extra-repo1.repo",
"https://example.com/extra-repo2.repo",
],
}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"task_id": 1234,
"retcode": 0,
"output": "Foo bar\n",
}
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
sources = [
"https://example.com/extra-repo1.repo",
"https://example.com/extra-repo2.repo",
"http://example.com/repo/1",
"http://example.com/work/$basearch/comps_repo_Everything",
]
self.assertRunrootCall(
koji,
sources,
cfg["release"],
isfinal=True,
extra=["--logfile=%s/%s/lorax.log" % (self.topdir, LOG_PATH)],
)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_run_with_multiple_variant_repos(
self, KojiWrapper, link, iso, get_file_size, get_mtime, ImageCls, copy_all
):
pool = mock.Mock()
cfg = {
"release": "20160321.n.0",
"repo": [
"Everything", # this variant-type repo is deprecated, in result will be replaced with default repo # noqa: E501
"Server", # this variant-type repo is deprecated, in result will be replaced with default repo # noqa: E501
"https://example.com/extra-repo1.repo",
"https://example.com/extra-repo2.repo",
],
}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"task_id": 1234,
"retcode": 0,
"output": "Foo bar\n",
}
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
sources = [
"https://example.com/extra-repo1.repo",
"https://example.com/extra-repo2.repo",
"http://example.com/repo/1",
"http://example.com/work/$basearch/comps_repo_Everything",
]
self.assertRunrootCall(
koji,
sources,
cfg["release"],
isfinal=True,
extra=["--logfile=%s/%s/lorax.log" % (self.topdir, LOG_PATH)],
)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_run_without_comps(
self, KojiWrapper, link, iso, get_file_size, get_mtime, ImageCls, copy_all
):
self.compose.has_comps = False
pool = mock.Mock()
cfg = {
"release": "20160321.n.0",
"repo": [],
}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"task_id": 1234,
"retcode": 0,
"output": "Foo bar\n",
}
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
sources = ["http://example.com/repo/1"]
self.assertRunrootCall(
koji,
sources,
cfg["release"],
isfinal=True,
extra=["--logfile=%s/%s/lorax.log" % (self.topdir, LOG_PATH)],
)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.wrappers.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_fail_with_relative_template_path_but_no_repo(
self, KojiWrapper, link, iso, get_file_size, get_mtime, ImageCls, copy_all
):
pool = mock.Mock()
cfg = {
"repo": "Everything",
"release": "20160321.n.0",
"add_template": ["some-file.txt"],
}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"task_id": 1234,
"retcode": 0,
"output": "Foo bar\n",
}
get_file_size.return_value = 1024
get_mtime.return_value = 13579
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
with self.assertRaises(RuntimeError) as ctx:
t.process(
(self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1
)
self.assertIn("template_repo", str(ctx.exception))
@mock.patch("pungi.wrappers.scm.get_dir_from_scm")
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_run_clone_templates(
self,
KojiWrapper,
link,
iso,
get_file_size,
get_mtime,
ImageCls,
copy_all,
get_dir_from_scm,
):
pool = mock.Mock()
cfg = {
"repo": "Everything", # this variant-type repo is deprecated, in result will be replaced with default repo # noqa: E501
"release": "20160321.n.0",
"add_template": ["some_file.txt"],
"add_arch_template": ["other_file.txt"],
"template_repo": "git://example.com/templates.git",
"template_branch": "f24",
"extra_runroot_pkgs": ["templatedep"],
}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"task_id": 1234,
"retcode": 0,
"output": "Foo bar\n",
}
get_file_size.return_value = 1024
get_mtime.return_value = 13579
final_iso_path = self.topdir + "/compose/Everything/x86_64/iso/image-name"
templ_dir = self.topdir + "/work/x86_64/Everything/lorax_templates"
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
self.assertEqual(
get_dir_from_scm.call_args_list,
[
mock.call(
{
"scm": "git",
"repo": "git://example.com/templates.git",
"branch": "f24",
"dir": ".",
},
templ_dir,
compose=self.compose,
)
],
)
self.assertRunrootCall(
koji,
[
"http://example.com/repo/1",
"http://example.com/work/$basearch/comps_repo_Everything",
],
cfg["release"],
isfinal=True,
extra=[
"--add-template=%s/some_file.txt" % templ_dir,
"--add-arch-template=%s/other_file.txt" % templ_dir,
"--logfile=%s/%s/lorax.log" % (self.topdir, LOG_PATH),
],
extra_pkgs=["templatedep"],
)
self.assertIsoLinked(link, get_file_size, get_mtime, final_iso_path)
self.assertImageAdded(self.compose, ImageCls, iso)
self.assertAllCopied(copy_all)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_run_with_explicitly_generated_release(
self, KojiWrapper, link, iso, get_file_size, get_mtime, ImageCls, copy_all
):
pool = mock.Mock()
cfg = {
"repo": "Everything", # this variant-type repo is deprecated, in result will be replaced with default repo # noqa: E501
"release": "!RELEASE_FROM_LABEL_DATE_TYPE_RESPIN",
"installpkgs": ["fedora-productimg-atomic"],
"add_template": [
"/spin-kickstarts/atomic-installer/lorax-configure-repo.tmpl"
],
"add_template_var": [
"ostree_osname=fedora-atomic",
"ostree_ref=fedora-atomic/Rawhide/x86_64/docker-host",
],
"add_arch_template": [
"/spin-kickstarts/atomic-installer/lorax-embed-repo.tmpl"
],
"add_arch_template_var": [
"ostree_repo=https://kojipkgs.fedoraproject.org/compose/atomic/Rawhide/", # noqa: E501
"ostree_osname=fedora-atomic",
"ostree_ref=fedora-atomic/Rawhide/x86_64/docker-host",
],
}
self.compose.conf["runroot_weights"] = {"ostree_installer": 123}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"task_id": 1234,
"retcode": 0,
"output": "Foo bar\n",
}
get_file_size.return_value = 1024
get_mtime.return_value = 13579
final_iso_path = self.topdir + "/compose/Everything/x86_64/iso/image-name"
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
self.assertRunrootCall(
koji,
[
"http://example.com/repo/1",
"http://example.com/work/$basearch/comps_repo_Everything",
],
"20151203.t.0",
isfinal=True,
extra=[
"--installpkgs=fedora-productimg-atomic",
"--add-template=/spin-kickstarts/atomic-installer/lorax-configure-repo.tmpl", # noqa: E501
"--add-arch-template=/spin-kickstarts/atomic-installer/lorax-embed-repo.tmpl", # noqa: E501
"--add-template-var=ostree_osname=fedora-atomic",
"--add-template-var=ostree_ref=fedora-atomic/Rawhide/x86_64/docker-host", # noqa: E501
"--add-arch-template-var=ostree_repo=https://kojipkgs.fedoraproject.org/compose/atomic/Rawhide/", # noqa: E501
"--add-arch-template-var=ostree_osname=fedora-atomic",
"--add-arch-template-var=ostree_ref=fedora-atomic/Rawhide/x86_64/docker-host", # noqa: E501
"--logfile=%s/%s/lorax.log" % (self.topdir, LOG_PATH),
],
weight=123,
)
self.assertIsoLinked(link, get_file_size, get_mtime, final_iso_path)
self.assertImageAdded(self.compose, ImageCls, iso)
self.assertAllCopied(copy_all)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_run_with_implicit_release(
self, KojiWrapper, link, iso, get_file_size, get_mtime, ImageCls, copy_all
):
pool = mock.Mock()
cfg = {
"repo": "Everything", # this variant-type repo is deprecated, in result will be replaced with default repo. # noqa: E501
"release": None,
"installpkgs": ["fedora-productimg-atomic"],
"add_template": [
"/spin-kickstarts/atomic-installer/lorax-configure-repo.tmpl"
],
"add_template_var": [
"ostree_osname=fedora-atomic",
"ostree_ref=fedora-atomic/Rawhide/x86_64/docker-host",
],
"add_arch_template": [
"/spin-kickstarts/atomic-installer/lorax-embed-repo.tmpl"
],
"add_arch_template_var": [
"ostree_repo=https://kojipkgs.fedoraproject.org/compose/atomic/Rawhide/", # noqa: E501
"ostree_osname=fedora-atomic",
"ostree_ref=fedora-atomic/Rawhide/x86_64/docker-host",
],
}
self.compose.conf["runroot_weights"] = {"ostree_installer": 123}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"task_id": 1234,
"retcode": 0,
"output": "Foo bar\n",
}
get_file_size.return_value = 1024
get_mtime.return_value = 13579
final_iso_path = self.topdir + "/compose/Everything/x86_64/iso/image-name"
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
self.assertRunrootCall(
koji,
[
"http://example.com/repo/1",
"http://example.com/work/$basearch/comps_repo_Everything",
],
"20151203.t.0",
isfinal=True,
extra=[
"--installpkgs=fedora-productimg-atomic",
"--add-template=/spin-kickstarts/atomic-installer/lorax-configure-repo.tmpl", # noqa: E501
"--add-arch-template=/spin-kickstarts/atomic-installer/lorax-embed-repo.tmpl", # noqa: E501
"--add-template-var=ostree_osname=fedora-atomic",
"--add-template-var=ostree_ref=fedora-atomic/Rawhide/x86_64/docker-host", # noqa: E501
"--add-arch-template-var=ostree_repo=https://kojipkgs.fedoraproject.org/compose/atomic/Rawhide/", # noqa: E501
"--add-arch-template-var=ostree_osname=fedora-atomic",
"--add-arch-template-var=ostree_ref=fedora-atomic/Rawhide/x86_64/docker-host", # noqa: E501
"--logfile=%s/%s/lorax.log" % (self.topdir, LOG_PATH),
],
weight=123,
)
self.assertIsoLinked(link, get_file_size, get_mtime, final_iso_path)
self.assertImageAdded(self.compose, ImageCls, iso)
self.assertAllCopied(copy_all)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_fail_crash(
self, KojiWrapper, link, iso, get_file_size, get_mtime, ImageCls, copy_all
):
pool = mock.Mock()
cfg = {"repo": "Everything", "release": None, "failable": ["x86_64"]}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.side_effect = helpers.boom
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
pool._logger.error.assert_has_calls(
[
mock.call(
"[FAIL] Ostree installer (variant Everything, arch x86_64) failed, but going on anyway." # noqa: E501
),
mock.call("BOOM"),
]
)
@mock.patch("pungi.util.copy_all")
@mock.patch("productmd.images.Image")
@mock.patch("pungi.util.get_mtime")
@mock.patch("pungi.util.get_file_size")
@mock.patch("pungi.phases.ostree_installer.iso")
@mock.patch("os.link")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
def test_fail_runroot_fail(
self, KojiWrapper, link, iso, get_file_size, get_mtime, ImageCls, copy_all
):
pool = mock.Mock()
cfg = {
"repo": "Everything",
"release": None,
"failable": ["*"],
}
koji = KojiWrapper.return_value
koji.run_runroot_cmd.return_value = {
"output": "Failed",
"task_id": 1234,
"retcode": 1,
}
t = ostree.OstreeInstallerThread(pool, ["http://example.com/repo/1"])
t.process((self.compose, self.compose.variants["Everything"], "x86_64", cfg), 1)
pool._logger.error.assert_has_calls(
[
mock.call(
"[FAIL] Ostree installer (variant Everything, arch x86_64) failed, but going on anyway." # noqa: E501
),
mock.call(
"Runroot task failed: 1234. See %s/%s/runroot.log for more details."
% (self.topdir, LOG_PATH)
),
]
)