pungi/tests/test_compose.py
soksanichenko f430e3fc9a - Mock of Koji is moved to the separate modules, classes
- Unittests for mock of Koji are moved to the separate
- AL9 version
- Use builtin mock instead python library
2022-11-07 20:10:33 +02:00

756 lines
25 KiB
Python

# -*- coding: utf-8 -*-
import logging
from unittest import mock
try:
import unittest2 as unittest
except ImportError:
import unittest
import os
import six
import tempfile
import shutil
import json
from pungi.compose import Compose
class ConfigWrapper(dict):
def __init__(self, *args, **kwargs):
super(ConfigWrapper, self).__init__(*args, **kwargs)
self._open_file = "%s/fixtures/config.conf" % os.path.abspath(
os.path.dirname(__file__)
)
class ComposeTestCase(unittest.TestCase):
def setUp(self):
self.tmp_dir = tempfile.mkdtemp()
# Basic ComposeInfo metadata used in tests.
self.ci_json = {
"header": {"type": "productmd.composeinfo", "version": mock.ANY},
"payload": {
"compose": {
"date": "20200526",
"id": "test-1.0-20200526.0",
"respin": 0,
"type": "production",
},
"release": {
"internal": False,
"name": "Test",
"short": "test",
"type": "ga",
"version": "1.0",
},
"variants": {},
},
}
def tearDown(self):
shutil.rmtree(self.tmp_dir)
@mock.patch("pungi.compose.ComposeInfo")
def test_setup_logger(self, ci):
conf = {}
logger = logging.getLogger("test_setup_logger")
logger.setLevel(logging.DEBUG)
compose = Compose(conf, self.tmp_dir, logger=logger)
self.assertEqual(len(logger.handlers), 2)
pungi_log = logger.handlers[0].stream.name
exclude_arch_log = logger.handlers[1].stream.name
self.assertEqual(os.path.basename(pungi_log), "pungi.global.log")
self.assertEqual(
os.path.basename(exclude_arch_log), "excluding-arch.global.log"
)
msg = "test log"
compose.log_info(msg)
with open(pungi_log) as f:
self.assertTrue(msg in f.read())
with open(exclude_arch_log) as f:
self.assertTrue(msg not in f.read())
msg = "Populating package set for arch: x86_64"
compose.log_info(msg)
with open(exclude_arch_log) as f:
self.assertTrue(msg in f.read())
@mock.patch("pungi.compose.ComposeInfo")
def test_can_fail(self, ci):
conf = {
"failable_deliverables": [
(
"^.*$",
{"*": ["buildinstall"], "i386": ["buildinstall", "live", "iso"]},
),
]
}
compose = Compose(conf, self.tmp_dir)
variant = mock.Mock(uid="Server")
self.assertTrue(compose.can_fail(variant, "x86_64", "buildinstall"))
self.assertFalse(compose.can_fail(variant, "x86_64", "live"))
self.assertTrue(compose.can_fail(variant, "i386", "live"))
self.assertFalse(compose.can_fail(None, "x86_64", "live"))
self.assertTrue(compose.can_fail(None, "i386", "live"))
self.assertTrue(compose.can_fail(variant, "*", "buildinstall"))
self.assertFalse(compose.can_fail(variant, "*", "live"))
@mock.patch("pungi.compose.ComposeInfo")
def test_get_image_name(self, ci):
conf = {}
variant = mock.Mock(uid="Server", type="variant")
ci.return_value.compose.respin = 2
ci.return_value.compose.id = "compose_id"
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "nightly"
ci.return_value.compose.type_suffix = ".n"
ci.return_value.compose.label = "RC-1.0"
ci.return_value.compose.label_major_version = "1"
ci.return_value.release.version = "3.0"
ci.return_value.release.short = "rel_short"
compose = Compose(conf, self.tmp_dir)
keys = [
"arch",
"compose_id",
"date",
"disc_num",
"disc_type",
"label",
"label_major_version",
"release_short",
"respin",
"suffix",
"type",
"type_suffix",
"variant",
"version",
]
format = "-".join(["%(" + k + ")s" for k in keys])
name = compose.get_image_name(
"x86_64",
variant,
format=format,
disc_num=7,
disc_type="live",
suffix=".iso",
)
self.assertEqual(
name,
"-".join(
[
"x86_64",
"compose_id",
"20160107",
"7",
"live",
"RC-1.0",
"1",
"rel_short",
"2",
".iso",
"nightly",
".n",
"Server",
"3.0",
]
),
)
@mock.patch("pungi.compose.ComposeInfo")
def test_get_image_name_variant_mapping(self, ci):
conf = {"image_name_format": {"^Server$": "whatever"}}
variant = mock.Mock(uid="Server", type="variant")
compose = Compose(conf, self.tmp_dir)
name = compose.get_image_name(
"x86_64", variant, disc_num=7, disc_type="live", suffix=".iso"
)
self.assertEqual(name, "whatever")
@mock.patch("pungi.compose.ComposeInfo")
def test_get_image_name_variant_mapping_no_match(self, ci):
conf = {"image_name_format": {"^Client$": "whatever"}}
variant = mock.Mock(uid="Server", type="variant")
ci.return_value.compose.id = "compose_id"
compose = Compose(conf, self.tmp_dir)
name = compose.get_image_name(
"x86_64", variant, disc_num=7, disc_type="live", suffix=".iso"
)
self.assertEqual(name, "compose_id-Server-x86_64-live7.iso")
@mock.patch("pungi.compose.ComposeInfo")
def test_get_image_name_layered_product(self, ci):
conf = {}
variant = mock.Mock(uid="Server-LP", type="layered-product")
variant.parent = mock.Mock(uid="Server")
ci.return_value.compose.respin = 2
ci.return_value.compose.id = "compose_id"
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "nightly"
ci.return_value.compose.type_suffix = ".n"
ci.return_value.compose.label = "RC-1.0"
ci.return_value.compose.label_major_version = "1"
ci.return_value.release.version = "3.0"
ci.return_value.release.short = "rel_short"
ci.return_value["Server-LP"].compose_id = "Gluster 1.0"
compose = Compose(conf, self.tmp_dir)
format = "{compose_id} {variant}"
name = compose.get_image_name(
"x86_64",
variant,
format=format,
disc_num=7,
disc_type="live",
suffix=".iso",
)
self.assertEqual(name, "Gluster 1.0 Server")
@mock.patch("pungi.compose.ComposeInfo")
def test_get_image_name_type_netinst(self, ci):
conf = {}
variant = mock.Mock(uid="Server", type="variant")
ci.return_value.compose.respin = 2
ci.return_value.compose.id = "compose_id"
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "nightly"
ci.return_value.compose.type_suffix = ".n"
ci.return_value.compose.label = "RC-1.0"
ci.return_value.compose.label_major_version = "1"
ci.return_value.release.version = "3.0"
ci.return_value.release.short = "rel_short"
compose = Compose(conf, self.tmp_dir)
keys = [
"arch",
"compose_id",
"date",
"disc_num",
"disc_type",
"label",
"label_major_version",
"release_short",
"respin",
"suffix",
"type",
"type_suffix",
"variant",
"version",
]
format = "-".join(["%(" + k + ")s" for k in keys])
name = compose.get_image_name(
"x86_64",
variant,
format=format,
disc_num=7,
disc_type="netinst",
suffix=".iso",
)
self.assertEqual(
name,
"-".join(
[
"x86_64",
"compose_id",
"20160107",
"7",
"netinst",
"RC-1.0",
"1",
"rel_short",
"2",
".iso",
"nightly",
".n",
"Server",
"3.0",
]
),
)
@mock.patch("pungi.compose.ComposeInfo")
def test_image_release(self, ci):
conf = {}
ci.return_value.compose.respin = 2
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "nightly"
ci.return_value.compose.type_suffix = ".n"
ci.return_value.compose.label = None
compose = Compose(conf, self.tmp_dir)
self.assertEqual(compose.image_release, "20160107.n.2")
@mock.patch("pungi.compose.ComposeInfo")
def test_image_release_production(self, ci):
conf = {}
ci.return_value.compose.respin = 2
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "production"
ci.return_value.compose.type_suffix = ""
ci.return_value.compose.label = None
compose = Compose(conf, self.tmp_dir)
self.assertEqual(compose.image_release, "20160107.2")
@mock.patch("pungi.compose.ComposeInfo")
def test_image_release_from_label(self, ci):
conf = {}
ci.return_value.compose.respin = 2
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "production"
ci.return_value.compose.type_suffix = ".n"
ci.return_value.compose.label = "Alpha-1.2"
compose = Compose(conf, self.tmp_dir)
self.assertEqual(compose.image_release, "1.2")
@mock.patch("pungi.compose.ComposeInfo")
def test_image_version_without_label(self, ci):
conf = {}
ci.return_value.compose.respin = 2
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "nightly"
ci.return_value.compose.type_suffix = ".n"
ci.return_value.compose.label = None
ci.return_value.release.version = "25"
compose = Compose(conf, self.tmp_dir)
self.assertEqual(compose.image_version, "25")
@mock.patch("pungi.compose.ComposeInfo")
def test_image_version_with_label(self, ci):
conf = {}
ci.return_value.compose.respin = 2
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "nightly"
ci.return_value.compose.type_suffix = ".n"
ci.return_value.compose.label = "Alpha-1.2"
ci.return_value.release.version = "25"
compose = Compose(conf, self.tmp_dir)
self.assertEqual(compose.image_version, "25_Alpha")
@mock.patch("pungi.compose.ComposeInfo")
def test_image_version_with_label_rc(self, ci):
conf = {}
ci.return_value.compose.respin = 2
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "nightly"
ci.return_value.compose.type_suffix = ".n"
ci.return_value.compose.label = "RC-1.2"
ci.return_value.release.version = "25"
compose = Compose(conf, self.tmp_dir)
self.assertEqual(compose.image_version, "25")
@mock.patch("pungi.compose.ComposeInfo")
def test_get_variant_arches_without_filter(self, ci):
ci.return_value.compose.id = "composeid"
conf = ConfigWrapper(
variants_file={"scm": "file", "repo": None, "file": "variants.xml"},
release_name="Test",
release_version="1.0",
release_short="test",
release_type="ga",
release_internal=False,
)
compose = Compose(conf, self.tmp_dir)
compose.read_variants()
self.assertEqual(
sorted(v.uid for v in compose.variants.values()),
["Client", "Crashy", "Live", "Server"],
)
self.assertEqual(
sorted(v.uid for v in compose.variants["Server"].variants.values()),
["Server-Gluster", "Server-ResilientStorage", "Server-optional"],
)
six.assertCountEqual(
self, compose.variants["Client"].arches, ["i386", "x86_64"]
)
self.assertEqual(compose.variants["Crashy"].arches, ["ppc64le"])
self.assertEqual(compose.variants["Live"].arches, ["x86_64"])
six.assertCountEqual(
self, compose.variants["Server"].arches, ["s390x", "x86_64"]
)
self.assertEqual(
compose.variants["Server"].variants["Gluster"].arches, ["x86_64"]
)
self.assertEqual(
compose.variants["Server"].variants["ResilientStorage"].arches, ["x86_64"]
)
six.assertCountEqual(
self,
compose.variants["Server"].variants["optional"].arches,
["s390x", "x86_64"],
)
self.assertEqual(
[v.uid for v in compose.get_variants()],
[
"Client",
"Crashy",
"Live",
"Server",
"Server-Gluster",
"Server-ResilientStorage",
"Server-optional",
],
)
self.assertEqual(compose.get_arches(), ["i386", "ppc64le", "s390x", "x86_64"])
@mock.patch("pungi.compose.ComposeInfo")
def test_get_variant_arches_with_arch_filter(self, ci):
ci.return_value.compose.id = "composeid"
conf = ConfigWrapper(
variants_file={"scm": "file", "repo": None, "file": "variants.xml"},
release_name="Test",
release_version="1.0",
release_short="test",
release_type="ga",
release_internal=False,
tree_arches=["x86_64"],
)
compose = Compose(conf, self.tmp_dir)
compose.read_variants()
self.assertEqual(
sorted(v.uid for v in compose.variants.values()),
["Client", "Live", "Server"],
)
self.assertEqual(
sorted(v.uid for v in compose.variants["Server"].variants.values()),
["Server-Gluster", "Server-ResilientStorage", "Server-optional"],
)
self.assertEqual(compose.variants["Client"].arches, ["x86_64"])
self.assertEqual(compose.variants["Live"].arches, ["x86_64"])
self.assertEqual(compose.variants["Server"].arches, ["x86_64"])
self.assertEqual(
compose.variants["Server"].variants["Gluster"].arches, ["x86_64"]
)
self.assertEqual(
compose.variants["Server"].variants["ResilientStorage"].arches, ["x86_64"]
)
self.assertEqual(
compose.variants["Server"].variants["optional"].arches, ["x86_64"]
)
self.assertEqual(compose.get_arches(), ["x86_64"])
self.assertEqual(
[v.uid for v in compose.get_variants()],
[
"Client",
"Live",
"Server",
"Server-Gluster",
"Server-ResilientStorage",
"Server-optional",
],
)
@mock.patch("pungi.compose.ComposeInfo")
def test_get_variant_arches_with_variant_filter(self, ci):
ci.return_value.compose.id = "composeid"
ci.return_value.compose.respin = 2
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "production"
ci.return_value.compose.type_suffix = ".n"
conf = ConfigWrapper(
variants_file={"scm": "file", "repo": None, "file": "variants.xml"},
release_name="Test",
release_version="1.0",
release_short="test",
release_type="ga",
release_internal=False,
tree_variants=["Server", "Client", "Server-Gluster"],
)
compose = Compose(conf, self.tmp_dir)
compose.read_variants()
self.assertEqual(
sorted(v.uid for v in compose.variants.values()), ["Client", "Server"]
)
six.assertCountEqual(
self, compose.variants["Client"].arches, ["i386", "x86_64"]
)
six.assertCountEqual(
self, compose.variants["Server"].arches, ["s390x", "x86_64"]
)
self.assertEqual(
compose.variants["Server"].variants["Gluster"].arches, ["x86_64"]
)
self.assertEqual(compose.get_arches(), ["i386", "s390x", "x86_64"])
self.assertEqual(
[v.uid for v in compose.get_variants()],
["Client", "Server", "Server-Gluster"],
)
@mock.patch("pungi.compose.ComposeInfo")
def test_get_variant_arches_with_both_filters(self, ci):
ci.return_value.compose.id = "composeid"
ci.return_value.compose.respin = 2
ci.return_value.compose.date = "20160107"
ci.return_value.compose.type = "production"
ci.return_value.compose.type_suffix = ".n"
logger = mock.Mock()
logger.handlers = []
conf = ConfigWrapper(
variants_file={"scm": "file", "repo": None, "file": "variants.xml"},
release_name="Test",
release_version="1.0",
release_short="test",
release_type="ga",
release_internal=False,
tree_variants=["Server", "Client", "Server-optional"],
tree_arches=["x86_64"],
)
compose = Compose(conf, self.tmp_dir, logger=logger)
compose.read_variants()
self.assertEqual(
sorted(v.uid for v in compose.variants.values()), ["Client", "Server"]
)
self.assertEqual(compose.variants["Client"].arches, ["x86_64"])
self.assertEqual(compose.variants["Server"].arches, ["x86_64"])
self.assertEqual(
compose.variants["Server"].variants["optional"].arches, ["x86_64"]
)
self.assertEqual(compose.get_arches(), ["x86_64"])
self.assertEqual(
[v.uid for v in compose.get_variants()],
["Client", "Server", "Server-optional"],
)
six.assertCountEqual(
self,
logger.info.call_args_list,
[
mock.call("Excluding variant Live: filtered by configuration."),
mock.call("Excluding variant Crashy: all its arches are filtered."),
mock.call(
"Excluding variant Server-ResilientStorage: filtered by configuration." # noqa: E501
),
mock.call(
"Excluding variant Server-Gluster: filtered by configuration."
),
],
)
@mock.patch("pungi.compose.ComposeInfo")
def test_mkdtemp(self, ci):
ci.return_value.compose.id = "composeid"
conf = ConfigWrapper(
variants_file={"scm": "file", "repo": None, "file": "variants.xml"},
release_name="Test",
release_version="1.0",
release_short="test",
release_type="ga",
release_internal=False,
tree_variants=["Server", "Client", "Server-optional"],
tree_arches=["x86_64"],
)
compose = Compose(conf, self.tmp_dir)
d = compose.mkdtemp()
self.assertTrue(os.path.isdir(d))
d = compose.mkdtemp(prefix="tweak_buildinstall")
self.assertTrue(os.path.isdir(d))
@mock.patch("time.strftime", new=lambda fmt, time: "20200526")
def test_get_compose_info(self):
conf = ConfigWrapper(
release_name="Test",
release_version="1.0",
release_short="test",
release_type="ga",
release_internal=False,
)
ci = Compose.get_compose_info(conf)
ci_json = json.loads(ci.dumps())
self.assertEqual(ci_json, self.ci_json)
@mock.patch("time.strftime", new=lambda fmt, time: "20200526")
def test_get_compose_info_cts(self):
conf = ConfigWrapper(
release_name="Test",
release_version="1.0",
release_short="test",
release_type="ga",
release_internal=False,
cts_url="https://cts.localhost.tld/",
cts_keytab="/tmp/some.keytab",
)
# The `mock.ANY` in ["header"]["version"] cannot be serialized,
# so for this test, we replace it with real version.
ci_copy = dict(self.ci_json)
ci_copy["header"]["version"] = "1.2"
mocked_response = mock.MagicMock()
mocked_response.text = json.dumps(self.ci_json)
mocked_requests = mock.MagicMock()
mocked_requests.post.return_value = mocked_response
mocked_requests_kerberos = mock.MagicMock()
# The `requests` and `requests_kerberos` modules are imported directly
# in the `get_compose_info` function. To patch them, we need to patch
# the `sys.modules` directly so the patched modules are returned by
# `import`.
with mock.patch.dict(
"sys.modules",
requests=mocked_requests,
requests_kerberos=mocked_requests_kerberos,
):
ci = Compose.get_compose_info(conf, respin_of="Fedora-Rawhide-20200517.n.1")
ci_json = json.loads(ci.dumps())
self.assertEqual(ci_json, self.ci_json)
expected_json = {
"compose_info": self.ci_json,
"parent_compose_ids": None,
"respin_of": "Fedora-Rawhide-20200517.n.1",
}
mocked_response.raise_for_status.assert_called_once()
mocked_requests.post.assert_called_once_with(
"https://cts.localhost.tld/api/1/composes/",
auth=mock.ANY,
json=expected_json,
)
class StatusTest(unittest.TestCase):
def setUp(self):
self.tmp_dir = tempfile.mkdtemp()
self.logger = mock.Mock()
self.logger.handlers = []
with mock.patch("pungi.compose.ComposeInfo"):
self.compose = Compose({}, self.tmp_dir, logger=self.logger)
def tearDown(self):
shutil.rmtree(self.tmp_dir)
def test_get_status_non_existing(self):
status = self.compose.get_status()
self.assertIsNone(status)
def test_get_status_existing(self):
with open(os.path.join(self.tmp_dir, "STATUS"), "w") as f:
f.write("FOOBAR")
self.assertEqual(self.compose.get_status(), "FOOBAR")
def test_get_status_is_dir(self):
os.mkdir(os.path.join(self.tmp_dir, "STATUS"))
self.assertIsNone(self.compose.get_status())
def test_write_status(self):
self.compose.write_status("DOOMED")
with open(os.path.join(self.tmp_dir, "STATUS"), "r") as f:
self.assertEqual(f.read(), "DOOMED\n")
def test_write_non_standard_status(self):
self.compose.write_status("FOOBAR")
self.assertEqual(self.logger.log.call_count, 1)
with open(os.path.join(self.tmp_dir, "STATUS"), "r") as f:
self.assertEqual(f.read(), "FOOBAR\n")
def test_write_status_on_finished(self):
self.compose.write_status("FINISHED")
with self.assertRaises(RuntimeError):
self.compose.write_status("NOT REALLY")
def test_write_status_with_failed_deliverables(self):
self.compose.conf = {
"failable_deliverables": [("^.+$", {"*": ["live", "build-image"]})]
}
variant = mock.Mock(uid="Server")
self.compose.fail_deliverable(variant, "x86_64", "live")
self.compose.fail_deliverable(None, "*", "build-image")
self.compose.write_status("FINISHED")
self.logger.log.assert_has_calls(
[
mock.call(
20, "Failed build-image on variant <>, arch <*>, subvariant <None>."
),
mock.call(
20,
"Failed live on variant <Server>, arch <x86_64>, subvariant <None>.", # noqa: E501
),
],
any_order=True,
)
with open(os.path.join(self.tmp_dir, "STATUS"), "r") as f:
self.assertEqual(f.read(), "FINISHED_INCOMPLETE\n")
def test_calls_notifier(self):
self.compose.notifier = mock.Mock()
self.compose.write_status("FINISHED")
self.assertTrue(self.compose.notifier.send.call_count, 1)
def test_no_database_with_dnf_backend(self):
self.compose.conf["gather_backend"] = "dnf"
self.assertFalse(self.compose.should_create_yum_database)
def test_no_database_with_dnf_backend_config_override(self):
self.compose.conf["gather_backend"] = "dnf"
self.compose.conf["createrepo_database"] = True
self.assertTrue(self.compose.should_create_yum_database)
def test_no_database_with_yum_backend(self):
self.compose.conf["gather_backend"] = "yum"
self.assertTrue(self.compose.should_create_yum_database)
def test_no_database_with_yum_backend_config_override(self):
self.compose.conf["gather_backend"] = "yum"
self.compose.conf["createrepo_database"] = False
self.assertFalse(self.compose.should_create_yum_database)