def test_assert_resources_error_props(self, props, reverse):
"""Test assert_resources() with failing property checks."""
faked_cpcs = self.add_cpcs()
cpcs = self.client.cpcs.list(full_properties=True)
resources = cpcs
exp_resources = faked_cpcs
if reverse:
exp_resources = list(reversed(exp_resources))
if props == 'all':
prop_names = exp_resources[0].properties.keys()
# We change a property that is being checked:
exp_resources[0].properties['description'] = 'changed description'
if props == 'some':
prop_names = ['name', 'status']
# We change a property that is being checked:
exp_resources[0].properties['status'] = 'not-operating'
elif props == 'none':
# All properties are checked.
prop_names = None
# We change a property that is being checked:
exp_resources[0].properties['description'] = 'changed description'
# Execute the code to be tested
with pytest.raises(AssertionError):
assert_resources(resources, exp_resources, prop_names)
def test_upm_list(self, filter_args, exp_names, full_properties_kwargs,
prop_names):
"""Test UserPatternManager.list()."""
faked_user1 = self.add_user(name='a', type_='standard')
faked_user2 = self.add_user(name='b', type_='standard')
faked_user_pattern1 = self.add_user_pattern(
name='a',
pattern='a_*',
type_='glob-like',
user_template_uri=faked_user1.uri)
faked_user_pattern2 = self.add_user_pattern(
name='b',
pattern='b_.*',
type_='regular-expression',
user_template_uri=faked_user2.uri)
faked_user_patterns = [faked_user_pattern1, faked_user_pattern2]
exp_faked_user_patterns = [
u for u in faked_user_patterns if u.name in exp_names
]
user_pattern_mgr = self.console.user_patterns
# Execute the code to be tested
user_patterns = user_pattern_mgr.list(filter_args=filter_args,
**full_properties_kwargs)
assert_resources(user_patterns, exp_faked_user_patterns, prop_names)
def test_assert_resources_success(self, props, reverse):
"""Test assert_resources() with successful parameters."""
faked_cpcs = self.add_cpcs()
cpcs = self.client.cpcs.list(full_properties=True)
resources = cpcs
exp_resources = faked_cpcs
if reverse:
exp_resources = list(reversed(exp_resources))
if props == 'all':
prop_names = exp_resources[0].properties.keys()
if props == 'some':
prop_names = ['name', 'status']
# We change a property that is not being checked:
exp_resources[0].properties['description'] = 'changed description'
elif props == 'empty':
prop_names = []
# No properties are checked, we change a property:
exp_resources[0].properties['description'] = 'changed description'
elif props == 'none':
# All properties are checked.
prop_names = None
# Execute the code to be tested
assert_resources(resources, exp_resources, prop_names)
def test_console_list_unmanaged_cpcs(self, name, exp_cpc_names,
prop_names):
"""Test Console.list_unmanaged_cpcs() and
UnmanagedCpcManager.list()."""
console_mgr = self.client.consoles
console = console_mgr.find(name=self.faked_console.name)
# Add two unmanaged faked CPCs
faked_ucpc1 = self.faked_console.unmanaged_cpcs.add({
'object-id':
'ucpc-oid-1',
# object-uri is set up automatically
'name':
'ucpc_name_1',
})
faked_ucpc2 = self.faked_console.unmanaged_cpcs.add({
'object-id':
'ucpc-oid-2',
# object-uri is set up automatically
'name':
'ucpc_name_2',
})
faked_ucpcs = [faked_ucpc1, faked_ucpc2]
exp_faked_ucpcs = [
cpc for cpc in faked_ucpcs if cpc.name in exp_cpc_names
]
# Execute the code to be tested.
# This indirectly tests UnmanagedCpcManager.list().
ucpcs = console.list_unmanaged_cpcs(name)
assert_resources(ucpcs, exp_faked_ucpcs, prop_names)
def test_consolemanager_list(self, filter_args, full_properties_kwargs,
prop_names):
"""Test ConsoleManager.list()."""
exp_faked_consoles = [self.faked_console]
console_mgr = self.client.consoles
# Execute the code to be tested
consoles = console_mgr.list(filter_args=filter_args,
**full_properties_kwargs)
assert_resources(consoles, exp_faked_consoles, prop_names)
def test_profilemanager_list_full_properties(self, full_properties_kwargs,
prop_names, profile_type):
"""Test ActivationProfileManager.list() with full_properties."""
mgr_attr = profile_type + '_activation_profiles'
faked_profile_mgr = getattr(self.faked_cpc, mgr_attr)
exp_faked_profiles = faked_profile_mgr.list()
profile_mgr = getattr(self.cpc, mgr_attr)
# Execute the code to be tested
profiles = profile_mgr.list(**full_properties_kwargs)
assert_resources(profiles, exp_faked_profiles, prop_names)
def test_pm_list_full_properties(self, full_properties_kwargs, prop_names):
"""Test PartitionManager.list() with full_properties."""
# Add two faked partitions
faked_partition1 = self.add_partition1()
faked_partition2 = self.add_partition2()
exp_faked_partitions = [faked_partition1, faked_partition2]
partition_mgr = self.cpc.partitions
# Execute the code to be tested
partitions = partition_mgr.list(**full_properties_kwargs)
assert_resources(partitions, exp_faked_partitions, prop_names)
def test_ucpc_manager_list(self, filter_args, exp_names,
full_properties_kwargs, prop_names):
"""Test UnmanagedCpcManager.list()."""
faked_ucpc1 = self.add_unmanaged_cpc(name='a')
faked_ucpc2 = self.add_unmanaged_cpc(name='b')
faked_ucpcs = [faked_ucpc1, faked_ucpc2]
exp_faked_ucpcs = [u for u in faked_ucpcs if u.name in exp_names]
ucpc_mgr = self.console.unmanaged_cpcs
# Execute the code to be tested
ucpcs = ucpc_mgr.list(filter_args=filter_args,
**full_properties_kwargs)
assert_resources(ucpcs, exp_faked_ucpcs, prop_names)
def test_task_manager_list(self, filter_args, exp_names,
full_properties_kwargs, prop_names):
"""Test TaskManager.list()."""
faked_task1 = self.add_task(name='a')
faked_task2 = self.add_task(name='b')
faked_tasks = [faked_task1, faked_task2]
exp_faked_tasks = [u for u in faked_tasks if u.name in exp_names]
task_mgr = self.console.tasks
# Execute the code to be tested
tasks = task_mgr.list(filter_args=filter_args,
**full_properties_kwargs)
assert_resources(tasks, exp_faked_tasks, prop_names)
def test_lparmanager_list_full_properties(self, full_properties_kwargs,
prop_names):
"""Test LparManager.list() with full_properties."""
# Add two faked LPARs
faked_lpar1 = self.add_lpar1()
faked_lpar2 = self.add_lpar2()
exp_faked_lpars = [faked_lpar1, faked_lpar2]
lpar_mgr = self.cpc.lpars
# Execute the code to be tested
lpars = lpar_mgr.list(**full_properties_kwargs)
assert_resources(lpars, exp_faked_lpars, prop_names)
def test_adaptermanager_list_full_properties(self, full_properties_kwargs,
prop_names):
"""Test AdapterManager.list() with full_properties."""
# Add two faked adapters
faked_osa1 = self.add_standard_osa()
faked_hs2 = self.add_standard_hipersocket()
exp_faked_adapters = [faked_osa1, faked_hs2]
adapter_mgr = self.cpc.adapters
# Execute the code to be tested
adapters = adapter_mgr.list(**full_properties_kwargs)
assert_resources(adapters, exp_faked_adapters, prop_names)
def test_user_manager_list(self, filter_args, exp_names,
full_properties_kwargs, prop_names):
"""Test UserManager.list()."""
faked_user1 = self.add_user(name='a', type_='standard')
faked_user2 = self.add_user(name='b', type_='standard')
faked_users = [faked_user1, faked_user2]
exp_faked_users = [u for u in faked_users if u.name in exp_names]
user_mgr = self.console.users
# Execute the code to be tested
users = user_mgr.list(filter_args=filter_args,
**full_properties_kwargs)
assert_resources(users, exp_faked_users, prop_names)
def test_sm_list_full_properties(
self, full_properties_kwargs, prop_names):
"""Test StorageGroupManager.list() with full_properties."""
# Add two faked storage groups
faked_storage_group1 = self.add_storage_group1()
faked_storage_group2 = self.add_storage_group2()
exp_faked_storage_groups = [faked_storage_group1, faked_storage_group2]
storage_group_mgr = self.console.storage_groups
# Execute the code to be tested
storage_groups = storage_group_mgr.list(**full_properties_kwargs)
assert_resources(storage_groups, exp_faked_storage_groups, prop_names)
def test_hbamanager_list_full_properties(self, full_properties_kwargs,
prop_names):
"""Test HbaManager.list() with full_properties."""
# Add two faked HBAs
faked_hba1 = self.add_hba1()
faked_hba2 = self.add_hba2()
exp_faked_hbas = [faked_hba1, faked_hba2]
hba_mgr = self.partition.hbas
# Execute the code to be tested
hbas = hba_mgr.list(**full_properties_kwargs)
assert_resources(hbas, exp_faked_hbas, prop_names)
def test_nicmanager_list_full_properties(self, full_properties_kwargs,
prop_names):
"""Test NicManager.list() with full_properties."""
# Add two faked NICs
faked_nic1 = self.add_nic1()
faked_nic2 = self.add_nic2()
exp_faked_nics = [faked_nic1, faked_nic2]
nic_mgr = self.partition.nics
# Execute the code to be tested
nics = nic_mgr.list(**full_properties_kwargs)
assert_resources(nics, exp_faked_nics, prop_names)
def test_cpcmanager_list_full_properties(self, full_properties_kwargs,
prop_names):
"""Test CpcManager.list() with full_properties."""
# Add two faked CPCs
faked_cpc1 = self.add_cpc(CPC1_NAME)
faked_cpc2 = self.add_cpc(CPC2_NAME)
exp_faked_cpcs = [faked_cpc1, faked_cpc2]
cpc_mgr = self.client.cpcs
# Execute the code to be tested
cpcs = cpc_mgr.list(**full_properties_kwargs)
assert_resources(cpcs, exp_faked_cpcs, prop_names)
def test_assert_resources_error_res(self, reverse):
"""Test assert_resources() with failing resource list checks."""
faked_cpcs = self.add_cpcs()
cpcs = self.client.cpcs.list(full_properties=True)
resources = cpcs[0:1] # trigger non-matching resource list
exp_resources = faked_cpcs
if reverse:
exp_resources = list(reversed(exp_resources))
prop_names = exp_resources[0].properties.keys()
# Execute the code to be tested
with pytest.raises(AssertionError):
assert_resources(resources, exp_resources, prop_names)
def test_ldap_srv_def_manager_list(
self, filter_args, exp_names, full_properties_kwargs, prop_names):
"""Test LdapServerDefinitionManager.list()."""
faked_ldap_srv_def1 = self.add_ldap_srv_def(name='a')
faked_ldap_srv_def2 = self.add_ldap_srv_def(name='b')
faked_ldap_srv_defs = [faked_ldap_srv_def1, faked_ldap_srv_def2]
exp_faked_ldap_srv_defs = [u for u in faked_ldap_srv_defs
if u.name in exp_names]
ldap_srv_def_mgr = self.console.ldap_server_definitions
# Execute the code to be tested
ldap_srv_defs = ldap_srv_def_mgr.list(filter_args=filter_args,
**full_properties_kwargs)
assert_resources(ldap_srv_defs, exp_faked_ldap_srv_defs, prop_names)
def test_user_role_manager_list(self, filter_args, exp_names,
full_properties_kwargs, prop_names):
"""Test UserRoleManager.list()."""
faked_user_role1 = self.add_user_role(name='a', type_='user-defined')
faked_user_role2 = self.add_user_role(name='b', type_='user-defined')
faked_user_roles = [faked_user_role1, faked_user_role2]
exp_faked_user_roles = [
u for u in faked_user_roles if u.name in exp_names
]
user_role_mgr = self.console.user_roles
# Execute the code to be tested
user_roles = user_role_mgr.list(filter_args=filter_args,
**full_properties_kwargs)
assert_resources(user_roles, exp_faked_user_roles, prop_names)
def test_pr_manager_list(
self, filter_args, exp_names, full_properties_kwargs, prop_names):
"""Test PasswordRuleManager.list()."""
faked_password_rule1 = self.add_password_rule(
name='a', type_='user-defined')
faked_password_rule2 = self.add_password_rule(
name='b', type_='system-defined')
faked_password_rules = [faked_password_rule1, faked_password_rule2]
exp_faked_password_rules = [u for u in faked_password_rules
if u.name in exp_names]
password_rule_mgr = self.console.password_rules
# Execute the code to be tested
password_rules = password_rule_mgr.list(filter_args=filter_args,
**full_properties_kwargs)
assert_resources(password_rules, exp_faked_password_rules, prop_names)
def test_metricscontextmanager_list_full_properties(
self, full_properties_kwargs, prop_names):
"""Test MetricsContextManager.list() with full_properties."""
# Add faked metric groups
self.add_metricgroupdefinition1()
self.add_metricgroupdefinition2()
# Create (non-faked) metrics contexts (list() will only return those)
metricscontext1 = self.create_metricscontext1()
metricscontext2 = self.create_metricscontext2()
exp_metricscontexts = [metricscontext1, metricscontext2]
metricscontext_mgr = self.client.metrics_contexts
# Execute the code to be tested
metricscontexts = metricscontext_mgr.list(**full_properties_kwargs)
assert_resources(metricscontexts, exp_metricscontexts, prop_names)
