ff5a7e6377
https://fedoraproject.org/wiki/Changes/RemovePythonMockUsage Prefer using unittest.mock to a standalone package. The separate packages should only really be needed on Python 2.7 these days. The test requirements file is updated to only require mock on old Python, and the dependency is removed from setup.py to avoid issues there. Relates: https://src.fedoraproject.org/rpms/pungi/pull-request/9 Signed-off-by: Lubomír Sedlář <lsedlar@redhat.com>
868 lines
31 KiB
Python
868 lines
31 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
try:
|
|
from unittest import mock
|
|
except ImportError:
|
|
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)
|
|
),
|
|
]
|
|
)
|