def run(self):
"""Change a device in the device tree.
:raise: StorageConfigurationError if the device cannot be changed
"""
log.debug("Change device: %s", self._request)
# Nothing to do. Skip.
if compare_data(self._request, self._original_request):
log.debug("Nothing to change.")
return
try:
# Change the container.
self._rename_container()
# Change or replace the device.
if not self._device.raw_device.exists:
self._replace_device()
else:
self._change_device()
except StorageError as e:
log.error("Failed to change a device: %s", e)
raise StorageConfigurationError(str(e)) from e
def run(self):
"""Change a device in the device tree.
:raise: StorageConfigurationError if the device cannot be changed
"""
log.debug("Change device: %s", self._request)
# Nothing to do. Skip.
if compare_data(self._request, self._original_request):
log.debug("Nothing to change.")
return
try:
# Change the container.
self._rename_container()
# Change or replace the device.
if not self._device.raw_device.exists:
self._replace_device()
else:
self._change_device()
except InconsistentPVSectorSize as e:
self._handle_storage_error(
e, "\n\n".join([
_("Failed to change a device."),
str(e).strip(),
_(INCONSISTENT_SECTOR_SIZES_SUGGESTIONS)
]))
except StorageError as e:
self._handle_storage_error(e, str(e))
def test_install_with_tasks_configured(self, publisher):
"""Test install tasks - module in configured state."""
self.timezone_interface.SetIsUTC(True)
self.timezone_interface.SetTimezone("Asia/Tokyo")
self.timezone_interface.SetNTPEnabled(False)
# --nontp and --ntpservers are mutually exclusive in kicstart but
# there is no such enforcement in the module so for testing this is ok
server = TimeSourceData()
server.type = TIME_SOURCE_SERVER
server.hostname = "clock1.example.com"
server.options = ["iburst"]
pool = TimeSourceData()
pool.type = TIME_SOURCE_POOL
pool.hostname = "clock2.example.com"
self.timezone_interface.SetTimeSources(
TimeSourceData.to_structure_list([server, pool])
)
task_classes = [
ConfigureHardwareClockTask,
ConfigureTimezoneTask,
ConfigureNTPTask,
]
task_paths = self.timezone_interface.InstallWithTasks()
task_objs = check_task_creation_list(task_paths, publisher, task_classes)
# ConfigureHardwareClockTask
obj = task_objs[0]
assert obj.implementation._is_utc is True
# ConfigureTimezoneTask
obj = task_objs[1]
assert obj.implementation._timezone == "Asia/Tokyo"
assert obj.implementation._is_utc is True
# ConfigureNTPTask
obj = task_objs[2]
assert obj.implementation._ntp_enabled is False
assert len(obj.implementation._ntp_servers) == 2
assert compare_data(obj.implementation._ntp_servers[0], server)
assert compare_data(obj.implementation._ntp_servers[1], pool)
def test_get_default_user(self):
"""Test that default user is correctly added by get_user_list()."""
users_module_mock = Mock()
users_module_mock.Users = []
user_data_list = get_user_list(users_module_mock, add_default=True)
assert len(user_data_list) == 1
assert isinstance(user_data_list[0], UserData)
assert compare_data(user_data_list[0], UserData())
def get_default_user_test(self):
"""Test that default user is correctly added by get_user_list()."""
users_module_mock = Mock()
users_module_mock.Users = []
user_data_list = get_user_list(users_module_mock, add_default=True)
self.assertEqual(len(user_data_list), 1)
self.assertIsInstance(user_data_list[0], UserData)
self.assertTrue(compare_data(user_data_list[0], UserData()))
def test_get_user_list(self):
"""Test the shared get_user_list() method."""
user1 = UserData()
user1.name = "user1"
user1.uid = 123
user1.groups = ["foo", "bar"]
user1.gid = 321
user1.homedir = "user1_home"
user1.password = "******"
user1.is_crypted = False
user1.lock = False
user1.shell = "zsh"
user1.gecos = "some stuff"
user2 = UserData()
user2.name = "user2"
user2.uid = 456
user2.groups = ["baz", "bar"]
user2.gid = 654
user2.homedir = "user2_home"
user2.password = "******"
user2.is_crypted = True
user2.lock = False
user2.shell = "csh"
user2.gecos = "some other stuff"
users_module_mock = Mock()
users_module_mock.Users = UserData.to_structure_list([user1, user2])
user_data_list = get_user_list(users_module_mock)
assert len(user_data_list) == 2
assert isinstance(user_data_list[0], UserData)
assert isinstance(user_data_list[1], UserData)
assert compare_data(user_data_list[0], user1)
assert compare_data(user_data_list[1], user2)
user_data_list = get_user_list(users_module_mock, add_default=True)
assert len(user_data_list) == 2
assert isinstance(user_data_list[0], UserData)
assert isinstance(user_data_list[1], UserData)
assert compare_data(user_data_list[0], user1)
assert compare_data(user_data_list[1], user2)
user_data_list = get_user_list(users_module_mock,
add_default=True,
add_if_not_empty=True)
default_added_user_data = UserData()
default_added_user_data.set_admin_priviledges(True)
assert len(user_data_list) == 3
assert isinstance(user_data_list[0], UserData)
assert isinstance(user_data_list[1], UserData)
assert isinstance(user_data_list[2], UserData)
assert compare_data(user_data_list[0], default_added_user_data)
assert compare_data(user_data_list[1], user1)
assert compare_data(user_data_list[2], user2)
def test_get_group_data(self):
"""Test the get_group_data method."""
self._add_group("g1")
expected = CompsGroupData()
expected.id = "g1"
expected.name = "The 'g1' group"
expected.description = "This is the 'g1' group."
data = self.dnf_manager.get_group_data("g1")
assert isinstance(data, CompsGroupData)
assert compare_data(data, expected)
def default_password_policies_test(self):
"""Test the password policies property."""
policies = PasswordPolicy.from_structure_dict(
self.interface.PasswordPolicies)
expected_names = {"root", "user", "luks"}
self.assertEqual(policies.keys(), expected_names)
for name in expected_names:
policy = policies[name]
expected_policy = PasswordPolicy.from_defaults(name)
self.assertTrue(compare_data(policy, expected_policy))
def test_get_environment_data(self):
"""Test the get_environment_data method."""
self._add_environment("e1")
expected = CompsEnvironmentData()
expected.id = "e1"
expected.name = "The 'e1' environment"
expected.description = "This is the 'e1' environment."
data = self.dnf_manager.get_environment_data("e1")
assert isinstance(data, CompsEnvironmentData)
assert compare_data(data, expected)
def test_default_password_policies(self):
"""Test the password policies property."""
policies = PasswordPolicy.from_structure_dict(
self.interface.PasswordPolicies)
expected_names = {"root", "user", "luks"}
assert policies.keys() == expected_names
for name in expected_names:
policy = policies[name]
expected_policy = PasswordPolicy.from_defaults(name)
assert compare_data(policy, expected_policy)
def get_user_list_test(self):
"""Test the shared get_user_list() method."""
user1 = UserData()
user1.name = "user1"
user1.uid = 123
user1.groups = ["foo", "bar"]
user1.gid = 321
user1.homedir = "user1_home"
user1.password = "******"
user1.is_crypted = False
user1.lock = False
user1.shell = "zsh"
user1.gecos = "some stuff"
user2 = UserData()
user2.name = "user2"
user2.uid = 456
user2.groups = ["baz", "bar"]
user2.gid = 654
user2.homedir = "user2_home"
user2.password = "******"
user2.is_crypted = True
user2.lock = False
user2.shell = "csh"
user2.gecos = "some other stuff"
users_module_mock = Mock()
users_module_mock.Users = UserData.to_structure_list([user1, user2])
user_data_list = get_user_list(users_module_mock)
self.assertEqual(len(user_data_list), 2)
self.assertIsInstance(user_data_list[0], UserData)
self.assertIsInstance(user_data_list[1], UserData)
self.assertTrue(compare_data(user_data_list[0], user1))
self.assertTrue(compare_data(user_data_list[1], user2))
user_data_list = get_user_list(users_module_mock, add_default=True)
self.assertEqual(len(user_data_list), 2)
self.assertIsInstance(user_data_list[0], UserData)
self.assertIsInstance(user_data_list[1], UserData)
self.assertTrue(compare_data(user_data_list[0], user1))
self.assertTrue(compare_data(user_data_list[1], user2))
user_data_list = get_user_list(users_module_mock,
add_default=True,
add_if_not_empty=True)
self.assertEqual(len(user_data_list), 3)
self.assertIsInstance(user_data_list[0], UserData)
self.assertIsInstance(user_data_list[1], UserData)
self.assertIsInstance(user_data_list[2], UserData)
self.assertTrue(compare_data(user_data_list[0], UserData()))
self.assertTrue(compare_data(user_data_list[1], user1))
self.assertTrue(compare_data(user_data_list[2], user2))
def reset_device_factory_request_test(self):
"""Test reset_container_data."""
default = DeviceFactoryRequest()
request = DeviceFactoryRequest()
request.container_spec = "dev1"
request.container_name = "dev1"
request.container_size_policy = 123
request.container_encrypted = True
request.container_raid_level = "raid1"
request.reset_container_data()
self.assertEqual(compare_data(request, default), True)
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 schedule_partitions_with_task_test(self, publisher):
"""Test SchedulePartitionsWithTask."""
self.module.on_storage_changed(Mock())
request = PartitioningRequest()
request.partitioning_scheme = AUTOPART_TYPE_PLAIN
task_path = self.interface.SchedulePartitionsWithTask(
PartitioningRequest.to_structure(request))
obj = check_task_creation(self, task_path, publisher,
InteractiveAutoPartitioningTask)
self.assertEqual(obj.implementation._storage, self.module.storage)
self.assertTrue(compare_data(obj.implementation._request, request))
def run(self):
"""Change a device in the device tree.
:raise: StorageError if the device cannot be changed
"""
log.debug("Change device: %s", self._request)
if compare_data(self._request, self._original_request):
log.debug("Nothing to change.")
return
if not self._device.raw_device.exists:
self._replace_device()
else:
self._change_device()
def test_compare_simple_structure(self):
data = self.SimpleData()
self.assertTrue(compare_data(data, data))
self.assertTrue(compare_data(data, self.SimpleData()))
self.assertFalse(compare_data(data, None))
self.assertFalse(compare_data(None, data))
self.assertTrue(compare_data(
self.SimpleData.from_structure({'x': get_variant(Int, 10)}),
self.SimpleData.from_structure({'x': get_variant(Int, 10)})
))
self.assertFalse(compare_data(
self.SimpleData.from_structure({'x': get_variant(Int, 10)}),
self.SimpleData.from_structure({'x': get_variant(Int, 9)})
))
def test_compare_complicated_structure(self):
self.assertTrue(compare_data(
self.ComplicatedData(),
self.ComplicatedData(),
))
self.assertFalse(compare_data(
self.ComplicatedData(),
self.SimpleData()
))
self.assertFalse(compare_data(
self.SimpleData(),
self.ComplicatedData()
))
self.assertTrue(compare_data(
self.ComplicatedData.from_structure(
{
'dictionary': get_variant(
Dict[Int, Str], {1: "1", 2: "2"}
),
'bool-list': get_variant(
List[Bool], [True, False, False]
),
'very-long-property-name': get_variant(
Str, "My String Value"
)
}
),
self.ComplicatedData.from_structure(
{
'dictionary': get_variant(
Dict[Int, Str], {1: "1", 2: "2"}
),
'bool-list': get_variant(
List[Bool], [True, False, False]
),
'very-long-property-name': get_variant(
Str, "My String Value"
)
}
)
))
self.assertFalse(compare_data(
self.ComplicatedData.from_structure(
{
'dictionary': get_variant(
Dict[Int, Str], {1: "1", 2: "2"}
),
'bool-list': get_variant(
List[Bool], [True, False, False]
),
'very-long-property-name': get_variant(
Str, "My String Value"
)
}
),
self.ComplicatedData.from_structure(
{
'dictionary': get_variant(
Dict[Int, Str], {1: "1", 2: "2"}
),
'bool-list': get_variant(
List[Bool], [True, False, True]
),
'very-long-property-name': get_variant(
Str, "My String Value"
)
}
)
))
