def setup_method(self):
self.session = Session('vswitch-dpm-host', 'vswitch-user',
'vswitch-pwd')
self.client = Client(self.session)
with requests_mock.mock() as m:
# Because logon is deferred until needed, we perform it
# explicitly in order to keep mocking in the actual test simple.
m.post('/api/sessions', json={'api-session': 'vswitch-session-id'})
self.session.logon()
self.cpc_mgr = self.client.cpcs
with requests_mock.mock() as m:
result = {
'cpcs': [
{
'object-uri': '/api/cpcs/vswitch-cpc-id-1',
'name': 'CPC',
'status': 'service-required',
}
]
}
m.get('/api/cpcs', json=result)
cpcs = self.cpc_mgr.list()
self.cpc = cpcs[0]
def _do_parse_error_logon(self, m, json_content, exp_msg_pattern, exp_line,
exp_col):
"""
Perform a session logon, and mock the provided (invalid) JSON content
for the response so that a JSON parsing error is triggered.
Assert that this is surfaced via a `zhmcclient.ParseError` exception,
with the expected message (as a regexp pattern), line and column.
"""
m.register_uri('POST', '/api/sessions',
content=json_content,
headers={'X-Request-Id': 'fake-request-id'})
session = Session('fake-host', 'fake-user', 'fake-pw')
exp_pe_pattern = \
r"^JSON parse error in HTTP response: %s\. " \
r"HTTP request: [^ ]+ [^ ]+\. " \
r"Response status .*" % \
exp_msg_pattern
with pytest.raises(ParseError) as exc_info:
session.logon()
exc = exc_info.value
assert re.match(exp_pe_pattern, str(exc))
assert exc.line == exp_line
assert exc.column == exp_col
def test_session_get_error_html_1():
"""
This tests a dummy GET with a 500 response with HTML content.
"""
session = Session('fake-host', 'fake-user', 'fake-id')
with requests_mock.mock() as m:
get_uri = "/api/version"
get_resp_status = 500
get_resp_content_type = 'text/html; charset=utf-8'
get_resp_headers = {
'content-type': get_resp_content_type,
}
get_resp_content = u"""\
<!doctype html public "-//IETF//DTD HTML 2.0//EN">\
<html>\
<head>\
<title>Console Internal Error</title>\
<link href="/skin/HMCskin.css" rel="stylesheet" type="text/css"/>\
</head>\
<body>\
<h1>Console Internal Error</h1>\
<br><hr size="1" noshade>\
<h2>Details:</h2>\
<p><br>HTTP status code: 500\
<p><br>The server encountered an internal error that prevented it from\
fulfilling this request.\
<p><br>\
<pre>javax.servlet.ServletException: Web Services are not enabled.
\tat com.ibm.hwmca.fw.api.ApiServlet.execute(ApiServlet.java:135)
\t. . .
</pre>\
<hr size="1" noshade>\
</body>\
</html>"""
m.get(get_uri,
text=get_resp_content,
headers=get_resp_headers,
status_code=get_resp_status)
# The following expected results reflect what is done in
# _session._result_object().
exp_reason = 900
exp_message = \
"Console Configuration Error: " \
"Web Services API is not enabled on the HMC."
with pytest.raises(HTTPError) as exc_info:
session.get(get_uri, logon_required=False)
exc = exc_info.value
assert exc.http_status == get_resp_status
assert exc.reason == exp_reason
assert exc.message == exp_message
assert exc.request_uri.endswith(get_uri)
assert exc.request_method == 'GET'
def test_logoff(self):
"""Test Session.logoff() (and also Session.is_logon())."""
with requests_mock.Mocker() as m:
self.mock_server_1(m)
# Create a session in logged-off state
session = Session('fake-host', 'fake-userid', 'fake-pw')
session.logon()
logged_on = session.is_logon()
assert logged_on
# The code to be tested:
session.logoff()
assert session.session_id is None
assert session.session is None
assert 'X-API-Session' not in session.headers
assert len(session.headers) == 2
logged_on = session.is_logon()
assert not logged_on
def test_logon(
self, host, userid, password, use_get_password, exp_exc):
"""Test Session.logon() (and also Session.is_logon())."""
with requests_mock.Mocker() as m:
self.mock_server_1(m)
if use_get_password:
get_password = mock.MagicMock()
get_password.return_value = \
'fake-pw-{}-{}'.format(host, userid)
else:
get_password = None
# Create a session in logged-off state
session = Session(host, userid, password, None, get_password)
assert session.session_id is None
assert 'X-API-Session' not in session.headers
assert session.session is None
logged_on = session.is_logon()
assert not logged_on
if exp_exc:
try:
# The code to be tested:
session.logon()
except exp_exc:
pass
logged_on = session.is_logon()
assert not logged_on
else:
# The code to be tested:
session.logon()
assert session.session_id == 'fake-session-id'
assert 'X-API-Session' in session.headers
assert isinstance(session.session, requests.Session)
if get_password:
if password is None:
get_password.assert_called_with(host, userid)
assert session._password == get_password.return_value
else:
get_password.assert_not_called()
logged_on = session.is_logon()
assert logged_on
def test_job_wait_complete3_success_result():
"""Test wait_for_completion() with successful complete job with a
result."""
with requests_mock.mock() as m:
mock_server_1(m)
session = Session('fake-host', 'fake-user', 'fake-pw')
op_method = 'POST'
op_uri = '/api/foo'
job = Job(session, JOB_URI, op_method, op_uri)
exp_op_result = {
'foo': 'bar',
}
m.get(JOB_URI, [
{
'text': result_running_callback
},
{
'text': result_complete_callback
},
])
m.delete(JOB_URI, status_code=204)
op_result = job.wait_for_completion()
assert op_result == exp_op_result
def test_job_check_complete_error1():
"""Test check_for_completion() with complete job in error (1)."""
with requests_mock.mock() as m:
mock_server_1(m)
session = Session('fake-host', 'fake-user', 'fake-pw')
op_method = 'POST'
op_uri = '/api/foo'
job = Job(session, JOB_URI, op_method, op_uri)
query_job_status_result = {
'status': 'complete',
'job-status-code': 500,
'job-reason-code': 42,
# no 'job-results' field (it is not guaranteed to be there)
}
m.get(JOB_URI, json=query_job_status_result)
m.delete(JOB_URI, status_code=204)
with pytest.raises(HTTPError) as exc_info:
job.check_for_completion()
exc = exc_info.value
assert exc.http_status == 500
assert exc.reason == 42
assert exc.message is None
def test_init(self, host, userid, password, use_get_password, session_id):
"""Test initialization of Session object."""
# TODO: Add support for input parameter: retry_timeout_config
# TODO: Add support for input parameter: time_stats_keeper
if use_get_password:
def get_password(host, userid):
pw = 'fake-pw-{}-{}'.format(host, userid)
return pw
else:
get_password = None
session = Session(host, userid, password, session_id, get_password)
assert session.host == host
assert session.userid == userid
assert session._password == password
assert session.session_id == session_id
assert session.get_password == get_password
base_url = 'https://{}:6794'.format(session.host)
assert session.base_url == base_url
assert session.headers['Content-type'] == 'application/json'
assert session.headers['Accept'] == '*/*'
if session_id is None:
assert session.session is None
assert 'X-API-Session' not in session.headers
assert len(session.headers) == 2
else:
assert isinstance(session.session, requests.Session)
assert session.headers['X-API-Session'] == session_id
assert len(session.headers) == 3
def setup_method(self):
self.session = Session(host='fake-host')
self.mgr = MyManager(self.session)
self.uri = self.mgr._base_uri + '/deadbeef-beef-beef-beef-deadbeefbeef'
self.name = "fake-name"
self.uri_prop = 'fake-uri-prop' # same as in MyManager
self.name_prop = 'fake-name-prop' # same as in MyManager
def test_check_complete_success_result(self):
"""Test check_for_completion() with successful complete job with a
result."""
with requests_mock.mock() as m:
self.mock_server_1(m)
session = Session('fake-host', 'fake-user', 'fake-pw')
op_method = 'POST'
op_uri = '/api/foo'
job = Job(session, self.job_uri, op_method, op_uri)
exp_op_result = {
'foo': 'bar',
}
query_job_status_result = {
'status': 'complete',
'job-status-code': 200,
# 'job-reason-code' omitted because HTTP status good
'job-results': exp_op_result,
}
m.get(self.job_uri, json=query_job_status_result)
m.delete(self.job_uri, status_code=204)
job_status, op_result = job.check_for_completion()
assert job_status == 'complete'
assert op_result == exp_op_result
def setup_method(self):
"""
Setup that is called by pytest before each test method.
"""
# pylint: disable=attribute-defined-outside-init
self.session = Session(host='fake-host', userid='fake-user',
password='******')
self.manager = MyManager(self.session)
self.resource1_uri = "/api/fake-uri-1"
self.resource1_name = "fake-name-1"
self.resource1 = MyResource(
self.manager, uri=self.resource1_uri,
properties={
self.manager._name_prop: self.resource1_name,
"other": "fake-other-1"
})
self.resource2_uri = "/api/fake-uri-2"
self.resource2_name = "fake-name-2"
self.resource2 = MyResource(
self.manager, uri=self.resource2_uri,
properties={
self.manager._name_prop: self.resource2_name,
"other": "fake-other-2"
})
self.all_names = {self.resource1_name, self.resource2_name}
self.manager._list_resources = [self.resource1, self.resource2]
self.timetolive = 1.0 # seconds
self.cache = _NameUriCache(self.manager, self.timetolive)
self.created = datetime.now()
def setup_method(self):
"""
Setup that is called by pytest before each test method.
"""
# pylint: disable=attribute-defined-outside-init
self.session = Session(host='fake-host', userid='fake-user',
password='******')
self.manager = MyManager(self.session)
self.resource1 = MyResource(
self.manager,
uri="/api/fake-uri-1",
properties={
self.manager._name_prop: "fake-name-1",
"other": "fake-other-1",
"same": "fake-same",
"int_other": 23,
"int_same": 42,
})
self.resource2 = MyResource(
self.manager,
uri="/api/fake-uri-2",
properties={
self.manager._name_prop: "fake-name-2",
"other": "fake-other-2",
"same": "fake-same",
"int_other": 24,
"int_same": 42,
})
self.manager._list_resources = [self.resource1, self.resource2]
def setup_method(self):
self.session = Session(host='fake-host',
userid='fake-user',
password='******')
self.manager = MyManager(self.session)
self.resource1_uri = "/api/fake-uri-1"
self.resource1_name = "fake-name-1"
self.resource1 = MyResource(self.manager,
uri=self.resource1_uri,
properties={
self.manager._name_prop:
self.resource1_name,
"other": "fake-other-1"
})
self.resource2_uri = "/api/fake-uri-2"
self.resource2_name = "fake-name-2"
self.resource2 = MyResource(self.manager,
uri=self.resource2_uri,
properties={
self.manager._name_prop:
self.resource2_name,
"other": "fake-other-2"
})
self.all_names = {self.resource1_name, self.resource2_name}
self.manager._list_resources = [self.resource1, self.resource2]
self.timetolive = 1.0 # seconds
self.cache = _NameUriCache(self.manager, self.timetolive)
self.created = datetime.now()
def test_check_complete_error4(self):
"""Test check_for_completion() with complete job in error (4)."""
with requests_mock.mock() as m:
self.mock_server_1(m)
session = Session('fake-host', 'fake-user', 'fake-pw')
op_method = 'POST'
op_uri = '/api/foo'
job = Job(session, self.job_uri, op_method, op_uri)
query_job_status_result = {
'status': 'complete',
'job-status-code': 500,
'job-reason-code': 42,
'job-results': {
# Content is not documented for the error case.
# Some failures result in an 'message' field.
'message': 'bla message',
},
}
m.get(self.job_uri, json=query_job_status_result)
m.delete(self.job_uri, status_code=204)
with pytest.raises(HTTPError) as exc_info:
job_status, op_result = job.check_for_completion()
exc = exc_info.value
assert exc.http_status == 500
assert exc.reason == 42
assert exc.message == 'bla message'
def test_check_complete_error2(self):
"""Test check_for_completion() with complete job in error (2)."""
with requests_mock.mock() as m:
self.mock_server_1(m)
session = Session('fake-host', 'fake-user', 'fake-pw')
op_method = 'POST'
op_uri = '/api/foo'
job = Job(session, self.job_uri, op_method, op_uri)
query_job_status_result = {
'status': 'complete',
'job-status-code': 500,
'job-reason-code': 42,
'job-results': {}, # it is not guaranteed to have any content
}
m.get(self.job_uri, json=query_job_status_result)
m.delete(self.job_uri, status_code=204)
with pytest.raises(HTTPError) as exc_info:
job_status, op_result = job.check_for_completion()
exc = exc_info.value
assert exc.http_status == 500
assert exc.reason == 42
assert exc.message is None
def setup_method(self):
"""
Setup that is called by pytest before each test method.
"""
# pylint: disable=attribute-defined-outside-init
self.session = Session(host='fake-host', userid='fake-user',
password='******')
def test_session_get_notification_topics():
"""
This tests the 'Get Notification Topics' operation.
"""
session = Session('fake-host', 'fake-user', 'fake-id')
with requests_mock.mock() as m:
# Because logon is deferred until needed, we perform it
# explicitly in order to keep mocking in the actual test simple.
m.post('/api/sessions', json={'api-session': 'fake-session-id'})
session.logon()
gnt_uri = "/api/sessions/operations/get-notification-topics"
gnt_result = {
"topics": [{
'topic-name': 'ensadmin.145',
'topic-type': 'object-notification',
}, {
'topic-name': 'ensadmin.145job',
'topic-type': 'job-notification',
}, {
'topic-name': 'ensadmin.145aud',
'topic-type': 'audit-notification',
}, {
'topic-name': 'ensadmin.145sec',
'topic-type': 'security-notification',
}]
}
m.get(gnt_uri, json=gnt_result)
result = session.get_notification_topics()
assert result == gnt_result['topics']
m.delete('/api/sessions/this-session', status_code=204)
session.logoff()
def probe_hmcz_and_enlist(
user: str,
hostname: str,
username: str,
password: str,
accept_all: bool = False,
domain: str = None,
prefix_filter: str = None,
):
"""Extracts all of the VMs from an HMC for Z and enlists them into MAAS.
:param user: user for the nodes.
:param hostname: Hostname for Proxmox
:param username: The username to connect to Proxmox to
:param password: The password to connect to Proxmox with.
:param accept_all: If True, commission enlisted nodes.
:param domain: What domain discovered machines to be apart of.
:param prefix_filter: only enlist nodes that have the prefix.
"""
session = Session(hostname, username, password)
client = Client(session)
# Each HMC manages one or more CPCs(Central Processor Complex). Iterate
# over all CPCs to find all partitions to add.
for cpc in client.cpcs.list():
if not cpc.dpm_enabled:
maaslog.warning(
f"DPM is not enabled on '{cpc.get_property('name')}', "
"skipping")
continue
for partition in cpc.partitions.list():
if prefix_filter and not partition.name.startswith(prefix_filter):
continue
system_id = yield create_node(
[
nic.get_property("mac-address")
for nic in partition.nics.list()
],
"s390x",
"hmcz",
{
"power_address": hostname,
"power_user": username,
"power_pass": password,
"power_partition_name": partition.name,
},
domain,
partition.name,
)
# If the system_id is None an error occured when creating the machine.
# Most likely the error is the node already exists.
if system_id is None:
continue
if accept_all:
yield commission_node(system_id, user)
def test_session_repr():
"""Test Session.__repr__()."""
session = Session('fake-host', 'fake-user', 'fake-pw')
repr_str = repr(session)
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=session.__class__.__name__, id=id(session)), repr_str)
def setup_method(self):
"""
Setup that is called by pytest before each test method.
"""
# pylint: disable=attribute-defined-outside-init
self.session = Session(host='fake-host')
self.mgr = MyManager(self.session)
self.uri = self.mgr._base_uri + '/deadbeef-beef-beef-beef-deadbeefbeef'
self.name = "fake-name"
self.uri_prop = 'fake-uri-prop' # same as in MyManager
self.name_prop = 'fake-name-prop' # same as in MyManager
def get_session(faked_session, host, userid, password, ca_certs, verify):
"""
Return a session object for the HMC.
Parameters:
faked_session (zhmcclient_mock.FakedSession or None):
If this object is a `zhmcclient_mock.FakedSession` object, return that
object.
Else, return a new `zhmcclient.Session` object from the other arguments.
"""
if isinstance(faked_session, FakedSession):
return faked_session
else:
verify_cert = ca_certs if verify else False
return Session(host, userid, password, verify_cert=verify_cert)
def setup_method(self):
self.session = Session(host='fake-host',
userid='fake-user',
password='******')
self.manager = MyManager(self.session)
self.resource_uri = "/api/fake-uri-1"
self.resource_name = "fake-name-1"
self.resource = MyResource(self.manager,
uri=self.resource_uri,
properties={
self.manager._name_prop:
self.resource_name,
"other": "fake-other-1",
})
self.manager._list_resources = [self.resource]
def get_session(faked_session, host, userid, password):
"""
Return a session object for the HMC.
Parameters:
faked_session (zhmcclient_mock.FakedSession or None):
If this object is a `zhmcclient_mock.FakedSession` object, return that
object.
Else, return a new `zhmcclient.Session` object from the `host`,
`userid`, and `password` arguments.
"""
if isinstance(faked_session, FakedSession):
return faked_session
else:
return Session(host, userid, password)
def test_init(self):
"""Test initialization of Job object."""
session = Session('fake-host', 'fake-user', 'fake-pw')
# Jobs exist only for POST, but we want to test that the specified HTTP
# method comes back regardless:
op_method = 'GET'
op_uri = '/api/bla'
job = Job(session, self.job_uri, op_method, op_uri)
assert job.uri == self.job_uri
assert job.session == session
assert job.op_method == op_method
assert job.op_uri == op_uri
def test_check_incomplete(self):
"""Test check_for_completion() with incomplete job."""
with requests_mock.mock() as m:
self.mock_server_1(m)
session = Session('fake-host', 'fake-user', 'fake-pw')
op_method = 'POST'
op_uri = '/api/foo'
job = Job(session, self.job_uri, op_method, op_uri)
query_job_status_result = {
'status': 'running',
}
m.get(self.job_uri, json=query_job_status_result)
m.delete(self.job_uri, status_code=204)
job_status, op_result = job.check_for_completion()
assert job_status == 'running'
assert op_result is None
def test_job_wait_complete3_timeout():
"""Test wait_for_completion() with timeout."""
with requests_mock.mock() as m:
mock_server_1(m)
session = Session('fake-host', 'fake-user', 'fake-pw')
op_method = 'POST'
op_uri = '/api/foo'
job = Job(session, JOB_URI, op_method, op_uri)
m.get(JOB_URI, [
{
'text': result_running_callback
},
{
'text': result_running_callback
},
{
'text': result_complete_callback
},
])
m.delete(JOB_URI, status_code=204)
# Here we provoke a timeout, by setting the timeout to less than
# the time it would take to return the completed job status.
# The time it would take is the sum of the following:
# - 2 * 1 s (1 s is the sleep time in Job.wait_for_completion(),
# and this happens before each repeated status retrieval)
# - 3 * 1 s (1 s is the sleep time in result_*_callback() in this
# module, and this happens in each mocked status retrieval)
# Because status completion is given priority over achieving the
# timeout duration, the timeout value needed to provoke the
# timeout exception needs to be shorter by the last status
# retrieval (the one that completes the job), so 3 s is the
# boundary for the timeout value.
operation_timeout = 2.9
try:
start_time = time.time()
job.wait_for_completion(operation_timeout=operation_timeout)
duration = time.time() - start_time
raise AssertionError(
"No OperationTimeout raised. Actual duration: %s s, "
"timeout: %s s" % (duration, operation_timeout))
except OperationTimeout as exc:
msg = exc.args[0]
assert msg.startswith("Waiting for completion of job")
def _get_partition(self, context: dict):
session = Session(
context["power_address"],
context["power_user"],
context["power_pass"],
)
partition_name = context["power_partition_name"]
client = Client(session)
# Each HMC manages one or more CPCs(Central Processor Complex). To find
# a partition MAAS must iterate over all CPCs.
for cpc in client.cpcs.list():
if not cpc.dpm_enabled:
maaslog.warning(
f"DPM is not enabled on '{cpc.get_property('name')}', "
"skipping")
continue
with contextlib.suppress(NotFound):
return cpc.partitions.find(name=partition_name)
raise PowerActionError(f"Unable to find '{partition_name}' on HMC!")
def test_job_check_complete_success_noresult():
"""Test check_for_completion() with successful complete job without
result."""
with requests_mock.mock() as m:
mock_server_1(m)
session = Session('fake-host', 'fake-user', 'fake-pw')
op_method = 'POST'
op_uri = '/api/foo'
job = Job(session, JOB_URI, op_method, op_uri)
query_job_status_result = {
'status': 'complete',
'job-status-code': 200,
# 'job-reason-code' omitted because HTTP status good
# 'job-results' is optional and is omitted
}
m.get(JOB_URI, json=query_job_status_result)
m.delete(JOB_URI, status_code=204)
job_status, op_result = job.check_for_completion()
assert job_status == 'complete'
assert op_result is None
def setup_method(self):
self.session = Session(host='fake-host',
userid='fake-user',
password='******')
self.manager = MyManager(self.session)
self.resource1 = MyResource(self.manager,
uri="/api/fake-uri-1",
properties={
self.manager._name_prop: "fake-name-1",
"other": "fake-other-1",
"same": "fake-same",
"int_other": 23,
"int_same": 42,
})
self.resource2 = MyResource(self.manager,
uri="/api/fake-uri-2",
properties={
self.manager._name_prop: "fake-name-2",
"other": "fake-other-2",
"same": "fake-same",
"int_other": 24,
"int_same": 42,
})
self.manager._list_resources = [self.resource1, self.resource2]
class TestVirtualSwitch(object):
"""All tests for VirtualSwitch and VirtualSwitchManager classes."""
def setup_method(self):
self.session = Session('vswitch-dpm-host', 'vswitch-user',
'vswitch-pwd')
self.client = Client(self.session)
with requests_mock.mock() as m:
# Because logon is deferred until needed, we perform it
# explicitly in order to keep mocking in the actual test simple.
m.post('/api/sessions', json={'api-session': 'vswitch-session-id'})
self.session.logon()
self.cpc_mgr = self.client.cpcs
with requests_mock.mock() as m:
result = {
'cpcs': [
{
'object-uri': '/api/cpcs/vswitch-cpc-id-1',
'name': 'CPC',
'status': 'service-required',
}
]
}
m.get('/api/cpcs', json=result)
cpcs = self.cpc_mgr.list()
self.cpc = cpcs[0]
def teardown_method(self):
with requests_mock.mock() as m:
m.delete('/api/sessions/this-session', status_code=204)
self.session.logoff()
def test_init(self):
"""Test __init__() on VirtualSwitchManager instance in CPC."""
vswitch_mgr = self.cpc.virtual_switches
assert vswitch_mgr.cpc == self.cpc
def test_list_short_ok(self):
"""
Test successful list() with short set of properties
on VirtualSwitchManager instance in CPC.
"""
vswitch_mgr = self.cpc.virtual_switches
with requests_mock.mock() as m:
result = {
'virtual-switches': [
{
'name': 'VSWITCH1',
'object-uri': '/api/virtual-switches/fake-vswitch-id1',
'type': 'osd'
},
{
'name': 'VSWITCH2',
'object-uri': '/api/virtual-switches/fake-vswitch-id2',
'type': 'hpersockets'
}
]
}
m.get('/api/cpcs/vswitch-cpc-id-1/virtual-switches', json=result)
vswitches = vswitch_mgr.list(full_properties=False)
assert len(vswitches) == len(result['virtual-switches'])
for idx, vswitch in enumerate(vswitches):
assert vswitch.properties == \
result['virtual-switches'][idx]
assert vswitch.uri == \
result['virtual-switches'][idx]['object-uri']
assert not vswitch.full_properties
assert vswitch.manager == vswitch_mgr
def test_list_full_ok(self):
"""
Test successful list() with full set of properties on
VirtualSwitchManager instance in CPC.
"""
vswitch_mgr = self.cpc.virtual_switches
with requests_mock.mock() as m:
result = {
'virtual-switches': [
{
'name': 'VSWITCH1',
'object-uri': '/api/virtual-switches/fake-vswitch-id1',
'type': 'osd'
},
{
'name': 'VSWITCH2',
'object-uri': '/api/virtual-switches/fake-vswitch-id2',
'type': 'hipersockets'
}
]
}
m.get('/api/cpcs/vswitch-cpc-id-1/virtual-switches', json=result)
mock_result_virtual_switch1 = {
'name': 'VSWITCH1',
'object-uri': '/api/virtual-switches/fake-vswitch-id1',
'type': 'osd',
'class': 'virtual-switch',
'description': 'Test VirtualSwitch',
'more_properties': 'bliblablub'
}
m.get('/api/virtual-switches/fake-vswitch-id1',
json=mock_result_virtual_switch1)
mock_result_virtual_switch2 = {
'name': 'VSWITCH2',
'object-uri': '/api/virtual-switches/fake-vswitch-id2',
'type': 'hipersockets',
'class': 'virtual-switch',
'description': 'Test VirtualSwitch',
'more_properties': 'bliblablub'
}
m.get('/api/virtual-switches/fake-vswitch-id2',
json=mock_result_virtual_switch2)
vswitches = vswitch_mgr.list(full_properties=True)
assert len(vswitches) == len(result['virtual-switches'])
for idx, vswitch in enumerate(vswitches):
assert vswitch.properties['name'] == \
result['virtual-switches'][idx]['name']
assert vswitch.uri == \
result['virtual-switches'][idx]['object-uri']
assert vswitch.full_properties
assert vswitch.manager == vswitch_mgr
def test_update_properties(self):
"""
This tests the 'Update VirtualSwitch Properties' operation.
"""
vswitch_mgr = self.cpc.virtual_switches
with requests_mock.mock() as m:
result = {
'virtual-switches': [
{
'name': 'VSWITCH1',
'object-uri': '/api/virtual-switches/fake-vswitch-id1',
'type': 'osd'
},
{
'name': 'VSWITCH2',
'object-uri': '/api/virtual-switches/fake-vswitch-id2',
'type': 'hpersockets'
}
]
}
m.get('/api/cpcs/vswitch-cpc-id-1/virtual-switches', json=result)
vswitches = vswitch_mgr.list(full_properties=False)
vswitch = vswitches[0]
m.post("/api/virtual-switches/fake-vswitch-id1", status_code=204)
vswitch.update_properties(properties={})
def test_get_connected_nics(self):
"""
This tests the `get_connected_nics()` method.
"""
vswitch_mgr = self.cpc.virtual_switches
with requests_mock.mock() as m:
result = {
'virtual-switches': [
{
'name': 'VSWITCH1',
'object-uri': '/api/virtual-switches/fake-vswitch-id1',
'type': 'osd'
},
{
'name': 'VSWITCH2',
'object-uri': '/api/virtual-switches/fake-vswitch-id2',
'type': 'hpersockets'
}
]
}
m.get('/api/cpcs/vswitch-cpc-id-1/virtual-switches', json=result)
vswitches = vswitch_mgr.list(full_properties=False)
vswitch = vswitches[0]
result = {
'connected-vnic-uris': [
'/api/partitions/fake-part-id1/nics/fake-nic-id1',
'/api/partitions/fake-part-id1/nics/fake-nic-id2',
'/api/partitions/fake-part-id1/nics/fake-nic-id3'
]
}
m.get(
"/api/virtual-switches/fake-vswitch-id1/"
"operations/get-connected-vnics",
json=result)
nics = vswitch.get_connected_nics()
assert isinstance(nics, list)
for i, nic in enumerate(nics):
assert isinstance(nic, Nic)
nic_uri = result['connected-vnic-uris'][i]
assert nic.uri == nic_uri
assert nic.properties['element-uri'] == nic_uri
m = re.match(r"^/api/partitions/([^/]+)/nics/([^/]+)/?$",
nic_uri)
nic_id = m.group(2)
assert nic.properties['element-id'] == nic_id
