pungi/tests/test_checks.py
Lubomír Sedlář ff5a7e6377 Make python3-mock dependency optional
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>
2024-01-26 09:45:19 +01:00

668 lines
24 KiB
Python

# -*- coding: utf-8 -*-
try:
from unittest import mock
except ImportError:
import mock
try:
import unittest2 as unittest
except ImportError:
import unittest
import os
from six import StringIO
import kobo.conf
from pungi import checks
class CheckDependenciesTestCase(unittest.TestCase):
def dont_find(self, paths):
return lambda path: path not in paths
def test_all_deps_missing(self):
def custom_exists(path):
return False
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("os.path.exists") as exists:
exists.side_effect = custom_exists
result = checks.check({})
self.assertGreater(len(out.getvalue().strip().split("\n")), 1)
self.assertFalse(result)
def test_all_deps_ok(self):
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("platform.machine") as machine:
machine.return_value = "x86_64"
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find([])
result = checks.check({})
self.assertEqual("", out.getvalue())
self.assertTrue(result)
def test_does_not_require_jigdo_if_not_configured(self):
conf = {"create_jigdo": False}
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("platform.machine") as machine:
machine.return_value = "x86_64"
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find(["/usr/bin/jigdo-lite"])
result = checks.check(conf)
self.assertEqual("", out.getvalue())
self.assertTrue(result)
def test_isohybrid_not_required_without_productimg_phase(self):
conf = {
"bootable": True,
"productimg": False,
"runroot_tag": "dummy_tag",
}
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find(["/usr/bin/isohybrid"])
result = checks.check(conf)
self.assertEqual("", out.getvalue())
self.assertTrue(result)
def test_isohybrid_not_required_on_not_bootable(self):
conf = {
"bootable": False,
"runroot_tag": "dummy_tag",
}
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find(["/usr/bin/isohybrid"])
result = checks.check(conf)
self.assertEqual("", out.getvalue())
self.assertTrue(result)
def test_isohybrid_not_required_on_arm(self):
conf = {
"buildinstall_method": "lorax",
"runroot_tag": "",
}
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("platform.machine") as machine:
machine.return_value = "armhfp"
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find(["/usr/bin/isohybrid"])
result = checks.check(conf)
self.assertRegex(out.getvalue(), r"^Not checking.*Expect failures.*$")
self.assertTrue(result)
def test_isohybrid_not_needed_in_runroot(self):
conf = {
"runroot_tag": "dummy_tag",
}
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find(["/usr/bin/isohybrid"])
result = checks.check(conf)
self.assertEqual("", out.getvalue())
self.assertTrue(result)
def test_genisoimg_not_needed_in_runroot(self):
conf = {
"runroot_tag": "dummy_tag",
}
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find(["/usr/bin/genisoimage"])
result = checks.check(conf)
self.assertEqual("", out.getvalue())
self.assertTrue(result)
def test_requires_modifyrepo(self):
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find(["/usr/bin/modifyrepo"])
result = checks.check({"createrepo_c": False})
self.assertIn("createrepo", out.getvalue())
self.assertFalse(result)
def test_requires_modifyrepo_c(self):
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find(["/usr/bin/modifyrepo_c"])
result = checks.check({"createrepo_c": True})
self.assertIn("createrepo_c", out.getvalue())
self.assertFalse(result)
def test_requires_createrepo_c(self):
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find(["/usr/bin/createrepo_c"])
result = checks.check({"createrepo_c": True})
self.assertIn("createrepo_c", out.getvalue())
self.assertFalse(result)
def test_doesnt_require_createrepo_c_if_configured(self):
conf = {
"createrepo_c": False,
}
with mock.patch("sys.stdout", new_callable=StringIO) as out:
with mock.patch("os.path.exists") as exists:
exists.side_effect = self.dont_find(["/usr/bin/createrepo_c"])
result = checks.check(conf)
self.assertNotIn("createrepo_c", out.getvalue())
self.assertTrue(result)
class TestSchemaValidator(unittest.TestCase):
def _load_conf_from_string(self, string):
conf = kobo.conf.PyConfigParser()
conf.load_from_string(string)
return conf
@mock.patch("pungi.checks.make_schema")
def test_property(self, make_schema):
schema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"properties": {
"release_name": {"type": "string", "alias": "product_name"},
},
"additionalProperties": False,
"required": ["release_name"],
}
make_schema.return_value = schema
string = """
release_name = "dummy product"
"""
config = self._load_conf_from_string(string)
errors, warnings = checks.validate(config)
self.assertEqual(len(errors), 0)
self.assertEqual(len(warnings), 0)
self.assertEqual(config.get("release_name", None), "dummy product")
@mock.patch("pungi.checks.make_schema")
def test_alias_property(self, make_schema):
schema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"properties": {
"release_name": {"type": "string", "alias": "product_name"},
},
"additionalProperties": False,
}
make_schema.return_value = schema
string = """
product_name = "dummy product"
"""
config = self._load_conf_from_string(string)
errors, warnings = checks.validate(config)
self.assertEqual(len(errors), 0)
self.assertEqual(len(warnings), 1)
self.assertRegex(
warnings[0],
r"^WARNING: Config option 'product_name' is deprecated and now an alias to 'release_name'.*", # noqa: E501
)
self.assertEqual(config.get("release_name", None), "dummy product")
@mock.patch("pungi.checks.make_schema")
def test_required_is_missing(self, make_schema):
schema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"properties": {
"release_name": {"type": "string", "alias": "product_name"},
},
"additionalProperties": False,
"required": ["release_name"],
}
make_schema.return_value = schema
string = """
name = "dummy product"
"""
config = self._load_conf_from_string(string)
errors, warnings = checks.validate(config)
self.assertEqual(len(errors), 1)
self.assertIn(
"Failed validation in : 'release_name' is a required property", errors
)
self.assertEqual(len(warnings), 1)
self.assertIn("WARNING: Unrecognized config option: name.", warnings)
@mock.patch("pungi.checks.make_schema")
def test_required_is_in_alias(self, make_schema):
schema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"properties": {
"release_name": {"type": "string", "alias": "product_name"},
},
"additionalProperties": False,
"required": ["release_name"],
}
make_schema.return_value = schema
string = """
product_name = "dummy product"
"""
config = self._load_conf_from_string(string)
errors, warnings = checks.validate(config)
self.assertEqual(len(errors), 0)
self.assertEqual(len(warnings), 1)
self.assertRegex(
warnings[0],
r"^WARNING: Config option 'product_name' is deprecated and now an alias to 'release_name'.*", # noqa: E501
)
self.assertEqual(config.get("release_name", None), "dummy product")
@mock.patch("pungi.checks.make_schema")
def test_redundant_alias(self, make_schema):
schema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"properties": {
"release_name": {"type": "string", "alias": "product_name"},
},
"additionalProperties": False,
"required": ["release_name"],
}
make_schema.return_value = schema
string = """
product_name = "dummy product"
release_name = "dummy product"
"""
config = self._load_conf_from_string(string)
errors, warnings = checks.validate(config)
self.assertEqual(len(errors), 1)
self.assertRegex(
errors[0],
r"^ERROR: Config option 'product_name' is an alias of 'release_name', only one can be used.*", # noqa: E501
)
self.assertEqual(len(warnings), 1)
self.assertRegex(
warnings[0],
r"^WARNING: Config option 'product_name' is deprecated and now an alias to 'release_name'.*", # noqa: E501
)
self.assertEqual(config.get("release_name", None), "dummy product")
@mock.patch("pungi.checks.make_schema")
def test_properties_in_deep(self, make_schema):
schema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"properties": {
"release_name": {"type": "string", "alias": "product_name"},
"keys": {"type": "array", "items": {"type": "string"}},
"foophase": {
"type": "object",
"properties": {"repo": {"type": "string", "alias": "tree"}},
"additionalProperties": False,
"required": ["repo"],
},
},
"additionalProperties": False,
"required": ["release_name"],
}
make_schema.return_value = schema
string = """
product_name = "dummy product"
foophase = {
"tree": "http://www.exampe.com/os"
}
"""
config = self._load_conf_from_string(string)
errors, warnings = checks.validate(config)
self.assertEqual(len(errors), 0)
self.assertEqual(len(warnings), 2)
self.assertRegex(
warnings[0],
r"^WARNING: Config option '.+' is deprecated and now an alias to '.+'.*",
)
self.assertRegex(
warnings[1],
r"^WARNING: Config option '.+' is deprecated and now an alias to '.+'.*",
)
self.assertEqual(config.get("release_name", None), "dummy product")
self.assertEqual(
config.get("foophase", {}).get("repo", None), "http://www.exampe.com/os"
)
@mock.patch("pungi.checks.make_schema")
def test_append_option(self, make_schema):
schema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"definitions": {
"list_of_strings": {"type": "array", "items": {"type": "string"}},
"strings": {
"anyOf": [
{"type": "string"},
{"$ref": "#/definitions/list_of_strings"},
]
},
},
"properties": {
"release_name": {"type": "string"},
"repo": {"$ref": "#/definitions/strings", "append": "repo_from"},
},
"additionalProperties": False,
}
make_schema.return_value = schema
string = """
release_name = "dummy product"
repo = "http://url/to/repo"
repo_from = 'Server'
"""
config = self._load_conf_from_string(string)
errors, warnings = checks.validate(config)
self.assertEqual(len(errors), 0)
self.assertEqual(len(warnings), 2)
self.assertRegex(
warnings[0],
r"^WARNING: Config option 'repo_from' is deprecated, its value will be appended to option 'repo'.*", # noqa: E501
)
self.assertRegex(
warnings[1],
r"^WARNING: Value from config option 'repo_from' is now appended to option 'repo'", # noqa: E501
)
self.assertEqual(config.get("release_name", None), "dummy product")
self.assertEqual(config.get("repo", None), ["http://url/to/repo", "Server"])
@mock.patch("pungi.checks.make_schema")
def test_append_to_nonexist_option(self, make_schema):
schema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"definitions": {
"list_of_strings": {"type": "array", "items": {"type": "string"}},
"strings": {
"anyOf": [
{"type": "string"},
{"$ref": "#/definitions/list_of_strings"},
]
},
},
"properties": {
"release_name": {"type": "string"},
"repo": {"$ref": "#/definitions/strings", "append": "repo_from"},
},
"additionalProperties": False,
}
make_schema.return_value = schema
string = """
release_name = "dummy product"
repo_from = ['http://url/to/repo', 'Server']
"""
config = self._load_conf_from_string(string)
errors, warnings = checks.validate(config)
self.assertEqual(len(errors), 0)
self.assertEqual(len(warnings), 2)
self.assertRegex(
warnings[0],
r"^WARNING: Config option 'repo_from' is deprecated, its value will be appended to option 'repo'.*", # noqa: E501
)
self.assertRegex(
warnings[1],
r"^WARNING: Config option 'repo' is not found, but 'repo_from' is specified,", # noqa: E501
)
self.assertEqual(config.get("release_name", None), "dummy product")
self.assertEqual(config.get("repo", None), ["http://url/to/repo", "Server"])
@mock.patch("pungi.checks.make_schema")
def test_multiple_appends(self, make_schema):
schema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"definitions": {
"list_of_strings": {"type": "array", "items": {"type": "string"}},
"strings": {
"anyOf": [
{"type": "string"},
{"$ref": "#/definitions/list_of_strings"},
]
},
},
"properties": {
"release_name": {"type": "string"},
"repo": {
"$ref": "#/definitions/strings",
"append": ["repo_from", "source_repo_from"],
},
},
"additionalProperties": False,
}
make_schema.return_value = schema
string = """
release_name = "dummy product"
repo_from = ['http://url/to/repo', 'Server']
source_repo_from = 'Client'
"""
config = self._load_conf_from_string(string)
errors, warnings = checks.validate(config)
self.assertEqual(len(errors), 0)
self.assertEqual(len(warnings), 4)
self.assertRegex(
warnings[0],
r"^WARNING: Config option 'repo_from' is deprecated, its value will be appended to option 'repo'.*", # noqa: E501
)
self.assertRegex(
warnings[1],
r"^WARNING: Config option 'repo' is not found, but 'repo_from' is specified,", # noqa: E501
)
self.assertRegex(
warnings[2],
r"^WARNING: Config option 'source_repo_from' is deprecated, its value will be appended to option 'repo'", # noqa: E501
)
self.assertRegex(
warnings[3],
r"^WARNING: Value from config option 'source_repo_from' is now appended to option 'repo'.", # noqa: E501
)
self.assertEqual(config.get("release_name", None), "dummy product")
self.assertEqual(
config.get("repo", None), ["http://url/to/repo", "Server", "Client"]
)
@mock.patch("pungi.checks.make_schema")
def test_anyof_validator_not_raise_our_warnings_as_error(self, make_schema):
# https://pagure.io/pungi/issue/598
schema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"definitions": {
"live_image_config": {
"type": "object",
"properties": {"repo": {"type": "string", "append": "repo_from"}},
},
},
"properties": {
"live_images": checks._variant_arch_mapping(
{
"anyOf": [
{"$ref": "#/definitions/live_image_config"},
{
"type": "array",
"items": {"$ref": "#/definitions/live_image_config"},
},
]
}
),
},
}
make_schema.return_value = schema
string = """
live_images = [
('^Spins$', {
'armhfp': {
'repo_from': 'Everything',
}}),
]
"""
config = self._load_conf_from_string(string)
errors, warnings = checks.validate(config)
self.assertEqual(len(errors), 0)
self.assertEqual(len(warnings), 2)
self.assertRegex(
warnings[0],
r"^WARNING: Config option 'repo_from' is deprecated, its value will be appended to option 'repo'.*", # noqa: E501
)
self.assertRegex(
warnings[1],
r"^WARNING: Config option 'repo' is not found, but 'repo_from' is specified, value from 'repo_from' is now added as 'repo'.*", # noqa: E501
)
self.assertEqual(
config.get("live_images")[0][1]["armhfp"]["repo"], "Everything"
)
@mock.patch("pungi.util.resolve_git_url")
@mock.patch("pungi.checks.make_schema")
def test_resolve_url(self, make_schema, resolve_git_url):
resolve_git_url.return_value = "git://example.com/repo.git#CAFE"
make_schema.return_value = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"properties": {"foo": {"type": "url"}},
}
config = self._load_conf_from_string("foo = 'git://example.com/repo.git#HEAD'")
errors, warnings = checks.validate(config)
self.assertEqual(errors, [])
self.assertEqual(warnings, [])
self.assertEqual(config["foo"], resolve_git_url.return_value)
@mock.patch("pungi.util.resolve_git_url")
@mock.patch("pungi.checks.make_schema")
def test_resolve_url_when_offline(self, make_schema, resolve_git_url):
make_schema.return_value = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "Pungi Configuration",
"type": "object",
"properties": {"foo": {"type": "url"}},
}
config = self._load_conf_from_string("foo = 'git://example.com/repo.git#HEAD'")
errors, warnings = checks.validate(config, offline=True)
self.assertEqual(errors, [])
self.assertEqual(warnings, [])
self.assertEqual(config["foo"], "git://example.com/repo.git#HEAD")
self.assertEqual(resolve_git_url.call_args_list, [])
def test_update_schema(self):
schema = checks.make_schema()
schema_override = {
"definitions": {
"scm_dict": {
"properties": {
"scm": {"enum": ["git"]},
"repo": {"enum": ["git://localhost/pungi-fedora.git"]},
}
}
}
}
schema = checks.update_schema(schema, schema_override)
scm_dict_properties = schema["definitions"]["scm_dict"]["properties"]
self.assertEqual(
scm_dict_properties["scm"], {"enum": ["git"], "type": "string"}
)
self.assertEqual(
scm_dict_properties["repo"],
{"enum": ["git://localhost/pungi-fedora.git"], "type": "string"},
)
self.assertEqual(scm_dict_properties["file"], {"type": "string"})
class TestUmask(unittest.TestCase):
def setUp(self):
self.orig_umask = os.umask(0)
os.umask(self.orig_umask)
def tearDown(self):
os.umask(self.orig_umask)
def test_no_warning_with_0022(self):
os.umask(0o022)
logger = mock.Mock()
checks.check_umask(logger)
self.assertEqual(logger.mock_calls, [])
def test_no_warning_with_0000(self):
os.umask(0o000)
logger = mock.Mock()
checks.check_umask(logger)
self.assertEqual(logger.mock_calls, [])
def test_warning_with_0044(self):
os.umask(0o044)
logger = mock.Mock()
checks.check_umask(logger)
self.assertEqual(
logger.mock_calls,
[
mock.call.warning(
"Unusually strict umask detected (0%03o), "
"expect files with broken permissions.",
0o044,
)
],
)
class TestCheckSkipPhases(unittest.TestCase):
def test_skip_phase(self):
logger = mock.Mock()
passed = checks.check_skip_phases(logger, ["gather"], [])
self.assertFalse(passed)
self.assertEqual(
logger.mock_calls,
[
mock.call.error(
"gather phase is skipped but it's needed by createrepo phase"
)
],
)
def test_just_phase(self):
logger = mock.Mock()
passed = checks.check_skip_phases(logger, [], ["gather"])
self.assertFalse(passed)
self.assertEqual(
logger.mock_calls,
[
mock.call.error(
"pkgset phase is skipped but it's needed by gather phase"
)
],
)