def test_generate_device_factory_permissions(self):
"""Test GenerateDeviceFactoryPermissions."""
dev1 = DiskDevice("dev1",
fmt=get_format("disklabel"),
size=Size("10 GiB"),
exists=True)
dev2 = PartitionDevice("dev2",
size=Size("5 GiB"),
parents=[dev1],
fmt=get_format("ext4",
mountpoint="/",
label="root"))
self._add_device(dev1)
self._add_device(dev2)
request = self.interface.GenerateDeviceFactoryRequest("dev1")
permissions = self.interface.GenerateDeviceFactoryPermissions(request)
assert get_native(permissions) == {
'mount-point': False,
'reformat': False,
'format-type': True,
'label': False,
'device-type': False,
'device-name': False,
'device-size': False,
'device-encrypted': True,
'device-raid-level': False,
'disks': False,
'container-spec': False,
'container-name': False,
'container-size-policy': False,
'container-encrypted': False,
'container-raid-level': False,
}
request = self.interface.GenerateDeviceFactoryRequest("dev2")
permissions = self.interface.GenerateDeviceFactoryPermissions(request)
assert get_native(permissions) == {
'mount-point': True,
'reformat': False,
'format-type': True,
'label': True,
'device-type': True,
'device-name': False,
'device-size': True,
'device-encrypted': True,
'device-raid-level': True,
'disks': True,
'container-spec': False,
'container-name': False,
'container-size-policy': False,
'container-encrypted': False,
'container-raid-level': False,
}
dev2.protected = True
permissions = self.interface.GenerateDeviceFactoryPermissions(request)
for value in get_native(permissions).values():
assert value is False
def test_get_native_complicated_structure(self):
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"
)
})
structure = self.ComplicatedData.to_structure(
data
)
dictionary = {
'dictionary': {1: "1", 2: "2"},
'bool-list': [True, False, False],
'very-long-property-name': "My String Value"
}
self.assertEqual(get_native(structure), dictionary)
self.assertEqual(get_native(dictionary), dictionary)
def collect_supported_systems_test(self, update_size_info):
"""Test CollectSupportedSystems."""
dev1 = DiskDevice("dev1", fmt=get_format("disklabel"))
dev2 = StorageDevice(
"dev2",
parents=[dev1],
fmt=get_format("ext4", mountpoint="/", exists=True),
)
dev3 = StorageDevice("dev3",
parents=[dev1],
fmt=get_format("swap", exists=True))
self._add_device(dev1)
self._add_device(dev2)
self._add_device(dev3)
self.storage.roots = [
Root(name="My Linux", mounts={"/": dev2}, swaps=[dev3])
]
os_data_list = self.interface.CollectSupportedSystems()
self.assertEqual(get_native(os_data_list), [{
'os-name': 'My Linux',
'mount-points': {
'/': 'dev2'
},
'swap-devices': ['dev3']
}])
def get_rhsm_config_defaults(self):
"""Return RHSM config default values.
We need to have these available in case the user decides
to return to default values from a custom value at
runtime.
This method is lazy evaluated, the first call it fetches
the full config dict from RHSM and subsequent calls are
then served from cache.
Due to this it is important not to set RHSM configuration
values before first calling this method to populate the cache
or else the method might return non-default (Anaconda overwritten)
data.
NOTE: While RHSM GetAll() DBus call returns a nested dictionary,
we turn it into a flat key/value dict, in the same format SetAll()
uses.
:return : dictionary of default RHSM configuration values
:rtype: dict
"""
if self._rhsm_config_defaults is None:
# config defaults cache not yet populated, do it now
proxy = self.rhsm_observer.get_proxy(RHSM_CONFIG)
# turn the variant into a dict with get_native()
nested_dict = get_native(proxy.GetAll(""))
# flatten the nested dict
flat_dict = self._flatten_rhsm_nested_dict(nested_dict)
self._rhsm_config_defaults = flat_dict
return self._rhsm_config_defaults
def generate_device_factory_request_test(self):
"""Test GenerateDeviceFactoryRequest."""
dev1 = DiskDevice("dev1")
dev2 = PartitionDevice("dev2",
size=Size("5 GiB"),
parents=[dev1],
fmt=get_format("ext4",
mountpoint="/",
label="root"))
self._add_device(dev1)
self._add_device(dev2)
request = self.interface.GenerateDeviceFactoryRequest("dev2")
self.assertEqual(
get_native(request), {
'device-spec': 'dev2',
'disks': ['dev1'],
'mount-point': '/',
'reformat': True,
'format-type': 'ext4',
'label': 'root',
'luks-version': '',
'device-type': DEVICE_TYPE_PARTITION,
'device-name': 'dev2',
'device-size': Size("5 GiB").get_bytes(),
'device-encrypted': False,
'device-raid-level': '',
'container-name': '',
'container-size-policy': SIZE_POLICY_AUTO,
'container-encrypted': False,
'container-raid-level': '',
})
def realm_property_test(self):
"""Test the realm property."""
realm_in = {
"name": "domain.example.com",
"discover-options": ["--client-software=sssd"],
"join-options": ["--one-time-password=password"],
"discovered": True
}
realm_out = {
"name":
get_variant(Str, "domain.example.com"),
"discover-options":
get_variant(List[Str], ["--client-software=sssd"]),
"join-options":
get_variant(List[Str], ["--one-time-password=password"]),
"discovered":
get_variant(Bool, True),
"required-packages":
get_variant(List[Str], [])
}
self.security_interface.SetRealm(realm_in)
self.assertEqual(realm_out, self.security_interface.Realm)
self.callback.assert_called_once_with(SECURITY.interface_name,
{'Realm': get_native(realm_out)},
[])
def test_generate_device_factory_permissions_btrfs(self):
"""Test GenerateDeviceFactoryPermissions with btrfs."""
dev1 = StorageDevice("dev1",
fmt=get_format("btrfs"),
size=Size("10 GiB"))
dev2 = BTRFSVolumeDevice("dev2", size=Size("5 GiB"), parents=[dev1])
self._add_device(dev1)
self._add_device(dev2)
# Make the btrfs format not mountable.
with patch.object(BTRFS,
"_mount_class",
return_value=Mock(available=False)):
request = self.interface.GenerateDeviceFactoryRequest(dev2.name)
permissions = self.interface.GenerateDeviceFactoryPermissions(
request)
assert get_native(permissions) == {
'mount-point': False,
'reformat': False,
'format-type': False,
'label': False,
'device-type': True,
'device-name': False,
'device-size': False,
'device-encrypted': False,
'device-raid-level': True,
'disks': False,
'container-spec': False,
'container-name': True,
'container-size-policy': True,
'container-encrypted': True,
'container-raid-level': True,
}
def run_network_initialization_task(task_path):
"""Run network initialization task and log the result."""
task_proxy = NETWORK.get_proxy(task_path)
log.debug("Running task %s", task_proxy.Name)
sync_run_task(task_proxy)
result = get_native(task_proxy.GetResult())
msg = "%s result: %s" % (task_proxy.Name, result)
log.debug(msg)
def generate_device_factory_permissions_test(self):
"""Test GenerateDeviceFactoryPermissions."""
dev1 = DiskDevice("dev1",
fmt=get_format("disklabel"),
size=Size("10 GiB"),
exists=True)
dev2 = PartitionDevice("dev2",
size=Size("5 GiB"),
parents=[dev1],
fmt=get_format("ext4",
mountpoint="/",
label="root"))
self._add_device(dev1)
self._add_device(dev2)
request = self.interface.GenerateDeviceFactoryRequest("dev1")
permissions = self.interface.GenerateDeviceFactoryPermissions(request)
self.assertEqual(
get_native(permissions), {
'mount-point': False,
'reformat': True,
'format-type': True,
'label': True,
'device-type': False,
'device-name': False,
'device-size': False,
'device-encrypted': True,
'device-raid-level': False,
})
request = self.interface.GenerateDeviceFactoryRequest("dev2")
permissions = self.interface.GenerateDeviceFactoryPermissions(request)
self.assertEqual(
get_native(permissions), {
'mount-point': True,
'reformat': False,
'format-type': True,
'label': True,
'device-type': True,
'device-name': False,
'device-size': True,
'device-encrypted': True,
'device-raid-level': True,
})
def _check_report(self, report, error_message=None):
"""Check the given validation report."""
errors = [error_message] if error_message else []
warnings = []
self.assertEqual(get_native(report), {
"error-messages": errors,
"warning-messages": warnings
})
def _test_native(self, variants, values):
"""Test native values of variants."""
for variant, value in zip(variants, values):
self.assertEqual(get_native(variant), value)
self.assertEqual(get_native(tuple(variants)), tuple(values))
self.assertEqual(get_native(list(variants)), list(values))
self.assertEqual(get_native(dict(enumerate(variants))),
dict(enumerate(values)))
variant = get_variant(Tuple[Variant, Variant, Variant, Variant],
tuple(variants))
self.assertEqual(unwrap_variant(variant), tuple(variants))
variant = get_variant(List[Variant], list(variants))
self.assertEqual(unwrap_variant(variant), list(variants))
variant = get_variant(Dict[Int, Variant], dict(enumerate(variants)))
self.assertEqual(unwrap_variant(variant), dict(enumerate(variants)))
def _test_variant(self, type_hint, expected_string, value):
"""Create a variant."""
# Create a variant from a type hint.
v1 = get_variant(type_hint, value)
self.assertTrue(isinstance(v1, Variant))
self.assertEqual(v1.format_string, expected_string)
self.assertEqual(v1.unpack(), value)
self.assertEqual(unwrap_variant(v1), value)
v2 = Variant(expected_string, value)
self.assertTrue(v2.equal(v1))
self.assertEqual(get_native(v1), value)
self.assertEqual(get_native(v1), get_native(v2))
self.assertEqual(get_native(value), value)
# Create a variant from a type string.
v3 = get_variant(expected_string, value)
self.assertTrue(isinstance(v3, Variant))
self.assertTrue(v2.equal(v3))
def generate_system_data_test(self):
"""Test GenerateSystemData."""
self._add_device(StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/boot")))
self._add_device(StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/")))
self._add_device(StorageDevice("dev3", fmt=get_format("swap")))
os_data = self.interface.GenerateSystemData("dev1")
self.assertEqual(get_native(os_data), {
'mount-points': {'/boot': 'dev1', '/': 'dev2'},
'os-name': 'New anaconda bluesky Installation',
'swap-devices': ['dev3']
})
def test_system_purpose_json_parsing(self):
"""Test the system purpose JSON parsing method of ParseAttachedSubscriptionsTask."""
parse_method = ParseAttachedSubscriptionsTask._parse_system_purpose_json
# the parsing method should be able to survive also getting an empty string
expected_struct = {"role": "", "sla": "", "usage": "", "addons": []}
struct = get_native(SystemPurposeData.to_structure(parse_method("")))
self.assertEqual(struct, expected_struct)
# try parsing expected complete system purpose data
system_purpose_dict = {
"role": "important",
"service_level_agreement": "it will work just fine",
"usage": "careful",
"addons": ["red", "green", "blue"]
}
system_purpose_json = json.dumps(system_purpose_dict)
expected_struct = {
"role": "important",
"sla": "it will work just fine",
"usage": "careful",
"addons": ["red", "green", "blue"]
}
struct = get_native(
SystemPurposeData.to_structure(parse_method(system_purpose_json)))
self.assertEqual(struct, expected_struct)
# try also partial parsing, just in case
system_purpose_dict = {
"role": "important",
"usage": "careful",
}
system_purpose_json = json.dumps(system_purpose_dict)
expected_struct = {
"role": "important",
"sla": "",
"usage": "careful",
"addons": []
}
struct = get_native(
SystemPurposeData.to_structure(parse_method(system_purpose_json)))
self.assertEqual(struct, expected_struct)
def subscription_json_parsing_test(self):
"""Test the subscription JSON parsing method of ParseAttachedSubscriptionsTask."""
parse_method = ParseAttachedSubscriptionsTask._parse_subscription_json
# the method should be able to survive the RHSM DBus API returning an empty string,
# as empty list of subscriptions is a lesser issue than crashed installation
self.assertEqual(parse_method(""), [])
# try parsing a json file containing two subscriptions
# - to make this look sane, we write it as a dict that we then convert to JSON
subscription_dict = {
"consumed": [{
"subscription_name": "Foo Bar Beta",
"service_level": "very good",
"sku": "ABC1234",
"contract": "12345678",
"starts": "05/12/20",
"ends": "05/12/21",
"quantity_used": "1"
}, {
"subscription_name": "Foo Bar Beta NG",
"service_level": "even better",
"sku": "ABC4321",
"contract": "87654321",
"starts": "now",
"ends": "never",
"quantity_used": "1000"
}]
}
subscription_json = json.dumps(subscription_dict)
expected_structs = [{
"name": "Foo Bar Beta",
"service-level": "very good",
"sku": "ABC1234",
"contract": "12345678",
"start-date": "May 12, 2020",
"end-date": "May 12, 2021",
"consumed-entitlement-count": 1
}, {
"name": "Foo Bar Beta NG",
"service-level": "even better",
"sku": "ABC4321",
"contract": "87654321",
"start-date": "now",
"end-date": "never",
"consumed-entitlement-count": 1000
}]
structs = get_native(
AttachedSubscription.to_structure_list(
parse_method(subscription_json)))
# check the content of the AttachedSubscription corresponds to the input JSON,
# including date formatting
self.assertEqual(structs, expected_structs)
def check_kickstart_interface(test,
interface,
ks_in,
ks_out=None,
ks_valid=True,
ks_tmp=None):
"""Test the parsing and generating of a kickstart module.
:param test: instance of TestCase
:param interface: instance of KickstartModuleInterface
:param ks_in: string with the input kickstart
:param ks_out: string with the output kickstart
:param ks_valid: True if the input kickstart is valid, otherwise False
:param ks_tmp: string with the temporary output kickstart
"""
callback = PropertiesChangedCallback()
interface.PropertiesChanged.connect(callback)
# Read a kickstart,
if ks_in is not None:
ks_in = dedent(ks_in).strip()
result = KickstartReport.from_structure(
get_native(interface.ReadKickstart(ks_in)))
test.assertEqual(ks_valid, result.is_valid())
if not ks_valid:
return
if ks_out is None:
return
# Generate a kickstart
ks_out = dedent(ks_out).strip()
test.assertEqual(ks_out, interface.GenerateKickstart().strip())
# Test the properties changed callback.
if ks_in is not None:
callback.assert_any_call(KICKSTART_MODULE.interface_name,
{'Kickstarted': True}, [])
else:
test.assertEqual(interface.Kickstarted, False)
callback.assert_not_called()
# Test the temporary kickstart.
if ks_tmp is None:
return
ks_tmp = dedent(ks_tmp).strip()
test.assertEqual(ks_tmp, interface.GenerateTemporaryKickstart().strip())
def ReadKickstart(self, kickstart):
"""Mock parsing for now.
Returns parse error if PARSE_ERROR string is found in kickstart.
"""
self.kickstart = kickstart
report = KickstartReport()
for lnum, line in enumerate(kickstart.splitlines(), 1):
if "PARSE_ERROR" in line:
data = KickstartMessage()
data.message = "Mocked parse error: \"PARSE_ERROR\" found"
data.line_number = lnum
report.error_messages.append(data)
return get_native(KickstartReport.to_structure(report))
def check_dbus_property(test,
interface_id,
interface,
property_name,
in_value,
out_value=None,
getter=None,
setter=None,
changed=None):
"""Check DBus property.
:param test: instance of TestCase
:param interface_id: instance of DBusInterfaceIdentifier
:param interface: instance of a DBus interface
:param property_name: a DBus property name
:param in_value: an input value of the property
:param out_value: an output value of the property or None
:param getter: a property getter or None
:param setter: a property setter or None
:param changed: a dictionary of changed properties or None
"""
callback = PropertiesChangedCallback()
interface.PropertiesChanged.connect(callback)
if out_value is None:
out_value = in_value
# Set the property.
if not setter:
setter = getattr(interface, "Set{}".format(property_name))
setter(in_value)
if not changed:
changed = {property_name: out_value}
callback.assert_called_once_with(interface_id.interface_name,
get_native(changed), [])
# Get the property.
if not getter:
getter = lambda: getattr(interface, property_name)
test.assertEqual(getter(), out_value)
def setup_install_source_task_failed_to_mount_test(self, proxy_getter,
os_stat, stat, mount):
"""Test Live OS Source setup installation source task mount error."""
device_tree = Mock()
proxy_getter.return_value = device_tree
device_tree.ResolveDevice = Mock()
device_tree.ResolveDevice.return_value = "resolvedDeviceName"
device = DeviceData()
device.path = "/resolved/path/to/base/image"
device_tree.GetDeviceData = Mock()
device_tree.GetDeviceData.return_value = get_native(
DeviceData.to_structure(device))
mount.return_value = -20
with self.assertRaises(SourceSetupError,
msg="Failed to mount the install tree"):
SetUpLiveOSSourceTask("/path/to/base/image",
"/path/to/mount/source/image").run()
def setup_install_source_task_run_test(self, proxy_getter, os_stat, stat,
mount):
"""Test Live OS Source setup installation source task run."""
device_tree = Mock()
proxy_getter.return_value = device_tree
device_tree.ResolveDevice = Mock()
device_tree.ResolveDevice.return_value = "resolvedDeviceName"
device = DeviceData()
device.path = "/resolved/path/to/base/image"
device_tree.GetDeviceData = Mock()
device_tree.GetDeviceData.return_value = get_native(
DeviceData.to_structure(device))
mount.return_value = 0
SetUpLiveOSSourceTask("/path/to/base/image",
"/path/to/mount/source/image").run()
device_tree.ResolveDevice.assert_called_once_with(
"/path/to/base/image")
os_stat.assert_called_once_with("/resolved/path/to/base/image")
def setup_install_source_task_invalid_block_dev_test(
self, proxy_getter, os_stat, stat_mock):
"""Test Live OS Source setup installation source task with invalid block device error."""
device_tree = Mock()
proxy_getter.return_value = device_tree
device_tree.ResolveDevice = Mock()
device_tree.ResolveDevice.return_value = "resolvedDeviceName"
device = DeviceData()
device.path = "/resolved/path/to/base/image"
device_tree.GetDeviceData = Mock()
device_tree.GetDeviceData.return_value = get_native(
DeviceData.to_structure(device))
stat_mock.S_ISBLK = Mock()
stat_mock.S_ISBLK.return_value = False
with self.assertRaises(
SourceSetupError,
msg="/path/to/base/image is not a valid block device"):
SetUpLiveOSSourceTask("/path/to/base/image",
"/path/to/mount/source/image").run()
def generate_device_factory_permissions_btrfs_test(self):
"""Test GenerateDeviceFactoryPermissions with btrfs."""
dev1 = StorageDevice("dev1",
fmt=get_format("btrfs"),
size=Size("10 GiB"))
dev2 = BTRFSVolumeDevice("dev2", size=Size("5 GiB"), parents=[dev1])
self._add_device(dev1)
self._add_device(dev2)
request = self.interface.GenerateDeviceFactoryRequest(dev2.name)
permissions = self.interface.GenerateDeviceFactoryPermissions(request)
self.assertEqual(
get_native(permissions), {
'mount-point': True,
'reformat': False,
'format-type': False,
'label': True,
'device-type': True,
'device-name': False,
'device-size': False,
'device-encrypted': False,
'device-raid-level': True,
})
def validate_selected_disks_test(self):
"""Test ValidateSelectedDisks."""
storage = create_storage()
self.disk_selection_module.on_storage_reset(storage)
dev1 = DiskDevice("dev1",
exists=False,
size=Size("15 GiB"),
fmt=get_format("disklabel"))
dev2 = DiskDevice("dev2",
exists=False,
parents=[dev1],
size=Size("6 GiB"),
fmt=get_format("disklabel"))
dev3 = DiskDevice("dev3",
exists=False,
parents=[dev2],
size=Size("6 GiB"),
fmt=get_format("disklabel"))
storage.devicetree._add_device(dev1)
storage.devicetree._add_device(dev2)
storage.devicetree._add_device(dev3)
report = ValidationReport.from_structure(
get_native(self.disk_selection_interface.ValidateSelectedDisks(
[])))
self.assertEqual(report.is_valid(), True)
report = ValidationReport.from_structure(
get_native(
self.disk_selection_interface.ValidateSelectedDisks(["dev1"])))
self.assertEqual(report.is_valid(), False)
self.assertEqual(report.error_messages, [
"You selected disk dev1, which contains devices that also use "
"unselected disks dev2, dev3. You must select or de-select "
"these disks as a set."
])
self.assertEqual(report.warning_messages, [])
report = ValidationReport.from_structure(
get_native(
self.disk_selection_interface.ValidateSelectedDisks(
["dev1", "dev2"])))
self.assertEqual(report.is_valid(), False)
self.assertEqual(report.error_messages, [
"You selected disk dev1, which contains devices that also "
"use unselected disk dev3. You must select or de-select "
"these disks as a set.",
"You selected disk dev2, which contains devices that also "
"use unselected disk dev3. You must select or de-select "
"these disks as a set."
])
self.assertEqual(report.warning_messages, [])
report = ValidationReport.from_structure(
get_native(
self.disk_selection_interface.ValidateSelectedDisks(
["dev1", "dev2", "dev3"])))
self.assertEqual(report.is_valid(), True)
def test_nested_structure(self):
class SimpleData(DBusData):
def __init__(self):
self._x = 0
@property
def x(self) -> Int:
return self._x
@x.setter
def x(self, value):
self._x = value
class NestedData(DBusData):
def __init__(self):
self._attr = SimpleData()
self._list = []
@property
def attr(self) -> SimpleData:
return self._attr
@attr.setter
def attr(self, value):
self._attr = value
@property
def list(self) -> List[SimpleData]:
return self._list
@list.setter
def list(self, value):
self._list = value
data = NestedData()
expected = "NestedData(attr={'x': 0}, list=[])"
self.assertEqual(str(data), expected)
self.assertEqual(repr(data), expected)
data.attr.x = -1
for x in range(2):
item = SimpleData()
item.x = x
data.list.append(item)
expected = "NestedData(attr={'x': -1}, list=[{'x': 0}, {'x': 1}])"
self.assertEqual(str(data), expected)
self.assertEqual(repr(data), expected)
self.assertEqual(NestedData.to_structure(data), {
'attr': get_variant(Structure, {
'x': get_variant(Int, -1)
}),
'list': get_variant(List[Structure], [
{'x': get_variant(Int, 0)},
{'x': get_variant(Int, 1)}
])
})
dictionary = {
'attr': {'x': 10},
'list': [{'x': 200}, {'x': 300}]
}
structure = {
'attr': get_variant(Dict[Str, Variant], {
'x': get_variant(Int, 10)
}),
'list': get_variant(List[Dict[Str, Variant]], [
{'x': get_variant(Int, 200)},
{'x': get_variant(Int, 300)}
])
}
data = NestedData.from_structure(structure)
self.assertEqual(data.attr.x, 10)
self.assertEqual(len(data.list), 2)
self.assertEqual(data.list[0].x, 200)
self.assertEqual(data.list[1].x, 300)
structure = NestedData.to_structure(data)
self.assertEqual(get_native(structure), dictionary)
def test_nested_structure(self):
class SimpleData(DBusData):
def __init__(self):
self._x = 0
@property
def x(self) -> Int:
return self._x
@x.setter
def x(self, value):
self._x = value
class SecretData(DBusData):
def __init__(self):
self._y = ""
@property
def y(self) -> Str:
return self._y
@y.setter
def y(self, value):
self._y = value
def __repr__(self):
return generate_string_from_data(self,
skip=["y"],
add={"y_set": bool(self.y)})
class NestedData(DBusData):
def __init__(self):
self._attr = SimpleData()
self._secret = SecretData()
self._list = []
@property
def attr(self) -> SimpleData:
return self._attr
@attr.setter
def attr(self, value):
self._attr = value
@property
def secret(self) -> SecretData:
return self._secret
@secret.setter
def secret(self, value):
self._secret = value
@property
def list(self) -> List[SimpleData]:
return self._list
@list.setter
def list(self, value):
self._list = value
data = NestedData()
expected = \
"NestedData(" \
"attr=SimpleData(x=0), " \
"list=[], " \
"secret=SecretData(y_set=False))"
self.assertEqual(str(data), expected)
self.assertEqual(repr(data), expected)
data.attr.x = -1
data.secret.y = "SECRET"
for x in range(2):
item = SimpleData()
item.x = x
data.list.append(item)
expected = \
"NestedData(" \
"attr=SimpleData(x=-1), " \
"list=[SimpleData(x=0), SimpleData(x=1)], " \
"secret=SecretData(y_set=True))"
self.assertEqual(str(data), expected)
self.assertEqual(repr(data), expected)
self.assertEqual(
NestedData.to_structure(data), {
'attr':
get_variant(Structure, {'x': get_variant(Int, -1)}),
'secret':
get_variant(Structure, {'y': get_variant(Str, "SECRET")}),
'list':
get_variant(List[Structure], [{
'x': get_variant(Int, 0)
}, {
'x': get_variant(Int, 1)
}])
})
dictionary = {
'attr': {
'x': 10
},
'secret': {
'y': "SECRET"
},
'list': [{
'x': 200
}, {
'x': 300
}]
}
structure = {
'attr':
get_variant(Dict[Str, Variant], {'x': get_variant(Int, 10)}),
'secret':
get_variant(Dict[Str, Variant], {'y': get_variant(Str, "SECRET")}),
'list':
get_variant(List[Dict[Str, Variant]], [{
'x': get_variant(Int, 200)
}, {
'x': get_variant(Int, 300)
}])
}
data = NestedData.from_structure(structure)
self.assertEqual(data.attr.x, 10)
self.assertEqual(data.secret.y, "SECRET")
self.assertEqual(len(data.list), 2)
self.assertEqual(data.list[0].x, 200)
self.assertEqual(data.list[1].x, 300)
structure = NestedData.to_structure(data)
self.assertEqual(get_native(structure), dictionary)
def assert_call(self, property_name, value):
self.assert_called_once_with(OSCAP.interface_name,
{property_name: get_native(value)}, [])
def __call__(self, interface, changed, invalid):
return super().__call__(interface, get_native(changed), invalid)
