def test_set_up_installation_sources_task(self, publisher): """Test Live OS is able to create a set up installation sources task.""" self._prepare_and_use_source() task_path = self.live_os_interface.SetUpSourcesWithTask() check_task_creation(self, task_path, publisher, SetUpSourcesTask)
def test_tear_down_installation_source_task(self, publisher): """Test Live OS is able to create a tear down installation sources task.""" self._prepare_and_use_source() task_path = self.live_os_interface.TearDownSourcesWithTask() check_task_creation(self, task_path, publisher, TearDownSourcesTask)
def test_configure_fips_with_task(self, publisher): """Test the ConfigureFIPSWithTask method.""" task_path = self.security_interface.ConfigureFIPSWithTask() obj = check_task_creation(self, task_path, publisher, ConfigureFIPSTask) self.assertEqual(obj.implementation._sysroot, "/mnt/sysroot") self.assertEqual(obj.implementation._fips_enabled, False)
def test_discover_with_task(self, publisher): """Test DiscoverWithTask.""" task_path = self.dasd_interface.DiscoverWithTask("0.0.A100") obj = check_task_creation(task_path, publisher, DASDDiscoverTask) assert obj.implementation._device_number == "0.0.A100"
def test_realm_join_default(self, publisher): """Test module in default state with realm join task.""" realm_join_task_path = self.security_interface.JoinRealmWithTask() obj = check_task_creation(self, realm_join_task_path, publisher, RealmJoinTask) self.assertEqual(obj.implementation._realm_data.discovered, False) self.assertEqual(obj.implementation._realm_data.name, "") self.assertEqual(obj.implementation._realm_data.join_options, [])
def test_validate_with_task(self, publisher): """Test ValidateWithTask.""" self.module.on_storage_changed(Mock()) task_path = self.interface.ValidateWithTask() obj = check_task_creation(task_path, publisher, StorageValidateTask) assert obj.implementation._storage == self.module.storage report = ValidationReport() report.error_messages = [ "Something is wrong.", "Something is very wrong." ] report.warning_messages = ["Something might be wrong."] obj.implementation._set_result(report) result = obj.GetResult() expected_result = get_variant( Structure, { "error-messages": get_variant( List[Str], ["Something is wrong.", "Something is very wrong."]), "warning-messages": get_variant(List[Str], ["Something might be wrong."]) }) assert isinstance(result, Variant) assert get_native(result) == get_native(expected_result) assert result.equal(expected_result)
def test_finish_installation_with_tasks(self, publisher): """Test FinishInstallationWithTasks.""" task_list = self.interface.FinishInstallationWithTasks() assert len(task_list) == 2 task_path = task_list[0] task_proxy = check_task_creation(task_path, publisher, SetContextsTask, 0) task = task_proxy.implementation assert task.name == "Set file contexts" task_path = task_list[1] task_proxy = check_task_creation(task_path, publisher, CopyLogsTask, 1) task = task_proxy.implementation assert task.name == "Copy installation logs"
def test_preconfigure_fips_with_task(self, publisher): """Test the PreconfigureFIPSWithTask method.""" task_path = self.security_interface.PreconfigureFIPSWithTask(PAYLOAD_TYPE_DNF) obj = check_task_creation(task_path, publisher, PreconfigureFIPSTask) assert obj.implementation._sysroot == "/mnt/sysroot" assert obj.implementation._payload_type == PAYLOAD_TYPE_DNF assert obj.implementation._fips_enabled is False
def test_find_devices_with_task(self, publisher): """Test FindDevicesWithTask.""" task_path = self.interface.FindDevicesWithTask() obj = check_task_creation(self, task_path, publisher, FindDevicesTask) self.assertEqual(obj.implementation._devicetree, self.module.storage.devicetree)
def test_realm_data_propagation(self, publisher): """Test that realm data changes propagate to realm join task.""" # We connect to the realm_changed signal and update the realm data holder # in the realm join task when the signal is triggered. realm1 = RealmData() realm1.name = "domain.example.com" realm1.discover_options = ["--client-software=sssd"] realm1.discovered = False self.security_interface.SetRealm(RealmData.to_structure(realm1)) realm_join_task_path = self.security_interface.JoinRealmWithTask() # realm join - after task creation obj = check_task_creation(realm_join_task_path, publisher, RealmJoinTask) assert obj.implementation._realm_data.discovered is False assert obj.implementation._realm_data.name == "domain.example.com" assert obj.implementation._realm_data.join_options == [] # change realm data and check the changes propagate to the realm join task realm2 = RealmData() realm2.name = "domain.example.com" realm2.discover_options = ["--client-software=sssd"] realm2.join_options = ["--one-time-password=password"] realm2.discovered = True self.security_interface.SetRealm(RealmData.to_structure(realm2)) # realm join - after realm data update assert obj.implementation._realm_data.discovered is True assert obj.implementation._realm_data.name == "domain.example.com" assert obj.implementation._realm_data.join_options == [ "--one-time-password=password" ]
def test_realm_join_default(self, publisher): """Test module in default state with realm join task.""" realm_join_task_path = self.security_interface.JoinRealmWithTask() obj = check_task_creation(realm_join_task_path, publisher, RealmJoinTask) assert obj.implementation._realm_data.discovered is False assert obj.implementation._realm_data.name == "" assert obj.implementation._realm_data.join_options == []
def test_tear_down_sources_with_task(self, publisher): """Test TearDownSourcesWithTask.""" source = SourceFactory.create_source(SourceType.CDROM) self.module.add_source(source) task_path = self.interface.TearDownSourcesWithTask() obj = check_task_creation(task_path, publisher, TearDownSourcesTask) assert obj.implementation._sources == [source]
def test_format_with_task(self, publisher): """Test the discover task.""" task_path = self.dasd_interface.FormatWithTask( ["/dev/sda", "/dev/sdb"]) obj = check_task_creation(task_path, publisher, DASDFormatTask) assert obj.implementation._dasds == ["/dev/sda", "/dev/sdb"]
def test_realm_discover_default(self, publisher): """Test module in default state with realm discover task.""" realm_discover_task_path = self.security_interface.DiscoverRealmWithTask( ) obj = check_task_creation(realm_discover_task_path, publisher, RealmDiscoverTask) assert obj.implementation._realm_data.name == "" assert obj.implementation._realm_data.discover_options == []
def test_set_up_sources_with_task(self, publisher): """Test SetUpSourcesWithTask.""" source = SourceFactory.create_source(SourceType.CDROM) self.module.add_source(source) task_path = self.interface.SetUpSourcesWithTask() obj = check_task_creation(self, task_path, publisher, SetUpSourcesTask) self.assertEqual(obj.implementation._sources, [source])
def test_configure_with_task(self, publisher): """Test ConfigureWithTask.""" self.module.on_storage_changed(Mock()) task_path = self.interface.ConfigureWithTask() obj = check_task_creation(task_path, publisher, ManualPartitioningTask) assert obj.implementation._storage == self.module.storage assert obj.implementation._requests == self.module.requests
def test_install_with_tasks(self, publisher): """Test CopyLogsWithTask.""" task_path = self.interface.CopyLogsWithTask() task_proxy = check_task_creation(task_path, publisher, CopyLogsTask) task = task_proxy.implementation assert task.name == "Copy installation logs" task = self.module.copy_logs_with_task() assert task.name == "Copy installation logs"
def test_configure_with_task(self, publisher): """Test ConfigureWithTask.""" self.module.on_storage_changed(create_storage()) task_path = self.interface.ConfigureWithTask() obj = check_task_creation(self, task_path, publisher, InteractivePartitioningTask) self.assertEqual(obj.implementation._storage, self.module.storage)
def test_configure_with_task(self, publisher): """Test ConfigureWithTask.""" self.module.on_storage_changed(Mock()) self.module.process_kickstart(Mock()) task_path = self.interface.ConfigureWithTask() obj = check_task_creation(task_path, publisher, CustomPartitioningTask) assert obj.implementation._storage == self.module.storage
def test_populate_missing_keyboard_configuration_with_task(self, publisher): """Test PopulateMissingKeyboardConfigurationWithTask.""" self.localization_interface.SetVirtualConsoleKeymap('us') self.localization_interface.SetXLayouts(['cz', 'cz (qwerty)']) task_path = self.localization_interface.PopulateMissingKeyboardConfigurationWithTask() obj = check_task_creation(task_path, publisher, GetMissingKeyboardConfigurationTask) assert obj.implementation._vc_keymap == 'us' assert obj.implementation._x_layouts == ['cz', 'cz (qwerty)']
def test_mount_existing_system_with_task(self, publisher): """Test MountExistingSystemWithTask.""" self._add_device(StorageDevice("dev1", fmt=get_format("ext4"))) task_path = self.interface.MountExistingSystemWithTask("dev1", True) obj = check_task_creation(self, task_path, publisher, MountExistingSystemTask) self.assertEqual(obj.implementation._storage, self.module.storage) self.assertEqual(obj.implementation._device.name, "dev1") self.assertEqual(obj.implementation._read_only, True)
def test_apply_keyboard_with_task(self, publisher): """Test ApplyKeyboardWithTask.""" self.localization_interface.SetVirtualConsoleKeymap('us') self.localization_interface.SetXLayouts(['cz', 'cz (qwerty)']) self.localization_interface.SetLayoutSwitchOptions(["grp:alt_shift_toggle"]) task_path = self.localization_interface.ApplyKeyboardWithTask() obj = check_task_creation(task_path, publisher, ApplyKeyboardTask) assert obj.implementation._vc_keymap == 'us' assert obj.implementation._x_layouts == ['cz', 'cz (qwerty)'] assert obj.implementation._switch_options == ["grp:alt_shift_toggle"]
def test_realm_discover_configured(self, publisher): """Test module in configured state with realm discover task.""" realm = RealmData() realm.name = "domain.example.com" realm.discover_options = ["--client-software=sssd"] self.security_interface.SetRealm(RealmData.to_structure(realm)) realm_discover_task_path = self.security_interface.DiscoverRealmWithTask() obj = check_task_creation(realm_discover_task_path, publisher, RealmDiscoverTask) assert obj.implementation._realm_data.name == "domain.example.com" assert obj.implementation._realm_data.discover_options == ["--client-software=sssd"]
def test_find_existing_systems_with_task(self, publisher): """Test FindExistingSystemsWithTask.""" task_path = self.interface.FindExistingSystemsWithTask() obj = check_task_creation(self, task_path, publisher, FindExistingSystemsTask) self.assertEqual(obj.implementation._devicetree, self.module.storage.devicetree) roots = [Root(name="My Linux")] obj.implementation._set_result(roots) obj.implementation.succeeded_signal.emit() self.assertEqual(self.storage.roots, roots)
def test_login_with_task(self, publisher): """Test the login task.""" task_path = self.iscsi_interface.LoginWithTask( Portal.to_structure(self._portal), Credentials.to_structure(self._credentials), Node.to_structure(self._node), ) obj = check_task_creation(task_path, publisher, ISCSILoginTask) assert obj.implementation._portal == self._portal assert obj.implementation._credentials == self._credentials assert obj.implementation._node == self._node
def test_start_modules_with_task(self, publisher): """Test StartModulesWithTask.""" task_path = self.interface.StartModulesWithTask() task_proxy = check_task_creation(task_path, publisher, StartModulesTask) task = task_proxy.implementation callback = Mock() self.module._module_manager.module_observers_changed.connect(callback) observers = [Mock(), Mock(), Mock()] task._set_result(observers) task.succeeded_signal.emit() callback.assert_called_once_with(observers)
def test_discover_with_task(self, publisher): """Test the discover task.""" task_path = self.fcoe_interface.DiscoverWithTask( "eth0", # nic False, # dcb True # auto_vlan ) obj = check_task_creation(task_path, publisher, FCOEDiscoverTask) assert obj.implementation._nic == "eth0" assert obj.implementation._dcb is False assert obj.implementation._auto_vlan is True
def test_create_with_task(self, publisher): """Test CreateWithTask.""" with pytest.raises(UnavailableStorageError): self.interface.CreateWithTask(SNAPSHOT_WHEN_PRE_INSTALL) self.module.on_storage_changed(Mock()) task_path = self.interface.CreateWithTask(SNAPSHOT_WHEN_PRE_INSTALL) obj = check_task_creation(task_path, publisher, SnapshotCreateTask) assert obj.implementation._storage == self.module.storage assert obj.implementation._requests == [] assert obj.implementation._when == SNAPSHOT_WHEN_PRE_INSTALL
def test_discover_with_task(self, publisher): """Test the discover task.""" task_path = self.fcoe_interface.DiscoverWithTask( "eth0", # nic False, # dcb True # auto_vlan ) obj = check_task_creation(self, task_path, publisher, FCOEDiscoverTask) self.assertEqual(obj.implementation._nic, "eth0") self.assertEqual(obj.implementation._dcb, False) self.assertEqual(obj.implementation._auto_vlan, True)
def test_discover_with_task(self, publisher): """Test the discover task.""" task_path = self.zfcp_interface.DiscoverWithTask( "0.0.fc00", "0x5105074308c212e9", "0x401040a000000000" ) obj = check_task_creation(task_path, publisher, ZFCPDiscoverTask) assert obj.implementation._device_number == "0.0.fc00" assert obj.implementation._wwpn == "0x5105074308c212e9" assert obj.implementation._lun == "0x401040a000000000"