def get_installation_specs_groups_test(self):
"""Test the get_installation_specs function with groups."""
data = PackagesConfigurationData()
data.groups = ["g1", "g2", "g3"]
data.excluded_groups = ["g4", "g5", "g6"]
data.groups_package_types = {
"g1": GROUP_PACKAGE_TYPES_REQUIRED,
"g3": GROUP_PACKAGE_TYPES_ALL,
"g4": GROUP_PACKAGE_TYPES_REQUIRED,
"g6": GROUP_PACKAGE_TYPES_ALL,
}
self.assertEqual(get_installation_specs(data), (
[
"@core",
"@g1/mandatory,conditional",
"@g2",
"@g3/mandatory,default,conditional,optional"],
[
"@g4",
"@g5",
"@g6"
]
))
def get_installation_specs_packages_test(self):
"""Test the get_installation_specs function with packages."""
data = PackagesConfigurationData()
data.packages = ["p1", "p2", "p3"]
data.excluded_packages = ["p4", "p5", "p6"]
self.assertEqual(get_installation_specs(data), (
["@core", "p1", "p2", "p3"], ["p4", "p5", "p6"]
))
def set_rpm_macros_exclude_docs_test(self, mock_rpm):
data = PackagesConfigurationData()
data.docs_excluded = True
macros = [
('__dbi_htconfig', 'hash nofsync %{__dbi_other} %{__dbi_perms}'),
('_excludedocs', '1'),
]
task = self._run_task(data)
self._check_macros(task, mock_rpm, macros)
def set_rpm_macros_install_langs_test(self, mock_rpm):
data = PackagesConfigurationData()
data.languages = "en,es"
macros = [
('__dbi_htconfig', 'hash nofsync %{__dbi_other} %{__dbi_perms}'),
('_install_langs', 'en,es'),
]
task = self._run_task(data)
self._check_macros(task, mock_rpm, macros)
def set_rpm_macros_no_install_langs_test(self, mock_rpm):
data = PackagesConfigurationData()
data.languages = RPM_LANGUAGES_NONE
macros = [
('__dbi_htconfig', 'hash nofsync %{__dbi_other} %{__dbi_perms}'),
('_install_langs', '%{nil}'),
]
task = self._run_task(data)
self._check_macros(task, mock_rpm, macros)
def configure_base_test(self):
"""Test the configuration of the DNF base."""
data = PackagesConfigurationData()
self.dnf_manager.configure_base(data)
self._check_configuration(
"multilib_policy = best",
"timeout = 30",
"retries = 10",
"install_weak_deps = 1",
)
self.assertEqual(self.dnf_manager._ignore_broken_packages, False)
self.assertEqual(self.dnf_manager._ignore_missing_packages, False)
data.multilib_policy = MULTILIB_POLICY_ALL
data.timeout = 100
data.retries = 5
data.broken_ignored = True
data.missing_ignored = True
data.weakdeps_excluded = True
self.dnf_manager.configure_base(data)
self._check_configuration(
"multilib_policy = all",
"timeout = 100",
"retries = 5",
"install_weak_deps = 0",
)
self.assertEqual(self.dnf_manager._ignore_broken_packages, True)
self.assertEqual(self.dnf_manager._ignore_missing_packages, True)
def SetPackages(self, data: Structure):
"""Set the packages configuration.
:param data: a structure of the type PackagesConfigurationData
"""
self.implementation.set_packages(
PackagesConfigurationData.from_structure(data))
def Packages(self) -> Structure:
"""The packages configuration.
:return: a structure of the type PackagesConfigurationData
"""
return PackagesConfigurationData.to_structure(
self.implementation.packages)
def packages_property_test(self):
"""Test the Packages property."""
data = {
"core-group-enabled":
get_variant(Bool, False),
"default-environment-enabled":
get_variant(Bool, False),
"environment":
get_variant(Str, "environment"),
"groups":
get_variant(List[Str], ["g1", "g2"]),
"groups-package-types":
get_variant(Dict[Str, List[Str]], {
"g1": GROUP_PACKAGE_TYPES_ALL,
"g2": GROUP_PACKAGE_TYPES_REQUIRED
}),
"excluded-groups":
get_variant(List[Str], ["g3", "g4"]),
"packages":
get_variant(List[Str], ["p1", "p2"]),
"excluded-packages":
get_variant(List[Str], ["p3", "p4"]),
"docs-excluded":
get_variant(Bool, True),
"weakdeps-excluded":
get_variant(Bool, True),
"missing-ignored":
get_variant(Bool, True),
"broken-ignored":
get_variant(Bool, True),
"languages":
get_variant(Str, "en,es"),
"multilib-policy":
get_variant(Str, MULTILIB_POLICY_ALL),
"timeout":
get_variant(Int, 10),
"retries":
get_variant(Int, 5),
}
self._check_dbus_property("Packages", data)
data = PackagesConfigurationData.to_structure(
PackagesConfigurationData())
self._check_dbus_property("Packages", data)
def get_installation_specs_environment_test(self):
"""Test the get_installation_specs function with environment."""
data = PackagesConfigurationData()
data.environment = "environment-1"
self.assertEqual(get_installation_specs(data), (
["@environment-1", "@core"], []
))
env = "environment-2"
self.assertEqual(get_installation_specs(data, default_environment=env), (
["@environment-1", "@core"], []
))
data.default_environment_enabled = True
self.assertEqual(get_installation_specs(data, default_environment=env), (
["@environment-2", "@core"], []
))
def set_rpm_macros_default_test(self, mock_rpm):
data = PackagesConfigurationData()
macros = [
('__dbi_htconfig', 'hash nofsync %{__dbi_other} %{__dbi_perms}')
]
task = self._run_task(data)
self._check_macros(task, mock_rpm, macros)
def set_rpm_macros_selinux_disabled_test(self, mock_rpm, mock_conf):
mock_conf.security.selinux = 0
data = PackagesConfigurationData()
macros = [
('__dbi_htconfig', 'hash nofsync %{__dbi_other} %{__dbi_perms}'),
('__file_context_path', '%{nil}'),
]
task = self._run_task(data)
self._check_macros(task, mock_rpm, macros)
def set_rpm_macros_selinux_test(self, mock_rpm, mock_os):
mock_os.access.return_value = True
data = PackagesConfigurationData()
macros = [
('__dbi_htconfig', 'hash nofsync %{__dbi_other} %{__dbi_perms}'),
('__file_context_path', '/tmp/updates/file_contexts'),
]
task = self._run_task(data)
self._check_macros(task, mock_rpm, macros)
def get_installation_specs_nocore_test(self):
"""Test the get_installation_specs function without core."""
data = PackagesConfigurationData()
data.core_group_enabled = False
self.assertEqual(get_installation_specs(data), ([], ["@core"]))
def _process_kickstart_packages(self, data):
"""Process the kickstart packages."""
packages = PackagesConfigurationData()
packages.core_group_enabled = not data.packages.nocore
packages.default_environment_enabled = data.packages.default
if data.packages.environment is not None:
packages.environment = data.packages.environment
packages.packages = data.packages.packageList
packages.excluded_packages = data.packages.excludedList
for group in data.packages.groupList:
packages.groups.append(group.name)
if group.include == GROUP_ALL:
packages.groups_package_types[group.name] = GROUP_PACKAGE_TYPES_ALL
if group.include == GROUP_REQUIRED:
packages.groups_package_types[group.name] = GROUP_PACKAGE_TYPES_REQUIRED
for group in data.packages.excludedGroupList:
packages.excluded_groups.append(group.name)
packages.docs_excluded = data.packages.excludeDocs
packages.weakdeps_excluded = data.packages.excludeWeakdeps
if data.packages.handleMissing == KS_MISSING_IGNORE:
packages.missing_ignored = True
if data.packages.handleBroken == KS_BROKEN_IGNORE:
packages.broken_ignored = True
if data.packages.instLangs == "":
packages.languages = RPM_LANGUAGES_NONE
elif data.packages.instLangs is not None:
packages.languages = data.packages.instLangs
if data.packages.multiLib:
packages.multilib_policy = MULTILIB_POLICY_ALL
if data.packages.timeout is not None:
packages.timeout = data.packages.timeout
if data.packages.retries is not None:
packages.retries = data.packages.retries
self.set_packages(packages)
def get_installation_specs_default_test(self):
"""Test the get_installation_specs function with defaults."""
data = PackagesConfigurationData()
self.assertEqual(get_installation_specs(data), (["@core"], []))
def __init__(self):
super().__init__()
self._packages = PackagesConfigurationData()
self.packages_changed = Signal()
