def test_is_software_selection_complete(self):
"""Test the is_software_selection_complete function."""
selection = PackagesSelectionData()
selection.environment = "e1"
dnf_manager = Mock(spec=DNFManager)
dnf_manager.is_environment_valid.return_value = True
assert is_software_selection_complete(dnf_manager, selection)
assert is_software_selection_complete(dnf_manager,
selection,
kickstarted=True)
dnf_manager.is_environment_valid.return_value = False
assert not is_software_selection_complete(dnf_manager, selection)
assert not is_software_selection_complete(
dnf_manager, selection, kickstarted=True)
selection.environment = ""
assert not is_software_selection_complete(dnf_manager, selection)
assert is_software_selection_complete(dnf_manager,
selection,
kickstarted=True)
def check_selection_test(self, kernel_getter):
kernel_getter.return_value = None
dnf_manager = Mock()
selection = PackagesSelectionData()
selection.core_group_enabled = False
selection.environment = "e1"
selection.packages = ["p1", "p2"]
selection.excluded_packages = ["p3", "p4"]
selection.groups = ["g1", "g2"]
selection.excluded_groups = ["g3", "g4"]
selection.modules = ["m1", "m2"]
selection.disabled_modules = ["m3", "m4"]
task = CheckPackagesSelectionTask(dnf_manager, selection)
report = task.run()
dnf_manager.clear_selection.assert_called_once_with()
dnf_manager.disable_modules.assert_called_once_with(["m3", "m4"])
dnf_manager.enable_modules.assert_called_once_with(["m1", "m2"])
dnf_manager.apply_specs.assert_called_once_with(
["@e1", "@g1", "@g2", "p1", "p2"],
["@core", "@g3", "@g4", "p3", "p4"])
dnf_manager.resolve_selection.assert_called_once_with()
self.assertEqual(report.get_messages(), [])
def is_software_selection_complete_test(self):
"""Test the is_software_selection_complete function."""
selection = PackagesSelectionData()
selection.environment = "e1"
dnf_manager = Mock(spec=DNFManager)
dnf_manager.is_environment_valid.return_value = True
self.assertTrue(is_software_selection_complete(dnf_manager, selection))
self.assertTrue(
is_software_selection_complete(dnf_manager,
selection,
kickstarted=True))
dnf_manager.is_environment_valid.return_value = False
self.assertFalse(is_software_selection_complete(
dnf_manager, selection))
self.assertFalse(
is_software_selection_complete(dnf_manager,
selection,
kickstarted=True))
selection.environment = ""
self.assertFalse(is_software_selection_complete(
dnf_manager, selection))
self.assertTrue(
is_software_selection_complete(dnf_manager,
selection,
kickstarted=True))
def test_resolve(self, kernel_getter, req_getter1, req_getter2,
req_getter3, req_getter4):
"""Test the successful ResolvePackagesTask task."""
kernel_getter.return_value = None
req_getter1.return_value = [
Requirement.for_group("r1"),
Requirement.for_group("r2")
]
req_getter2.return_value = [Requirement.for_group("r3")]
req_getter3.return_value = [
Requirement.for_package("r4"),
Requirement.for_package("r5")
]
req_getter4.return_value = [Requirement.for_package("r6")]
selection = PackagesSelectionData()
selection.excluded_groups = ["r3"]
selection.excluded_packages = ["r6"]
dnf_manager = Mock()
dnf_manager.default_environment = None
task = ResolvePackagesTask(dnf_manager, selection)
task.run()
dnf_manager.clear_selection.assert_called_once_with()
dnf_manager.disable_modules.assert_called_once_with([])
dnf_manager.enable_modules.assert_called_once_with([])
dnf_manager.apply_specs.assert_called_once_with(
["@core", "@r1", "@r2", "r4", "r5"], ["@r3", "r6"])
dnf_manager.resolve_selection.assert_called_once_with()
def get_installation_specs_groups_test(self):
"""Test the get_installation_specs function with groups."""
data = PackagesSelectionData()
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 test_get_installation_specs_packages(self):
"""Test the get_installation_specs function with packages."""
data = PackagesSelectionData()
data.packages = ["p1", "p2", "p3"]
data.excluded_packages = ["p4", "p5", "p6"]
assert get_installation_specs(data) == (["@core", "p1", "p2",
"p3"], ["p4", "p5", "p6"])
def get_installation_specs_packages_test(self):
"""Test the get_installation_specs function with packages."""
data = PackagesSelectionData()
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 get_selection_data(self) -> PackagesSelectionData:
"""Generate the selection data.
:return: a packages selection data
"""
selection = PackagesSelectionData()
selection.environment = self.environment
selection.groups = self.groups
return selection
def test_apply_selection_data(self):
"""Test the apply_selection_data method."""
selection = PackagesSelectionData()
selection.environment = "e1"
selection.groups = ["g1", "g2", "g3"]
self.cache.apply_selection_data(selection)
assert self.cache.environment == "e1"
assert self.cache.groups == ["g1", "g2", "g3"]
def apply_selection_data_test(self):
"""Test the apply_selection_data method."""
selection = PackagesSelectionData()
selection.environment = "e1"
selection.groups = ["g1", "g2", "g3"]
self.cache.apply_selection_data(selection)
self.assertEqual(self.cache.environment, "e1")
self.assertEqual(self.cache.groups, ["g1", "g2", "g3"])
def packages_selection_data_test(self):
"""Test the PackagesSelectionData structure."""
data = PackagesSelectionData.to_structure(
PackagesSelectionData()
)
self._check_dbus_property(
"PackagesSelection",
data
)
def test_evaluation_package_rules(proxy_getter, rule_data, ksdata_mock, storage_mock):
rule_data.new_rule("package --add=firewalld --remove=telnet --add=vim")
packages_data = PackagesSelectionData()
packages_data.packages = ["vim"]
dnf_payload_mock = PAYLOADS.get_proxy("/fake/payload/1")
dnf_payload_mock.PackagesSelection = PackagesSelectionData.to_structure(packages_data)
messages = rule_data.eval_rules(ksdata_mock, storage_mock)
# one info message for each (really) added/removed package
assert len(messages) == 2
assert all(message.type == common.MESSAGE_TYPE_INFO for message in messages)
# all packages should appear in the messages
not_seen = _quoted_keywords_not_seen_in_messages(
{"firewalld", "telnet"},
messages,
)
assert not not_seen
packages_data = PackagesSelectionData()
packages_data.packages = ["vim", "firewalld"]
packages_data.excluded_packages = ["telnet"]
assert dnf_payload_mock.PackagesSelection == \
PackagesSelectionData.to_structure(packages_data)
def test_apply_selection_data_invalid_groups(self):
"""Test the apply_selection_data method with invalid groups."""
self.dnf_manager.resolve_group.return_value = False
selection = PackagesSelectionData()
selection.environment = "e1"
selection.groups = ["g1", "g2", "g3"]
self.cache.apply_selection_data(selection)
assert self.cache.environment == "e1"
assert self.cache.groups == []
def test_apply_selection_data_default_environment(self):
"""Test the apply_selection_data method with a default environment."""
self.dnf_manager.default_environment = "e1"
self.dnf_manager.resolve_environment.return_value = False
selection = PackagesSelectionData()
selection.environment = "e2"
self.cache.apply_selection_data(selection)
self.assertEqual(self.cache.environment, "e1")
self.assertEqual(self.cache.groups, [])
def test_apply_selection_data_invalid_environment(self):
"""Test the apply_selection_data method with an invalid environment."""
self.dnf_manager.default_environment = ""
self.dnf_manager.resolve_environment.return_value = False
selection = PackagesSelectionData()
selection.environment = "e2"
self.cache.apply_selection_data(selection)
assert self.cache.environment == ""
assert self.cache.groups == []
def get_packages_data() -> PackagesSelectionData:
"""Get the DBus data with the packages configuration.
:return: a packages configuration
"""
payload_proxy = get_payload_proxy()
if payload_proxy.Type != PAYLOAD_TYPE_DNF:
return PackagesSelectionData()
return PackagesSelectionData.from_structure(
payload_proxy.PackagesSelection)
def test_get_selection_data(self):
"""Test the get_selection_data method."""
self.cache.select_environment("e1")
self.cache.select_group("g1")
self.cache.select_group("g2")
self.cache.select_group("g3")
expected = PackagesSelectionData()
expected.environment = "e1"
expected.groups = ["g1", "g2", "g3"]
data = self.cache.get_selection_data()
assert compare_data(data, expected)
def test_get_installation_specs_environment(self):
"""Test the get_installation_specs function with environment."""
data = PackagesSelectionData()
data.environment = "environment-1"
assert get_installation_specs(data) == (["@environment-1",
"@core"], [])
env = "environment-2"
assert get_installation_specs(
data, default_environment=env) == (["@environment-1", "@core"], [])
data.default_environment_enabled = True
assert get_installation_specs(
data, default_environment=env) == (["@environment-2", "@core"], [])
def get_installation_specs_environment_test(self):
"""Test the get_installation_specs function with environment."""
data = PackagesSelectionData()
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 test_fail(self, kernel_getter, req_getter1, req_getter2, req_getter3, req_getter4):
"""Test the failed ResolvePackagesTask task."""
kernel_getter.return_value = None
req_getter1.return_value = []
req_getter2.return_value = []
req_getter3.return_value = []
req_getter4.return_value = []
selection = PackagesSelectionData()
dnf_manager = Mock()
dnf_manager.default_environment = None
dnf_manager.disable_modules.side_effect = MissingSpecsError("e1")
dnf_manager.apply_specs.side_effect = MissingSpecsError("e2")
with pytest.raises(NonCriticalInstallationError) as cm:
task = ResolvePackagesTask(dnf_manager, selection)
task.run()
expected = "e1\n\ne2"
assert str(cm.value) == expected
dnf_manager.enable_modules.side_effect = BrokenSpecsError("e3")
dnf_manager.resolve_selection.side_effect = InvalidSelectionError("e4")
with pytest.raises(PayloadInstallationError) as cm:
task = ResolvePackagesTask(dnf_manager, selection)
task.run()
expected = "e3\n\ne4"
assert str(cm.value) == expected
def PackagesSelection(self, data: Structure):
"""Set the packages selection.
:param: a structure of the type PackagesSelectionData
"""
self.implementation.set_packages_selection(
PackagesSelectionData.from_structure(data))
def PackagesSelection(self) -> Structure:
"""The packages selection.
:return: a structure of the type PackagesSelectionData
"""
return PackagesSelectionData.to_structure(
self.implementation.packages_selection)
def _process_kickstart_packages_selection(self, data):
"""Process the kickstart packages selection."""
selection = PackagesSelectionData()
selection.core_group_enabled = not data.packages.nocore
selection.default_environment_enabled = data.packages.default
if data.packages.environment is not None:
selection.environment = data.packages.environment
selection.packages = data.packages.packageList
selection.excluded_packages = data.packages.excludedList
for group in data.packages.groupList:
selection.groups.append(group.name)
if group.include == GROUP_ALL:
selection.groups_package_types[
group.name] = GROUP_PACKAGE_TYPES_ALL
if group.include == GROUP_REQUIRED:
selection.groups_package_types[
group.name] = GROUP_PACKAGE_TYPES_REQUIRED
for group in data.packages.excludedGroupList:
selection.excluded_groups.append(group.name)
self.set_packages_selection(selection)
self.set_packages_kickstarted(data.packages.seen)
def __init__(self):
super().__init__()
self._packages_configuration = PackagesConfigurationData()
self.packages_configuration_changed = Signal()
self._packages_selection = PackagesSelectionData()
self.packages_selection_changed = Signal()
self._packages_kickstarted = False
def check_no_selection_test(self, kernel_getter):
kernel_getter.return_value = None
dnf_manager = Mock()
dnf_manager.default_environment = None
selection = PackagesSelectionData()
selection.default_environment_enabled = False
selection.core_group_enabled = False
task = CheckPackagesSelectionTask(dnf_manager, selection)
report = task.run()
dnf_manager.clear_selection.assert_called_once_with()
dnf_manager.disable_modules.assert_called_once_with([])
dnf_manager.enable_modules.assert_called_once_with([])
dnf_manager.apply_specs.assert_called_once_with([], ["@core"])
dnf_manager.resolve_selection.assert_called_once_with()
self.assertEqual(report.get_messages(), [])
def test_check_default_selection(self, kernel_getter):
kernel_getter.return_value = "kernel"
dnf_manager = Mock()
dnf_manager.default_environment = "environment"
selection = PackagesSelectionData()
selection.default_environment_enabled = True
selection.core_group_enabled = True
task = CheckPackagesSelectionTask(dnf_manager, selection)
report = task.run()
dnf_manager.clear_selection.assert_called_once_with()
dnf_manager.disable_modules.assert_called_once_with([])
dnf_manager.enable_modules.assert_called_once_with([])
dnf_manager.apply_specs.assert_called_once_with(
["@environment", "@core", "kernel"], [])
dnf_manager.resolve_selection.assert_called_once_with()
self.assertEqual(report.get_messages(), [])
def set_dbus_defaults():
boss = BOSS.get_proxy()
boss.GetModules.return_value = [
KDUMP.service_name
]
kdump = KDUMP.get_proxy()
kdump.KdumpEnabled = True
user_interface = BOSS.get_proxy(USER_INTERFACE)
user_interface.PasswordPolicies = {}
network = NETWORK.get_proxy()
network.Connected.return_value = True
firewall = NETWORK.get_proxy(FIREWALL)
firewall.EnabledServices = []
firewall.DisabledServices = []
firewall.EnabledPorts = []
firewall.Trusts = []
device_tree = STORAGE.get_proxy(DEVICE_TREE)
device_tree.GetDeviceMountOptions.return_value = "defaults"
device_tree.GetMountPoints.return_value = {}
bootloader = STORAGE.get_proxy(BOOTLOADER)
bootloader.IsPasswordSet = False
users = USERS.get_proxy()
users.IsRootPasswordSet = True
users.IsRootPasswordCrypted = False
users.RootPassword = "******"
payloads = PAYLOADS.get_proxy()
payloads.ActivePayload = "/fake/payload/1"
dnf_payload = PAYLOADS.get_proxy("/fake/payload/1")
dnf_payload.Type = PAYLOAD_TYPE_DNF
packages_data = PackagesSelectionData()
dnf_payload.PackagesSelection = PackagesSelectionData.to_structure(packages_data)
def test_revert_package_rules(proxy_getter, rule_data, ksdata_mock, storage_mock):
rule_data.new_rule("package --add=firewalld --remove=telnet --add=iptables --add=vim")
packages_data = PackagesSelectionData()
packages_data.packages = ["vim"]
dnf_payload_mock = PAYLOADS.get_proxy("/fake/payload/1")
dnf_payload_mock.PackagesSelection = PackagesSelectionData.to_structure(packages_data)
# run twice --> nothing should be different in the second run
messages = rule_data.eval_rules(ksdata_mock, storage_mock)
messages = rule_data.eval_rules(ksdata_mock, storage_mock)
# one info message for each added/removed package
assert len(messages) == 3
rule_data.revert_changes(ksdata_mock, storage_mock)
# (only) added and excluded packages should have been removed from the
# list
assert dnf_payload_mock.PackagesSelection == \
PackagesSelectionData.to_structure(packages_data)
# now do the same again #
messages = rule_data.eval_rules(ksdata_mock, storage_mock)
# one info message for each added/removed package
assert len(messages) == 3
rule_data.revert_changes(ksdata_mock, storage_mock)
# (only) added and excluded packages should have been removed from the
# list
assert dnf_payload_mock.PackagesSelection == \
PackagesSelectionData.to_structure(packages_data)
def test_get_software_selection_status(self):
"""Test the get_software_selection_status function."""
selection = PackagesSelectionData()
selection.environment = "e1"
environment_data = CompsEnvironmentData()
environment_data.name = "The e1 environment"
dnf_manager = Mock(spec=DNFManager)
dnf_manager.is_environment_valid.return_value = True
dnf_manager.get_environment_data.return_value = environment_data
status = get_software_selection_status(dnf_manager, selection)
assert status == "The e1 environment"
status = get_software_selection_status(dnf_manager,
selection,
kickstarted=True)
assert status == "The e1 environment"
dnf_manager.is_environment_valid.return_value = False
status = get_software_selection_status(dnf_manager, selection)
assert status == "Selected environment is not valid"
status = get_software_selection_status(dnf_manager,
selection,
kickstarted=True)
assert status == "Invalid environment specified in kickstart"
selection.environment = ""
status = get_software_selection_status(dnf_manager, selection)
assert status == "Please confirm software selection"
status = get_software_selection_status(dnf_manager,
selection,
kickstarted=True)
assert status == "Custom software selected"
def test_evaluation_package_rules_report_only(proxy_getter, rule_data, ksdata_mock, storage_mock):
rule_data.new_rule("package --add=firewalld --remove=telnet --add=iptables")
messages = rule_data.eval_rules(ksdata_mock, storage_mock, report_only=True)
# one info message for each added/removed package
assert len(messages) == 3
assert all(message.type == common.MESSAGE_TYPE_INFO for message in messages)
not_seen = _quoted_keywords_not_seen_in_messages(
{"firewalld", "telnet", "iptables"},
messages,
)
assert not not_seen
# report_only --> no packages should be added or excluded
dnf_payload_mock = PAYLOADS.get_proxy("/fake/payload/1")
packages_data = PackagesSelectionData()
assert dnf_payload_mock.PackagesSelection == \
PackagesSelectionData.to_structure(packages_data)
