openstack/ironic
Code Issues Proposed changes

Add create() and destroy() to Node

Browse Source 
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
This commit is contained in:
Chris Behrens 2014-04-02 02:56:55 -07:00
parent 56e8424ffc
commit 7ecca8868a
17 changed files with 511 additions and 531 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ironic/api/controllers/v1/node.py
View File

@ -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])

5
ironic/conductor/manager.py
View File

@ -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,

1
ironic/db/sqlalchemy/api.py
View File

@ -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'):

38
ironic/objects/node.py
View File

@ -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.

10
ironic/tests/api/v1/test_chassis.py
View File

@ -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)

231
ironic/tests/api/v1/test_nodes.py
View File

@ -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)

17
ironic/tests/api/v1/test_ports.py
View File

@ -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)

101
ironic/tests/conductor/test_conductor_utils.py
View File

@ -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)

432
ironic/tests/conductor/test_manager.py
View File

File diff suppressed because it is too large Load Diff

19
ironic/tests/conductor/test_task_manager.py
View File

@ -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

30
ironic/tests/drivers/test_ipminative.py
View File

@ -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:

7
ironic/tests/drivers/test_ipmitool.py
View File

@ -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):

104
ironic/tests/drivers/test_pxe.py
View File

@ -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)

12
ironic/tests/drivers/test_seamicro.py
View File

@ -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

17
ironic/tests/drivers/test_ssh.py
View File

@ -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,

4
ironic/tests/drivers/test_utils.py
View File

@ -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,

9
ironic/tests/objects/utils.py
View File

@ -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