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_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_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 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
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
class TestPort(object):
"""All tests for Port and PortManager classes."""
def setup_method(self):
"""
Setup that is called by pytest before each test method.
"""
# pylint: disable=attribute-defined-outside-init
self.session = Session('port-dpm-host', 'port-user',
'port-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': 'port-session-id'})
self.session.logon()
self.cpc_mgr = self.client.cpcs
with requests_mock.mock() as m:
result = {
'cpcs': [
{
'object-uri': '/api/cpcs/port-cpc-id-1',
'name': 'CPC',
'status': 'service-required',
}
]
}
m.get('/api/cpcs', json=result)
cpcs = self.cpc_mgr.list()
self.cpc = cpcs[0]
adapter_mgr = self.cpc.adapters
with requests_mock.mock() as m:
self.result = {
'adapters': [
{
'adapter-family': 'ficon',
'adapter-id': '18C',
'type': 'fcp',
'status': 'active',
'object-uri': '/api/adapters/fake-adapter-id-1',
'name': 'FCP Adapter 1',
'port-count': 1,
'storage-port-uris': [
'/api/adapters/fake-adapter-id-1/storage-ports/0'
]
},
{
'adapter-family': 'osa',
'adapter-id': '1C4',
'type': 'osd',
'status': 'active',
'object-uri': '/api/adapters/fake-adapter-id-2',
'name': 'OSD Adapter 1',
'port-count': 2,
'network-port-uris': [
'/api/adapters/fake-adapter-id-2/network-ports/0',
'/api/adapters/fake-adapter-id-2/network-ports/1'
]
},
{
'status': 'not-active',
'configured-capacity': 3,
'description': '',
'parent': '/api/cpcs//port-cpc-id-1',
'object-id': 'fake-adapter-id-3',
'detected-card-type': 'zedc-express',
'class': 'adapter',
'name': 'zEDC 01CC Z15B-23',
'used-capacity': 0,
'adapter-id': '1CC',
'maximum-total-capacity': 15,
'adapter-family': 'accelerator',
'allowed-capacity': 15,
'state': 'reserved',
'object-uri': '/api/adapters/fake-adapter-id-3',
'card-location': 'Z15B-LG23',
'type': 'zedc'
}
]
}
m.get('/api/cpcs/port-cpc-id-1/adapters', json=self.result)
adapters = adapter_mgr.list(full_properties=False)
self.adapters = adapters
def teardown_method(self):
"""
Teardown that is called by pytest after each test method.
"""
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 PortManager instance in Adapter."""
port_mgr = self.adapters[0].ports
assert port_mgr.adapter == self.adapters[0]
def test_list_short_ok(self):
"""
Test successful list() with short set of properties on PortManager
instance in Adapter.
"""
adapters = self.adapters
for idy, adapter in enumerate(adapters):
with requests_mock.mock() as m:
m.get(adapter.uri, json=adapter.properties)
port_mgr = adapter.ports
ports = port_mgr.list(full_properties=False)
if len(ports) != 0:
result_adapter = self.result['adapters'][idy]
if 'storage-port-uris' in result_adapter:
storage_uris = result_adapter['storage-port-uris']
uris = storage_uris
else:
network_uris = result_adapter['network-port-uris']
uris = network_uris
assert adapter.properties['port-count'] == len(uris)
else:
uris = []
assert len(ports) == len(uris)
for _, port in enumerate(ports):
assert port.properties['element-uri'] in uris
assert not port.full_properties
assert port.manager == port_mgr
def test_list_full_ok(self):
"""
Test successful list() with full set of properties on PortManager
instance in Adapter.
"""
adapters = self.adapters
adapter = adapters[0]
port_mgr = adapter.ports
with requests_mock.mock() as m:
mock_result_port1 = {
'parent': '/api/adapters/fake-adapter-id-1',
'index': 0,
'fabric-id': '',
'description': '',
'element-uri':
'/api/adapters/fake-adapter-id-1/storage-ports/0',
'element-id': '0',
'class': 'storage-port',
'name': 'Port 0'
}
m.get('/api/adapters/fake-adapter-id-1/storage-ports/0',
json=mock_result_port1)
ports = port_mgr.list(full_properties=True)
if len(ports) != 0:
storage_uris = self.result['adapters'][0]['storage-port-uris']
assert adapter.properties['port-count'] == len(storage_uris)
else:
storage_uris = []
assert len(ports) == len(storage_uris)
for idx, port in enumerate(ports):
assert port.properties['element-uri'] == storage_uris[idx]
assert port.full_properties
assert port.manager == port_mgr
def test_list_filter_name_ok(self):
"""
Test successful list() with filter arguments using the 'name' property
on a PortManager instance in a partition.
"""
adapters = self.adapters
adapter = adapters[0]
port_mgr = adapter.ports
with requests_mock.mock() as m:
mock_result_port1 = {
'parent': '/api/adapters/fake-adapter-id-1',
'index': 0,
'fabric-id': '',
'description': '',
'element-uri':
'/api/adapters/fake-adapter-id-1/storage-ports/0',
'element-id': '0',
'class': 'storage-port',
'name': 'Port 0'
}
m.get('/api/adapters/fake-adapter-id-1/storage-ports/0',
json=mock_result_port1)
filter_args = {'name': 'Port 0'}
ports = port_mgr.list(filter_args=filter_args)
assert len(ports) == 1
port = ports[0]
assert port.name == 'Port 0'
assert port.uri == \
'/api/adapters/fake-adapter-id-1/storage-ports/0'
assert port.properties['name'] == 'Port 0'
assert port.properties['element-id'] == '0'
assert port.manager == port_mgr
def test_list_filter_elementid_ok(self):
"""
Test successful list() with filter arguments using the 'element-id'
property on a PortManager instance in a partition.
"""
adapters = self.adapters
adapter = adapters[0]
port_mgr = adapter.ports
with requests_mock.mock() as m:
mock_result_port1 = {
'parent': '/api/adapters/fake-adapter-id-1',
'index': 0,
'fabric-id': '',
'description': '',
'element-uri':
'/api/adapters/fake-adapter-id-1/storage-ports/0',
'element-id': '0',
'class': 'storage-port',
'name': 'Port 0'
}
m.get('/api/adapters/fake-adapter-id-1/storage-ports/0',
json=mock_result_port1)
filter_args = {'element-id': '0'}
ports = port_mgr.list(filter_args=filter_args)
assert len(ports) == 1
port = ports[0]
assert port.name == 'Port 0'
assert port.uri == \
'/api/adapters/fake-adapter-id-1/storage-ports/0'
assert port.properties['name'] == 'Port 0'
assert port.properties['element-id'] == '0'
assert port.manager == port_mgr
def test_update_properties(self):
"""
This tests the 'Update Port Properties' operation.
"""
port_mgr = self.adapters[0].ports
ports = port_mgr.list(full_properties=False)
port = ports[0]
with requests_mock.mock() as m:
m.post('/api/adapters/fake-adapter-id-1/storage-ports/0',
status_code=204)
port.update_properties(properties={})
class TestVirtualFunction(object):
"""
All tests for VirtualFunction and VirtualFunctionManager classes.
"""
def setup_method(self):
"""
Setup that is called by pytest before each test method.
"""
# pylint: disable=attribute-defined-outside-init
self.session = Session('test-dpm-host', 'test-user', 'test-id')
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': 'test-session-id'})
self.session.logon()
self.cpc_mgr = self.client.cpcs
with requests_mock.mock() as m:
result = {
'cpcs': [{
'object-uri': '/api/cpcs/fake-cpc-id-1',
'name': 'CPC1',
'status': '',
}]
}
m.get('/api/cpcs', json=result)
# self.cpc = self.cpc_mgr.find(name="CPC1", full_properties=False)
cpcs = self.cpc_mgr.list()
self.cpc = cpcs[0]
partition_mgr = self.cpc.partitions
with requests_mock.mock() as m:
result = {
'partitions': [{
'status': 'active',
'object-uri': '/api/partitions/fake-part-id-1',
'name': 'PART1'
}, {
'status': 'stopped',
'object-uri': '/api/partitions/fake-part-id-2',
'name': 'PART2'
}]
}
m.get('/api/cpcs/fake-cpc-id-1/partitions', json=result)
mock_result_part1 = {
'status':
'active',
'object-uri':
'/api/partitions/fake-part-id-1',
'name':
'PART1',
'description':
'Test Partition',
'more_properties':
'bliblablub',
'virtual-function-uris': [
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1',
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-2'
]
}
m.get('/api/partitions/fake-part-id-1', json=mock_result_part1)
mock_result_part2 = {
'status':
'stopped',
'object-uri':
'/api/partitions/fake-lpar-id-2',
'name':
'PART2',
'description':
'Test Partition',
'more_properties':
'bliblablub',
'virtual-function-uris': [
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1',
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-2'
]
}
m.get('/api/partitions/fake-part-id-2', json=mock_result_part2)
partitions = partition_mgr.list(full_properties=True)
self.partition = partitions[0]
def teardown_method(self):
"""
Teardown that is called by pytest after each test method.
"""
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 VirtualFunctionManager instance in Partition."""
vf_mgr = self.partition.virtual_functions
assert vf_mgr.partition == self.partition
def test_list_short_ok(self):
"""
Test successful list() with short set of properties on
VirtualFunctionManager instance in partition.
"""
vf_mgr = self.partition.virtual_functions
vfs = vf_mgr.list(full_properties=False)
assert len(vfs) == \
len(self.partition.properties['virtual-function-uris'])
for idx, vf in enumerate(vfs):
assert vf.properties['element-uri'] == \
self.partition.properties['virtual-function-uris'][idx]
assert vf.uri == \
self.partition.properties['virtual-function-uris'][idx]
assert not vf.full_properties
assert vf.manager == vf_mgr
def test_list_full_ok(self):
"""
Test successful list() with full set of properties on
VirtualFunctionManager instance in partition.
"""
vf_mgr = self.partition.virtual_functions
with requests_mock.mock() as m:
mock_result_vf1 = {
'parent': '/api/partitions/fake-part-id-1',
'name': 'vf1',
'element-uri':
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1',
'class': 'virtual-function',
'element-id': 'fake-vf-id-1',
'description': '',
'more_properties': 'bliblablub'
}
m.get(
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1',
json=mock_result_vf1)
mock_result_vf2 = {
'parent': '/api/partitions/fake-part-id-1',
'name': 'vf2',
'element-uri':
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-2',
'class': 'virtual-function',
'element-id': 'fake-vf-id-2',
'description': '',
'more_properties': 'bliblablub'
}
m.get(
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-2',
json=mock_result_vf2)
vfs = vf_mgr.list(full_properties=True)
assert len(vfs) == \
len(self.partition.properties['virtual-function-uris'])
for idx, vf in enumerate(vfs):
assert vf.properties['element-uri'] == \
self.partition.properties['virtual-function-uris'][idx]
assert vf.uri == \
self.partition.properties['virtual-function-uris'][idx]
assert vf.full_properties
assert vf.manager == vf_mgr
def test_list_filter_name_ok(self):
"""
Test successful list() with filter arguments using the 'name' property
on a VirtualFunctionManager instance in a partition.
"""
vf_mgr = self.partition.virtual_functions
with requests_mock.mock() as m:
mock_result_vf1 = {
'parent': '/api/partitions/fake-part-id-1',
'name': 'vf1',
'element-uri':
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1',
'class': 'virtual-function',
'element-id': 'fake-vf-id-1',
'description': '',
'more_properties': 'bliblablub'
}
m.get(
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1',
json=mock_result_vf1)
mock_result_vf2 = {
'parent': '/api/partitions/fake-part-id-1',
'name': 'vf2',
'element-uri':
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-2',
'class': 'virtual-function',
'element-id': 'fake-vf-id-2',
'description': '',
'more_properties': 'bliblablub'
}
m.get(
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-2',
json=mock_result_vf2)
filter_args = {'name': 'vf2'}
vfs = vf_mgr.list(filter_args=filter_args)
assert len(vfs) == 1
vf = vfs[0]
assert vf.name == 'vf2'
assert vf.uri == \
'/api/partitions/fake-part-id-1/virtual-functions/' \
'fake-vf-id-2'
assert vf.properties['name'] == 'vf2'
assert vf.properties['element-id'] == 'fake-vf-id-2'
assert vf.manager == vf_mgr
def test_list_filter_elementid_ok(self):
"""
Test successful list() with filter arguments using the 'element-id'
property on a VirtualFunctionManager instance in a partition.
"""
vf_mgr = self.partition.virtual_functions
with requests_mock.mock() as m:
mock_result_vf1 = {
'parent': '/api/partitions/fake-part-id-1',
'name': 'vf1',
'element-uri':
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1',
'class': 'virtual-function',
'element-id': 'fake-vf-id-1',
'description': '',
'more_properties': 'bliblablub'
}
m.get(
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1',
json=mock_result_vf1)
mock_result_vf2 = {
'parent': '/api/partitions/fake-part-id-1',
'name': 'vf2',
'element-uri':
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-2',
'class': 'virtual-function',
'element-id': 'fake-vf-id-2',
'description': '',
'more_properties': 'bliblablub'
}
m.get(
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-2',
json=mock_result_vf2)
filter_args = {'element-id': 'fake-vf-id-2'}
vfs = vf_mgr.list(filter_args=filter_args)
assert len(vfs) == 1
vf = vfs[0]
assert vf.name == 'vf2'
assert vf.uri == \
'/api/partitions/fake-part-id-1/virtual-functions/' \
'fake-vf-id-2'
assert vf.properties['name'] == 'vf2'
assert vf.properties['element-id'] == 'fake-vf-id-2'
assert vf.manager == vf_mgr
def test_create(self):
"""
This tests the 'Create Virtual Function' operation.
"""
vf_mgr = self.partition.virtual_functions
with requests_mock.mock() as m:
result = {
'element-uri':
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1'
}
m.post('/api/partitions/fake-part-id-1/virtual-functions',
json=result)
vf = vf_mgr.create(properties={})
assert isinstance(vf, VirtualFunction)
assert vf.properties == result
assert vf.uri == result['element-uri']
def test_delete(self):
"""
This tests the 'Delete Virtual Function' operation.
"""
vf_mgr = self.partition.virtual_functions
vfs = vf_mgr.list(full_properties=False)
vf = vfs[0]
with requests_mock.mock() as m:
m.delete(
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1',
status_code=204)
vf.delete()
def test_update_properties(self):
"""
This tests the 'Update Virtual Function Properties' operation.
"""
vf_mgr = self.partition.virtual_functions
vfs = vf_mgr.list(full_properties=False)
vf = vfs[0]
with requests_mock.mock() as m:
m.post(
'/api/partitions/fake-part-id-1/virtual-functions/'
'fake-vf-id-1',
status_code=204)
vf.update_properties(properties={})
