def test_query_api_version(self, hmc_name, hmc_version, api_version):
"""All tests for Client.query_api_version()."""
session = FakedSession('fake-host', hmc_name, hmc_version, api_version)
# Client object under test
client = Client(session)
# Execute the code to be tested
api_version_info = client.query_api_version()
api_major_version = int(api_version.split('.')[0])
api_minor_version = int(api_version.split('.')[1])
exp_api_version_info = {
'api-major-version': api_major_version,
'api-minor-version': api_minor_version,
'hmc-version': hmc_version,
'hmc-name': hmc_name,
}
assert api_version_info == exp_api_version_info
class TestConsole(object):
"""All tests for the Console and ConsoleManager classes."""
def setup_method(self):
"""
Set up a faked session, and add a faked Console without any
child resources.
"""
self.session = FakedSession('fake-host', 'fake-hmc', '2.13.1', '1.8')
self.client = Client(self.session)
self.faked_console = self.session.hmc.consoles.add({
'object-id':
None,
# object-uri will be automatically set
'parent':
None,
'class':
'console',
'name':
'fake-console1',
'description':
'Console #1',
})
def test_consolemanager_initial_attrs(self):
"""Test initial attributes of ConsoleManager."""
console_mgr = self.client.consoles
# Verify all public properties of the manager object
assert console_mgr.resource_class == Console
assert console_mgr.class_name == 'console'
assert console_mgr.session == self.session
assert console_mgr.parent is None
assert console_mgr.client == self.client
# TODO: Test for ConsoleManager.__repr__()
@pytest.mark.parametrize(
"full_properties_kwargs, prop_names",
[
(dict(full_properties=False), ['object-uri']),
(dict(full_properties=True), ['object-uri', 'name']),
(
dict(), # test default for full_properties (True)
['object-uri', 'name']),
])
@pytest.mark.parametrize(
"filter_args",
[ # will be ignored
None,
{},
{
'name': 'foo'
},
])
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_console_initial_attrs(self):
"""Test initial attributes of Console."""
console_mgr = self.client.consoles
console = console_mgr.find(name=self.faked_console.name)
# Verify all public properties of the resource object (except those
# of its BaseResource superclass which are tested at that level).
assert isinstance(console.users, UserManager)
assert isinstance(console.user_roles, UserRoleManager)
assert isinstance(console.user_patterns, UserPatternManager)
assert isinstance(console.password_rules, PasswordRuleManager)
assert isinstance(console.tasks, TaskManager)
assert isinstance(console.ldap_server_definitions,
LdapServerDefinitionManager)
def test_console_repr(self):
"""Test Console.__repr__()."""
console_mgr = self.client.consoles
console = console_mgr.find(name=self.faked_console.name)
# Execute the code to be tested
repr_str = repr(console)
repr_str = repr_str.replace('\n', '\\n')
# We check just the begin of the string:
assert re.match(
r'^{classname}\s+at\s+0x{id:08x}\s+\(\\n.*'.format(
classname=console.__class__.__name__, id=id(console)),
repr_str)
@pytest.mark.parametrize(
"wait",
[
True,
# False, # TODO: Re-enable once implemented
])
@pytest.mark.parametrize("force", [
True,
False,
])
def test_console_restart(self, force, wait):
"""Test Console.restart()."""
console_mgr = self.client.consoles
console = console_mgr.find(name=self.faked_console.name)
# Note: The force parameter is passed in, but we expect the restart
# to always succeed. This means we are not testing cases with other
# HMC users being logged on, that would either cause a non-forced
# restart to be rejected, or a forced restart to succeed despite them.
# Execute the code to be tested.
ret = console.restart(force=force,
wait_for_available=wait,
operation_timeout=600)
assert ret is None
if wait:
# The HMC is expected to be up again, and therefore a simple
# operation is expected to succeed:
try:
self.client.query_api_version()
except Error as exc:
pytest.fail("Unexpected zhmcclient exception during "
"query_api_version() after HMC restart: %s" % exc)
else:
# The HMC is expected to still be in the restart process, and
# therefore a simple operation is expected to fail. This test
# may end up to be timing dependent.
try:
self.client.query_api_version()
except Error:
pass
except Exception as exc:
pytest.fail("Unexpected non-zhmcclient exception during "
"query_api_version() after HMC restart: %s" % exc)
else:
pytest.fail(
"Unexpected success of query_api_version() after HMC "
"restart.")
@pytest.mark.parametrize("force", [
True,
False,
])
def test_console_shutdown(self, force):
"""Test Console.shutdown()."""
console_mgr = self.client.consoles
console = console_mgr.find(name=self.faked_console.name)
# Note: The force parameter is passed in, but we expect the shutdown
# to always succeed. This means we are not testing cases with other
# HMC users being logged on, that would either cause a non-forced
# shutdown to be rejected, or a forced shutdown to succeed despite
# them.
# Execute the code to be tested.
ret = console.shutdown(force=force)
assert ret is None
# The HMC is expected to be offline, and therefore a simple operation
# is expected to fail.
try:
self.client.query_api_version()
except Error:
pass
except Exception as exc:
pytest.fail("Unexpected non-zhmcclient exception during "
"query_api_version() after HMC shutdown: %s" % exc)
else:
pytest.fail("Unexpected success of query_api_version() after HMC "
"shutdown.")
def test_console_audit_log(self):
"""Test Console.get_audit_log()."""
# TODO: Add begin/end_time once mocked audit log is supported
console_mgr = self.client.consoles
console = console_mgr.find(name=self.faked_console.name)
# Execute the code to be tested.
log_items = console.get_audit_log()
assert isinstance(log_items, list)
# TODO: Verify log items once mocked audit log is supported
def test_console_security_log(self):
"""Test Console.get_security_log()."""
# TODO: Add begin/end_time once mocked security log is supported
console_mgr = self.client.consoles
console = console_mgr.find(name=self.faked_console.name)
# Execute the code to be tested.
log_items = console.get_security_log()
assert isinstance(log_items, list)
# TODO: Verify log items once mocked security log is supported
@pytest.mark.parametrize("name, exp_cpc_names, prop_names", [
(None, ['ucpc_name_1', 'ucpc_name_2'], ['object-uri', 'name']),
('.*', ['ucpc_name_1', 'ucpc_name_2'], ['object-uri', 'name']),
('ucpc_name_.*', ['ucpc_name_1', 'ucpc_name_2'
], ['object-uri', 'name']),
('ucpc_name_1', ['ucpc_name_1'], ['object-uri', 'name']),
('ucpc_name_1.*', ['ucpc_name_1'], ['object-uri', 'name']),
('ucpc_name_1.+', [], ['object-uri', 'name']),
])
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)
