From 7ecca8868a63237485e1b0ca25278d526e1324d2 Mon Sep 17 00:00:00 2001 From: Chris Behrens Date: Wed, 2 Apr 2014 02:56:55 -0700 Subject: [PATCH] Add create() and destroy() to Node What it says. Also make the code use them vs direct calls to dbapi. This also removes passing context to node.refresh() and node.save() since context is cached on the Node object on create. Partial-Bug: 1314732 Change-Id: Id3fafe1eae70954095ed94dec86e4583b23c5af8 --- ironic/api/controllers/v1/node.py | 5 +- ironic/conductor/manager.py | 5 +- ironic/db/sqlalchemy/api.py | 1 - ironic/objects/node.py | 38 +- ironic/tests/api/v1/test_chassis.py | 10 +- ironic/tests/api/v1/test_nodes.py | 231 +++++----- ironic/tests/api/v1/test_ports.py | 17 +- .../tests/conductor/test_conductor_utils.py | 101 ++-- ironic/tests/conductor/test_manager.py | 432 ++++++++---------- ironic/tests/conductor/test_task_manager.py | 19 +- ironic/tests/drivers/test_ipminative.py | 30 +- ironic/tests/drivers/test_ipmitool.py | 7 +- ironic/tests/drivers/test_pxe.py | 104 ++--- ironic/tests/drivers/test_seamicro.py | 12 +- ironic/tests/drivers/test_ssh.py | 17 +- ironic/tests/drivers/test_utils.py | 4 +- ironic/tests/objects/utils.py | 9 + 17 files changed, 511 insertions(+), 531 deletions(-) diff --git a/ironic/api/controllers/v1/node.py b/ironic/api/controllers/v1/node.py index b44d4bc2e3..616017f48a 100644 --- a/ironic/api/controllers/v1/node.py +++ b/ironic/api/controllers/v1/node.py @@ -657,8 +657,9 @@ class NodesController(rest.RestController): e.code = 400 raise e - new_node = pecan.request.dbapi.create_node(node.as_dict()) - + new_node = objects.Node(context=pecan.request.context, + **node.as_dict()) + new_node.create() return Node.convert_with_links(new_node) @wsme.validate(types.uuid, [NodePatchType]) diff --git a/ironic/conductor/manager.py b/ironic/conductor/manager.py index 12ad3cde9f..52fac14814 100644 --- a/ironic/conductor/manager.py +++ b/ironic/conductor/manager.py @@ -779,8 +779,9 @@ class ConductorManager(periodic_task.PeriodicTasks): msg = (_("Node %s can't be deleted because it's not " "powered off") % node.uuid) raise exception.NodeInWrongPowerState(msg) - - self.dbapi.destroy_node(node_id) + # FIXME(comstud): Remove context argument after we ensure + # every instantiation of Node includes the context + node.destroy(context) @messaging.expected_exceptions(exception.NodeLocked, exception.UnsupportedDriverExtension, diff --git a/ironic/db/sqlalchemy/api.py b/ironic/db/sqlalchemy/api.py index bc1eb25ab6..b62c576f62 100644 --- a/ironic/db/sqlalchemy/api.py +++ b/ironic/db/sqlalchemy/api.py @@ -300,7 +300,6 @@ class Connection(api.Connection): # one or more node had reservation != tag _check_node_already_locked(query, query_by) - @objects.objectify(objects.Node) def create_node(self, values): # ensure defaults are present for new nodes if not values.get('uuid'): diff --git a/ironic/objects/node.py b/ironic/objects/node.py index 74af8c41f6..9efe0ce64a 100644 --- a/ironic/objects/node.py +++ b/ironic/objects/node.py @@ -25,7 +25,8 @@ class Node(base.IronicObject): # Version 1.1: Added instance_info # Version 1.2: Add get() and get_by_id() and make get_by_uuid() # only work with a uuid - VERSION = '1.2' + # Version 1.3: Add create() and destroy() + VERSION = '1.3' dbapi = db_api.get_instance() @@ -115,6 +116,41 @@ class Node(base.IronicObject): node._context = context return node + @base.remotable + def create(self, context=None): + """Create a Node record in the DB. + + Column-wise updates will be made based on the result of + self.what_changed(). If target_power_state is provided, + it will be checked against the in-database copy of the + node before updates are made. + + :param context: Security context. NOTE: This should only + be used internally by the indirection_api. + Unfortunately, RPC requires context as the first + argument, even though we don't use it. + A context should be set when instantiating the + object, e.g.: Node(context=context) + + """ + values = self.obj_get_changes() + db_node = self.dbapi.create_node(values) + self._from_db_object(self, db_node) + + @base.remotable + def destroy(self, context=None): + """Delete the Node from the DB. + + :param context: Security context. NOTE: This should only + be used internally by the indirection_api. + Unfortunately, RPC requires context as the first + argument, even though we don't use it. + A context should be set when instantiating the + object, e.g.: Node(context=context) + """ + self.dbapi.destroy_node(self.id) + self.obj_reset_changes() + @base.remotable def save(self, context=None): """Save updates to this Node. diff --git a/ironic/tests/api/v1/test_chassis.py b/ironic/tests/api/v1/test_chassis.py index 7e145d3580..de2e2178a5 100644 --- a/ironic/tests/api/v1/test_chassis.py +++ b/ironic/tests/api/v1/test_chassis.py @@ -25,6 +25,7 @@ from ironic.openstack.common import timeutils from ironic.tests.api import base from ironic.tests.api import utils as apiutils from ironic.tests.db import utils as dbutils +from ironic.tests.objects import utils as obj_utils class TestListChassis(base.FunctionalTest): @@ -126,9 +127,9 @@ class TestListChassis(base.FunctionalTest): self.dbapi.create_chassis(cdict) for id in range(2): - ndict = dbutils.get_test_node(id=id, chassis_id=cdict['id'], - uuid=utils.generate_uuid()) - self.dbapi.create_node(ndict) + obj_utils.create_test_node(self.context, id=id, + chassis_id=cdict['id'], + uuid=utils.generate_uuid()) data = self.get_json('/chassis/%s/nodes' % cdict['uuid']) self.assertEqual(2, len(data['nodes'])) @@ -374,8 +375,7 @@ class TestDelete(base.FunctionalTest): def test_delete_chassis_with_node(self): cdict = dbutils.get_test_chassis() self.dbapi.create_chassis(cdict) - ndict = dbutils.get_test_node(chassis_id=cdict['id']) - self.dbapi.create_node(ndict) + obj_utils.create_test_node(self.context, chassis_id=cdict['id']) response = self.delete('/chassis/%s' % cdict['uuid'], expect_errors=True) self.assertEqual(400, response.status_int) diff --git a/ironic/tests/api/v1/test_nodes.py b/ironic/tests/api/v1/test_nodes.py index ce37f101da..39f6cb85df 100644 --- a/ironic/tests/api/v1/test_nodes.py +++ b/ironic/tests/api/v1/test_nodes.py @@ -26,10 +26,12 @@ from ironic.common import states from ironic.common import utils from ironic.conductor import rpcapi from ironic import objects +from ironic.openstack.common import context from ironic.openstack.common import timeutils from ironic.tests.api import base from ironic.tests.api import utils as apiutils from ironic.tests.db import utils as dbutils +from ironic.tests.objects import utils as obj_utils # NOTE(lucasagomes): When creating a node via API (POST) @@ -57,19 +59,17 @@ class TestListNodes(base.FunctionalTest): #create some unassociated nodes unassociated_nodes = [] for id in range(3): - ndict = dbutils.get_test_node(id=id, - uuid=utils.generate_uuid()) - node = self.dbapi.create_node(ndict) - unassociated_nodes.append(node['uuid']) + node = obj_utils.create_test_node(self.context, + id=id, + uuid=utils.generate_uuid()) + unassociated_nodes.append(node.uuid) #created some associated nodes associated_nodes = [] for id in range(3, 7): - ndict = dbutils.get_test_node( - id=id, - uuid=utils.generate_uuid(), - instance_uuid=utils.generate_uuid()) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node( + self.context, id=id, uuid=utils.generate_uuid(), + instance_uuid=utils.generate_uuid()) associated_nodes.append(node['uuid']) return {'associated': associated_nodes, 'unassociated': unassociated_nodes} @@ -79,8 +79,7 @@ class TestListNodes(base.FunctionalTest): self.assertEqual([], data['nodes']) def test_one(self): - ndict = dbutils.get_test_node() - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context) data = self.get_json('/nodes') self.assertIn('instance_uuid', data['nodes'][0]) self.assertIn('maintenance', data['nodes'][0]) @@ -102,10 +101,9 @@ class TestListNodes(base.FunctionalTest): self.assertNotIn('chassis_id', data['nodes'][0]) def test_get_one(self): - ndict = dbutils.get_test_node() - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context) data = self.get_json('/nodes/%s' % node['uuid']) - self.assertEqual(node['uuid'], data['uuid']) + self.assertEqual(node.uuid, data['uuid']) self.assertIn('driver', data) self.assertIn('driver_info', data) self.assertIn('extra', data) @@ -116,8 +114,7 @@ class TestListNodes(base.FunctionalTest): self.assertNotIn('chassis_id', data) def test_detail(self): - ndict = dbutils.get_test_node() - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context) data = self.get_json('/nodes/detail') self.assertEqual(node['uuid'], data['nodes'][0]["uuid"]) self.assertIn('driver', data['nodes'][0]) @@ -135,8 +132,7 @@ class TestListNodes(base.FunctionalTest): self.assertNotIn('chassis_id', data['nodes'][0]) def test_detail_against_single(self): - ndict = dbutils.get_test_node() - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context) response = self.get_json('/nodes/%s/detail' % node['uuid'], expect_errors=True) self.assertEqual(404, response.status_int) @@ -144,10 +140,9 @@ class TestListNodes(base.FunctionalTest): def test_many(self): nodes = [] for id in range(5): - ndict = dbutils.get_test_node(id=id, - uuid=utils.generate_uuid()) - node = self.dbapi.create_node(ndict) - nodes.append(node['uuid']) + node = obj_utils.create_test_node(self.context, id=id, + uuid=utils.generate_uuid()) + nodes.append(node.uuid) data = self.get_json('/nodes') self.assertEqual(len(nodes), len(data['nodes'])) @@ -156,8 +151,7 @@ class TestListNodes(base.FunctionalTest): def test_links(self): uuid = utils.generate_uuid() - ndict = dbutils.get_test_node(id=1, uuid=uuid) - self.dbapi.create_node(ndict) + obj_utils.create_test_node(self.context, id=1, uuid=uuid) data = self.get_json('/nodes/%s' % uuid) self.assertIn('links', data.keys()) self.assertEqual(2, len(data['links'])) @@ -168,10 +162,9 @@ class TestListNodes(base.FunctionalTest): def test_collection_links(self): nodes = [] for id in range(5): - ndict = dbutils.get_test_node(id=id, - uuid=utils.generate_uuid()) - node = self.dbapi.create_node(ndict) - nodes.append(node['uuid']) + node = obj_utils.create_test_node(self.context, id=id, + uuid=utils.generate_uuid()) + nodes.append(node.uuid) data = self.get_json('/nodes/?limit=3') self.assertEqual(3, len(data['nodes'])) @@ -182,10 +175,9 @@ class TestListNodes(base.FunctionalTest): cfg.CONF.set_override('max_limit', 3, 'api') nodes = [] for id in range(5): - ndict = dbutils.get_test_node(id=id, - uuid=utils.generate_uuid()) - node = self.dbapi.create_node(ndict) - nodes.append(node['uuid']) + node = obj_utils.create_test_node(self.context, id=id, + uuid=utils.generate_uuid()) + nodes.append(node.uuid) data = self.get_json('/nodes') self.assertEqual(3, len(data['nodes'])) @@ -193,35 +185,31 @@ class TestListNodes(base.FunctionalTest): self.assertIn(next_marker, data['next']) def test_ports_subresource_link(self): - ndict = dbutils.get_test_node() - self.dbapi.create_node(ndict) - - data = self.get_json('/nodes/%s' % ndict['uuid']) + node = obj_utils.create_test_node(self.context) + data = self.get_json('/nodes/%s' % node.uuid) self.assertIn('ports', data.keys()) def test_ports_subresource(self): - ndict = dbutils.get_test_node() - self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context) for id in range(2): - pdict = dbutils.get_test_port(id=id, node_id=ndict['id'], + pdict = dbutils.get_test_port(id=id, node_id=node.id, uuid=utils.generate_uuid(), address='52:54:00:cf:2d:3%s' % id) self.dbapi.create_port(pdict) - data = self.get_json('/nodes/%s/ports' % ndict['uuid']) + data = self.get_json('/nodes/%s/ports' % node.uuid) self.assertEqual(2, len(data['ports'])) self.assertNotIn('next', data.keys()) # Test collection pagination - data = self.get_json('/nodes/%s/ports?limit=1' % ndict['uuid']) + data = self.get_json('/nodes/%s/ports?limit=1' % node.uuid) self.assertEqual(1, len(data['ports'])) self.assertIn('next', data.keys()) def test_ports_subresource_noid(self): - ndict = dbutils.get_test_node() - self.dbapi.create_node(ndict) - pdict = dbutils.get_test_port(node_id=ndict['id']) + node = obj_utils.create_test_node(self.context) + pdict = dbutils.get_test_port(node_id=node.id) self.dbapi.create_port(pdict) # No node id specified response = self.get_json('/nodes/ports', expect_errors=True) @@ -239,14 +227,14 @@ class TestListNodes(base.FunctionalTest): fake_error = 'fake-error' test_time = datetime.datetime(2000, 1, 1, 0, 0) mock_utcnow.return_value = test_time - ndict = dbutils.get_test_node(power_state=fake_state, - target_power_state=fake_state, - provision_state=fake_state, - target_provision_state=fake_state, - provision_updated_at=test_time, - last_error=fake_error) - self.dbapi.create_node(ndict) - data = self.get_json('/nodes/%s/states' % ndict['uuid']) + node = obj_utils.create_test_node(self.context, + power_state=fake_state, + target_power_state=fake_state, + provision_state=fake_state, + target_provision_state=fake_state, + provision_updated_at=test_time, + last_error=fake_error) + data = self.get_json('/nodes/%s/states' % node.uuid) self.assertEqual(fake_state, data['power_state']) self.assertEqual(fake_state, data['target_power_state']) self.assertEqual(fake_state, data['provision_state']) @@ -258,10 +246,10 @@ class TestListNodes(base.FunctionalTest): self.assertFalse(data['console_enabled']) def test_node_by_instance_uuid(self): - ndict = dbutils.get_test_node(uuid=utils.generate_uuid(), - instance_uuid=utils.generate_uuid()) - node = self.dbapi.create_node(ndict) - instance_uuid = node['instance_uuid'] + node = obj_utils.create_test_node(self.context, + uuid=utils.generate_uuid(), + instance_uuid=utils.generate_uuid()) + instance_uuid = node.instance_uuid data = self.get_json('/nodes?instance_uuid=%s' % instance_uuid) @@ -270,9 +258,8 @@ class TestListNodes(base.FunctionalTest): data['nodes'][0]["instance_uuid"]) def test_node_by_instance_uuid_wrong_uuid(self): - ndict = dbutils.get_test_node(uuid=utils.generate_uuid(), - instance_uuid=utils.generate_uuid()) - self.dbapi.create_node(ndict) + obj_utils.create_test_node(self.context, uuid=utils.generate_uuid(), + instance_uuid=utils.generate_uuid()) wrong_uuid = utils.generate_uuid() data = self.get_json('/nodes?instance_uuid=%s' % wrong_uuid) @@ -347,10 +334,10 @@ class TestListNodes(base.FunctionalTest): self.assertIn('associated=True', data['next']) def test_detail_with_instance_uuid(self): - ndict = dbutils.get_test_node(uuid=utils.generate_uuid(), - instance_uuid=utils.generate_uuid()) - node = self.dbapi.create_node(ndict) - instance_uuid = node['instance_uuid'] + node = obj_utils.create_test_node(self.context, + uuid=utils.generate_uuid(), + instance_uuid=utils.generate_uuid()) + instance_uuid = node.instance_uuid data = self.get_json('/nodes/detail?instance_uuid=%s' % instance_uuid) @@ -367,9 +354,9 @@ class TestListNodes(base.FunctionalTest): def test_maintenance_nodes(self): nodes = [] for id in range(5): - ndict = dbutils.get_test_node(id=id, uuid=utils.generate_uuid(), - maintenance=id % 2) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, id=id, + uuid=utils.generate_uuid(), + maintenance=id % 2) nodes.append(node) data = self.get_json('/nodes?maintenance=true') @@ -391,9 +378,9 @@ class TestListNodes(base.FunctionalTest): def test_maintenance_nodes_associated(self): self._create_association_test_nodes() - ndict = dbutils.get_test_node(instance_uuid=utils.generate_uuid(), - maintenance=True) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + instance_uuid=utils.generate_uuid(), + maintenance=True) data = self.get_json('/nodes?associated=true&maintenance=false') uuids = [n['uuid'] for n in data['nodes']] @@ -406,7 +393,7 @@ class TestListNodes(base.FunctionalTest): self.assertIn(node.uuid, uuids) def test_get_console_information(self): - node = self.dbapi.create_node(dbutils.get_test_node()) + node = obj_utils.create_test_node(self.context) expected_console_info = {'test': 'test-data'} expected_data = {'console_enabled': True, 'console_info': expected_console_info} @@ -418,7 +405,7 @@ class TestListNodes(base.FunctionalTest): mock_gci.assert_called_once_with(mock.ANY, node.uuid, 'test-topic') def test_get_console_information_console_disabled(self): - node = self.dbapi.create_node(dbutils.get_test_node()) + node = obj_utils.create_test_node(self.context) expected_data = {'console_enabled': False, 'console_info': None} with mock.patch.object(rpcapi.ConductorAPI, @@ -430,7 +417,7 @@ class TestListNodes(base.FunctionalTest): mock_gci.assert_called_once_with(mock.ANY, node.uuid, 'test-topic') def test_get_console_information_not_supported(self): - node = self.dbapi.create_node(dbutils.get_test_node()) + node = obj_utils.create_test_node(self.context) with mock.patch.object(rpcapi.ConductorAPI, 'get_console_information') as mock_gci: mock_gci.side_effect = exception.UnsupportedDriverExtension( @@ -447,8 +434,7 @@ class TestPatch(base.FunctionalTest): super(TestPatch, self).setUp() cdict = dbutils.get_test_chassis() self.chassis = self.dbapi.create_chassis(cdict) - ndict = dbutils.get_test_node() - self.node = self.dbapi.create_node(ndict) + self.node = obj_utils.create_test_node(self.context) p = mock.patch.object(rpcapi.ConductorAPI, 'get_topic_for') self.mock_gtf = p.start() self.mock_gtf.return_value = 'test-topic' @@ -583,10 +569,10 @@ class TestPatch(base.FunctionalTest): self.assertTrue(response.json['error_message']) def test_update_state_in_progress(self): - ndict = dbutils.get_test_node(id=99, uuid=utils.generate_uuid(), - target_power_state=states.POWER_OFF) - node = self.dbapi.create_node(ndict) - response = self.patch_json('/nodes/%s' % node['uuid'], + node = obj_utils.create_test_node(self.context, id=99, + uuid=utils.generate_uuid(), + target_power_state=states.POWER_OFF) + response = self.patch_json('/nodes/%s' % node.uuid, [{'path': '/extra/foo', 'value': 'bar', 'op': 'add'}], expect_errors=True) self.assertEqual('application/json', response.content_type) @@ -600,8 +586,7 @@ class TestPatch(base.FunctionalTest): self.assertEqual(403, response.status_int) def test_remove_uuid(self): - ndict = dbutils.get_test_node() - response = self.patch_json('/nodes/%s' % ndict['uuid'], + response = self.patch_json('/nodes/%s' % self.node.uuid, [{'path': '/uuid', 'op': 'remove'}], expect_errors=True) self.assertEqual('application/json', response.content_type) @@ -700,6 +685,11 @@ class TestPost(base.FunctionalTest): self.assertEqual(test_time, return_created_at) def test_create_node_doesnt_contain_id(self): + # FIXME(comstud): I'd like to make this test not use the + # dbapi, however, no matter what I do when trying to mock + # Node.create(), the API fails to convert the objects.Node + # into the API Node object correctly (it leaves all fields + # as Unset). with mock.patch.object(self.dbapi, 'create_node', wraps=self.dbapi.create_node) as cn_mock: ndict = post_get_test_node(extra={'foo': 123}) @@ -724,9 +714,8 @@ class TestPost(base.FunctionalTest): self.assertTrue(response.json['error_message']) def test_vendor_passthru_ok(self): - ndict = dbutils.get_test_node() - self.dbapi.create_node(ndict) - uuid = ndict['uuid'] + node = obj_utils.create_test_node(self.context) + uuid = node.uuid info = {'foo': 'bar'} with mock.patch.object( @@ -740,15 +729,14 @@ class TestPost(base.FunctionalTest): self.assertEqual(202, response.status_code) def test_vendor_passthru_no_such_method(self): - ndict = dbutils.get_test_node() - self.dbapi.create_node(ndict) - uuid = ndict['uuid'] + node = obj_utils.create_test_node(self.context) + uuid = node.uuid info = {'foo': 'bar'} with mock.patch.object( rpcapi.ConductorAPI, 'vendor_passthru') as mock_vendor: mock_vendor.side_effect = exception.UnsupportedDriverExtension( - {'driver': ndict['driver'], + {'driver': node.driver, 'node': uuid, 'extension': 'test'}) response = self.post_json('/nodes/%s/vendor_passthru/test' % uuid, @@ -758,19 +746,17 @@ class TestPost(base.FunctionalTest): self.assertEqual(400, response.status_code) def test_vendor_passthru_without_method(self): - ndict = dbutils.get_test_node() - self.dbapi.create_node(ndict) - response = self.post_json('/nodes/%s/vendor_passthru' % ndict['uuid'], + node = obj_utils.create_test_node(self.context) + response = self.post_json('/nodes/%s/vendor_passthru' % node.uuid, {'foo': 'bar'}, expect_errors=True) self.assertEqual('application/json', response.content_type, ) self.assertEqual(400, response.status_code) self.assertTrue(response.json['error_message']) def test_post_ports_subresource(self): - ndict = dbutils.get_test_node() - self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context) pdict = apiutils.port_post_data(node_id=None) - pdict['node_uuid'] = ndict['uuid'] + pdict['node_uuid'] = node.uuid response = self.post_json('/nodes/ports', pdict, expect_errors=True) self.assertEqual(403, response.status_int) @@ -836,38 +822,36 @@ class TestDelete(base.FunctionalTest): @mock.patch.object(rpcapi.ConductorAPI, 'destroy_node') def test_delete_node(self, mock_dn): - ndict = dbutils.get_test_node() - self.dbapi.create_node(ndict) - self.delete('/nodes/%s' % ndict['uuid']) - mock_dn.assert_called_once_with(mock.ANY, ndict['uuid'], 'test-topic') + node = obj_utils.create_test_node(self.context) + self.delete('/nodes/%s' % node.uuid) + mock_dn.assert_called_once_with(mock.ANY, node.uuid, 'test-topic') @mock.patch.object(objects.Node, 'get_by_uuid') def test_delete_node_not_found(self, mock_gbu): - ndict = dbutils.get_test_node() - mock_gbu.side_effect = exception.NodeNotFound(node=ndict['uuid']) + node = obj_utils.get_test_node(context.get_admin_context()) + mock_gbu.side_effect = exception.NodeNotFound(node=node.uuid) - response = self.delete('/nodes/%s' % ndict['uuid'], expect_errors=True) + response = self.delete('/nodes/%s' % node.uuid, expect_errors=True) self.assertEqual(404, response.status_int) self.assertEqual('application/json', response.content_type) self.assertTrue(response.json['error_message']) - mock_gbu.assert_called_once_with(mock.ANY, ndict['uuid']) + mock_gbu.assert_called_once_with(mock.ANY, node.uuid) def test_delete_ports_subresource(self): - ndict = dbutils.get_test_node() - self.dbapi.create_node(ndict) - response = self.delete('/nodes/%s/ports' % ndict['uuid'], + node = obj_utils.create_test_node(self.context) + response = self.delete('/nodes/%s/ports' % node.uuid, expect_errors=True) self.assertEqual(403, response.status_int) @mock.patch.object(rpcapi.ConductorAPI, 'destroy_node') def test_delete_associated(self, mock_dn): - ndict = dbutils.get_test_node( - instance_uuid='aaaaaaaa-1111-bbbb-2222-cccccccccccc') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node( + self.context, + instance_uuid='aaaaaaaa-1111-bbbb-2222-cccccccccccc') mock_dn.side_effect = exception.NodeAssociated(node=node.uuid, instance=node.instance_uuid) - response = self.delete('/nodes/%s' % ndict['uuid'], expect_errors=True) + response = self.delete('/nodes/%s' % node.uuid, expect_errors=True) self.assertEqual(409, response.status_int) mock_dn.assert_called_once_with(mock.ANY, node.uuid, 'test-topic') @@ -878,8 +862,7 @@ class TestPut(base.FunctionalTest): super(TestPut, self).setUp() cdict = dbutils.get_test_chassis() self.chassis = self.dbapi.create_chassis(cdict) - ndict = dbutils.get_test_node() - self.node = self.dbapi.create_node(ndict) + self.node = obj_utils.create_test_node(self.context) p = mock.patch.object(rpcapi.ConductorAPI, 'get_topic_for') self.mock_gtf = p.start() self.mock_gtf.return_value = 'test-topic' @@ -931,19 +914,19 @@ class TestPut(base.FunctionalTest): self.assertEqual(400, ret.status_code) def test_provision_already_in_progress(self): - ndict = dbutils.get_test_node(id=1, uuid=utils.generate_uuid(), - target_provision_state=states.ACTIVE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, id=1, + uuid=utils.generate_uuid(), + target_provision_state=states.ACTIVE) ret = self.put_json('/nodes/%s/states/provision' % node.uuid, {'target': states.ACTIVE}, expect_errors=True) self.assertEqual(409, ret.status_code) # Conflict def test_provision_with_tear_down_in_progress_deploywait(self): - ndict = dbutils.get_test_node(id=1, uuid=utils.generate_uuid(), - provision_state=states.DEPLOYWAIT, - target_provision_state=states.DEPLOYDONE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node( + self.context, id=1, uuid=utils.generate_uuid(), + provision_state=states.DEPLOYWAIT, + target_provision_state=states.DEPLOYDONE) ret = self.put_json('/nodes/%s/states/provision' % node.uuid, {'target': states.DELETED}) self.assertEqual(202, ret.status_code) @@ -952,10 +935,10 @@ class TestPut(base.FunctionalTest): mock.ANY, node.uuid, 'test-topic') def test_provision_already_in_state(self): - ndict = dbutils.get_test_node(id=1, uuid=utils.generate_uuid(), - target_provision_state=states.NOSTATE, - provision_state=states.ACTIVE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node( + self.context, id=1, uuid=utils.generate_uuid(), + target_provision_state=states.NOSTATE, + provision_state=states.ACTIVE) ret = self.put_json('/nodes/%s/states/provision' % node.uuid, {'target': states.ACTIVE}, expect_errors=True) @@ -1013,9 +996,9 @@ class TestPut(base.FunctionalTest): def test_provision_node_in_maintenance_fail(self): with mock.patch.object(rpcapi.ConductorAPI, 'do_node_deploy') as dnd: - ndict = dbutils.get_test_node(id=1, uuid=utils.generate_uuid(), - maintenance=True) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, id=1, + uuid=utils.generate_uuid(), + maintenance=True) dnd.side_effect = exception.NodeInMaintenance(op='provisioning', node=node.uuid) diff --git a/ironic/tests/api/v1/test_ports.py b/ironic/tests/api/v1/test_ports.py index fd627745a7..b267017185 100644 --- a/ironic/tests/api/v1/test_ports.py +++ b/ironic/tests/api/v1/test_ports.py @@ -29,6 +29,7 @@ from ironic.openstack.common import timeutils from ironic.tests.api import base from ironic.tests.api import utils as apiutils from ironic.tests.db import utils as dbutils +from ironic.tests.objects import utils as obj_utils # NOTE(lucasagomes): When creating a port via API (POST) @@ -45,8 +46,7 @@ class TestListPorts(base.FunctionalTest): def setUp(self): super(TestListPorts, self).setUp() - ndict = dbutils.get_test_node() - self.node = self.dbapi.create_node(ndict) + self.node = obj_utils.create_test_node(context.get_admin_context()) def test_empty(self): data = self.get_json('/ports') @@ -179,10 +179,9 @@ class TestPatch(base.FunctionalTest): def setUp(self): super(TestPatch, self).setUp() - ndict = dbutils.get_test_node() - self.node = self.dbapi.create_node(ndict) - pdict = dbutils.get_test_port(id=None) - self.port = self.dbapi.create_port(pdict) + self.node = obj_utils.create_test_node(context.get_admin_context()) + self.pdict = dbutils.get_test_port(id=None) + self.port = self.dbapi.create_port(self.pdict) p = mock.patch.object(rpcapi.ConductorAPI, 'get_topic_for') self.mock_gtf = p.start() @@ -438,8 +437,7 @@ class TestPost(base.FunctionalTest): def setUp(self): super(TestPost, self).setUp() - ndict = dbutils.get_test_node() - self.node = self.dbapi.create_node(ndict) + self.node = obj_utils.create_test_node(context.get_admin_context()) @mock.patch.object(timeutils, 'utcnow') def test_create_port(self, mock_utcnow): @@ -555,8 +553,7 @@ class TestDelete(base.FunctionalTest): def setUp(self): super(TestDelete, self).setUp() - ndict = dbutils.get_test_node() - self.node = self.dbapi.create_node(ndict) + self.node = obj_utils.create_test_node(context.get_admin_context()) pdict = dbutils.get_test_port() self.dbapi.create_port(pdict) diff --git a/ironic/tests/conductor/test_conductor_utils.py b/ironic/tests/conductor/test_conductor_utils.py index 1acd8f2a4d..e9656d4aa9 100644 --- a/ironic/tests/conductor/test_conductor_utils.py +++ b/ironic/tests/conductor/test_conductor_utils.py @@ -23,6 +23,7 @@ from ironic.openstack.common import context from ironic.tests.conductor import utils as mgr_utils from ironic.tests.db import base from ironic.tests.db import utils +from ironic.tests.objects import utils as obj_utils class NodeSetBootDeviceTestCase(base.DbTestCase): @@ -34,9 +35,9 @@ class NodeSetBootDeviceTestCase(base.DbTestCase): def test_node_set_boot_device_non_existent_device(self): mgr_utils.mock_the_extension_manager(driver="fake_ipmitool") self.driver = driver_factory.get_driver("fake_ipmitool") - ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), - driver='fake_ipmitool') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + uuid=cmn_utils.generate_uuid(), + driver='fake_ipmitool') task = task_manager.TaskManager(self.context, node.uuid) self.assertRaises(exception.InvalidParameterValue, conductor_utils.node_set_boot_device, @@ -47,10 +48,10 @@ class NodeSetBootDeviceTestCase(base.DbTestCase): mgr_utils.mock_the_extension_manager(driver="fake_ipmitool") self.driver = driver_factory.get_driver("fake_ipmitool") ipmi_info = utils.get_test_ipmi_info() - ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), - driver='fake_ipmitool', - driver_info=ipmi_info) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + uuid=cmn_utils.generate_uuid(), + driver='fake_ipmitool', + driver_info=ipmi_info) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.vendor, @@ -74,10 +75,10 @@ class NodePowerActionTestCase(base.DbTestCase): def test_node_power_action_power_on(self): """Test node_power_action to turn node power on.""" - ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), - driver='fake', - power_state=states.POWER_OFF) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + uuid=cmn_utils.generate_uuid(), + driver='fake', + power_state=states.POWER_OFF) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') \ @@ -87,7 +88,7 @@ class NodePowerActionTestCase(base.DbTestCase): conductor_utils.node_power_action(task, task.node, states.POWER_ON) - node.refresh(self.context) + node.refresh() get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) @@ -95,10 +96,10 @@ class NodePowerActionTestCase(base.DbTestCase): def test_node_power_action_power_off(self): """Test node_power_action to turn node power off.""" - ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), - driver='fake', - power_state=states.POWER_ON) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + uuid=cmn_utils.generate_uuid(), + driver='fake', + power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') \ @@ -108,7 +109,7 @@ class NodePowerActionTestCase(base.DbTestCase): conductor_utils.node_power_action(task, task.node, states.POWER_OFF) - node.refresh(self.context) + node.refresh() get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) @@ -116,17 +117,17 @@ class NodePowerActionTestCase(base.DbTestCase): def test_node_power_action_power_reboot(self): """Test for reboot a node.""" - ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), - driver='fake', - power_state=states.POWER_ON) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + uuid=cmn_utils.generate_uuid(), + driver='fake', + power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'reboot') as reboot_mock: conductor_utils.node_power_action(task, task.node, states.REBOOT) - node.refresh(self.context) + node.refresh() reboot_mock.assert_called_once_with(mock.ANY, mock.ANY) self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) @@ -136,10 +137,10 @@ class NodePowerActionTestCase(base.DbTestCase): """Test if an exception is thrown when changing to an invalid power state. """ - ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), - driver='fake', - power_state=states.POWER_ON) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + uuid=cmn_utils.generate_uuid(), + driver='fake', + power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') \ @@ -152,7 +153,7 @@ class NodePowerActionTestCase(base.DbTestCase): task.node, "INVALID_POWER_STATE") - node.refresh(self.context) + node.refresh() get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) @@ -161,7 +162,7 @@ class NodePowerActionTestCase(base.DbTestCase): # last_error is cleared when a new transaction happens conductor_utils.node_power_action(task, task.node, states.POWER_OFF) - node.refresh(self.context) + node.refresh() self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error']) @@ -173,17 +174,17 @@ class NodePowerActionTestCase(base.DbTestCase): attempt and left the target_power_state set to states.POWER_OFF, and the user is attempting to power-off again.) """ - ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), - driver='fake', - power_state=states.POWER_ON, - target_power_state=states.POWER_OFF) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + uuid=cmn_utils.generate_uuid(), + driver='fake', + power_state=states.POWER_ON, + target_power_state=states.POWER_OFF) task = task_manager.TaskManager(self.context, node.uuid) conductor_utils.node_power_action(task, task.node, states.POWER_OFF) - node.refresh(self.context) + node.refresh() self.assertEqual(states.POWER_OFF, node['power_state']) self.assertEqual(states.NOSTATE, node['target_power_state']) self.assertIsNone(node['last_error']) @@ -192,11 +193,11 @@ class NodePowerActionTestCase(base.DbTestCase): """Test that we don't try to set the power state if the requested state is the same as the current state. """ - ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), - driver='fake', - last_error='anything but None', - power_state=states.POWER_ON) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + uuid=cmn_utils.generate_uuid(), + driver='fake', + last_error='anything but None', + power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') \ @@ -208,7 +209,7 @@ class NodePowerActionTestCase(base.DbTestCase): conductor_utils.node_power_action(task, task.node, states.POWER_ON) - node.refresh(self.context) + node.refresh() get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) self.assertFalse(set_power_mock.called, "set_power_state unexpectedly called") @@ -220,10 +221,10 @@ class NodePowerActionTestCase(base.DbTestCase): """Test if an exception is thrown when we can't get the current power state. """ - ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), - driver='fake', - power_state=states.POWER_ON) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + uuid=cmn_utils.generate_uuid(), + driver='fake', + power_state=states.POWER_ON) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') \ @@ -237,7 +238,7 @@ class NodePowerActionTestCase(base.DbTestCase): task.node, states.POWER_ON) - node.refresh(self.context) + node.refresh() get_power_state_mock.assert_called_once_with(mock.ANY, mock.ANY) self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) @@ -247,10 +248,10 @@ class NodePowerActionTestCase(base.DbTestCase): """Test if an exception is thrown when the set_power call fails. """ - ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(), - driver='fake', - power_state=states.POWER_OFF) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + uuid=cmn_utils.generate_uuid(), + driver='fake', + power_state=states.POWER_OFF) task = task_manager.TaskManager(self.context, node.uuid) with mock.patch.object(self.driver.power, 'get_power_state') \ @@ -267,7 +268,7 @@ class NodePowerActionTestCase(base.DbTestCase): task.node, states.POWER_ON) - node.refresh(self.context) + node.refresh() get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) set_power_mock.assert_called_once_with(mock.ANY, mock.ANY, states.POWER_ON) diff --git a/ironic/tests/conductor/test_manager.py b/ironic/tests/conductor/test_manager.py index 75135a9f66..0c2a8df597 100644 --- a/ironic/tests/conductor/test_manager.py +++ b/ironic/tests/conductor/test_manager.py @@ -42,6 +42,7 @@ from ironic.tests import base as tests_base from ironic.tests.conductor import utils as mgr_utils from ironic.tests.db import base as tests_db_base from ironic.tests.db import utils +from ironic.tests.objects import utils as obj_utils CONF = cfg.CONF @@ -131,9 +132,9 @@ class ManagerTestCase(tests_db_base.DbTestCase): def test_change_node_power_state_power_on(self): # Test change_node_power_state including integration with # conductor.utils.node_power_action and lower. - n = utils.get_test_node(driver='fake', - power_state=states.POWER_OFF) - db_node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, + driver='fake', + power_state=states.POWER_OFF) self._start_service() with mock.patch.object(self.driver.power, 'get_power_state') \ @@ -141,18 +142,18 @@ class ManagerTestCase(tests_db_base.DbTestCase): get_power_mock.return_value = states.POWER_OFF self.service.change_node_power_state(self.context, - db_node.uuid, + node.uuid, states.POWER_ON) self.service._worker_pool.waitall() get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) - db_node.refresh(self.context) - self.assertEqual(states.POWER_ON, db_node.power_state) - self.assertIsNone(db_node.target_power_state) - self.assertIsNone(db_node.last_error) + node.refresh() + self.assertEqual(states.POWER_ON, node.power_state) + self.assertIsNone(node.target_power_state) + self.assertIsNone(node.last_error) # Verify the reservation has been cleared by # background task's link callback. - self.assertIsNone(db_node.reservation) + self.assertIsNone(node.reservation) @mock.patch.object(conductor_utils, 'node_power_action') def test_change_node_power_state_node_already_locked(self, @@ -161,16 +162,15 @@ class ManagerTestCase(tests_db_base.DbTestCase): # conductor.utils.node_power_action. fake_reservation = 'fake-reserv' pwr_state = states.POWER_ON - n = utils.get_test_node(driver='fake', - power_state=pwr_state, - reservation=fake_reservation) - db_node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, driver='fake', + power_state=pwr_state, + reservation=fake_reservation) self._start_service() exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.change_node_power_state, self.context, - db_node.uuid, + node.uuid, states.POWER_ON) # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NodeLocked, exc.exc_info[0]) @@ -181,16 +181,15 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertFalse(pwr_act_mock.called, 'node_power_action has been ' 'unexpectedly called.') # Verify existing reservation wasn't broken. - db_node.refresh(self.context) - self.assertEqual(fake_reservation, db_node.reservation) + node.refresh() + self.assertEqual(fake_reservation, node.reservation) def test_change_node_power_state_worker_pool_full(self): # Test change_node_power_state including integration with # conductor.utils.node_power_action and lower. initial_state = states.POWER_OFF - n = utils.get_test_node(driver='fake', - power_state=initial_state) - db_node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, driver='fake', + power_state=initial_state) self._start_service() with mock.patch.object(self.service, '_spawn_worker') \ @@ -200,28 +199,27 @@ class ManagerTestCase(tests_db_base.DbTestCase): exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.change_node_power_state, self.context, - db_node.uuid, + node.uuid, states.POWER_ON) # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NoFreeConductorWorker, exc.exc_info[0]) spawn_mock.assert_called_once_with(mock.ANY, mock.ANY, mock.ANY, mock.ANY) - db_node.refresh(self.context) - self.assertEqual(initial_state, db_node.power_state) - self.assertIsNone(db_node.target_power_state) - self.assertIsNone(db_node.last_error) + node.refresh() + self.assertEqual(initial_state, node.power_state) + self.assertIsNone(node.target_power_state) + self.assertIsNone(node.last_error) # Verify the picked reservation has been cleared due to full pool. - self.assertIsNone(db_node.reservation) + self.assertIsNone(node.reservation) def test_change_node_power_state_exception_in_background_task( self): # Test change_node_power_state including integration with # conductor.utils.node_power_action and lower. initial_state = states.POWER_OFF - n = utils.get_test_node(driver='fake', - power_state=initial_state) - db_node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, driver='fake', + power_state=initial_state) self._start_service() with mock.patch.object(self.driver.power, 'get_power_state') \ @@ -236,28 +234,27 @@ class ManagerTestCase(tests_db_base.DbTestCase): ) self.service.change_node_power_state(self.context, - db_node.uuid, + node.uuid, new_state) self.service._worker_pool.waitall() get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) set_power_mock.assert_called_once_with(mock.ANY, mock.ANY, new_state) - db_node.refresh(self.context) - self.assertEqual(initial_state, db_node.power_state) - self.assertIsNone(db_node.target_power_state) - self.assertIsNotNone(db_node.last_error) + node.refresh() + self.assertEqual(initial_state, node.power_state) + self.assertIsNone(node.target_power_state) + self.assertIsNotNone(node.last_error) # Verify the reservation has been cleared by background task's # link callback despite exception in background task. - self.assertIsNone(db_node.reservation) + self.assertIsNone(node.reservation) def test_change_node_power_state_validate_fail(self): # Test change_node_power_state where task.driver.power.validate # fails and raises an exception initial_state = states.POWER_ON - n = utils.get_test_node(driver='fake', - power_state=initial_state) - db_node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, driver='fake', + power_state=initial_state) self._start_service() with mock.patch.object(self.driver.power, 'validate') \ @@ -268,33 +265,33 @@ class ManagerTestCase(tests_db_base.DbTestCase): exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.change_node_power_state, self.context, - db_node.uuid, + node.uuid, states.POWER_ON) self.assertEqual(exception.InvalidParameterValue, exc.exc_info[0]) - db_node.refresh(self.context) + node.refresh() validate_mock.assert_called_once_with(mock.ANY, mock.ANY) - self.assertEqual(states.POWER_ON, db_node.power_state) - self.assertIsNone(db_node.target_power_state) - self.assertIsNone(db_node.last_error) + self.assertEqual(states.POWER_ON, node.power_state) + self.assertIsNone(node.target_power_state) + self.assertIsNone(node.last_error) def test_update_node(self): - ndict = utils.get_test_node(driver='fake', extra={'test': 'one'}) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + extra={'test': 'one'}) # check that ManagerService.update_node actually updates the node - node['extra'] = {'test': 'two'} + node.extra = {'test': 'two'} res = self.service.update_node(self.context, node) self.assertEqual({'test': 'two'}, res['extra']) def test_update_node_already_locked(self): - ndict = utils.get_test_node(driver='fake', extra={'test': 'one'}) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + extra={'test': 'one'}) # check that it fails if something else has locked it already with task_manager.acquire(self.context, node['id'], shared=False): - node['extra'] = {'test': 'two'} + node.extra = {'test': 'two'} exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.update_node, self.context, @@ -307,14 +304,13 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertEqual({'test': 'one'}, res['extra']) def test_associate_node_invalid_state(self): - ndict = utils.get_test_node(driver='fake', - extra={'test': 'one'}, - instance_uuid=None, - power_state=states.POWER_ON) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + extra={'test': 'one'}, + instance_uuid=None, + power_state=states.POWER_ON) # check that it fails because state is POWER_ON - node['instance_uuid'] = 'fake-uuid' + node.instance_uuid = 'fake-uuid' exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.update_node, self.context, @@ -323,34 +319,34 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertEqual(exception.NodeInWrongPowerState, exc.exc_info[0]) # verify change did not happen - res = objects.Node.get_by_uuid(self.context, node['uuid']) - self.assertIsNone(res['instance_uuid']) + node.refresh() + self.assertIsNone(node.instance_uuid) def test_associate_node_valid_state(self): - ndict = utils.get_test_node(driver='fake', - instance_uuid=None, - power_state=states.NOSTATE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + instance_uuid=None, + power_state=states.NOSTATE) with mock.patch('ironic.drivers.modules.fake.FakePower.' 'get_power_state') as mock_get_power_state: mock_get_power_state.return_value = states.POWER_OFF - node['instance_uuid'] = 'fake-uuid' + node.instance_uuid = 'fake-uuid' self.service.update_node(self.context, node) # Check if the change was applied - res = objects.Node.get_by_uuid(self.context, node['uuid']) - self.assertEqual('fake-uuid', res['instance_uuid']) + node.instance_uuid = 'meow' + node.refresh() + self.assertEqual('fake-uuid', node.instance_uuid) def test_update_node_invalid_driver(self): existing_driver = 'fake' wrong_driver = 'wrong-driver' - ndict = utils.get_test_node(driver=existing_driver, - extra={'test': 'one'}, - instance_uuid=None, - task_state=states.POWER_ON) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + driver=existing_driver, + extra={'test': 'one'}, + instance_uuid=None, + task_state=states.POWER_ON) # check that it fails because driver not found node.driver = wrong_driver node.driver_info = {} @@ -360,82 +356,78 @@ class ManagerTestCase(tests_db_base.DbTestCase): node) # verify change did not happen - res = objects.Node.get_by_uuid(self.context, node['uuid']) - self.assertEqual(existing_driver, res['driver']) + node.refresh() + self.assertEqual(existing_driver, node.driver) def test_vendor_passthru_success(self): - n = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, driver='fake') info = {'bar': 'baz'} self._start_service() self.service.vendor_passthru( - self.context, n['uuid'], 'first_method', info) + self.context, node.uuid, 'first_method', info) # Waiting to make sure the below assertions are valid. self.service._worker_pool.waitall() - node.refresh(self.context) + node.refresh() self.assertIsNone(node.last_error) # Verify reservation has been cleared. self.assertIsNone(node.reservation) def test_vendor_passthru_node_already_locked(self): fake_reservation = 'test_reserv' - n = utils.get_test_node(driver='fake', reservation=fake_reservation) - node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, driver='fake', + reservation=fake_reservation) info = {'bar': 'baz'} self._start_service() exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.vendor_passthru, - self.context, n['uuid'], 'first_method', info) + self.context, node.uuid, 'first_method', info) # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NodeLocked, exc.exc_info[0]) - node.refresh(self.context) + node.refresh() self.assertIsNone(node.last_error) # Verify the existing reservation is not broken. self.assertEqual(fake_reservation, node.reservation) def test_vendor_passthru_unsupported_method(self): - n = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, driver='fake') info = {'bar': 'baz'} self._start_service() exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.vendor_passthru, self.context, - n['uuid'], 'unsupported_method', info) + node.uuid, 'unsupported_method', info) # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.UnsupportedDriverExtension, exc.exc_info[0]) - node.refresh(self.context) + node.refresh() self.assertIsNone(node.last_error) # Verify reservation has been cleared. self.assertIsNone(node.reservation) def test_vendor_passthru_invalid_method_parameters(self): - n = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, driver='fake') info = {'invalid_param': 'whatever'} self._start_service() exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.vendor_passthru, - self.context, n['uuid'], 'first_method', info) + self.context, node.uuid, 'first_method', info) # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.InvalidParameterValue, exc.exc_info[0]) - node.refresh(self.context) + node.refresh() self.assertIsNone(node.last_error) # Verify reservation has been cleared. self.assertIsNone(node.reservation) def test_vendor_passthru_vendor_interface_not_supported(self): - n = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, driver='fake') info = {'bar': 'baz'} self.driver.vendor = None self._start_service() @@ -443,18 +435,17 @@ class ManagerTestCase(tests_db_base.DbTestCase): exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.vendor_passthru, self.context, - n['uuid'], 'whatever_method', info) + node.uuid, 'whatever_method', info) # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.UnsupportedDriverExtension, exc.exc_info[0]) - node.refresh(self.context) + node.refresh() # Verify reservation has been cleared. self.assertIsNone(node.reservation) def test_vendor_passthru_worker_pool_full(self): - n = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, driver='fake') info = {'bar': 'baz'} self._start_service() @@ -465,14 +456,14 @@ class ManagerTestCase(tests_db_base.DbTestCase): exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.vendor_passthru, self.context, - n['uuid'], 'first_method', info) + node.uuid, 'first_method', info) # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NoFreeConductorWorker, exc.exc_info[0]) # Waiting to make sure the below assertions are valid. self.service._worker_pool.waitall() - node.refresh(self.context) + node.refresh() self.assertIsNone(node.last_error) # Verify reservation has been cleared. self.assertIsNone(node.reservation) @@ -531,9 +522,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): def test_do_node_deploy_invalid_state(self): # test node['provision_state'] is not NOSTATE - ndict = utils.get_test_node(driver='fake', - provision_state=states.ACTIVE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + provision_state=states.ACTIVE) exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.do_node_deploy, self.context, node['uuid']) @@ -545,8 +535,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertIsNone(node.reservation) def test_do_node_deploy_maintenance(self): - ndict = utils.get_test_node(driver='fake', maintenance=True) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + maintenance=True) exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.do_node_deploy, self.context, node['uuid']) @@ -561,8 +551,7 @@ class ManagerTestCase(tests_db_base.DbTestCase): def test_do_node_deploy_validate_fail(self, mock_validate): # InvalidParameterValue should be re-raised as InstanceDeployFailure mock_validate.side_effect = exception.InvalidParameterValue('error') - ndict = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake') exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.do_node_deploy, self.context, node.uuid) @@ -577,15 +566,14 @@ class ManagerTestCase(tests_db_base.DbTestCase): def test__do_node_deploy_driver_raises_error(self, mock_deploy): # test when driver.deploy.deploy raises an exception mock_deploy.side_effect = exception.InstanceDeployFailure('test') - ndict = utils.get_test_node(driver='fake', - provision_state=states.NOSTATE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + provision_state=states.NOSTATE) task = task_manager.TaskManager(self.context, node.uuid) self.assertRaises(exception.InstanceDeployFailure, self.service._do_node_deploy, self.context, task) - node.refresh(self.context) + node.refresh() self.assertEqual(states.DEPLOYFAIL, node.provision_state) self.assertEqual(states.NOSTATE, node.target_provision_state) self.assertIsNotNone(node.last_error) @@ -595,13 +583,12 @@ class ManagerTestCase(tests_db_base.DbTestCase): def test__do_node_deploy_ok(self, mock_deploy): # test when driver.deploy.deploy returns DEPLOYDONE mock_deploy.return_value = states.DEPLOYDONE - ndict = utils.get_test_node(driver='fake', - provision_state=states.NOSTATE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + provision_state=states.NOSTATE) task = task_manager.TaskManager(self.context, node.uuid) self.service._do_node_deploy(self.context, task) - node.refresh(self.context) + node.refresh() self.assertEqual(states.ACTIVE, node.provision_state) self.assertEqual(states.NOSTATE, node.target_provision_state) self.assertIsNone(node.last_error) @@ -613,13 +600,12 @@ class ManagerTestCase(tests_db_base.DbTestCase): with mock.patch.object(self.service, '_spawn_worker') as mock_spawn: mock_spawn.return_value = thread - ndict = utils.get_test_node(driver='fake', - provision_state=states.NOSTATE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + provision_state=states.NOSTATE) self.service.do_node_deploy(self.context, node.uuid) self.service._worker_pool.waitall() - node.refresh(self.context) + node.refresh() self.assertEqual(states.DEPLOYING, node.provision_state) self.assertEqual(states.DEPLOYDONE, node.target_provision_state) # This is a sync operation last_error should be None. @@ -629,8 +615,7 @@ class ManagerTestCase(tests_db_base.DbTestCase): mock_spawn.assert_called_once_with(mock.ANY, mock.ANY, mock.ANY) def test_do_node_deploy_worker_pool_full(self): - ndict = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake') self._start_service() with mock.patch.object(self.service, '_spawn_worker') as mock_spawn: @@ -642,7 +627,7 @@ class ManagerTestCase(tests_db_base.DbTestCase): # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NoFreeConductorWorker, exc.exc_info[0]) self.service._worker_pool.waitall() - node.refresh(self.context) + node.refresh() # This is a sync operation last_error should be None. self.assertIsNone(node.last_error) # Verify reservation has been cleared. @@ -650,9 +635,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): def test_do_node_tear_down_invalid_state(self): # test node.provision_state is incorrect for tear_down - ndict = utils.get_test_node(driver='fake', - provision_state=states.NOSTATE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + provision_state=states.NOSTATE) exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.do_node_tear_down, self.context, node['uuid']) @@ -663,9 +647,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): def test_do_node_tear_down_validate_fail(self, mock_validate): # InvalidParameterValue should be re-raised as InstanceDeployFailure mock_validate.side_effect = exception.InvalidParameterValue('error') - ndict = utils.get_test_node(driver='fake') - ndict['provision_state'] = states.ACTIVE - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + provision_state=states.ACTIVE) exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.do_node_tear_down, self.context, node.uuid) @@ -675,9 +658,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): @mock.patch('ironic.drivers.modules.fake.FakeDeploy.tear_down') def test_do_node_tear_down_driver_raises_error(self, mock_tear_down): # test when driver.deploy.tear_down raises exception - ndict = utils.get_test_node(driver='fake', - provision_state=states.ACTIVE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + provision_state=states.ACTIVE) task = task_manager.TaskManager(self.context, node.uuid) self._start_service() @@ -685,7 +667,7 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertRaises(exception.InstanceDeployFailure, self.service._do_node_tear_down, self.context, task) - node.refresh(self.context) + node.refresh() self.assertEqual(states.ERROR, node.provision_state) self.assertEqual(states.NOSTATE, node.target_provision_state) self.assertIsNotNone(node.last_error) @@ -694,15 +676,14 @@ class ManagerTestCase(tests_db_base.DbTestCase): @mock.patch('ironic.drivers.modules.fake.FakeDeploy.tear_down') def test_do_node_tear_down_ok(self, mock_tear_down): # test when driver.deploy.tear_down returns DELETED - ndict = utils.get_test_node(driver='fake', - provision_state=states.ACTIVE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + provision_state=states.ACTIVE) task = task_manager.TaskManager(self.context, node.uuid) self._start_service() mock_tear_down.return_value = states.DELETED self.service._do_node_tear_down(self.context, task) - node.refresh(self.context) + node.refresh() self.assertEqual(states.NOSTATE, node.provision_state) self.assertEqual(states.NOSTATE, node.target_provision_state) self.assertIsNone(node.last_error) @@ -711,24 +692,22 @@ class ManagerTestCase(tests_db_base.DbTestCase): @mock.patch('ironic.drivers.modules.fake.FakeDeploy.tear_down') def test_do_node_tear_down_partial_ok(self, mock_tear_down): # test when driver.deploy.tear_down doesn't return DELETED - ndict = utils.get_test_node(driver='fake', - provision_state=states.ACTIVE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + provision_state=states.ACTIVE) self._start_service() task = task_manager.TaskManager(self.context, node.uuid) mock_tear_down.return_value = states.DELETING self.service._do_node_tear_down(self.context, task) - node.refresh(self.context) + node.refresh() self.assertEqual(states.DELETING, node.provision_state) self.assertIsNone(node.last_error) mock_tear_down.assert_called_once_with(mock.ANY, mock.ANY) @mock.patch('ironic.conductor.manager.ConductorManager._spawn_worker') def test_do_node_tear_down_worker_pool_full(self, mock_spawn): - ndict = utils.get_test_node(driver='fake', - provision_state=states.ACTIVE) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + provision_state=states.ACTIVE) self._start_service() mock_spawn.side_effect = exception.NoFreeConductorWorker() @@ -739,17 +718,16 @@ class ManagerTestCase(tests_db_base.DbTestCase): # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NoFreeConductorWorker, exc.exc_info[0]) self.service._worker_pool.waitall() - node.refresh(self.context) + node.refresh() # This is a sync operation last_error should be None. self.assertIsNone(node.last_error) # Verify reservation has been cleared. self.assertIsNone(node.reservation) def test_validate_driver_interfaces(self): - ndict = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake') ret = self.service.validate_driver_interfaces(self.context, - node['uuid']) + node.uuid) expected = {'console': {'result': True}, 'power': {'result': True}, 'management': {'result': True}, @@ -757,38 +735,34 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertEqual(expected, ret) def test_validate_driver_interfaces_validation_fail(self): - ndict = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake') with mock.patch('ironic.drivers.modules.fake.FakeDeploy.validate') \ as deploy: reason = 'fake reason' deploy.side_effect = exception.InvalidParameterValue(reason) ret = self.service.validate_driver_interfaces(self.context, - node['uuid']) + node.uuid) self.assertFalse(ret['deploy']['result']) self.assertEqual(reason, ret['deploy']['reason']) def test_maintenance_mode_on(self): - ndict = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake') self.service.change_node_maintenance_mode(self.context, node.uuid, True) - node.refresh(self.context) + node.refresh() self.assertTrue(node.maintenance) def test_maintenance_mode_off(self): - ndict = utils.get_test_node(driver='fake', - maintenance=True) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + maintenance=True) self.service.change_node_maintenance_mode(self.context, node.uuid, False) - node.refresh(self.context) + node.refresh() self.assertFalse(node.maintenance) def test_maintenance_mode_on_failed(self): - ndict = utils.get_test_node(driver='fake', - maintenance=True) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + maintenance=True) exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.change_node_maintenance_mode, self.context, node.uuid, True) @@ -798,8 +772,7 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertTrue(node.maintenance) def test_maintenance_mode_off_failed(self): - ndict = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake') exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.change_node_maintenance_mode, self.context, node.uuid, False) @@ -810,8 +783,7 @@ class ManagerTestCase(tests_db_base.DbTestCase): def test_destroy_node(self): self._start_service() - ndict = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake') self.service.destroy_node(self.context, node.uuid) self.assertRaises(exception.NodeNotFound, self.dbapi.get_node_by_uuid, @@ -820,8 +792,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): def test_destroy_node_reserved(self): self._start_service() fake_reservation = 'fake-reserv' - ndict = utils.get_test_node(reservation=fake_reservation) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + reservation=fake_reservation) exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.destroy_node, @@ -829,13 +801,13 @@ class ManagerTestCase(tests_db_base.DbTestCase): # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NodeLocked, exc.exc_info[0]) # Verify existing reservation wasn't broken. - node.refresh(self.context) + node.refresh() self.assertEqual(fake_reservation, node.reservation) def test_destroy_node_associated(self): self._start_service() - ndict = utils.get_test_node(instance_uuid='fake-uuid') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + instance_uuid='fake-uuid') exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.destroy_node, @@ -844,7 +816,7 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertEqual(exception.NodeAssociated, exc.exc_info[0]) # Verify reservation was released. - node.refresh(self.context) + node.refresh() self.assertIsNone(node.reservation) @mock.patch.object(timeutils, 'utcnow') @@ -854,16 +826,16 @@ class ManagerTestCase(tests_db_base.DbTestCase): present = past + datetime.timedelta(minutes=5) mock_utcnow.return_value = past self._start_service() - n = utils.get_test_node(provision_state=states.DEPLOYWAIT, - target_provision_state=states.DEPLOYDONE, - provision_updated_at=past) - node = self.dbapi.create_node(n) + node = obj_utils.create_test_node( + self.context, provision_state=states.DEPLOYWAIT, + target_provision_state=states.DEPLOYDONE, + provision_updated_at=past) mock_utcnow.return_value = present self.service._conductor_service_record_keepalive(self.context) with mock.patch.object(self.driver.deploy, 'clean_up') as clean_mock: self.service._check_deploy_timeouts(self.context) self.service._worker_pool.waitall() - node.refresh(self.context) + node.refresh() self.assertEqual(states.DEPLOYFAIL, node.provision_state) self.assertEqual(states.NOSTATE, node.target_provision_state) self.assertIsNotNone(node.last_error) @@ -876,15 +848,15 @@ class ManagerTestCase(tests_db_base.DbTestCase): present = past + datetime.timedelta(minutes=5) mock_utcnow.return_value = past self._start_service() - n = utils.get_test_node(provision_state=states.DEPLOYWAIT, - target_provision_state=states.DEPLOYDONE, - provision_updated_at=past) - node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, + provision_state=states.DEPLOYWAIT, + target_provision_state=states.DEPLOYDONE, + provision_updated_at=past) mock_utcnow.return_value = present self.service._conductor_service_record_keepalive(self.context) with mock.patch.object(self.driver.deploy, 'clean_up') as clean_mock: self.service._check_deploy_timeouts(self.context) - node.refresh(self.context) + node.refresh() self.assertEqual(states.DEPLOYWAIT, node.provision_state) self.assertEqual(states.DEPLOYDONE, node.target_provision_state) self.assertIsNone(node.last_error) @@ -904,10 +876,10 @@ class ManagerTestCase(tests_db_base.DbTestCase): present = past + datetime.timedelta(minutes=5) mock_utcnow.return_value = past self._start_service() - n = utils.get_test_node(provision_state=states.DEPLOYWAIT, - target_provision_state=states.DEPLOYDONE, - provision_updated_at=past) - node = self.dbapi.create_node(n) + node = obj_utils.create_test_node(self.context, + provision_state=states.DEPLOYWAIT, + target_provision_state=states.DEPLOYDONE, + provision_updated_at=past) mock_utcnow.return_value = present self.service._conductor_service_record_keepalive(self.context) with mock.patch.object(self.driver.deploy, 'clean_up') as clean_mock: @@ -915,15 +887,14 @@ class ManagerTestCase(tests_db_base.DbTestCase): clean_mock.side_effect = exception.IronicException(message=error) self.service._check_deploy_timeouts(self.context) self.service._worker_pool.waitall() - node.refresh(self.context) + node.refresh() self.assertEqual(states.DEPLOYFAIL, node.provision_state) self.assertEqual(states.NOSTATE, node.target_provision_state) self.assertIn(error, node.last_error) self.assertIsNone(node.reservation) def test_set_console_mode_worker_pool_full(self): - ndict = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake') self._start_service() with mock.patch.object(self.service, '_spawn_worker') \ as spawn_mock: @@ -949,12 +920,13 @@ class ManagerTestCase(tests_db_base.DbTestCase): test_nodes = [] for i in range(3): next = past + datetime.timedelta(minutes=i) - n = utils.get_test_node(provision_state=states.DEPLOYWAIT, - target_provision_state=states.DEPLOYDONE, - provision_updated_at=next, - uuid=ironic_utils.generate_uuid()) - del n['id'] - node = self.dbapi.create_node(n) + node = obj_utils.create_test_node( + self.context, + id=i + 1, + provision_state=states.DEPLOYWAIT, + target_provision_state=states.DEPLOYDONE, + provision_updated_at=next, + uuid=ironic_utils.generate_uuid()) test_nodes.append(node) mock_utcnow.return_value = present @@ -977,26 +949,24 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertEqual(2, clean_mock.call_count) def test_set_console_mode_enabled(self): - ndict = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake') self._start_service() self.service.set_console_mode(self.context, node.uuid, True) self.service._worker_pool.waitall() - node.refresh(self.context) + node.refresh() self.assertTrue(node.console_enabled) def test_set_console_mode_disabled(self): - ndict = utils.get_test_node(driver='fake') - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake') self._start_service() self.service.set_console_mode(self.context, node.uuid, False) self.service._worker_pool.waitall() - node.refresh(self.context) + node.refresh() self.assertFalse(node.console_enabled) def test_set_console_mode_not_supported(self): - ndict = utils.get_test_node(driver='fake', last_error=None) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + last_error=None) self._start_service() # null the console interface self.driver.console = None @@ -1007,11 +977,11 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertEqual(exception.UnsupportedDriverExtension, exc.exc_info[0]) self.service._worker_pool.waitall() - node.refresh(self.context) + node.refresh() def test_set_console_mode_validation_fail(self): - ndict = utils.get_test_node(driver='fake', last_error=None) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + last_error=None) self._start_service() with mock.patch.object(self.driver.console, 'validate') as mock_val: mock_val.side_effect = exception.InvalidParameterValue('error') @@ -1022,9 +992,9 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertEqual(exception.InvalidParameterValue, exc.exc_info[0]) def test_set_console_mode_start_fail(self): - ndict = utils.get_test_node(driver='fake', last_error=None, - console_enabled=False) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + last_error=None, + console_enabled=False) self._start_service() with mock.patch.object(self.driver.console, 'start_console') \ as mock_sc: @@ -1032,13 +1002,13 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.service.set_console_mode(self.context, node.uuid, True) self.service._worker_pool.waitall() mock_sc.assert_called_once_with(mock.ANY, mock.ANY) - node.refresh(self.context) + node.refresh() self.assertIsNotNone(node.last_error) def test_set_console_mode_stop_fail(self): - ndict = utils.get_test_node(driver='fake', last_error=None, - console_enabled=True) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + last_error=None, + console_enabled=True) self._start_service() with mock.patch.object(self.driver.console, 'stop_console') \ as mock_sc: @@ -1046,12 +1016,12 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.service.set_console_mode(self.context, node.uuid, False) self.service._worker_pool.waitall() mock_sc.assert_called_once_with(mock.ANY, mock.ANY) - node.refresh(self.context) + node.refresh() self.assertIsNotNone(node.last_error) def test_enable_console_already_enabled(self): - ndict = utils.get_test_node(driver='fake', console_enabled=True) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + console_enabled=True) self._start_service() with mock.patch.object(self.driver.console, 'start_console') \ as mock_sc: @@ -1060,8 +1030,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertFalse(mock_sc.called) def test_disable_console_already_disabled(self): - ndict = utils.get_test_node(driver='fake', console_enabled=False) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + console_enabled=False) self._start_service() with mock.patch.object(self.driver.console, 'stop_console') \ as mock_sc: @@ -1070,8 +1040,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertFalse(mock_sc.called) def test_get_console(self): - ndict = utils.get_test_node(driver='fake', console_enabled=True) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + console_enabled=True) console_info = {'test': 'test info'} with mock.patch.object(self.driver.console, 'get_console') as mock_gc: mock_gc.return_value = console_info @@ -1080,8 +1050,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertEqual(console_info, data) def test_get_console_not_supported(self): - ndict = utils.get_test_node(driver='fake', console_enabled=True) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + console_enabled=True) # null the console interface self.driver.console = None exc = self.assertRaises(messaging.rpc.ExpectedException, @@ -1092,8 +1062,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): exc.exc_info[0]) def test_get_console_disabled(self): - ndict = utils.get_test_node(driver='fake', console_enabled=False) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + console_enabled=False) exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.get_console_information, self.context, node.uuid) @@ -1101,8 +1071,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertEqual(exception.NodeConsoleNotEnabled, exc.exc_info[0]) def test_get_console_validate_fail(self): - ndict = utils.get_test_node(driver='fake', console_enabled=True) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, driver='fake', + console_enabled=True) with mock.patch.object(self.driver.console, 'validate') as mock_gc: mock_gc.side_effect = exception.InvalidParameterValue('error') exc = self.assertRaises(messaging.rpc.ExpectedException, @@ -1113,8 +1083,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): def test_destroy_node_power_on(self): self._start_service() - ndict = utils.get_test_node(power_state=states.POWER_ON) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + power_state=states.POWER_ON) exc = self.assertRaises(messaging.rpc.ExpectedException, self.service.destroy_node, @@ -1122,18 +1092,17 @@ class ManagerTestCase(tests_db_base.DbTestCase): # Compare true exception hidden by @messaging.expected_exceptions self.assertEqual(exception.NodeInWrongPowerState, exc.exc_info[0]) # Verify reservation was released. - node.refresh(self.context) + node.refresh() self.assertIsNone(node.reservation) def test_destroy_node_power_off(self): self._start_service() - ndict = utils.get_test_node(power_state=states.POWER_OFF) - node = self.dbapi.create_node(ndict) + node = obj_utils.create_test_node(self.context, + power_state=states.POWER_OFF) self.service.destroy_node(self.context, node.uuid) def test_update_port(self): - ndict = utils.get_test_node(driver='fake') - self.dbapi.create_node(ndict) + obj_utils.create_test_node(self.context, driver='fake') pdict = utils.get_test_port(extra={'foo': 'bar'}) port = self.dbapi.create_port(pdict) @@ -1143,8 +1112,8 @@ class ManagerTestCase(tests_db_base.DbTestCase): self.assertEqual(new_extra, res.extra) def test_update_port_node_locked(self): - ndict = utils.get_test_node(driver='fake', reservation='fake-reserv') - self.dbapi.create_node(ndict) + obj_utils.create_test_node(self.context, driver='fake', + reservation='fake-reserv') pdict = utils.get_test_port() port = self.dbapi.create_port(pdict) @@ -1157,8 +1126,7 @@ class ManagerTestCase(tests_db_base.DbTestCase): @mock.patch('ironic.common.neutron.NeutronAPI.update_port_address') def test_update_port_address(self, mac_update_mock): - ndict = utils.get_test_node(driver='fake') - self.dbapi.create_node(ndict) + obj_utils.create_test_node(self.context, driver='fake') pdict = utils.get_test_port(extra={'vif_port_id': 'fake-id'}) port = self.dbapi.create_port(pdict) @@ -1170,8 +1138,7 @@ class ManagerTestCase(tests_db_base.DbTestCase): @mock.patch('ironic.common.neutron.NeutronAPI.update_port_address') def test_update_port_address_fail(self, mac_update_mock): - ndict = utils.get_test_node(driver='fake') - self.dbapi.create_node(ndict) + obj_utils.create_test_node(self.context, driver='fake') pdict = utils.get_test_port(extra={'vif_port_id': 'fake-id'}) port = self.dbapi.create_port(pdict) @@ -1189,8 +1156,7 @@ class ManagerTestCase(tests_db_base.DbTestCase): @mock.patch('ironic.common.neutron.NeutronAPI.update_port_address') def test_update_port_address_no_vif_id(self, mac_update_mock): - ndict = utils.get_test_node(driver='fake') - self.dbapi.create_node(ndict) + obj_utils.create_test_node(self.context, driver='fake') pdict = utils.get_test_port() port = self.dbapi.create_port(pdict) diff --git a/ironic/tests/conductor/test_task_manager.py b/ironic/tests/conductor/test_task_manager.py index cccc568d48..230e708be2 100644 --- a/ironic/tests/conductor/test_task_manager.py +++ b/ironic/tests/conductor/test_task_manager.py @@ -34,15 +34,14 @@ from ironic.openstack.common import context from ironic.tests import base as tests_base from ironic.tests.conductor import utils as mgr_utils from ironic.tests.db import base as db_base -from ironic.tests.db import utils +from ironic.tests.objects import utils as obj_utils -def create_fake_node(i): - dbh = dbapi.get_instance() - node = utils.get_test_node(id=i, - uuid=ironic_utils.generate_uuid()) - dbh.create_node(node) - return node['uuid'] +def create_fake_node(ctxt, i): + node = obj_utils.create_test_node(ctxt, + id=i, + uuid=ironic_utils.generate_uuid()) + return node.uuid def ContainsUUIDs(uuids): @@ -68,7 +67,7 @@ class TaskManagerTestCase(TaskManagerSetup): def setUp(self): super(TaskManagerTestCase, self).setUp() - self.uuids = [create_fake_node(i) for i in range(1, 6)] + self.uuids = [create_fake_node(self.context, i) for i in range(1, 6)] self.uuids.sort() def test_task_manager_gets_node(self): @@ -257,7 +256,7 @@ class ExclusiveLockDecoratorTestCase(TaskManagerSetup): def setUp(self): super(ExclusiveLockDecoratorTestCase, self).setUp() - self.uuids = [create_fake_node(123)] + self.uuids = [create_fake_node(self.context, 123)] def test_require_exclusive_lock(self): @task_manager.require_exclusive_lock @@ -308,7 +307,7 @@ class ExclusiveLockDecoratorTestCase(TaskManagerSetup): self.assertEqual(task.node_manager, task.resources[0]) def test_one_node_per_task_properties_fail(self): - self.uuids.append(create_fake_node(456)) + self.uuids.append(create_fake_node(self.context, 456)) with task_manager.acquire(self.context, self.uuids) as task: def get_node(): return task.node diff --git a/ironic/tests/drivers/test_ipminative.py b/ironic/tests/drivers/test_ipminative.py index e7b0e68112..6e436e01c8 100644 --- a/ironic/tests/drivers/test_ipminative.py +++ b/ironic/tests/drivers/test_ipminative.py @@ -45,11 +45,10 @@ class IPMINativePrivateMethodTestCase(base.TestCase): def setUp(self): super(IPMINativePrivateMethodTestCase, self).setUp() self.context = context.get_admin_context() - n = db_utils.get_test_node( - driver='fake_ipminative', - driver_info=INFO_DICT) + self.node = obj_utils.create_test_node(self.context, + driver='fake_ipminative', + driver_info=INFO_DICT) self.dbapi = db_api.get_instance() - self.node = self.dbapi.create_node(n) self.info = ipminative._parse_driver_info(self.node) ipmi_patch = mock.patch('pyghmi.ipmi.command.Command') self.ipmi_mock = ipmi_patch.start() @@ -133,11 +132,10 @@ class IPMINativeDriverTestCase(db_base.DbTestCase): mgr_utils.mock_the_extension_manager(driver="fake_ipminative") self.driver = driver_factory.get_driver("fake_ipminative") - n = db_utils.get_test_node( - driver='fake_ipminative', - driver_info=INFO_DICT) + self.node = obj_utils.create_test_node(self.context, + driver='fake_ipminative', + driver_info=INFO_DICT) self.dbapi = db_api.get_instance() - self.node = self.dbapi.create_node(n) self.info = ipminative._parse_driver_info(self.node) def test_get_power_state(self): @@ -170,7 +168,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase): power_on_mock.return_value = states.POWER_ON with task_manager.acquire(self.context, - [self.node['uuid']]) as task: + [self.node.uuid]) as task: self.driver.power.set_power_state( task, self.node, states.POWER_ON) power_on_mock.assert_called_once_with(self.info) @@ -180,7 +178,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase): power_off_mock.return_value = states.POWER_OFF with task_manager.acquire(self.context, - [self.node['uuid']]) as task: + [self.node.uuid]) as task: self.driver.power.set_power_state( task, self.node, states.POWER_OFF) power_off_mock.assert_called_once_with(self.info) @@ -192,7 +190,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase): self.config(retry_timeout=500, group='ipmi') with task_manager.acquire(self.context, - [self.node['uuid']]) as task: + [self.node.uuid]) as task: self.assertRaises(exception.PowerStateFailure, self.driver.power.set_power_state, task, @@ -206,12 +204,12 @@ class IPMINativeDriverTestCase(db_base.DbTestCase): ipmicmd.set_bootdev.return_value = None with task_manager.acquire(self.context, - [self.node['uuid']]) as task: + [self.node.uuid]) as task: self.driver.vendor._set_boot_device(task, 'pxe') ipmicmd.set_bootdev.assert_called_once_with('pxe') def test_set_boot_device_bad_device(self): - with task_manager.acquire(self.context, [self.node['uuid']]) as task: + with task_manager.acquire(self.context, [self.node.uuid]) as task: self.assertRaises(exception.InvalidParameterValue, self.driver.vendor._set_boot_device, task, @@ -222,7 +220,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase): reboot_mock.return_value = None with task_manager.acquire(self.context, - [self.node['uuid']]) as task: + [self.node.uuid]) as task: self.driver.power.reboot(task, self.node) reboot_mock.assert_called_once_with(self.info) @@ -233,7 +231,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase): self.config(retry_timeout=500, group='ipmi') with task_manager.acquire(self.context, - [self.node['uuid']]) as task: + [self.node.uuid]) as task: self.assertRaises(exception.PowerStateFailure, self.driver.power.reboot, task, @@ -270,7 +268,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase): task, method='non-existent-method') def test_vendor_passthru_call__set_boot_device(self): - with task_manager.acquire(self.context, [self.node['uuid']], + with task_manager.acquire(self.context, [self.node.uuid], shared=False) as task: with mock.patch.object(ipminative.VendorPassthru, '_set_boot_device') as boot_mock: diff --git a/ironic/tests/drivers/test_ipmitool.py b/ironic/tests/drivers/test_ipmitool.py index 0be205a7e9..8b666aa97a 100644 --- a/ironic/tests/drivers/test_ipmitool.py +++ b/ironic/tests/drivers/test_ipmitool.py @@ -274,10 +274,9 @@ class IPMIToolDriverTestCase(db_base.DbTestCase): mgr_utils.mock_the_extension_manager(driver="fake_ipmitool") self.driver = driver_factory.get_driver("fake_ipmitool") - db_node = db_utils.get_test_node( - driver='fake_ipmitool', - driver_info=INFO_DICT) - self.node = self.dbapi.create_node(db_node) + self.node = obj_utils.create_test_node(self.context, + driver='fake_ipmitool', + driver_info=INFO_DICT) self.info = ipmi._parse_driver_info(self.node) def test_get_power_state(self): diff --git a/ironic/tests/drivers/test_pxe.py b/ironic/tests/drivers/test_pxe.py index d5d23a9983..eec06cc664 100644 --- a/ironic/tests/drivers/test_pxe.py +++ b/ironic/tests/drivers/test_pxe.py @@ -45,6 +45,7 @@ from ironic.tests import base from ironic.tests.conductor import utils as mgr_utils from ironic.tests.db import base as db_base from ironic.tests.db import utils as db_utils +from ironic.tests.objects import utils as obj_utils CONF = cfg.CONF @@ -56,17 +57,14 @@ class PXEValidateParametersTestCase(base.TestCase): def setUp(self): super(PXEValidateParametersTestCase, self).setUp() + self.context = context.get_admin_context() self.dbapi = dbapi.get_instance() - def _create_test_node(self, **kwargs): - n = db_utils.get_test_node(**kwargs) - return self.dbapi.create_node(n) - def test__parse_driver_info_good(self): # make sure we get back the expected things - node = self._create_test_node( - driver='fake_pxe', - driver_info=INFO_DICT) + node = obj_utils.create_test_node(self.context, + driver='fake_pxe', + driver_info=INFO_DICT) info = pxe._parse_driver_info(node) self.assertIsNotNone(info.get('image_source')) self.assertIsNotNone(info.get('deploy_kernel')) @@ -78,7 +76,7 @@ class PXEValidateParametersTestCase(base.TestCase): # make sure error is raised when info is missing info = dict(INFO_DICT) del info['pxe_image_source'] - node = self._create_test_node(driver_info=info) + node = obj_utils.create_test_node(self.context, driver_info=info) self.assertRaises(exception.InvalidParameterValue, pxe._parse_driver_info, node) @@ -87,7 +85,7 @@ class PXEValidateParametersTestCase(base.TestCase): # make sure error is raised when info is missing info = dict(INFO_DICT) del info['pxe_deploy_kernel'] - node = self._create_test_node(driver_info=info) + node = obj_utils.create_test_node(self.context, driver_info=info) self.assertRaises(exception.InvalidParameterValue, pxe._parse_driver_info, node) @@ -96,7 +94,7 @@ class PXEValidateParametersTestCase(base.TestCase): # make sure error is raised when info is missing info = dict(INFO_DICT) del info['pxe_deploy_ramdisk'] - node = self._create_test_node(driver_info=info) + node = obj_utils.create_test_node(self.context, driver_info=info) self.assertRaises(exception.InvalidParameterValue, pxe._parse_driver_info, node) @@ -105,7 +103,7 @@ class PXEValidateParametersTestCase(base.TestCase): # make sure error is raised when info is missing info = dict(INFO_DICT) del info['pxe_root_gb'] - node = self._create_test_node(driver_info=info) + node = obj_utils.create_test_node(self.context, driver_info=info) self.assertRaises(exception.InvalidParameterValue, pxe._parse_driver_info, node) @@ -113,7 +111,7 @@ class PXEValidateParametersTestCase(base.TestCase): def test__parse_driver_info_invalid_root_gb(self): info = dict(INFO_DICT) info['pxe_root_gb'] = 'foobar' - node = self._create_test_node(driver_info=info) + node = obj_utils.create_test_node(self.context, driver_info=info) self.assertRaises(exception.InvalidParameterValue, pxe._parse_driver_info, node) @@ -124,7 +122,7 @@ class PXEValidateParametersTestCase(base.TestCase): info = dict(INFO_DICT) info['pxe_ephemeral_gb'] = ephemeral_gb info['pxe_ephemeral_format'] = ephemeral_fmt - node = self._create_test_node(driver_info=info) + node = obj_utils.create_test_node(self.context, driver_info=info) data = pxe._parse_driver_info(node) self.assertEqual(ephemeral_gb, data.get('ephemeral_gb')) self.assertEqual(ephemeral_fmt, data.get('ephemeral_format')) @@ -133,7 +131,7 @@ class PXEValidateParametersTestCase(base.TestCase): info = dict(INFO_DICT) info['pxe_ephemeral_gb'] = 'foobar' info['pxe_ephemeral_format'] = 'exttest' - node = self._create_test_node(driver_info=info) + node = obj_utils.create_test_node(self.context, driver_info=info) self.assertRaises(exception.InvalidParameterValue, pxe._parse_driver_info, node) @@ -145,7 +143,7 @@ class PXEValidateParametersTestCase(base.TestCase): info['pxe_ephemeral_gb'] = ephemeral_gb info['pxe_ephemeral_format'] = None self.config(default_ephemeral_format=ephemeral_fmt, group='pxe') - node = self._create_test_node(driver_info=info) + node = obj_utils.create_test_node(self.context, driver_info=info) driver_info = pxe._parse_driver_info(node) self.assertEqual(ephemeral_fmt, driver_info['ephemeral_format']) @@ -154,8 +152,9 @@ class PXEValidateParametersTestCase(base.TestCase): for _id, opt in enumerate(['true', 'TRUE', 'True', 't', 'on', 'yes', 'y', '1']): info['pxe_preserve_ephemeral'] = opt - node = self._create_test_node(id=_id, uuid=utils.generate_uuid(), - driver_info=info) + node = obj_utils.create_test_node(self.context, id=_id, + uuid=utils.generate_uuid(), + driver_info=info) data = pxe._parse_driver_info(node) self.assertTrue(data.get('preserve_ephemeral')) @@ -164,15 +163,16 @@ class PXEValidateParametersTestCase(base.TestCase): for _id, opt in enumerate(['false', 'FALSE', 'False', 'f', 'off', 'no', 'n', '0']): info['pxe_preserve_ephemeral'] = opt - node = self._create_test_node(id=_id, uuid=utils.generate_uuid(), - driver_info=info) + node = obj_utils.create_test_node(self.context, id=_id, + uuid=utils.generate_uuid(), + driver_info=info) data = pxe._parse_driver_info(node) self.assertFalse(data.get('preserve_ephemeral')) def test__parse_driver_info_invalid_preserve_ephemeral(self): info = dict(INFO_DICT) info['pxe_preserve_ephemeral'] = 'foobar' - node = self._create_test_node(driver_info=info) + node = obj_utils.create_test_node(self.context, driver_info=info) self.assertRaises(exception.InvalidParameterValue, pxe._parse_driver_info, node) @@ -180,7 +180,7 @@ class PXEValidateParametersTestCase(base.TestCase): def test__parse_driver_info_swap_defaults_to_1mb(self): info = dict(INFO_DICT) info['pxe_swap_mb'] = 0 - node = self._create_test_node(driver_info=info) + node = obj_utils.create_test_node(self.context, driver_info=info) data = pxe._parse_driver_info(node) self.assertEqual(1, data.get('swap_mb')) @@ -273,12 +273,8 @@ class PXEPrivateMethodsTestCase(db_base.DbTestCase): } mgr_utils.mock_the_extension_manager(driver="fake_pxe") self.dbapi = dbapi.get_instance() - self.node = self._create_test_node(**n) self.context = context.get_admin_context() - - def _create_test_node(self, **kwargs): - n = db_utils.get_test_node(**kwargs) - return self.dbapi.create_node(n) + self.node = obj_utils.create_test_node(self.context, **n) def _create_test_port(self, **kwargs): p = db_utils.get_test_port(**kwargs) @@ -364,7 +360,7 @@ class PXEPrivateMethodsTestCase(db_base.DbTestCase): self.assertEqual(pxe_config_template, pxe_config) # test that deploy_key saved - db_node = self.dbapi.get_node_by_uuid(self.node['uuid']) + db_node = self.dbapi.get_node_by_uuid(self.node.uuid) db_key = db_node['driver_info'].get('pxe_deploy_key') self.assertEqual(fake_key, db_key) @@ -476,7 +472,7 @@ class PXEPrivateMethodsTestCase(db_base.DbTestCase): pxe._get_image_file_path(self.node.uuid)) def test_get_token_file_path(self): - node_uuid = self.node['uuid'] + node_uuid = self.node.uuid self.assertEqual('/tftpboot/token-' + node_uuid, pxe._get_token_file_path(node_uuid)) @@ -614,22 +610,21 @@ class PXEDriverTestCase(db_base.DbTestCase): mgr_utils.mock_the_extension_manager(driver="fake_pxe") driver_info = INFO_DICT driver_info['pxe_deploy_key'] = 'fake-56789' - n = db_utils.get_test_node( - driver='fake_pxe', - driver_info=driver_info) + self.node = obj_utils.create_test_node(self.context, + driver='fake_pxe', + driver_info=driver_info) self.dbapi = dbapi.get_instance() - self.node = self.dbapi.create_node(n) self.port = self.dbapi.create_port(db_utils.get_test_port( node_id=self.node.id)) self.config(group='conductor', api_url='http://127.0.0.1:1234/') def _create_token_file(self): - token_path = pxe._get_token_file_path(self.node['uuid']) + token_path = pxe._get_token_file_path(self.node.uuid) open(token_path, 'w').close() return token_path def test_validate_good(self): - with task_manager.acquire(self.context, [self.node['uuid']], + with task_manager.acquire(self.context, [self.node.uuid], shared=True) as task: task.resources[0].driver.deploy.validate(task, self.node) @@ -637,16 +632,17 @@ class PXEDriverTestCase(db_base.DbTestCase): info = dict(INFO_DICT) del info['pxe_image_source'] self.node['driver_info'] = json.dumps(info) - with task_manager.acquire(self.context, [self.node['uuid']], + with task_manager.acquire(self.context, [self.node.uuid], shared=True) as task: self.assertRaises(exception.InvalidParameterValue, task.resources[0].driver.deploy.validate, task, self.node) def test_validate_fail_no_port(self): - new_node = self.dbapi.create_node(db_utils.get_test_node(id=321, - uuid='aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', - driver='fake_pxe', driver_info=INFO_DICT)) + new_node = obj_utils.create_test_node( + self.context, + id=321, uuid='aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', + driver='fake_pxe', driver_info=INFO_DICT) with task_manager.acquire(self.context, [new_node.uuid], shared=True) as task: self.assertRaises(exception.InvalidParameterValue, @@ -690,14 +686,14 @@ class PXEDriverTestCase(db_base.DbTestCase): mock_ks.assert_called_once_with() def test_vendor_passthru_validate_good(self): - with task_manager.acquire(self.context, [self.node['uuid']], + with task_manager.acquire(self.context, [self.node.uuid], shared=True) as task: task.resources[0].driver.vendor.validate(task, method='pass_deploy_info', address='123456', iqn='aaa-bbb', key='fake-56789') def test_vendor_passthru_validate_fail(self): - with task_manager.acquire(self.context, [self.node['uuid']], + with task_manager.acquire(self.context, [self.node.uuid], shared=True) as task: self.assertRaises(exception.InvalidParameterValue, task.resources[0].driver.vendor.validate, @@ -705,7 +701,7 @@ class PXEDriverTestCase(db_base.DbTestCase): key='fake-56789') def test_vendor_passthru_validate_key_notmatch(self): - with task_manager.acquire(self.context, [self.node['uuid']], + with task_manager.acquire(self.context, [self.node.uuid], shared=True) as task: self.assertRaises(exception.InvalidParameterValue, task.resources[0].driver.vendor.validate, @@ -724,7 +720,7 @@ class PXEDriverTestCase(db_base.DbTestCase): cache_images_mock.return_value = None with task_manager.acquire(self.context, - self.node['uuid'], shared=True) as task: + self.node.uuid, shared=True) as task: task.driver.deploy.prepare(task, self.node) get_tftp_image_info_mock.assert_called_once_with( self.node, @@ -743,7 +739,7 @@ class PXEDriverTestCase(db_base.DbTestCase): with mock.patch.object(manager_utils, 'node_set_boot_device') as node_set_boot_mock: with task_manager.acquire(self.context, - self.node['uuid'], shared=False) as task: + self.node.uuid, shared=False) as task: state = task.driver.deploy.deploy(task, self.node) self.assertEqual(state, states.DEPLOYWAIT) update_neutron_mock.assert_called_once_with(task, @@ -756,7 +752,7 @@ class PXEDriverTestCase(db_base.DbTestCase): states.REBOOT) # ensure token file created - t_path = pxe._get_token_file_path(self.node['uuid']) + t_path = pxe._get_token_file_path(self.node.uuid) token = open(t_path, 'r').read() self.assertEqual(self.context.auth_token, token) @@ -764,7 +760,7 @@ class PXEDriverTestCase(db_base.DbTestCase): with mock.patch.object(manager_utils, 'node_power_action') as node_power_mock: with task_manager.acquire(self.context, - self.node['uuid']) as task: + self.node.uuid) as task: state = task.driver.deploy.tear_down(task, self.node) self.assertEqual(states.DELETED, state) node_power_mock.assert_called_once_with(task, self.node, @@ -778,11 +774,11 @@ class PXEDriverTestCase(db_base.DbTestCase): info['pxe_kernel'] = 'fake-123' info['pxe_ramdisk'] = 'fake-345' self.node.driver_info = info - self.node.save(self.context) + self.node.save() with task_manager.acquire(self.context, self.node.uuid) as task: task.driver.deploy.tear_down(task, self.node) - self.node.refresh(self.context) + self.node.refresh() self.assertNotIn('pxe_deploy_key', self.node.driver_info) self.assertNotIn('pxe_kernel', self.node.driver_info) self.assertNotIn('pxe_ramdisk', self.node.driver_info) @@ -791,7 +787,7 @@ class PXEDriverTestCase(db_base.DbTestCase): def test_take_over(self): with mock.patch.object(pxe, '_update_neutron') as update_neutron_mock: with task_manager.acquire( - self.context, self.node['uuid'], shared=True) as task: + self.context, self.node.uuid, shared=True) as task: task.driver.deploy.take_over(task, self.node) update_neutron_mock.assert_called_once_with(task, self.node) @@ -799,7 +795,7 @@ class PXEDriverTestCase(db_base.DbTestCase): token_path = self._create_token_file() self.node.power_state = states.POWER_ON self.node.provision_state = states.DEPLOYWAIT - self.node.save(self.context) + self.node.save() def fake_deploy(**kwargs): pass @@ -822,7 +818,7 @@ class PXEDriverTestCase(db_base.DbTestCase): token_path = self._create_token_file() self.node.power_state = states.POWER_ON self.node.provision_state = states.DEPLOYWAIT - self.node.save(self.context) + self.node.save() def fake_deploy(**kwargs): raise exception.InstanceDeployFailure("test deploy error") @@ -845,7 +841,7 @@ class PXEDriverTestCase(db_base.DbTestCase): token_path = self._create_token_file() self.node.power_state = states.POWER_ON self.node.provision_state = states.DEPLOYWAIT - self.node.save(self.context) + self.node.save() def fake_deploy(**kwargs): pass @@ -867,7 +863,7 @@ class PXEDriverTestCase(db_base.DbTestCase): def test_continue_deploy_invalid(self): self.node.power_state = states.POWER_ON self.node.provision_state = 'FAKE' - self.node.save(self.context) + self.node.save() with task_manager.acquire(self.context, [self.node.uuid]) as task: task.resources[0].driver.vendor.vendor_passthru(task, @@ -878,7 +874,7 @@ class PXEDriverTestCase(db_base.DbTestCase): self.assertEqual(states.POWER_ON, self.node.power_state) def test_lock_elevated(self): - with task_manager.acquire(self.context, [self.node['uuid']]) as task: + with task_manager.acquire(self.context, [self.node.uuid]) as task: with mock.patch.object(task.driver.vendor, '_continue_deploy') \ as _continue_deploy_mock: task.driver.vendor.vendor_passthru(task, @@ -953,7 +949,7 @@ class PXEDriverTestCase(db_base.DbTestCase): open(deploy_kernel_path, 'w').close() open(image_path, 'w').close() - with task_manager.acquire(self.context, [self.node['uuid']], + with task_manager.acquire(self.context, [self.node.uuid], shared=True) as task: task.resources[0].driver.deploy.clean_up(task, self.node) get_tftp_image_info_mock.called_once_with(self.node) diff --git a/ironic/tests/drivers/test_seamicro.py b/ironic/tests/drivers/test_seamicro.py index 96accebc7d..10e9a67a58 100644 --- a/ironic/tests/drivers/test_seamicro.py +++ b/ironic/tests/drivers/test_seamicro.py @@ -145,7 +145,7 @@ class SeaMicroPrivateMethodsTestCase(base.TestCase): } self.context = context.get_admin_context() self.dbapi = dbapi.get_instance() - self.node = self._create_test_node(**n) + self.node = obj_utils.create_test_node(self.context, **n) self.Server = Fake_Server self.Volume = Fake_Volume self.Pool = Fake_Pool @@ -155,10 +155,6 @@ class SeaMicroPrivateMethodsTestCase(base.TestCase): self.patcher = mock.patch('eventlet.greenthread.sleep') self.mock_sleep = self.patcher.start() - def _create_test_node(self, **kwargs): - n = db_utils.get_test_node(**kwargs) - return self.dbapi.create_node(n) - @mock.patch.object(seamicro, "_get_server") def test__get_power_status_on(self, mock_get_server): mock_get_server.return_value = self.Server(active=True) @@ -272,10 +268,10 @@ class SeaMicroPowerDriverTestCase(db_base.DbTestCase): self.skipTest("Seamicroclient library not found") mgr_utils.mock_the_extension_manager(driver='fake_seamicro') self.driver = driver_factory.get_driver('fake_seamicro') - db_node = db_utils.get_test_node(driver='fake_seamicro', - driver_info=INFO_DICT) + self.node = obj_utils.create_test_node(self.context, + driver='fake_seamicro', + driver_info=INFO_DICT) self.dbapi = dbapi.get_instance() - self.node = self.dbapi.create_node(db_node) self.get_server_patcher = mock.patch.object(seamicro, '_get_server') self.get_server_mock = None diff --git a/ironic/tests/drivers/test_ssh.py b/ironic/tests/drivers/test_ssh.py index 56e90381ab..f6715cd39e 100644 --- a/ironic/tests/drivers/test_ssh.py +++ b/ironic/tests/drivers/test_ssh.py @@ -606,11 +606,10 @@ class SSHDriverTestCase(db_base.DbTestCase): super(SSHDriverTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake_ssh") self.driver = driver_factory.get_driver("fake_ssh") - n = db_utils.get_test_node( - driver='fake_ssh', + self.node = obj_utils.create_test_node( + self.context, driver='fake_ssh', driver_info=db_utils.get_test_ssh_info()) self.dbapi = dbapi.get_instance() - self.node = self.dbapi.create_node(n) self.port = self.dbapi.create_port(db_utils.get_test_port( node_id=self.node.id)) self.sshclient = paramiko.SSHClient() @@ -658,12 +657,12 @@ class SSHDriverTestCase(db_base.DbTestCase): self.get_mac_addr_patcher.stop() self.get_mac_addr_mock = None - new_node = self.dbapi.create_node( - db_utils.get_test_node( - id=321, - uuid='aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', - driver='fake_ssh', - driver_info=db_utils.get_test_ssh_info())) + new_node = obj_utils.create_test_node( + self.context, + id=321, + uuid='aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', + driver='fake_ssh', + driver_info=db_utils.get_test_ssh_info()) with task_manager.acquire(self.context, [new_node.uuid], shared=True) as task: self.assertRaises(exception.InvalidParameterValue, diff --git a/ironic/tests/drivers/test_utils.py b/ironic/tests/drivers/test_utils.py index 533e0d4089..ff29b8b1e0 100644 --- a/ironic/tests/drivers/test_utils.py +++ b/ironic/tests/drivers/test_utils.py @@ -25,6 +25,7 @@ from ironic.openstack.common import context from ironic.tests import base from ironic.tests.conductor import utils as mgr_utils from ironic.tests.db import utils as db_utils +from ironic.tests.objects import utils as obj_utils class UtilsTestCase(base.TestCase): @@ -35,8 +36,7 @@ class UtilsTestCase(base.TestCase): self.dbapi = db_api.get_instance() mgr_utils.mock_the_extension_manager() self.driver = driver_factory.get_driver("fake") - ndict = db_utils.get_test_node() - self.node = self.dbapi.create_node(ndict) + self.node = obj_utils.create_test_node(self.context) @mock.patch.object(fake.FakeVendorA, 'validate') def test_vendor_interface_validate_valid_methods(self, diff --git a/ironic/tests/objects/utils.py b/ironic/tests/objects/utils.py index 3b57354e93..65b1c70ea1 100644 --- a/ironic/tests/objects/utils.py +++ b/ironic/tests/objects/utils.py @@ -29,3 +29,12 @@ def get_test_node(ctxt, **kw): for key in db_node: setattr(node, key, db_node[key]) return node + + +def create_test_node(ctxt, **kw): + """Create a node in the DB and return a Node object with appropriate + attributes. + """ + node = get_test_node(ctxt, **kw) + node.create() + return node