def test_baremetal_volume_target_delete_multiple_error(self):
fake_volume_target_uuid2 = 'vvv-tttttt-tttt'
arglist = [
baremetal_fakes.baremetal_volume_target_uuid,
fake_volume_target_uuid2
]
verifylist = [('volume_targets', [
baremetal_fakes.baremetal_volume_target_uuid,
fake_volume_target_uuid2
])]
self.baremetal_mock.volume_target.delete.side_effect = [
None, exc.NotFound()
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(exc.ClientException, self.cmd.take_action,
parsed_args)
self.baremetal_mock.volume_target.delete.assert_has_calls([
mock.call(baremetal_fakes.baremetal_volume_target_uuid),
mock.call(fake_volume_target_uuid2)
])
self.assertEqual(2,
self.baremetal_mock.volume_target.delete.call_count)
def test_macs_for_instance_http_not_found(self, mock_get):
mock_get.side_effect = ironic_exception.NotFound()
instance = fake_instance.fake_instance_obj(
self.ctx, node=uuidutils.generate_uuid())
result = self.driver.macs_for_instance(instance)
self.assertEqual([], result)
def get_by_address(self, address, fields=None):
"""Get a port group with the specified MAC address.
:param address: The MAC address of a portgroup.
:param fields: Optional, a list with a specified set of fields
of the resource to be returned. Can not be used
when 'detail' is set.
:returns: a :class:`Portgroup` object.
"""
path = '?address=%s' % address
if fields is not None:
path += '&fields=' + ','.join(fields)
else:
path = 'detail' + path
portgroups = self._list(self._path(path), 'portgroups')
# get all the details of the portgroup assuming that
# filtering by address returns a collection of one portgroup
# if successful.
if len(portgroups) == 1:
return portgroups[0]
else:
raise exc.NotFound()
def test_send_event_method_not_found(self, mock_client, mock_log):
self.ironic_notifier.irclient = mock_client
exception = ironic_exc.NotFound()
mock_client.events.create.side_effect = exception
self.ironic_notifier.send_events(['test', 'events'])
self.assertEqual(1, mock_log.call_count)
mock_log.assert_called_with('The ironic API appears to not support '
'posting events. The API likely needs to '
'be upgraded.')
def get_by_address(self, address):
path = "detail?address=%s" % address
ports = self._list(self._path(path), 'ports')
# get all the details of the port assuming that filtering by
# address returns a collection of one port if successful.
if len(ports) == 1:
return ports[0]
else:
raise exc.NotFound()
def test_validate_instance_and_node_failed(self, mock_gbiui):
icli = cw.IronicClientWrapper()
mock_gbiui.side_effect = ironic_exception.NotFound()
instance_uuid = uuidutils.generate_uuid(),
instance = fake_instance.fake_instance_obj(self.ctx,
uuid=instance_uuid)
self.assertRaises(exception.InstanceNotFound,
ironic_driver.validate_instance_and_node, icli,
instance)
def get_by_instance_uuid(self, instance_uuid):
path = "detail?instance_uuid=%s" % instance_uuid
nodes = self._list(self._path(path), 'nodes')
# get all the details of the node assuming that
# filtering by instance_uuid returns a collection
# of one node if successful.
if len(nodes) == 1:
return nodes[0]
else:
raise exc.NotFound()
def test_baremetal_volume_target_delete_error(self):
arglist = [baremetal_fakes.baremetal_volume_target_uuid]
verifylist = [('volume_targets',
[baremetal_fakes.baremetal_volume_target_uuid])]
self.baremetal_mock.volume_target.delete.side_effect = (exc.NotFound())
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
self.assertRaises(exc.ClientException, self.cmd.take_action,
parsed_args)
self.baremetal_mock.volume_target.delete.assert_called_with(
baremetal_fakes.baremetal_volume_target_uuid)
def test_get_info_http_not_found(self, mock_gbiu, mock_cli):
mock_gbiu.side_effect = ironic_exception.NotFound()
expected = {'state': nova_states.NOSTATE,
'max_mem': 0,
'mem': 0,
'num_cpu': 0,
'cpu_time': 0}
instance = fake_instance.fake_instance_obj(
self.ctx, uuid=uuidutils.generate_uuid())
mock_cli.return_value = FAKE_CLIENT
result = self.driver.get_info(instance)
self.assertEqual(expected, result)
def get_by_address(self, address, fields=None):
path = '?address=%s' % address
if fields is not None:
path += '&fields=' + ','.join(fields)
else:
path = 'detail' + path
ports = self._list(self._path(path), 'ports')
# get all the details of the port assuming that filtering by
# address returns a collection of one port if successful.
if len(ports) == 1:
return ports[0]
else:
raise exc.NotFound()
def get_by_instance_uuid(self, instance_uuid, fields=None):
path = '?instance_uuid=%s' % instance_uuid
if fields is not None:
path += '&fields=' + ','.join(fields)
else:
path = 'detail' + path
nodes = self._list(self._path(path), 'nodes')
# get all the details of the node assuming that
# filtering by instance_uuid returns a collection
# of one node if successful.
if len(nodes) == 1:
return nodes[0]
else:
raise exc.NotFound()
def test_change_server_power_state_with_rollback_status(
self, set_power_mock, get_power_mock, notify_mock):
server = obj_utils.create_test_server(
self.context, status=states.POWERING_OFF)
exception = ironic_exc.NotFound("The bare metal node is not found")
get_power_mock.return_value = states.POWER_ON
set_power_mock.side_effect = exception
self._start_service()
self.assertRaises(ironic_exc.NotFound, self.service.set_power_state,
self.context, server, 'off')
set_power_mock.assert_called_once_with(self.context, server, 'off')
get_power_mock.assert_called_once_with(self.context, server.uuid)
notify_mock.assert_called_once_with(
self.context, server, 'test-host',
action=fields.NotificationAction.POWER_OFF,
phase=fields.NotificationPhase.ERROR, exception=exception)
self.assertEqual(server.status, states.ACTIVE)
self._stop_service()
class BareMetalNodesTestV21(test.NoDBTestCase):
mod = b_nodes_v21
def setUp(self):
super(BareMetalNodesTestV21, self).setUp()
self._setup()
self.context = context.get_admin_context()
self.request = FakeRequest(self.context)
def _setup(self):
self.controller = b_nodes_v21.BareMetalNodeController()
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'list')
def test_index_ironic(self, mock_list):
properties = {'cpus': 2, 'memory_mb': 1024, 'local_gb': 20}
node = ironic_utils.get_test_node(properties=properties)
mock_list.return_value = [node]
res_dict = self.controller.index(self.request)
expected_output = {'nodes':
[{'memory_mb': properties['memory_mb'],
'host': 'IRONIC MANAGED',
'disk_gb': properties['local_gb'],
'interfaces': [],
'task_state': None,
'id': node.uuid,
'cpus': properties['cpus']}]}
self.assertEqual(expected_output, res_dict)
mock_list.assert_called_once_with(detail=True)
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'list')
def test_index_ironic_missing_properties(self, mock_list):
properties = {'cpus': 2}
node = ironic_utils.get_test_node(properties=properties)
mock_list.return_value = [node]
res_dict = self.controller.index(self.request)
expected_output = {'nodes':
[{'memory_mb': 0,
'host': 'IRONIC MANAGED',
'disk_gb': 0,
'interfaces': [],
'task_state': None,
'id': node.uuid,
'cpus': properties['cpus']}]}
self.assertEqual(expected_output, res_dict)
mock_list.assert_called_once_with(detail=True)
def test_index_ironic_not_implemented(self):
with mock.patch.object(self.mod, 'ironic_client', None):
self.assertRaises(exc.HTTPNotImplemented,
self.controller.index,
self.request)
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'list_ports')
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'get')
def test_show_ironic(self, mock_get, mock_list_ports):
properties = {'cpus': 1, 'memory_mb': 512, 'local_gb': 10}
node = ironic_utils.get_test_node(properties=properties)
port = ironic_utils.get_test_port()
mock_get.return_value = node
mock_list_ports.return_value = [port]
res_dict = self.controller.show(self.request, node.uuid)
expected_output = {'node':
{'memory_mb': properties['memory_mb'],
'instance_uuid': None,
'host': 'IRONIC MANAGED',
'disk_gb': properties['local_gb'],
'interfaces': [{'address': port.address}],
'task_state': None,
'id': node.uuid,
'cpus': properties['cpus']}}
self.assertEqual(expected_output, res_dict)
mock_get.assert_called_once_with(node.uuid)
mock_list_ports.assert_called_once_with(node.uuid)
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'list_ports')
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'get')
def test_show_ironic_no_properties(self, mock_get, mock_list_ports):
properties = {}
node = ironic_utils.get_test_node(properties=properties)
port = ironic_utils.get_test_port()
mock_get.return_value = node
mock_list_ports.return_value = [port]
res_dict = self.controller.show(self.request, node.uuid)
expected_output = {'node':
{'memory_mb': 0,
'instance_uuid': None,
'host': 'IRONIC MANAGED',
'disk_gb': 0,
'interfaces': [{'address': port.address}],
'task_state': None,
'id': node.uuid,
'cpus': 0}}
self.assertEqual(expected_output, res_dict)
mock_get.assert_called_once_with(node.uuid)
mock_list_ports.assert_called_once_with(node.uuid)
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'list_ports')
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'get')
def test_show_ironic_no_interfaces(self, mock_get, mock_list_ports):
properties = {'cpus': 1, 'memory_mb': 512, 'local_gb': 10}
node = ironic_utils.get_test_node(properties=properties)
mock_get.return_value = node
mock_list_ports.return_value = []
res_dict = self.controller.show(self.request, node.uuid)
self.assertEqual([], res_dict['node']['interfaces'])
mock_get.assert_called_once_with(node.uuid)
mock_list_ports.assert_called_once_with(node.uuid)
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'get',
side_effect=ironic_exc.NotFound())
def test_show_ironic_node_not_found(self, mock_get):
error = self.assertRaises(exc.HTTPNotFound, self.controller.show,
self.request, 'fake-uuid')
self.assertIn('fake-uuid', six.text_type(error))
def test_show_ironic_not_implemented(self):
with mock.patch.object(self.mod, 'ironic_client', None):
properties = {'cpus': 1, 'memory_mb': 512, 'local_gb': 10}
node = ironic_utils.get_test_node(properties=properties)
self.assertRaises(exc.HTTPNotImplemented, self.controller.show,
self.request, node.uuid)
def test_create_ironic_not_supported(self):
self.assertRaises(exc.HTTPBadRequest,
self.controller.create,
self.request, {'node': object()})
def test_delete_ironic_not_supported(self):
self.assertRaises(exc.HTTPBadRequest,
self.controller.delete,
self.request, 'fake-id')
def test_add_interface_ironic_not_supported(self):
self.assertRaises(exc.HTTPBadRequest,
self.controller._add_interface,
self.request, 'fake-id', 'fake-body')
def test_remove_interface_ironic_not_supported(self):
self.assertRaises(exc.HTTPBadRequest,
self.controller._remove_interface,
self.request, 'fake-id', 'fake-body')
class BareMetalNodesTest(test.NoDBTestCase):
def setUp(self):
super(BareMetalNodesTest, self).setUp()
self.ext_mgr = self.mox.CreateMock(extensions.ExtensionManager)
self.context = context.get_admin_context()
self.controller = baremetal_nodes.BareMetalNodeController(self.ext_mgr)
self.request = FakeRequest(self.context)
def _test_create(self, node, ext_status=False):
response = node.copy()
del response['pm_password']
response['instance_uuid'] = None
self.mox.StubOutWithMock(db, 'bm_node_create')
db.bm_node_create(self.context, node).AndReturn(response)
self.ext_mgr.is_loaded('os-baremetal-ext-status').AndReturn(ext_status)
self.mox.ReplayAll()
res_dict = self.controller.create(self.request, {'node': node})
self.assertEqual({'node': response}, res_dict)
def _test_show(self, node, ext_status=False):
interfaces = [
fake_interface(id=1, address='11:11:11:11:11:11'),
fake_interface(id=2, address='22:22:22:22:22:22'),
]
node.update(interfaces=interfaces)
response = node.copy()
del response['pm_password']
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
db.bm_node_get(self.context, node['id']).AndReturn(node)
db.bm_interface_get_all_by_bm_node_id(self.context, node['id']).\
AndReturn(interfaces)
self.ext_mgr.is_loaded('os-baremetal-ext-status').AndReturn(ext_status)
self.mox.ReplayAll()
res_dict = self.controller.show(self.request, node['id'])
self.assertEqual({'node': response}, res_dict)
self.assertEqual(2, len(res_dict['node']['interfaces']))
def _test_show_no_interfaces(self, ext_status=False):
node_id = 1
node = {'id': node_id}
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
db.bm_node_get(self.context, node_id).AndReturn(node)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).\
AndRaise(exception.NodeNotFound(node_id=node_id))
self.ext_mgr.is_loaded('os-baremetal-ext-status').AndReturn(ext_status)
self.mox.ReplayAll()
res_dict = self.controller.show(self.request, node_id)
self.assertEqual(node_id, res_dict['node']['id'])
self.assertEqual(0, len(res_dict['node']['interfaces']))
def _test_index(self, ext_status=False):
nodes = [
{
'id': 1
},
{
'id': 2
},
]
interfaces = [
{
'id': 1,
'address': '11:11:11:11:11:11'
},
{
'id': 2,
'address': '22:22:22:22:22:22'
},
]
self.mox.StubOutWithMock(db, 'bm_node_get_all')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
db.bm_node_get_all(self.context).AndReturn(nodes)
db.bm_interface_get_all_by_bm_node_id(self.context, 1).\
AndRaise(exception.NodeNotFound(node_id=1))
for n in nodes:
self.ext_mgr.is_loaded('os-baremetal-ext-status').\
AndReturn(ext_status)
db.bm_interface_get_all_by_bm_node_id(self.context, 2).\
AndReturn(interfaces)
self.mox.ReplayAll()
res_dict = self.controller.index(self.request)
self.assertEqual(2, len(res_dict['nodes']))
self.assertEqual([], res_dict['nodes'][0]['interfaces'])
self.assertEqual(2, len(res_dict['nodes'][1]['interfaces']))
def test_create(self):
node = fake_node(id=100)
self._test_create(node)
def test_create_ext_status(self):
node = fake_node_ext_status(id=100)
self._test_create(node, ext_status=True)
def test_create_with_prov_mac_address(self):
node = {
'service_host': "host",
'cpus': 8,
'memory_mb': 8192,
'local_gb': 128,
'pm_address': "10.1.2.3",
'pm_user': "******",
'pm_password': "******",
'terminal_port': 8000,
'interfaces': [],
}
intf = {
'address': '1a:B2:3C:4d:e5:6f',
'datapath_id': None,
'id': None,
'port_no': None,
}
request = node.copy()
request['prov_mac_address'] = intf['address']
db_node = node.copy()
db_node['id'] = 100
response = node.copy()
response.update(id=db_node['id'],
instance_uuid=None,
interfaces=[intf])
del response['pm_password']
self.mox.StubOutWithMock(db, 'bm_node_create')
self.mox.StubOutWithMock(db, 'bm_interface_create')
self.mox.StubOutWithMock(db, 'bm_interface_get')
db.bm_node_create(self.context, node).AndReturn(db_node)
self.ext_mgr.is_loaded('os-baremetal-ext-status').AndReturn(False)
db.bm_interface_create(self.context,
bm_node_id=db_node['id'],
address=intf['address'],
datapath_id=intf['datapath_id'],
port_no=intf['port_no']).AndReturn(1000)
db.bm_interface_get(self.context, 1000).AndReturn(intf)
self.mox.ReplayAll()
res_dict = self.controller.create(self.request, {'node': request})
self.assertEqual({'node': response}, res_dict)
def test_create_with_invalid_prov_mac_address(self):
node = {
'service_host': "host",
'cpus': 8,
'memory_mb': 8192,
'local_gb': 128,
'pm_address': "10.1.2.3",
'pm_user': "******",
'pm_password': "******",
'terminal_port': 8000,
'prov_mac_address': 'INVALID!!',
}
self.assertRaises(exc.HTTPBadRequest, self.controller.create,
self.request, {'node': node})
def test_delete(self):
self.mox.StubOutWithMock(db, 'bm_node_destroy')
db.bm_node_destroy(self.context, 1)
self.mox.ReplayAll()
self.controller.delete(self.request, 1)
def test_delete_node_not_found(self):
self.mox.StubOutWithMock(db, 'bm_node_destroy')
db.bm_node_destroy(self.context, 1).\
AndRaise(exception.NodeNotFound(node_id=1))
self.mox.ReplayAll()
self.assertRaises(exc.HTTPNotFound, self.controller.delete,
self.request, 1)
def test_index(self):
self._test_index()
def test_index_ext_status(self):
self._test_index(ext_status=True)
def test_show(self):
node = fake_node(id=1)
self._test_show(node)
def test_show_ext_status(self):
node = fake_node_ext_status(id=1)
self._test_show(node, ext_status=True)
def test_show_no_interfaces(self):
self._test_show_no_interfaces()
def test_show_no_interfaces_ext_status(self):
self._test_show_no_interfaces(ext_status=True)
@mock.patch.object(FAKE_IRONIC_CLIENT.node,
'get',
side_effect=ironic_exc.NotFound())
def test_show_ironic_node_not_found(self, mock_get):
CONF.set_override('compute_driver', 'nova.virt.ironic.driver')
error = self.assertRaises(exc.HTTPNotFound, self.controller.show,
self.request, 'fake-uuid')
self.assertIn('fake-uuid', six.text_type(error))
def test_add_interface(self):
node_id = 1
address = '11:22:33:ab:cd:ef'
body = {'add_interface': {'address': address}}
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_create')
self.mox.StubOutWithMock(db, 'bm_interface_get')
db.bm_node_get(self.context, node_id)
db.bm_interface_create(self.context,
bm_node_id=node_id,
address=address,
datapath_id=None,
port_no=None).\
AndReturn(12345)
db.bm_interface_get(self.context, 12345).\
AndReturn({'id': 12345, 'address': address})
self.mox.ReplayAll()
res_dict = self.controller._add_interface(self.request, node_id, body)
self.assertEqual(12345, res_dict['interface']['id'])
self.assertEqual(address, res_dict['interface']['address'])
def test_add_interface_invalid_address(self):
node_id = 1
body = {'add_interface': {'address': ''}}
self.mox.StubOutWithMock(db, 'bm_node_get')
db.bm_node_get(self.context, node_id)
self.mox.ReplayAll()
self.assertRaises(exc.HTTPBadRequest, self.controller._add_interface,
self.request, node_id, body)
def test_remove_interface(self):
node_id = 1
interfaces = [
{
'id': 1
},
{
'id': 2
},
{
'id': 3
},
]
body = {'remove_interface': {'id': 2}}
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
self.mox.StubOutWithMock(db, 'bm_interface_destroy')
db.bm_node_get(self.context, node_id)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).\
AndReturn(interfaces)
db.bm_interface_destroy(self.context, 2)
self.mox.ReplayAll()
self.controller._remove_interface(self.request, node_id, body)
def test_remove_interface_by_address(self):
node_id = 1
interfaces = [
{
'id': 1,
'address': '11:11:11:11:11:11'
},
{
'id': 2,
'address': '22:22:22:22:22:22'
},
{
'id': 3,
'address': '33:33:33:33:33:33'
},
]
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
self.mox.StubOutWithMock(db, 'bm_interface_destroy')
db.bm_node_get(self.context, node_id)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).\
AndReturn(interfaces)
db.bm_interface_destroy(self.context, 2)
self.mox.ReplayAll()
body = {'remove_interface': {'address': '22:22:22:22:22:22'}}
self.controller._remove_interface(self.request, node_id, body)
def test_remove_interface_no_id_no_address(self):
node_id = 1
self.mox.StubOutWithMock(db, 'bm_node_get')
db.bm_node_get(self.context, node_id)
self.mox.ReplayAll()
body = {'remove_interface': {}}
self.assertRaises(exc.HTTPBadRequest,
self.controller._remove_interface, self.request,
node_id, body)
def test_add_interface_node_not_found(self):
node_id = 1
self.mox.StubOutWithMock(db, 'bm_node_get')
db.bm_node_get(self.context, node_id).\
AndRaise(exception.NodeNotFound(node_id=node_id))
self.mox.ReplayAll()
body = {'add_interface': {'address': '11:11:11:11:11:11'}}
self.assertRaises(exc.HTTPNotFound, self.controller._add_interface,
self.request, node_id, body)
def test_remove_interface_node_not_found(self):
node_id = 1
self.mox.StubOutWithMock(db, 'bm_node_get')
db.bm_node_get(self.context, node_id).\
AndRaise(exception.NodeNotFound(node_id=node_id))
self.mox.ReplayAll()
body = {'remove_interface': {'address': '11:11:11:11:11:11'}}
self.assertRaises(exc.HTTPNotFound, self.controller._remove_interface,
self.request, node_id, body)
def test_is_valid_mac(self):
self.assertFalse(baremetal_nodes.is_valid_mac(None))
self.assertTrue(baremetal_nodes.is_valid_mac("52:54:00:cf:2d:31"))
self.assertTrue(baremetal_nodes.is_valid_mac(u"52:54:00:cf:2d:31"))
self.assertFalse(baremetal_nodes.is_valid_mac("127.0.0.1"))
self.assertFalse(baremetal_nodes.is_valid_mac("not:a:mac:address"))
self.assertFalse(baremetal_nodes.is_valid_mac("52-54-00-cf-2d-31"))
self.assertFalse(baremetal_nodes.is_valid_mac("5254.00cf.2d31"))
self.assertFalse(baremetal_nodes.is_valid_mac("52:54:0:cf:2d:31"))
self.assertFalse(baremetal_nodes.is_valid_mac("aa bb cc dd ee ff"))
self.assertTrue(baremetal_nodes.is_valid_mac("AA:BB:CC:DD:EE:FF"))
self.assertFalse(baremetal_nodes.is_valid_mac("AA BB CC DD EE FF"))
self.assertFalse(baremetal_nodes.is_valid_mac("AA-BB-CC-DD-EE-FF"))
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'list')
def test_index_ironic(self, mock_list):
CONF.set_override('compute_driver', 'nova.virt.ironic.driver')
properties = {'cpus': 2, 'memory_mb': 1024, 'local_gb': 20}
node = ironic_utils.get_test_node(properties=properties)
mock_list.return_value = [node]
res_dict = self.controller.index(self.request)
expected_output = {
'nodes': [{
'memory_mb': properties['memory_mb'],
'host': 'IRONIC MANAGED',
'disk_gb': properties['local_gb'],
'interfaces': [],
'task_state': None,
'id': node.uuid,
'cpus': properties['cpus']
}]
}
self.assertEqual(expected_output, res_dict)
mock_list.assert_called_once_with(detail=True)
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'list')
def test_index_ironic_missing_properties(self, mock_list):
CONF.set_override('compute_driver', 'nova.virt.ironic.driver')
properties = {'cpus': 2}
node = ironic_utils.get_test_node(properties=properties)
mock_list.return_value = [node]
res_dict = self.controller.index(self.request)
expected_output = {
'nodes': [{
'memory_mb': 0,
'host': 'IRONIC MANAGED',
'disk_gb': 0,
'interfaces': [],
'task_state': None,
'id': node.uuid,
'cpus': properties['cpus']
}]
}
self.assertEqual(expected_output, res_dict)
mock_list.assert_called_once_with(detail=True)
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'list_ports')
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'get')
def test_show_ironic(self, mock_get, mock_list_ports):
CONF.set_override('compute_driver', 'nova.virt.ironic.driver')
properties = {'cpus': 1, 'memory_mb': 512, 'local_gb': 10}
node = ironic_utils.get_test_node(properties=properties)
port = ironic_utils.get_test_port()
mock_get.return_value = node
mock_list_ports.return_value = [port]
res_dict = self.controller.show(self.request, node.uuid)
expected_output = {
'node': {
'memory_mb': properties['memory_mb'],
'instance_uuid': None,
'host': 'IRONIC MANAGED',
'disk_gb': properties['local_gb'],
'interfaces': [{
'address': port.address
}],
'task_state': None,
'id': node.uuid,
'cpus': properties['cpus']
}
}
self.assertEqual(expected_output, res_dict)
mock_get.assert_called_once_with(node.uuid)
mock_list_ports.assert_called_once_with(node.uuid)
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'list_ports')
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'get')
def test_show_ironic_no_properties(self, mock_get, mock_list_ports):
CONF.set_override('compute_driver', 'nova.virt.ironic.driver')
properties = {}
node = ironic_utils.get_test_node(properties=properties)
port = ironic_utils.get_test_port()
mock_get.return_value = node
mock_list_ports.return_value = [port]
res_dict = self.controller.show(self.request, node.uuid)
expected_output = {
'node': {
'memory_mb': 0,
'instance_uuid': None,
'host': 'IRONIC MANAGED',
'disk_gb': 0,
'interfaces': [{
'address': port.address
}],
'task_state': None,
'id': node.uuid,
'cpus': 0
}
}
self.assertEqual(expected_output, res_dict)
mock_get.assert_called_once_with(node.uuid)
mock_list_ports.assert_called_once_with(node.uuid)
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'list_ports')
@mock.patch.object(FAKE_IRONIC_CLIENT.node, 'get')
def test_show_ironic_no_interfaces(self, mock_get, mock_list_ports):
CONF.set_override('compute_driver', 'nova.virt.ironic.driver')
properties = {'cpus': 1, 'memory_mb': 512, 'local_gb': 10}
node = ironic_utils.get_test_node(properties=properties)
mock_get.return_value = node
mock_list_ports.return_value = []
res_dict = self.controller.show(self.request, node.uuid)
self.assertEqual([], res_dict['node']['interfaces'])
mock_get.assert_called_once_with(node.uuid)
mock_list_ports.assert_called_once_with(node.uuid)
def test_create_ironic_not_supported(self):
CONF.set_override('compute_driver', 'nova.virt.ironic.driver')
self.assertRaises(exc.HTTPBadRequest, self.controller.create,
self.request, {'node': object()})
def test_delete_ironic_not_supported(self):
CONF.set_override('compute_driver', 'nova.virt.ironic.driver')
self.assertRaises(exc.HTTPBadRequest, self.controller.delete,
self.request, 'fake-id')
def test_add_interface_ironic_not_supported(self):
CONF.set_override('compute_driver', 'nova.virt.ironic.driver')
self.assertRaises(exc.HTTPBadRequest, self.controller._add_interface,
self.request, 'fake-id', 'fake-body')
def test_remove_interface_ironic_not_supported(self):
CONF.set_override('compute_driver', 'nova.virt.ironic.driver')
self.assertRaises(exc.HTTPBadRequest,
self.controller._remove_interface, self.request,
'fake-id', 'fake-body')
