2026 lines
71 KiB
Python
2026 lines
71 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
|
|
import mock
|
|
import six
|
|
from copy import copy
|
|
|
|
import os
|
|
|
|
from pungi.phases.buildinstall import (
|
|
BuildinstallPhase,
|
|
BuildinstallThread,
|
|
link_boot_iso,
|
|
BOOT_CONFIGS,
|
|
tweak_configs,
|
|
)
|
|
from tests.helpers import DummyCompose, PungiTestCase, touch, MockPackageSet, MockPkg
|
|
|
|
|
|
class BuildInstallCompose(DummyCompose):
|
|
def __init__(self, *args, **kwargs):
|
|
super(BuildInstallCompose, self).__init__(*args, **kwargs)
|
|
self.variants = {
|
|
"Server": mock.Mock(
|
|
uid="Server",
|
|
arches=["x86_64", "amd64"],
|
|
type="variant",
|
|
buildinstallpackages=["bash", "vim"],
|
|
is_empty=False,
|
|
),
|
|
"Client": mock.Mock(
|
|
uid="Client",
|
|
arches=["amd64"],
|
|
type="variant",
|
|
buildinstallpackages=[],
|
|
is_empty=False,
|
|
),
|
|
}
|
|
self.all_variants = self.variants.copy()
|
|
self.has_comps = True
|
|
self.just_phases = []
|
|
self.skip_phases = []
|
|
|
|
|
|
class TestBuildinstallPhase(PungiTestCase):
|
|
def test_config_skip_unless_bootable(self):
|
|
compose = BuildInstallCompose(self.topdir, {})
|
|
compose.just_phases = None
|
|
compose.skip_phases = []
|
|
|
|
phase = BuildinstallPhase(compose)
|
|
|
|
self.assertTrue(phase.skip())
|
|
|
|
@mock.patch("pungi.phases.buildinstall.ThreadPool")
|
|
@mock.patch("pungi.phases.buildinstall.LoraxWrapper")
|
|
@mock.patch("pungi.phases.buildinstall.get_volid")
|
|
def test_skip_option(self, get_volid, loraxCls, poolCls):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"bootable": True,
|
|
"buildinstall_method": "lorax",
|
|
"buildinstall_skip": [
|
|
("^Server$", {"amd64": True}),
|
|
("^Client$", {"*": True}),
|
|
],
|
|
},
|
|
)
|
|
|
|
get_volid.return_value = "vol_id"
|
|
loraxCls.return_value.get_lorax_cmd.return_value = ["lorax", "..."]
|
|
|
|
phase = BuildinstallPhase(compose, self._make_pkgset_phase(["p1"]))
|
|
|
|
phase.run()
|
|
|
|
pool = poolCls.return_value
|
|
self.assertEqual(1, len(pool.queue_put.mock_calls))
|
|
|
|
def test_does_not_skip_on_bootable(self):
|
|
compose = BuildInstallCompose(self.topdir, {"buildinstall_method": "lorax"})
|
|
compose.just_phases = None
|
|
compose.skip_phases = []
|
|
|
|
phase = BuildinstallPhase(compose)
|
|
|
|
self.assertFalse(phase.skip())
|
|
|
|
@mock.patch("pungi.phases.buildinstall.ThreadPool")
|
|
@mock.patch("pungi.phases.buildinstall.LoraxWrapper")
|
|
@mock.patch("pungi.phases.buildinstall.get_volid")
|
|
def test_starts_threads_for_each_cmd_with_lorax(self, get_volid, loraxCls, poolCls):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"bootable": True,
|
|
"release_name": "Test",
|
|
"release_short": "t",
|
|
"release_version": "1",
|
|
"buildinstall_method": "lorax",
|
|
"disc_types": {"dvd": "DVD"},
|
|
},
|
|
)
|
|
|
|
get_volid.return_value = "vol_id"
|
|
loraxCls.return_value.get_lorax_cmd.return_value = ["lorax", "..."]
|
|
|
|
phase = BuildinstallPhase(compose, self._make_pkgset_phase(["p1", "p2"]))
|
|
|
|
phase.run()
|
|
|
|
# Three items added for processing in total.
|
|
# Server.x86_64, Client.amd64, Server.x86_64
|
|
pool = poolCls.return_value
|
|
self.assertEqual(3, len(pool.queue_put.mock_calls))
|
|
six.assertCountEqual(
|
|
self,
|
|
[call[0][0][3] for call in pool.queue_put.call_args_list],
|
|
[
|
|
"rm -rf %s/work/amd64/buildinstall/Client && lorax ..." % self.topdir,
|
|
"rm -rf %s/work/amd64/buildinstall/Server && lorax ..." % self.topdir,
|
|
"rm -rf %s/work/x86_64/buildinstall/Server && lorax ..." % self.topdir,
|
|
],
|
|
)
|
|
|
|
# Obtained correct lorax commands.
|
|
six.assertCountEqual(
|
|
self,
|
|
loraxCls.return_value.get_lorax_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/x86_64/repo/p1",
|
|
self.topdir + "/work/x86_64/repo/p2",
|
|
self.topdir + "/work/x86_64/comps_repo_Server",
|
|
],
|
|
self.topdir + "/work/x86_64/buildinstall/Server",
|
|
buildarch="x86_64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Server",
|
|
buildinstallpackages=["bash", "vim"],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/x86_64/buildinstall-Server-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
self.topdir + "/work/amd64/repo/p2",
|
|
self.topdir + "/work/amd64/comps_repo_Server",
|
|
],
|
|
self.topdir + "/work/amd64/buildinstall/Server",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Server",
|
|
buildinstallpackages=["bash", "vim"],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/amd64/buildinstall-Server-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
self.topdir + "/work/amd64/repo/p2",
|
|
self.topdir + "/work/amd64/comps_repo_Client",
|
|
],
|
|
self.topdir + "/work/amd64/buildinstall/Client",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Client",
|
|
buildinstallpackages=[],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/amd64/buildinstall-Client-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
],
|
|
)
|
|
six.assertCountEqual(
|
|
self,
|
|
get_volid.mock_calls,
|
|
[
|
|
mock.call(
|
|
compose,
|
|
"x86_64",
|
|
variant=compose.variants["Server"],
|
|
disc_type="DVD",
|
|
),
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Client"],
|
|
disc_type="DVD",
|
|
),
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Server"],
|
|
disc_type="DVD",
|
|
),
|
|
],
|
|
)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.ThreadPool")
|
|
@mock.patch("pungi.phases.buildinstall.get_volid")
|
|
def test_starts_threads_for_each_cmd_with_lorax_koji_plugin(
|
|
self, get_volid, poolCls
|
|
):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"bootable": True,
|
|
"release_name": "Test",
|
|
"release_short": "t",
|
|
"release_version": "1",
|
|
"buildinstall_method": "lorax",
|
|
"lorax_use_koji_plugin": True,
|
|
"disc_types": {"dvd": "DVD"},
|
|
},
|
|
)
|
|
|
|
get_volid.return_value = "vol_id"
|
|
|
|
phase = BuildinstallPhase(compose, self._make_pkgset_phase(["p1", "p2"]))
|
|
|
|
phase.run()
|
|
self.maxDiff = None
|
|
|
|
expected_args = [
|
|
{
|
|
"product": "Test",
|
|
"version": "1",
|
|
"release": "1",
|
|
"sources": [
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
self.topdir + "/work/amd64/repo/p2",
|
|
self.topdir + "/work/amd64/comps_repo_Server",
|
|
],
|
|
"variant": "Server",
|
|
"installpkgs": ["bash", "vim"],
|
|
"isfinal": True,
|
|
"buildarch": "amd64",
|
|
"volid": "vol_id",
|
|
"nomacboot": True,
|
|
"bugurl": None,
|
|
"add-template": [],
|
|
"add-arch-template": [],
|
|
"add-template-var": [],
|
|
"add-arch-template-var": [],
|
|
"noupgrade": True,
|
|
"rootfs-size": None,
|
|
"dracut-args": [],
|
|
"skip_branding": False,
|
|
"outputdir": self.topdir + "/work/amd64/buildinstall/Server",
|
|
},
|
|
{
|
|
"product": "Test",
|
|
"version": "1",
|
|
"release": "1",
|
|
"sources": [
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
self.topdir + "/work/amd64/repo/p2",
|
|
self.topdir + "/work/amd64/comps_repo_Client",
|
|
],
|
|
"variant": "Client",
|
|
"installpkgs": [],
|
|
"isfinal": True,
|
|
"buildarch": "amd64",
|
|
"volid": "vol_id",
|
|
"nomacboot": True,
|
|
"bugurl": None,
|
|
"add-template": [],
|
|
"add-arch-template": [],
|
|
"add-template-var": [],
|
|
"add-arch-template-var": [],
|
|
"noupgrade": True,
|
|
"rootfs-size": None,
|
|
"dracut-args": [],
|
|
"skip_branding": False,
|
|
"outputdir": self.topdir + "/work/amd64/buildinstall/Client",
|
|
},
|
|
{
|
|
"product": "Test",
|
|
"version": "1",
|
|
"release": "1",
|
|
"sources": [
|
|
self.topdir + "/work/x86_64/repo/p1",
|
|
self.topdir + "/work/x86_64/repo/p2",
|
|
self.topdir + "/work/x86_64/comps_repo_Server",
|
|
],
|
|
"variant": "Server",
|
|
"installpkgs": ["bash", "vim"],
|
|
"isfinal": True,
|
|
"buildarch": "x86_64",
|
|
"volid": "vol_id",
|
|
"nomacboot": True,
|
|
"bugurl": None,
|
|
"add-template": [],
|
|
"add-arch-template": [],
|
|
"add-template-var": [],
|
|
"add-arch-template-var": [],
|
|
"noupgrade": True,
|
|
"rootfs-size": None,
|
|
"dracut-args": [],
|
|
"skip_branding": False,
|
|
"outputdir": self.topdir + "/work/x86_64/buildinstall/Server",
|
|
},
|
|
]
|
|
|
|
# Three items added for processing in total.
|
|
# Server.x86_64, Client.amd64, Server.x86_64
|
|
pool = poolCls.return_value
|
|
self.assertEqual(3, len(pool.queue_put.mock_calls))
|
|
six.assertCountEqual(
|
|
self,
|
|
[call[0][0][3] for call in pool.queue_put.call_args_list],
|
|
expected_args,
|
|
)
|
|
|
|
six.assertCountEqual(
|
|
self,
|
|
get_volid.mock_calls,
|
|
[
|
|
mock.call(
|
|
compose,
|
|
"x86_64",
|
|
variant=compose.variants["Server"],
|
|
disc_type="DVD",
|
|
),
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Client"],
|
|
disc_type="DVD",
|
|
),
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Server"],
|
|
disc_type="DVD",
|
|
),
|
|
],
|
|
)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.ThreadPool")
|
|
@mock.patch("pungi.phases.buildinstall.LoraxWrapper")
|
|
@mock.patch("pungi.phases.buildinstall.get_volid")
|
|
def test_lorax_skips_empty_variants(self, get_volid, loraxCls, poolCls):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"bootable": True,
|
|
"release_name": "Test",
|
|
"release_short": "t",
|
|
"release_version": "1",
|
|
"buildinstall_method": "lorax",
|
|
},
|
|
)
|
|
|
|
get_volid.return_value = "vol_id"
|
|
compose.variants["Server"].is_empty = True
|
|
loraxCls.return_value.get_lorax_cmd.return_value = ["lorax", "..."]
|
|
|
|
phase = BuildinstallPhase(compose, self._make_pkgset_phase(["p1"]))
|
|
|
|
phase.run()
|
|
|
|
pool = poolCls.return_value
|
|
self.assertEqual(1, len(pool.queue_put.mock_calls))
|
|
self.assertEqual(
|
|
[call[0][0][3] for call in pool.queue_put.call_args_list],
|
|
["rm -rf %s/work/amd64/buildinstall/Client && lorax ..." % self.topdir],
|
|
)
|
|
|
|
# Obtained correct lorax command.
|
|
lorax = loraxCls.return_value
|
|
lorax.get_lorax_cmd.assert_has_calls(
|
|
[
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
self.topdir + "/work/amd64/comps_repo_Client",
|
|
],
|
|
self.topdir + "/work/amd64/buildinstall/Client",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Client",
|
|
buildinstallpackages=[],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/amd64/buildinstall-Client-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
)
|
|
],
|
|
any_order=True,
|
|
)
|
|
self.assertEqual(
|
|
get_volid.mock_calls,
|
|
[
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Client"],
|
|
disc_type="dvd",
|
|
)
|
|
],
|
|
)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.ThreadPool")
|
|
@mock.patch("pungi.phases.buildinstall.LoraxWrapper")
|
|
@mock.patch("pungi.phases.buildinstall.get_volid")
|
|
def test_starts_threads_for_each_cmd_with_buildinstall(
|
|
self, get_volid, loraxCls, poolCls
|
|
):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"bootable": True,
|
|
"release_name": "Test",
|
|
"release_short": "t",
|
|
"release_version": "1",
|
|
"buildinstall_method": "buildinstall",
|
|
"disc_types": {"dvd": "DVD"},
|
|
},
|
|
)
|
|
|
|
get_volid.return_value = "vol_id"
|
|
|
|
phase = BuildinstallPhase(compose, self._make_pkgset_phase(["p1"]))
|
|
|
|
phase.run()
|
|
|
|
# Two items added for processing in total.
|
|
pool = poolCls.return_value
|
|
self.assertEqual(2, len(pool.queue_put.mock_calls))
|
|
|
|
# Obtained correct lorax commands.
|
|
six.assertCountEqual(
|
|
self,
|
|
loraxCls.return_value.get_buildinstall_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[self.topdir + "/work/x86_64/repo/p1"],
|
|
self.topdir + "/work/x86_64/buildinstall",
|
|
buildarch="x86_64",
|
|
is_final=True,
|
|
volid="vol_id",
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[self.topdir + "/work/amd64/repo/p1"],
|
|
self.topdir + "/work/amd64/buildinstall",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
volid="vol_id",
|
|
),
|
|
],
|
|
)
|
|
six.assertCountEqual(
|
|
self,
|
|
get_volid.mock_calls,
|
|
[
|
|
mock.call(compose, "x86_64", disc_type="DVD"),
|
|
mock.call(compose, "amd64", disc_type="DVD"),
|
|
],
|
|
)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.ThreadPool")
|
|
@mock.patch("pungi.phases.buildinstall.LoraxWrapper")
|
|
@mock.patch("pungi.phases.buildinstall.get_volid")
|
|
def test_uses_lorax_options(self, get_volid, loraxCls, poolCls):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"bootable": True,
|
|
"release_name": "Test",
|
|
"release_short": "t",
|
|
"release_version": "1",
|
|
"buildinstall_method": "lorax",
|
|
"lorax_options": [
|
|
("^.*$", {"*": {}}),
|
|
(
|
|
"^Server$",
|
|
{
|
|
"x86_64": {
|
|
"bugurl": "http://example.com",
|
|
"add_template": ["foo", "FOO"],
|
|
"add_arch_template": ["bar"],
|
|
"add_template_var": ["baz=1"],
|
|
"add_arch_template_var": ["quux=2"],
|
|
"rootfs_size": 3,
|
|
"version": "1.2.3",
|
|
"dracut_args": ["--xz", "--install", "/.buildstamp"],
|
|
},
|
|
"amd64": {"noupgrade": False},
|
|
},
|
|
),
|
|
("^Client$", {"*": {"nomacboot": False}}),
|
|
("^.*$", {"*": {}}),
|
|
],
|
|
},
|
|
)
|
|
|
|
get_volid.return_value = "vol_id"
|
|
loraxCls.return_value.get_lorax_cmd.return_value = ["lorax", "..."]
|
|
|
|
phase = BuildinstallPhase(compose, self._make_pkgset_phase(["p1"]))
|
|
|
|
phase.run()
|
|
|
|
# Three items added for processing in total.
|
|
# Server.x86_64, Client.amd64, Server.x86_64
|
|
pool = poolCls.return_value
|
|
self.assertEqual(3, len(pool.queue_put.mock_calls))
|
|
six.assertCountEqual(
|
|
self,
|
|
[call[0][0][3] for call in pool.queue_put.call_args_list],
|
|
[
|
|
"rm -rf %s/work/amd64/buildinstall/Client && lorax ..." % self.topdir,
|
|
"rm -rf %s/work/amd64/buildinstall/Server && lorax ..." % self.topdir,
|
|
"rm -rf %s/work/x86_64/buildinstall/Server && lorax ..." % self.topdir,
|
|
],
|
|
)
|
|
|
|
# Obtained correct lorax commands.
|
|
six.assertCountEqual(
|
|
self,
|
|
loraxCls.return_value.get_lorax_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
"Test",
|
|
"1.2.3",
|
|
"1.2.3",
|
|
[
|
|
self.topdir + "/work/x86_64/repo/p1",
|
|
self.topdir + "/work/x86_64/comps_repo_Server",
|
|
],
|
|
self.topdir + "/work/x86_64/buildinstall/Server",
|
|
buildarch="x86_64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Server",
|
|
buildinstallpackages=["bash", "vim"],
|
|
add_template=["foo", "FOO"],
|
|
add_arch_template=["bar"],
|
|
add_template_var=["baz=1"],
|
|
add_arch_template_var=["quux=2"],
|
|
bugurl="http://example.com",
|
|
rootfs_size=3,
|
|
log_dir=self.topdir + "/logs/x86_64/buildinstall-Server-logs",
|
|
dracut_args=["--xz", "--install", "/.buildstamp"],
|
|
skip_branding=False,
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
self.topdir + "/work/amd64/comps_repo_Server",
|
|
],
|
|
self.topdir + "/work/amd64/buildinstall/Server",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=False,
|
|
volid="vol_id",
|
|
variant="Server",
|
|
buildinstallpackages=["bash", "vim"],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/amd64/buildinstall-Server-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
self.topdir + "/work/amd64/comps_repo_Client",
|
|
],
|
|
self.topdir + "/work/amd64/buildinstall/Client",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=False,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Client",
|
|
buildinstallpackages=[],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/amd64/buildinstall-Client-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
],
|
|
)
|
|
six.assertCountEqual(
|
|
self,
|
|
get_volid.mock_calls,
|
|
[
|
|
mock.call(
|
|
compose,
|
|
"x86_64",
|
|
variant=compose.variants["Server"],
|
|
disc_type="dvd",
|
|
),
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Client"],
|
|
disc_type="dvd",
|
|
),
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Server"],
|
|
disc_type="dvd",
|
|
),
|
|
],
|
|
)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.ThreadPool")
|
|
@mock.patch("pungi.phases.buildinstall.LoraxWrapper")
|
|
@mock.patch("pungi.phases.buildinstall.get_volid")
|
|
def test_multiple_lorax_options(self, get_volid, loraxCls, poolCls):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"bootable": True,
|
|
"release_name": "Test",
|
|
"release_short": "t",
|
|
"release_version": "1",
|
|
"buildinstall_method": "lorax",
|
|
"lorax_options": [
|
|
(
|
|
"^.*$",
|
|
{"x86_64": {"nomacboot": False}, "*": {"noupgrade": False}},
|
|
),
|
|
],
|
|
},
|
|
)
|
|
|
|
get_volid.return_value = "vol_id"
|
|
loraxCls.return_value.get_lorax_cmd.return_value = ["lorax", "..."]
|
|
|
|
phase = BuildinstallPhase(compose, self._make_pkgset_phase(["p1"]))
|
|
|
|
phase.run()
|
|
|
|
# Three items added for processing in total.
|
|
# Server.x86_64, Client.amd64, Server.x86_64
|
|
pool = poolCls.return_value
|
|
self.assertEqual(3, len(pool.queue_put.mock_calls))
|
|
six.assertCountEqual(
|
|
self,
|
|
[call[0][0][3] for call in pool.queue_put.call_args_list],
|
|
[
|
|
"rm -rf %s/work/amd64/buildinstall/Client && lorax ..." % self.topdir,
|
|
"rm -rf %s/work/amd64/buildinstall/Server && lorax ..." % self.topdir,
|
|
"rm -rf %s/work/x86_64/buildinstall/Server && lorax ..." % self.topdir,
|
|
],
|
|
)
|
|
|
|
# Obtained correct lorax commands.
|
|
six.assertCountEqual(
|
|
self,
|
|
loraxCls.return_value.get_lorax_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/x86_64/repo/p1",
|
|
self.topdir + "/work/x86_64/comps_repo_Server",
|
|
],
|
|
self.topdir + "/work/x86_64/buildinstall/Server",
|
|
buildarch="x86_64",
|
|
is_final=True,
|
|
nomacboot=False,
|
|
noupgrade=False,
|
|
volid="vol_id",
|
|
variant="Server",
|
|
buildinstallpackages=["bash", "vim"],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/x86_64/buildinstall-Server-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
self.topdir + "/work/amd64/comps_repo_Server",
|
|
],
|
|
self.topdir + "/work/amd64/buildinstall/Server",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=False,
|
|
volid="vol_id",
|
|
variant="Server",
|
|
buildinstallpackages=["bash", "vim"],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/amd64/buildinstall-Server-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
self.topdir + "/work/amd64/comps_repo_Client",
|
|
],
|
|
self.topdir + "/work/amd64/buildinstall/Client",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=False,
|
|
volid="vol_id",
|
|
variant="Client",
|
|
buildinstallpackages=[],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/amd64/buildinstall-Client-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
],
|
|
)
|
|
six.assertCountEqual(
|
|
self,
|
|
get_volid.mock_calls,
|
|
[
|
|
mock.call(
|
|
compose,
|
|
"x86_64",
|
|
variant=compose.variants["Server"],
|
|
disc_type="dvd",
|
|
),
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Client"],
|
|
disc_type="dvd",
|
|
),
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Server"],
|
|
disc_type="dvd",
|
|
),
|
|
],
|
|
)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.ThreadPool")
|
|
@mock.patch("pungi.phases.buildinstall.LoraxWrapper")
|
|
@mock.patch("pungi.phases.buildinstall.get_volid")
|
|
def test_uses_lorax_options_buildinstall_topdir(self, get_volid, loraxCls, poolCls):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"bootable": True,
|
|
"release_name": "Test",
|
|
"release_short": "t",
|
|
"release_version": "1",
|
|
"buildinstall_method": "lorax",
|
|
"buildinstall_topdir": "/buildinstall_topdir",
|
|
"translate_paths": [(self.topdir, "http://localhost/")],
|
|
},
|
|
)
|
|
|
|
buildinstall_topdir = os.path.join(
|
|
"/buildinstall_topdir", "buildinstall-" + os.path.basename(self.topdir)
|
|
)
|
|
self.maxDiff = None
|
|
|
|
get_volid.return_value = "vol_id"
|
|
loraxCls.return_value.get_lorax_cmd.return_value = ["lorax", "..."]
|
|
|
|
phase = BuildinstallPhase(compose, self._make_pkgset_phase(["p1"]))
|
|
|
|
phase.run()
|
|
|
|
# Three items added for processing in total.
|
|
# Server.x86_64, Client.amd64, Server.x86_64
|
|
pool = poolCls.return_value
|
|
self.assertEqual(3, len(pool.queue_put.mock_calls))
|
|
six.assertCountEqual(
|
|
self,
|
|
[call[0][0][3] for call in pool.queue_put.call_args_list],
|
|
[
|
|
"rm -rf %s/amd64/Client && lorax ..." % buildinstall_topdir,
|
|
"rm -rf %s/amd64/Server && lorax ..." % buildinstall_topdir,
|
|
"rm -rf %s/x86_64/Server && lorax ..." % buildinstall_topdir,
|
|
],
|
|
)
|
|
|
|
# Obtained correct lorax commands.
|
|
six.assertCountEqual(
|
|
self,
|
|
loraxCls.return_value.get_lorax_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
"http://localhost/work/x86_64/repo/p1",
|
|
"http://localhost/work/x86_64/comps_repo_Server",
|
|
],
|
|
buildinstall_topdir + "/x86_64/Server/results",
|
|
buildarch="x86_64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Server",
|
|
buildinstallpackages=["bash", "vim"],
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
bugurl=None,
|
|
rootfs_size=None,
|
|
log_dir=buildinstall_topdir + "/x86_64/Server/logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
"http://localhost/work/amd64/repo/p1",
|
|
"http://localhost/work/amd64/comps_repo_Server",
|
|
],
|
|
buildinstall_topdir + "/amd64/Server/results",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Server",
|
|
buildinstallpackages=["bash", "vim"],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=buildinstall_topdir + "/amd64/Server/logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
"http://localhost/work/amd64/repo/p1",
|
|
"http://localhost/work/amd64/comps_repo_Client",
|
|
],
|
|
buildinstall_topdir + "/amd64/Client/results",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Client",
|
|
buildinstallpackages=[],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=buildinstall_topdir + "/amd64/Client/logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
],
|
|
)
|
|
six.assertCountEqual(
|
|
self,
|
|
get_volid.mock_calls,
|
|
[
|
|
mock.call(
|
|
compose,
|
|
"x86_64",
|
|
variant=compose.variants["Server"],
|
|
disc_type="dvd",
|
|
),
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Client"],
|
|
disc_type="dvd",
|
|
),
|
|
mock.call(
|
|
compose,
|
|
"amd64",
|
|
variant=compose.variants["Server"],
|
|
disc_type="dvd",
|
|
),
|
|
],
|
|
)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.ThreadPool")
|
|
@mock.patch("pungi.phases.buildinstall.LoraxWrapper")
|
|
@mock.patch("pungi.phases.buildinstall.get_volid")
|
|
def test_uses_lorax_extra_repos(self, get_volid, loraxCls, poolCls):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"bootable": True,
|
|
"release_name": "Test",
|
|
"release_short": "t",
|
|
"release_version": "1",
|
|
"buildinstall_method": "lorax",
|
|
"lorax_extra_sources": [
|
|
("^Server$", {"x86_64": "http://example.com/repo1"}),
|
|
(
|
|
"^Client$",
|
|
{
|
|
"*": [
|
|
"http://example.com/repo2",
|
|
"http://example.com/repo3",
|
|
],
|
|
},
|
|
),
|
|
],
|
|
},
|
|
)
|
|
|
|
get_volid.return_value = "vol_id"
|
|
loraxCls.return_value.get_lorax_cmd.return_value = ["lorax", "..."]
|
|
|
|
phase = BuildinstallPhase(compose, self._make_pkgset_phase(["p1"]))
|
|
|
|
phase.run()
|
|
|
|
self.maxDiff = None
|
|
six.assertCountEqual(
|
|
self,
|
|
loraxCls.return_value.get_lorax_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/x86_64/repo/p1",
|
|
"http://example.com/repo1",
|
|
self.topdir + "/work/x86_64/comps_repo_Server",
|
|
],
|
|
self.topdir + "/work/x86_64/buildinstall/Server",
|
|
buildarch="x86_64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Server",
|
|
buildinstallpackages=["bash", "vim"],
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
bugurl=None,
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/x86_64/buildinstall-Server-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
self.topdir + "/work/amd64/comps_repo_Server",
|
|
],
|
|
self.topdir + "/work/amd64/buildinstall/Server",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Server",
|
|
buildinstallpackages=["bash", "vim"],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/amd64/buildinstall-Server-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
mock.call(
|
|
"Test",
|
|
"1",
|
|
"1",
|
|
[
|
|
self.topdir + "/work/amd64/repo/p1",
|
|
"http://example.com/repo2",
|
|
"http://example.com/repo3",
|
|
self.topdir + "/work/amd64/comps_repo_Client",
|
|
],
|
|
self.topdir + "/work/amd64/buildinstall/Client",
|
|
buildarch="amd64",
|
|
is_final=True,
|
|
nomacboot=True,
|
|
noupgrade=True,
|
|
volid="vol_id",
|
|
variant="Client",
|
|
buildinstallpackages=[],
|
|
bugurl=None,
|
|
add_template=[],
|
|
add_arch_template=[],
|
|
add_template_var=[],
|
|
add_arch_template_var=[],
|
|
rootfs_size=None,
|
|
log_dir=self.topdir + "/logs/amd64/buildinstall-Client-logs",
|
|
dracut_args=[],
|
|
skip_branding=False,
|
|
),
|
|
],
|
|
)
|
|
|
|
|
|
@mock.patch(
|
|
"pungi.phases.buildinstall.get_volid", new=lambda *args, **kwargs: "dummy-volid"
|
|
)
|
|
class BuildinstallThreadTestCase(PungiTestCase):
|
|
def setUp(self):
|
|
super(BuildinstallThreadTestCase, self).setUp()
|
|
self.pool = mock.Mock(finished_tasks=set())
|
|
self.cmd = ["echo", "1"]
|
|
|
|
@mock.patch("pungi.phases.buildinstall.link_boot_iso")
|
|
@mock.patch("pungi.phases.buildinstall.tweak_buildinstall")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.get_buildroot_rpms")
|
|
@mock.patch("pungi.phases.buildinstall.run")
|
|
def test_buildinstall_thread_with_lorax_in_runroot(
|
|
self, run, get_buildroot_rpms, KojiWrapperMock, mock_tweak, mock_link
|
|
):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"buildinstall_method": "lorax",
|
|
"runroot_tag": "rrt",
|
|
"koji_profile": "koji",
|
|
"runroot_weights": {"buildinstall": 123},
|
|
},
|
|
)
|
|
|
|
get_buildroot_rpms.return_value = ["bash", "zsh"]
|
|
|
|
get_runroot_cmd = KojiWrapperMock.return_value.get_runroot_cmd
|
|
|
|
run_runroot_cmd = KojiWrapperMock.return_value.run_runroot_cmd
|
|
run_runroot_cmd.return_value = {
|
|
"output": "Foo bar baz",
|
|
"retcode": 0,
|
|
"task_id": 1234,
|
|
}
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
|
|
with mock.patch("time.sleep"):
|
|
pkgset_phase = self._make_pkgset_phase(["p1"])
|
|
t.process(
|
|
(compose, "x86_64", compose.variants["Server"], self.cmd, pkgset_phase),
|
|
0,
|
|
)
|
|
|
|
destdir = os.path.join(self.topdir, "work/x86_64/buildinstall/Server")
|
|
self.assertEqual(
|
|
get_runroot_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
"rrt",
|
|
"x86_64",
|
|
self.cmd,
|
|
channel=None,
|
|
use_shell=True,
|
|
packages=["lorax"],
|
|
mounts=[self.topdir],
|
|
weight=123,
|
|
chown_paths=[
|
|
destdir,
|
|
os.path.join(
|
|
self.topdir, "logs/x86_64/buildinstall-Server-logs"
|
|
),
|
|
],
|
|
)
|
|
],
|
|
)
|
|
self.assertEqual(
|
|
run_runroot_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
get_runroot_cmd.return_value,
|
|
log_file=self.topdir
|
|
+ "/logs/x86_64/buildinstall-Server.x86_64.log",
|
|
)
|
|
],
|
|
)
|
|
with open(
|
|
self.topdir + "/logs/x86_64/buildinstall-Server-RPMs.x86_64.log"
|
|
) as f:
|
|
rpms = f.read().strip().split("\n")
|
|
six.assertCountEqual(self, rpms, ["bash", "zsh"])
|
|
six.assertCountEqual(self, self.pool.finished_tasks, [("Server", "x86_64")])
|
|
|
|
self.assertEqual(
|
|
mock_tweak.call_args_list,
|
|
[
|
|
mock.call(
|
|
compose,
|
|
destdir,
|
|
os.path.join(self.topdir, "compose/Server/x86_64/os"),
|
|
"x86_64",
|
|
"Server",
|
|
"",
|
|
"dummy-volid",
|
|
self.pool.kickstart_file,
|
|
)
|
|
],
|
|
)
|
|
self.assertEqual(
|
|
mock_link.call_args_list,
|
|
[mock.call(compose, "x86_64", compose.variants["Server"], False)],
|
|
)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.link_boot_iso")
|
|
@mock.patch("pungi.phases.buildinstall.tweak_buildinstall")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.get_buildroot_rpms")
|
|
@mock.patch("pungi.phases.buildinstall.run")
|
|
@mock.patch("pungi.phases.buildinstall.move_all")
|
|
def test_buildinstall_thread_with_lorax_using_koji_plugin(
|
|
self, move_all, run, get_buildroot_rpms, KojiWrapperMock, mock_tweak, mock_link
|
|
):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"buildinstall_method": "lorax",
|
|
"lorax_use_koji_plugin": True,
|
|
"runroot_tag": "rrt",
|
|
"koji_profile": "koji",
|
|
"runroot_weights": {"buildinstall": 123},
|
|
},
|
|
)
|
|
|
|
get_buildroot_rpms.return_value = ["bash", "zsh"]
|
|
|
|
get_pungi_buildinstall_cmd = (
|
|
KojiWrapperMock.return_value.get_pungi_buildinstall_cmd
|
|
)
|
|
|
|
run_runroot_cmd = KojiWrapperMock.return_value.run_runroot_cmd
|
|
run_runroot_cmd.return_value = {
|
|
"output": "Foo bar baz",
|
|
"retcode": 0,
|
|
"task_id": 1234,
|
|
}
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
|
|
with mock.patch("time.sleep"):
|
|
pkgset_phase = self._make_pkgset_phase(["p1"])
|
|
t.process(
|
|
(compose, "x86_64", compose.variants["Server"], self.cmd, pkgset_phase),
|
|
0,
|
|
)
|
|
|
|
destdir = os.path.join(self.topdir, "work/x86_64/buildinstall/Server")
|
|
self.assertEqual(
|
|
get_pungi_buildinstall_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
"rrt",
|
|
"x86_64",
|
|
self.cmd,
|
|
channel=None,
|
|
packages=["lorax"],
|
|
mounts=[self.topdir],
|
|
weight=123,
|
|
chown_uid=os.getuid(),
|
|
)
|
|
],
|
|
)
|
|
self.assertEqual(
|
|
run_runroot_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
get_pungi_buildinstall_cmd.return_value,
|
|
log_file=self.topdir
|
|
+ "/logs/x86_64/buildinstall-Server.x86_64.log",
|
|
)
|
|
],
|
|
)
|
|
with open(
|
|
self.topdir + "/logs/x86_64/buildinstall-Server-RPMs.x86_64.log"
|
|
) as f:
|
|
rpms = f.read().strip().split("\n")
|
|
six.assertCountEqual(self, rpms, ["bash", "zsh"])
|
|
six.assertCountEqual(self, self.pool.finished_tasks, [("Server", "x86_64")])
|
|
|
|
self.assertEqual(
|
|
mock_tweak.call_args_list,
|
|
[
|
|
mock.call(
|
|
compose,
|
|
destdir,
|
|
os.path.join(self.topdir, "compose/Server/x86_64/os"),
|
|
"x86_64",
|
|
"Server",
|
|
"",
|
|
"dummy-volid",
|
|
self.pool.kickstart_file,
|
|
)
|
|
],
|
|
)
|
|
self.assertEqual(
|
|
mock_link.call_args_list,
|
|
[mock.call(compose, "x86_64", compose.variants["Server"], False)],
|
|
)
|
|
self.assertEqual(
|
|
move_all.call_args_list,
|
|
[
|
|
mock.call(os.path.join(destdir, "results"), destdir, rm_src_dir=True),
|
|
mock.call(
|
|
os.path.join(destdir, "logs"),
|
|
os.path.join(self.topdir, "logs/x86_64/buildinstall-Server-logs"),
|
|
rm_src_dir=True,
|
|
),
|
|
],
|
|
)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.link_boot_iso")
|
|
@mock.patch("pungi.phases.buildinstall.tweak_buildinstall")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.get_buildroot_rpms")
|
|
@mock.patch("pungi.phases.buildinstall.run")
|
|
def test_buildinstall_thread_with_buildinstall_in_runroot(
|
|
self, run, get_buildroot_rpms, KojiWrapperMock, mock_tweak, mock_link
|
|
):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"buildinstall_method": "buildinstall",
|
|
"runroot_tag": "rrt",
|
|
"koji_profile": "koji",
|
|
},
|
|
)
|
|
|
|
get_buildroot_rpms.return_value = ["bash", "zsh"]
|
|
|
|
get_runroot_cmd = KojiWrapperMock.return_value.get_runroot_cmd
|
|
|
|
run_runroot_cmd = KojiWrapperMock.return_value.run_runroot_cmd
|
|
run_runroot_cmd.return_value = {
|
|
"output": "Foo bar baz",
|
|
"retcode": 0,
|
|
"task_id": 1234,
|
|
}
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
|
|
with mock.patch("time.sleep"):
|
|
pkgset_phase = self._make_pkgset_phase(["p1"])
|
|
t.process((compose, "amd64", None, self.cmd, pkgset_phase), 0)
|
|
|
|
destdir = os.path.join(self.topdir, "work/amd64/buildinstall")
|
|
self.assertEqual(
|
|
get_runroot_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
"rrt",
|
|
"amd64",
|
|
self.cmd,
|
|
channel=None,
|
|
use_shell=True,
|
|
packages=["anaconda"],
|
|
mounts=[self.topdir],
|
|
weight=None,
|
|
chown_paths=[destdir],
|
|
)
|
|
],
|
|
)
|
|
self.assertEqual(
|
|
run_runroot_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
get_runroot_cmd.return_value,
|
|
log_file=self.topdir + "/logs/amd64/buildinstall.amd64.log",
|
|
)
|
|
],
|
|
)
|
|
with open(self.topdir + "/logs/amd64/buildinstall-RPMs.amd64.log") as f:
|
|
rpms = f.read().strip().split("\n")
|
|
six.assertCountEqual(self, rpms, ["bash", "zsh"])
|
|
six.assertCountEqual(self, self.pool.finished_tasks, [(None, "amd64")])
|
|
six.assertCountEqual(
|
|
self,
|
|
mock_tweak.call_args_list,
|
|
[
|
|
mock.call(
|
|
compose,
|
|
destdir,
|
|
os.path.join(self.topdir, "compose", var, "amd64/os"),
|
|
"amd64",
|
|
var,
|
|
"",
|
|
"dummy-volid",
|
|
self.pool.kickstart_file,
|
|
)
|
|
for var in ["Client", "Server"]
|
|
],
|
|
)
|
|
six.assertCountEqual(
|
|
self,
|
|
mock_link.call_args_list,
|
|
[
|
|
mock.call(compose, "amd64", compose.variants["Client"], False),
|
|
mock.call(compose, "amd64", compose.variants["Server"], False),
|
|
],
|
|
)
|
|
|
|
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.get_buildroot_rpms")
|
|
@mock.patch("pungi.phases.buildinstall.run")
|
|
def test_buildinstall_fail_exit_code(
|
|
self, run, get_buildroot_rpms, KojiWrapperMock
|
|
):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"buildinstall_method": "buildinstall",
|
|
"runroot_tag": "rrt",
|
|
"koji_profile": "koji",
|
|
"failable_deliverables": [("^.+$", {"*": ["buildinstall"]})],
|
|
},
|
|
)
|
|
|
|
get_buildroot_rpms.return_value = ["bash", "zsh"]
|
|
|
|
run_runroot_cmd = KojiWrapperMock.return_value.run_runroot_cmd
|
|
run_runroot_cmd.return_value = {
|
|
"output": "Foo bar baz",
|
|
"retcode": 1,
|
|
"task_id": 1234,
|
|
}
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
|
|
with mock.patch("time.sleep"):
|
|
pkgset_phase = self._make_pkgset_phase(["p1"])
|
|
t.process((compose, "x86_64", None, self.cmd, pkgset_phase), 0)
|
|
|
|
compose._logger.error.assert_has_calls(
|
|
[
|
|
mock.call(
|
|
"[FAIL] Buildinstall (variant None, arch x86_64) failed, but going on anyway." # noqa: E501
|
|
),
|
|
mock.call(
|
|
"Runroot task failed: 1234. See %s/logs/x86_64/buildinstall.x86_64.log for more details." # noqa: E501
|
|
% self.topdir
|
|
),
|
|
]
|
|
)
|
|
self.assertEqual(self.pool.finished_tasks, set())
|
|
|
|
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.get_buildroot_rpms")
|
|
@mock.patch("pungi.phases.buildinstall.run")
|
|
def test_lorax_fail_exit_code(self, run, get_buildroot_rpms, KojiWrapperMock):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"buildinstall_method": "lorax",
|
|
"runroot_tag": "rrt",
|
|
"koji_profile": "koji",
|
|
"failable_deliverables": [("^.+$", {"*": ["buildinstall"]})],
|
|
},
|
|
)
|
|
|
|
get_buildroot_rpms.return_value = ["bash", "zsh"]
|
|
|
|
run_runroot_cmd = KojiWrapperMock.return_value.run_runroot_cmd
|
|
run_runroot_cmd.return_value = {
|
|
"output": "Foo bar baz",
|
|
"retcode": 1,
|
|
"task_id": 1234,
|
|
}
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
|
|
with mock.patch("time.sleep"):
|
|
pkgset_phase = self._make_pkgset_phase(["p1"])
|
|
t.process(
|
|
(compose, "x86_64", compose.variants["Server"], self.cmd, pkgset_phase),
|
|
0,
|
|
)
|
|
|
|
compose._logger.error.assert_has_calls(
|
|
[
|
|
mock.call(
|
|
"[FAIL] Buildinstall (variant Server, arch x86_64) failed, but going on anyway." # noqa: E501
|
|
),
|
|
mock.call(
|
|
"Runroot task failed: 1234. See %s/logs/x86_64/buildinstall-Server.x86_64.log for more details." # noqa: E501
|
|
% self.topdir
|
|
),
|
|
]
|
|
)
|
|
self.assertEqual(self.pool.finished_tasks, set())
|
|
|
|
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.get_buildroot_rpms")
|
|
@mock.patch("pungi.phases.buildinstall.run")
|
|
def test_skips_on_existing_output_dir(
|
|
self, run, get_buildroot_rpms, KojiWrapperMock
|
|
):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"buildinstall_method": "lorax",
|
|
"runroot_tag": "rrt",
|
|
"koji_profile": "koji",
|
|
"failable_deliverables": [("^.+$", {"*": ["buildinstall"]})],
|
|
},
|
|
)
|
|
|
|
get_buildroot_rpms.return_value = ["bash", "zsh"]
|
|
|
|
dummy_file = os.path.join(self.topdir, "work/x86_64/buildinstall/Server/dummy")
|
|
touch(os.path.join(dummy_file))
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
|
|
with mock.patch("time.sleep"):
|
|
pkgset_phase = self._make_pkgset_phase(["p1"])
|
|
t.process(
|
|
(compose, "x86_64", compose.variants["Server"], self.cmd, pkgset_phase),
|
|
0,
|
|
)
|
|
|
|
self.assertEqual(0, len(run.mock_calls))
|
|
|
|
self.assertTrue(os.path.exists(dummy_file))
|
|
self.assertEqual(self.pool.finished_tasks, set())
|
|
|
|
@mock.patch("pungi.phases.buildinstall.link_boot_iso")
|
|
@mock.patch("pungi.phases.buildinstall.tweak_buildinstall")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
|
|
@mock.patch("pungi.wrappers.kojiwrapper.get_buildroot_rpms")
|
|
@mock.patch("pungi.phases.buildinstall.run")
|
|
@mock.patch("pungi.phases.buildinstall.copy_all")
|
|
def test_buildinstall_thread_with_lorax_custom_buildinstall_topdir(
|
|
self, copy_all, run, get_buildroot_rpms, KojiWrapperMock, mock_tweak, mock_link
|
|
):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"buildinstall_method": "lorax",
|
|
"runroot_tag": "rrt",
|
|
"koji_profile": "koji",
|
|
"runroot_weights": {"buildinstall": 123},
|
|
"buildinstall_topdir": "/buildinstall_topdir",
|
|
},
|
|
)
|
|
|
|
get_buildroot_rpms.return_value = ["bash", "zsh"]
|
|
|
|
get_runroot_cmd = KojiWrapperMock.return_value.get_runroot_cmd
|
|
|
|
run_runroot_cmd = KojiWrapperMock.return_value.run_runroot_cmd
|
|
run_runroot_cmd.return_value = {
|
|
"output": "Foo bar baz",
|
|
"retcode": 0,
|
|
"task_id": 1234,
|
|
}
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
|
|
with mock.patch("time.sleep"):
|
|
pkgset_phase = self._make_pkgset_phase(["p1"])
|
|
t.process(
|
|
(compose, "x86_64", compose.variants["Server"], self.cmd, pkgset_phase),
|
|
0,
|
|
)
|
|
|
|
self.assertEqual(
|
|
get_runroot_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
"rrt",
|
|
"x86_64",
|
|
self.cmd,
|
|
channel=None,
|
|
use_shell=True,
|
|
packages=["lorax"],
|
|
mounts=[self.topdir],
|
|
weight=123,
|
|
chown_paths=[
|
|
"/buildinstall_topdir/buildinstall-%s/x86_64/Server"
|
|
% os.path.basename(self.topdir),
|
|
"/buildinstall_topdir/buildinstall-%s/x86_64/Server/logs"
|
|
% os.path.basename(self.topdir),
|
|
],
|
|
)
|
|
],
|
|
)
|
|
self.assertEqual(
|
|
run_runroot_cmd.mock_calls,
|
|
[
|
|
mock.call(
|
|
get_runroot_cmd.return_value,
|
|
log_file=self.topdir
|
|
+ "/logs/x86_64/buildinstall-Server.x86_64.log",
|
|
)
|
|
],
|
|
)
|
|
with open(
|
|
self.topdir + "/logs/x86_64/buildinstall-Server-RPMs.x86_64.log"
|
|
) as f:
|
|
rpms = f.read().strip().split("\n")
|
|
six.assertCountEqual(self, rpms, ["bash", "zsh"])
|
|
six.assertCountEqual(self, self.pool.finished_tasks, [("Server", "x86_64")])
|
|
|
|
buildinstall_topdir = os.path.join(
|
|
"/buildinstall_topdir", "buildinstall-" + os.path.basename(self.topdir)
|
|
)
|
|
six.assertCountEqual(
|
|
self,
|
|
copy_all.mock_calls,
|
|
[
|
|
mock.call(
|
|
os.path.join(buildinstall_topdir, "x86_64/Server/results"),
|
|
os.path.join(self.topdir, "work/x86_64/buildinstall/Server"),
|
|
),
|
|
mock.call(
|
|
os.path.join(buildinstall_topdir, "x86_64/Server/logs"),
|
|
os.path.join(self.topdir, "logs/x86_64/buildinstall-Server-logs"),
|
|
),
|
|
],
|
|
)
|
|
|
|
self.assertEqual(
|
|
mock_tweak.call_args_list,
|
|
[
|
|
mock.call(
|
|
compose,
|
|
os.path.join(self.topdir, "work/x86_64/buildinstall/Server"),
|
|
os.path.join(self.topdir, "compose/Server/x86_64/os"),
|
|
"x86_64",
|
|
"Server",
|
|
"",
|
|
"dummy-volid",
|
|
self.pool.kickstart_file,
|
|
)
|
|
],
|
|
)
|
|
self.assertEqual(
|
|
mock_link.call_args_list,
|
|
[mock.call(compose, "x86_64", compose.variants["Server"], False)],
|
|
)
|
|
|
|
def _prepare_buildinstall_reuse_test(self):
|
|
compose = BuildInstallCompose(
|
|
self.topdir,
|
|
{
|
|
"buildinstall_allow_reuse": True,
|
|
"buildinstall_method": "lorax",
|
|
"runroot_tag": "rrt",
|
|
"koji_profile": "koji",
|
|
},
|
|
)
|
|
|
|
pkgset = MockPackageSet(
|
|
MockPkg("/build/kernel-1.0.0-1.x86_64.rpm"),
|
|
MockPkg("/build/kernel-1.0.0-1.i686.rpm"),
|
|
MockPkg("/build/bash-1.0.0-1.x86_64.rpm"),
|
|
)
|
|
pkgset.file_cache = pkgset
|
|
pkgsets = [{"global": pkgset, "x86_64": pkgset}]
|
|
pkgset_phase = mock.Mock(package_sets=pkgsets)
|
|
|
|
cmd = {
|
|
"add-arch-template": [],
|
|
"buildarch": "x86_64",
|
|
"outputdir": self.topdir,
|
|
"product": "Fedora",
|
|
"release": "31",
|
|
"sources": ["/tmp/test/repo"],
|
|
"variant": "Server",
|
|
"version": "1",
|
|
}
|
|
return compose, pkgset_phase, cmd
|
|
|
|
@mock.patch("os.listdir")
|
|
@mock.patch("os.path.exists")
|
|
def test_generate_buildinstall_metadata(self, exists, listdir):
|
|
compose, pkgset_phase, cmd = self._prepare_buildinstall_reuse_test()
|
|
buildroot_rpms = ["bash-1-1.x86_64", "httpd-1-1.x86_64"]
|
|
listdir.return_value = ["kernel"]
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
metadata = t._generate_buildinstall_metadata(
|
|
compose,
|
|
"x86_64",
|
|
compose.variants["Server"],
|
|
cmd,
|
|
buildroot_rpms,
|
|
pkgset_phase,
|
|
)
|
|
self.assertEqual(metadata["cmd"], cmd)
|
|
self.assertEqual(metadata["buildroot_rpms"], buildroot_rpms)
|
|
self.assertEqual(
|
|
metadata["installed_rpms"],
|
|
["/build/kernel-1.0.0-1.i686.rpm", "/build/kernel-1.0.0-1.x86_64.rpm"],
|
|
)
|
|
|
|
@mock.patch(
|
|
"pungi.phases.buildinstall.BuildinstallThread._write_buildinstall_metadata"
|
|
)
|
|
@mock.patch(
|
|
"pungi.phases.buildinstall.BuildinstallThread._load_old_buildinstall_metadata"
|
|
)
|
|
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
|
|
@mock.patch("pungi.phases.buildinstall.copy_all")
|
|
def test_reuse_old_buildinstall_result(
|
|
self,
|
|
copy_all,
|
|
KojiWrapperMock,
|
|
load_old_buildinstall_metadata,
|
|
write_buildinstall_metadata,
|
|
):
|
|
compose, pkgset_phase, cmd = self._prepare_buildinstall_reuse_test()
|
|
|
|
listTaggedRPMS = KojiWrapperMock.return_value.koji_proxy.listTaggedRPMS
|
|
listTaggedRPMS.return_value = [
|
|
[{"name": "bash", "version": "1", "release": 1, "arch": "x86_64"}],
|
|
[],
|
|
]
|
|
|
|
load_old_buildinstall_metadata.return_value = {
|
|
"cmd": cmd,
|
|
"installed_rpms": ["/build/kernel-1.0.0-1.x86_64.rpm"],
|
|
"buildroot_rpms": ["bash-1-1.x86_64"],
|
|
}
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
with mock.patch.object(compose.paths, "old_compose_path") as old_compose_path:
|
|
old_compose_path.side_effect = ["/tmp/old/1", "/tmp/old/2"]
|
|
ret = t._reuse_old_buildinstall_result(
|
|
compose, "x86_64", compose.variants["Server"], cmd, pkgset_phase
|
|
)
|
|
|
|
self.assertEqual(ret, True)
|
|
self.assertEqual(
|
|
copy_all.mock_calls,
|
|
[
|
|
mock.call(
|
|
"/tmp/old/1",
|
|
os.path.join(self.topdir, "work/x86_64/buildinstall/Server"),
|
|
),
|
|
mock.call(
|
|
"/tmp/old/2",
|
|
os.path.join(self.topdir, "logs/x86_64/buildinstall-Server-logs"),
|
|
),
|
|
],
|
|
)
|
|
write_buildinstall_metadata.assert_called_once_with(
|
|
compose,
|
|
"x86_64",
|
|
compose.variants["Server"],
|
|
cmd,
|
|
["bash-1-1.x86_64"],
|
|
pkgset_phase,
|
|
)
|
|
|
|
@mock.patch(
|
|
"pungi.phases.buildinstall.BuildinstallThread._load_old_buildinstall_metadata"
|
|
)
|
|
def test_reuse_old_buildinstall_result_no_old_compose(
|
|
self, load_old_buildinstall_metadata,
|
|
):
|
|
compose, pkgset_phase, cmd = self._prepare_buildinstall_reuse_test()
|
|
load_old_buildinstall_metadata.return_value = None
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
ret = t._reuse_old_buildinstall_result(
|
|
compose, "x86_64", compose.variants["Server"], cmd, pkgset_phase
|
|
)
|
|
self.assertEqual(ret, None)
|
|
|
|
@mock.patch(
|
|
"pungi.phases.buildinstall.BuildinstallThread._load_old_buildinstall_metadata"
|
|
)
|
|
def test_reuse_old_buildinstall_result_different_cmd(
|
|
self, load_old_buildinstall_metadata,
|
|
):
|
|
compose, pkgset_phase, cmd = self._prepare_buildinstall_reuse_test()
|
|
|
|
old_cmd = copy(cmd)
|
|
old_cmd["version"] = "32"
|
|
|
|
load_old_buildinstall_metadata.return_value = {
|
|
"cmd": old_cmd,
|
|
"installed_rpms": ["/build/kernel-1.0.0-1.x86_64.rpm"],
|
|
"buildroot_rpms": ["bash-1-1.x86_64"],
|
|
}
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
ret = t._reuse_old_buildinstall_result(
|
|
compose, "x86_64", compose.variants["Server"], cmd, pkgset_phase
|
|
)
|
|
self.assertEqual(ret, None)
|
|
|
|
@mock.patch(
|
|
"pungi.phases.buildinstall.BuildinstallThread._load_old_buildinstall_metadata"
|
|
)
|
|
def test_reuse_old_buildinstall_result_different_installed_pkgs(
|
|
self, load_old_buildinstall_metadata,
|
|
):
|
|
compose, pkgset_phase, cmd = self._prepare_buildinstall_reuse_test()
|
|
load_old_buildinstall_metadata.return_value = {
|
|
"cmd": cmd,
|
|
"installed_rpms": ["/build/kernel-1.0.0-0.x86_64.rpm"],
|
|
"buildroot_rpms": ["bash-1-1.x86_64"],
|
|
}
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
ret = t._reuse_old_buildinstall_result(
|
|
compose, "x86_64", compose.variants["Server"], cmd, pkgset_phase
|
|
)
|
|
self.assertEqual(ret, None)
|
|
|
|
@mock.patch(
|
|
"pungi.phases.buildinstall.BuildinstallThread._load_old_buildinstall_metadata"
|
|
)
|
|
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
|
|
def test_reuse_old_buildinstall_result_different_buildroot_rpms(
|
|
self, KojiWrapperMock, load_old_buildinstall_metadata,
|
|
):
|
|
compose, pkgset_phase, cmd = self._prepare_buildinstall_reuse_test()
|
|
load_old_buildinstall_metadata.return_value = {
|
|
"cmd": cmd,
|
|
"installed_rpms": ["/build/kernel-1.0.0-1.x86_64.rpm"],
|
|
"buildroot_rpms": ["bash-1-1.x86_64"],
|
|
}
|
|
|
|
listTaggedRPMS = KojiWrapperMock.return_value.koji_proxy.listTaggedRPMS
|
|
listTaggedRPMS.return_value = [
|
|
[{"name": "bash", "version": "1", "release": 2, "arch": "x86_64"}],
|
|
[],
|
|
]
|
|
|
|
t = BuildinstallThread(self.pool)
|
|
ret = t._reuse_old_buildinstall_result(
|
|
compose, "x86_64", compose.variants["Server"], cmd, pkgset_phase
|
|
)
|
|
self.assertEqual(ret, None)
|
|
|
|
|
|
class TestSymlinkIso(PungiTestCase):
|
|
def setUp(self):
|
|
super(TestSymlinkIso, self).setUp()
|
|
self.compose = BuildInstallCompose(self.topdir, {})
|
|
os_tree = self.compose.paths.compose.os_tree(
|
|
"x86_64", self.compose.variants["Server"]
|
|
)
|
|
self.boot_iso_path = os.path.join(os_tree, "images", "boot.iso")
|
|
touch(self.boot_iso_path)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.Image")
|
|
@mock.patch("pungi.phases.buildinstall.get_mtime")
|
|
@mock.patch("pungi.phases.buildinstall.get_file_size")
|
|
@mock.patch("pungi.phases.buildinstall.iso")
|
|
@mock.patch("pungi.phases.buildinstall.run")
|
|
def test_hardlink(self, run, iso, get_file_size, get_mtime, ImageCls):
|
|
self.compose.conf = {"buildinstall_symlink": False, "disc_types": {}}
|
|
get_file_size.return_value = 1024
|
|
get_mtime.return_value = 13579
|
|
|
|
link_boot_iso(self.compose, "x86_64", self.compose.variants["Server"], False)
|
|
|
|
tgt = self.topdir + "/compose/Server/x86_64/iso/image-name"
|
|
self.assertTrue(os.path.isfile(tgt))
|
|
self.assertEqual(
|
|
os.stat(tgt).st_ino,
|
|
os.stat(self.topdir + "/compose/Server/x86_64/os/images/boot.iso").st_ino,
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.compose.get_image_name.mock_calls,
|
|
[
|
|
mock.call(
|
|
"x86_64",
|
|
self.compose.variants["Server"],
|
|
disc_type="boot",
|
|
disc_num=None,
|
|
suffix=".iso",
|
|
)
|
|
],
|
|
)
|
|
self.assertEqual(iso.get_implanted_md5.mock_calls, [mock.call(tgt)])
|
|
self.assertEqual(iso.get_manifest_cmd.mock_calls, [mock.call("image-name")])
|
|
self.assertEqual(iso.get_volume_id.mock_calls, [mock.call(tgt)])
|
|
self.assertEqual(
|
|
run.mock_calls,
|
|
[
|
|
mock.call(
|
|
iso.get_manifest_cmd.return_value,
|
|
workdir=self.topdir + "/compose/Server/x86_64/iso",
|
|
),
|
|
],
|
|
)
|
|
|
|
image = ImageCls.return_value
|
|
self.assertEqual(image.path, "Server/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, "boot")
|
|
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(image.can_fail, False)
|
|
self.assertEqual(
|
|
self.compose.im.add.mock_calls, [mock.call("Server", "x86_64", image)]
|
|
)
|
|
|
|
@mock.patch("pungi.phases.buildinstall.Image")
|
|
@mock.patch("pungi.phases.buildinstall.get_mtime")
|
|
@mock.patch("pungi.phases.buildinstall.get_file_size")
|
|
@mock.patch("pungi.phases.buildinstall.iso")
|
|
@mock.patch("pungi.phases.buildinstall.run")
|
|
def test_hardlink_with_custom_type(
|
|
self, run, iso, get_file_size, get_mtime, ImageCls
|
|
):
|
|
self.compose.conf = {
|
|
"buildinstall_symlink": False,
|
|
"disc_types": {"boot": "netinst"},
|
|
}
|
|
get_file_size.return_value = 1024
|
|
get_mtime.return_value = 13579
|
|
|
|
link_boot_iso(self.compose, "x86_64", self.compose.variants["Server"], True)
|
|
|
|
tgt = self.topdir + "/compose/Server/x86_64/iso/image-name"
|
|
self.assertTrue(os.path.isfile(tgt))
|
|
self.assertEqual(
|
|
os.stat(tgt).st_ino,
|
|
os.stat(self.topdir + "/compose/Server/x86_64/os/images/boot.iso").st_ino,
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.compose.get_image_name.mock_calls,
|
|
[
|
|
mock.call(
|
|
"x86_64",
|
|
self.compose.variants["Server"],
|
|
disc_type="netinst",
|
|
disc_num=None,
|
|
suffix=".iso",
|
|
)
|
|
],
|
|
)
|
|
self.assertEqual(iso.get_implanted_md5.mock_calls, [mock.call(tgt)])
|
|
self.assertEqual(iso.get_manifest_cmd.mock_calls, [mock.call("image-name")])
|
|
self.assertEqual(iso.get_volume_id.mock_calls, [mock.call(tgt)])
|
|
self.assertEqual(
|
|
run.mock_calls,
|
|
[
|
|
mock.call(
|
|
iso.get_manifest_cmd.return_value,
|
|
workdir=self.topdir + "/compose/Server/x86_64/iso",
|
|
)
|
|
],
|
|
)
|
|
|
|
image = ImageCls.return_value
|
|
self.assertEqual(image.path, "Server/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, "boot")
|
|
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(image.can_fail, True)
|
|
self.assertEqual(
|
|
self.compose.im.add.mock_calls, [mock.call("Server", "x86_64", image)]
|
|
)
|
|
|
|
|
|
class TestTweakConfigs(PungiTestCase):
|
|
def test_tweak_configs(self):
|
|
logger = mock.Mock()
|
|
configs = []
|
|
for cfg in BOOT_CONFIGS:
|
|
if "yaboot" not in cfg:
|
|
configs.append(os.path.join(self.topdir, cfg))
|
|
touch(configs[-1], ":LABEL=baz")
|
|
found_configs = tweak_configs(
|
|
self.topdir, "new volid", os.path.join(self.topdir, "ks.cfg"), logger=logger
|
|
)
|
|
self.assertEqual(
|
|
logger.info.call_args_list,
|
|
[
|
|
mock.call("Boot config %s changed" % os.path.join(self.topdir, cfg))
|
|
for cfg in found_configs
|
|
],
|
|
)
|
|
for cfg in configs:
|
|
self.assertFileContent(
|
|
cfg, ":LABEL=new\\x20volid ks=hd:LABEL=new\\x20volid:/ks.cfg\n"
|
|
)
|
|
|
|
def test_tweak_configs_yaboot(self):
|
|
configs = []
|
|
for cfg in BOOT_CONFIGS:
|
|
if "yaboot" in cfg:
|
|
configs.append(os.path.join(self.topdir, cfg))
|
|
touch(configs[-1], ":LABEL=baz")
|
|
tweak_configs(self.topdir, "new volid", os.path.join(self.topdir, "ks.cfg"))
|
|
for cfg in configs:
|
|
self.assertFileContent(
|
|
cfg, ":LABEL=new\\\\x20volid ks=hd:LABEL=new\\\\x20volid:/ks.cfg\n"
|
|
)
|