← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ironic/vivid-updates

« back to all changes in this revision

Viewing changes to ironic/tests/db/test_nodes.py

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2015-01-05 12:21:37 UTC
  • mfrom: (1.2.4)
  • Revision ID: package-import@ubuntu.com-20150105122137-171bqrdpcxqipunk
Tags: 2015.1~b1-0ubuntu1
* New upstream beta release:
  - d/control: Align version requirements with upstream release.
* d/watch: Update uversionmangle to deal with kilo beta versioning
  changes.
* d/control: Bumped Standards-Version to 3.9.6, no changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ironic/tests/db/test_nodes.py
24
24
from ironic.common import exception
25
25
from ironic.common import states
26
26
from ironic.common import utils as ironic_utils
27
 
from ironic.db import api as dbapi
28
27
from ironic.tests.db import base
29
28
from ironic.tests.db import utils
30
29
 
31
30
 
32
31
class DbNodeTestCase(base.DbTestCase):
33
32
 
34
 
    def setUp(self):
35
 
        super(DbNodeTestCase, self).setUp()
36
 
        self.dbapi = dbapi.get_instance()
37
 
 
38
 
    def _create_test_node(self, **kwargs):
39
 
        n = utils.get_test_node(**kwargs)
40
 
        self.dbapi.create_node(n)
41
 
        return n
42
 
 
43
33
    def test_create_node(self):
44
 
        self._create_test_node()
 
34
        utils.create_test_node()
45
35
 
46
36
    def test_create_node_nullable_chassis_id(self):
47
 
        n = utils.get_test_node()
48
 
        del n['chassis_id']
49
 
        self.dbapi.create_node(n)
 
37
        utils.create_test_node(chassis_id=None)
50
38
 
51
39
    def test_create_node_already_exists(self):
52
 
        n = utils.get_test_node()
53
 
        del n['id']
54
 
        self.dbapi.create_node(n)
 
40
        utils.create_test_node()
55
41
        self.assertRaises(exception.NodeAlreadyExists,
56
 
                          self.dbapi.create_node, n)
 
42
                          utils.create_test_node)
57
43
 
58
44
    def test_create_node_instance_already_associated(self):
59
45
        instance = ironic_utils.generate_uuid()
60
 
        n1 = utils.get_test_node(id=1, uuid=ironic_utils.generate_uuid(),
61
 
                                 instance_uuid=instance)
62
 
        self.dbapi.create_node(n1)
63
 
        n2 = utils.get_test_node(id=2, uuid=ironic_utils.generate_uuid(),
64
 
                                 instance_uuid=instance)
 
46
        utils.create_test_node(uuid=ironic_utils.generate_uuid(),
 
47
                               instance_uuid=instance)
65
48
        self.assertRaises(exception.InstanceAssociated,
66
 
                          self.dbapi.create_node, n2)
 
49
                          utils.create_test_node,
 
50
                          uuid=ironic_utils.generate_uuid(),
 
51
                          instance_uuid=instance)
67
52
 
68
53
    def test_get_node_by_id(self):
69
 
        n = self._create_test_node()
70
 
        res = self.dbapi.get_node_by_id(n['id'])
71
 
        self.assertEqual(n['id'], res.id)
72
 
        self.assertEqual(n['uuid'], res.uuid)
 
54
        node = utils.create_test_node()
 
55
        res = self.dbapi.get_node_by_id(node.id)
 
56
        self.assertEqual(node.id, res.id)
 
57
        self.assertEqual(node.uuid, res.uuid)
73
58
 
74
59
    def test_get_node_by_uuid(self):
75
 
        n = self._create_test_node()
76
 
        res = self.dbapi.get_node_by_uuid(n['uuid'])
77
 
        self.assertEqual(n['id'], res.id)
78
 
        self.assertEqual(n['uuid'], res.uuid)
 
60
        node = utils.create_test_node()
 
61
        res = self.dbapi.get_node_by_uuid(node.uuid)
 
62
        self.assertEqual(node.id, res.id)
 
63
        self.assertEqual(node.uuid, res.uuid)
79
64
 
80
65
    def test_get_node_that_does_not_exist(self):
81
66
        self.assertRaises(exception.NodeNotFound,
85
70
                          '12345678-9999-0000-aaaa-123456789012')
86
71
 
87
72
    def test_get_nodeinfo_list_defaults(self):
 
73
        node_id_list = []
88
74
        for i in range(1, 6):
89
 
            n = utils.get_test_node(id=i, uuid=ironic_utils.generate_uuid())
90
 
            self.dbapi.create_node(n)
 
75
            node = utils.create_test_node(uuid=ironic_utils.generate_uuid())
 
76
            node_id_list.append(node.id)
91
77
        res = [i[0] for i in self.dbapi.get_nodeinfo_list()]
92
 
        self.assertEqual(sorted(res), sorted(range(1, 6)))
 
78
        self.assertEqual(sorted(res), sorted(node_id_list))
93
79
 
94
80
    def test_get_nodeinfo_list_with_cols(self):
95
81
        uuids = {}
97
83
        for i in range(1, 6):
98
84
            uuid = ironic_utils.generate_uuid()
99
85
            extra = {'foo': i}
100
 
            uuids[i] = uuid
101
 
            extras[i] = extra
102
 
            n = utils.get_test_node(id=i, extra=extra, uuid=uuid)
103
 
            self.dbapi.create_node(n)
 
86
            node = utils.create_test_node(extra=extra, uuid=uuid)
 
87
            uuids[node.id] = uuid
 
88
            extras[node.id] = extra
104
89
        res = self.dbapi.get_nodeinfo_list(columns=['id', 'extra', 'uuid'])
105
90
        self.assertEqual(extras, dict((r[0], r[1]) for r in res))
106
91
        self.assertEqual(uuids, dict((r[0], r[2]) for r in res))
107
92
 
108
93
    def test_get_nodeinfo_list_with_filters(self):
109
 
        n1 = utils.get_test_node(id=1, driver='driver-one',
110
 
                                 instance_uuid=ironic_utils.generate_uuid(),
111
 
                                 reservation='fake-host',
112
 
                                 uuid=ironic_utils.generate_uuid())
113
 
        n2 = utils.get_test_node(id=2, driver='driver-two',
114
 
                                 uuid=ironic_utils.generate_uuid(),
115
 
                                 maintenance=True)
116
 
        self.dbapi.create_node(n1)
117
 
        self.dbapi.create_node(n2)
 
94
        node1 = utils.create_test_node(driver='driver-one',
 
95
            instance_uuid=ironic_utils.generate_uuid(),
 
96
            reservation='fake-host',
 
97
            uuid=ironic_utils.generate_uuid())
 
98
        node2 = utils.create_test_node(driver='driver-two',
 
99
            uuid=ironic_utils.generate_uuid(),
 
100
            maintenance=True)
118
101
 
119
102
        res = self.dbapi.get_nodeinfo_list(filters={'driver': 'driver-one'})
120
 
        self.assertEqual([1], [r[0] for r in res])
 
103
        self.assertEqual([node1.id], [r[0] for r in res])
121
104
 
122
105
        res = self.dbapi.get_nodeinfo_list(filters={'driver': 'bad-driver'})
123
106
        self.assertEqual([], [r[0] for r in res])
124
107
 
125
108
        res = self.dbapi.get_nodeinfo_list(filters={'associated': True})
126
 
        self.assertEqual([1], [r[0] for r in res])
 
109
        self.assertEqual([node1.id], [r[0] for r in res])
127
110
 
128
111
        res = self.dbapi.get_nodeinfo_list(filters={'associated': False})
129
 
        self.assertEqual([2], [r[0] for r in res])
 
112
        self.assertEqual([node2.id], [r[0] for r in res])
130
113
 
131
114
        res = self.dbapi.get_nodeinfo_list(filters={'reserved': True})
132
 
        self.assertEqual([1], [r[0] for r in res])
 
115
        self.assertEqual([node1.id], [r[0] for r in res])
133
116
 
134
117
        res = self.dbapi.get_nodeinfo_list(filters={'reserved': False})
135
 
        self.assertEqual([2], [r[0] for r in res])
 
118
        self.assertEqual([node2.id], [r[0] for r in res])
136
119
 
137
120
        res = self.dbapi.get_node_list(filters={'maintenance': True})
138
 
        self.assertEqual([2], [r.id for r in res])
 
121
        self.assertEqual([node2.id], [r.id for r in res])
139
122
 
140
123
        res = self.dbapi.get_node_list(filters={'maintenance': False})
141
 
        self.assertEqual([1], [r.id for r in res])
 
124
        self.assertEqual([node1.id], [r.id for r in res])
142
125
 
143
126
    @mock.patch.object(timeutils, 'utcnow')
144
127
    def test_get_nodeinfo_list_provision(self, mock_utcnow):
148
131
        mock_utcnow.return_value = past
149
132
 
150
133
        # node with provision_updated timeout
151
 
        n1 = utils.get_test_node(id=1, uuid=ironic_utils.generate_uuid(),
152
 
                                 provision_updated_at=past)
 
134
        node1 = utils.create_test_node(uuid=ironic_utils.generate_uuid(),
 
135
                                       provision_updated_at=past)
153
136
        # node with None in provision_updated_at
154
 
        n2 = utils.get_test_node(id=2, uuid=ironic_utils.generate_uuid(),
155
 
                                 provision_state=states.DEPLOYWAIT)
 
137
        node2 = utils.create_test_node(uuid=ironic_utils.generate_uuid(),
 
138
                                       provision_state=states.DEPLOYWAIT)
156
139
        # node without timeout
157
 
        n3 = utils.get_test_node(id=3, uuid=ironic_utils.generate_uuid(),
158
 
                                 provision_updated_at=next)
159
 
        self.dbapi.create_node(n1)
160
 
        self.dbapi.create_node(n2)
161
 
        self.dbapi.create_node(n3)
 
140
        utils.create_test_node(uuid=ironic_utils.generate_uuid(),
 
141
                            provision_updated_at=next)
162
142
 
163
143
        mock_utcnow.return_value = present
164
144
        res = self.dbapi.get_nodeinfo_list(filters={'provisioned_before': 300})
165
 
        self.assertEqual([1], [r[0] for r in res])
 
145
        self.assertEqual([node1.id], [r[0] for r in res])
166
146
 
167
147
        res = self.dbapi.get_nodeinfo_list(filters={'provision_state':
168
148
                                                    states.DEPLOYWAIT})
169
 
        self.assertEqual([2], [r[0] for r in res])
 
149
        self.assertEqual([node2.id], [r[0] for r in res])
170
150
 
171
151
    def test_get_node_list(self):
172
152
        uuids = []
173
153
        for i in range(1, 6):
174
 
            n = utils.get_test_node(id=i, uuid=ironic_utils.generate_uuid())
175
 
            self.dbapi.create_node(n)
176
 
            uuids.append(six.text_type(n['uuid']))
 
154
            node = utils.create_test_node(uuid=ironic_utils.generate_uuid())
 
155
            uuids.append(six.text_type(node['uuid']))
177
156
        res = self.dbapi.get_node_list()
178
157
        res_uuids = [r.uuid for r in res]
179
158
        self.assertEqual(uuids.sort(), res_uuids.sort())
184
163
        self.dbapi.create_chassis(ch1)
185
164
        self.dbapi.create_chassis(ch2)
186
165
 
187
 
        n1 = utils.get_test_node(id=1, driver='driver-one',
188
 
                                 instance_uuid=ironic_utils.generate_uuid(),
189
 
                                 reservation='fake-host',
190
 
                                 uuid=ironic_utils.generate_uuid(),
191
 
                                 chassis_id=ch1['id'])
192
 
        n2 = utils.get_test_node(id=2, driver='driver-two',
193
 
                                 uuid=ironic_utils.generate_uuid(),
194
 
                                 chassis_id=ch2['id'],
195
 
                                 maintenance=True)
196
 
        self.dbapi.create_node(n1)
197
 
        self.dbapi.create_node(n2)
 
166
        node1 = utils.create_test_node(driver='driver-one',
 
167
            instance_uuid=ironic_utils.generate_uuid(),
 
168
            reservation='fake-host',
 
169
            uuid=ironic_utils.generate_uuid(),
 
170
            chassis_id=ch1['id'])
 
171
        node2 = utils.create_test_node(driver='driver-two',
 
172
            uuid=ironic_utils.generate_uuid(),
 
173
            chassis_id=ch2['id'],
 
174
            maintenance=True)
198
175
 
199
176
        res = self.dbapi.get_node_list(filters={'chassis_uuid': ch1['uuid']})
200
 
        self.assertEqual([1], [r.id for r in res])
 
177
        self.assertEqual([node1.id], [r.id for r in res])
201
178
 
202
179
        res = self.dbapi.get_node_list(filters={'chassis_uuid': ch2['uuid']})
203
 
        self.assertEqual([2], [r.id for r in res])
 
180
        self.assertEqual([node2.id], [r.id for r in res])
204
181
 
205
182
        res = self.dbapi.get_node_list(filters={'driver': 'driver-one'})
206
 
        self.assertEqual([1], [r.id for r in res])
 
183
        self.assertEqual([node1.id], [r.id for r in res])
207
184
 
208
185
        res = self.dbapi.get_node_list(filters={'driver': 'bad-driver'})
209
186
        self.assertEqual([], [r.id for r in res])
210
187
 
211
188
        res = self.dbapi.get_node_list(filters={'associated': True})
212
 
        self.assertEqual([1], [r.id for r in res])
 
189
        self.assertEqual([node1.id], [r.id for r in res])
213
190
 
214
191
        res = self.dbapi.get_node_list(filters={'associated': False})
215
 
        self.assertEqual([2], [r.id for r in res])
 
192
        self.assertEqual([node2.id], [r.id for r in res])
216
193
 
217
194
        res = self.dbapi.get_node_list(filters={'reserved': True})
218
 
        self.assertEqual([1], [r.id for r in res])
 
195
        self.assertEqual([node1.id], [r.id for r in res])
219
196
 
220
197
        res = self.dbapi.get_node_list(filters={'reserved': False})
221
 
        self.assertEqual([2], [r.id for r in res])
 
198
        self.assertEqual([node2.id], [r.id for r in res])
222
199
 
223
200
        res = self.dbapi.get_node_list(filters={'maintenance': True})
224
 
        self.assertEqual([2], [r.id for r in res])
 
201
        self.assertEqual([node2.id], [r.id for r in res])
225
202
 
226
203
        res = self.dbapi.get_node_list(filters={'maintenance': False})
227
 
        self.assertEqual([1], [r.id for r in res])
 
204
        self.assertEqual([node1.id], [r.id for r in res])
228
205
 
229
206
    def test_get_node_list_chassis_not_found(self):
230
207
        self.assertRaises(exception.ChassisNotFound,
232
209
                          {'chassis_uuid': ironic_utils.generate_uuid()})
233
210
 
234
211
    def test_get_node_by_instance(self):
235
 
        n = self._create_test_node(
 
212
        node = utils.create_test_node(
236
213
                instance_uuid='12345678-9999-0000-aaaa-123456789012')
237
214
 
238
 
        res = self.dbapi.get_node_by_instance(n['instance_uuid'])
239
 
        self.assertEqual(n['uuid'], res.uuid)
 
215
        res = self.dbapi.get_node_by_instance(node.instance_uuid)
 
216
        self.assertEqual(node.uuid, res.uuid)
240
217
 
241
218
    def test_get_node_by_instance_wrong_uuid(self):
242
 
        self._create_test_node(
 
219
        utils.create_test_node(
243
220
                instance_uuid='12345678-9999-0000-aaaa-123456789012')
244
221
 
245
222
        self.assertRaises(exception.InstanceNotFound,
252
229
                          'fake_uuid')
253
230
 
254
231
    def test_destroy_node(self):
255
 
        n = self._create_test_node()
 
232
        node = utils.create_test_node()
256
233
 
257
 
        self.dbapi.destroy_node(n['id'])
 
234
        self.dbapi.destroy_node(node.id)
258
235
        self.assertRaises(exception.NodeNotFound,
259
 
                          self.dbapi.get_node_by_id, n['id'])
 
236
                          self.dbapi.get_node_by_id, node.id)
260
237
 
261
238
    def test_destroy_node_by_uuid(self):
262
 
        n = self._create_test_node()
 
239
        node = utils.create_test_node()
263
240
 
264
 
        self.dbapi.destroy_node(n['uuid'])
 
241
        self.dbapi.destroy_node(node.uuid)
265
242
        self.assertRaises(exception.NodeNotFound,
266
 
                          self.dbapi.get_node_by_uuid, n['uuid'])
 
243
                          self.dbapi.get_node_by_uuid, node.uuid)
267
244
 
268
245
    def test_destroy_node_that_does_not_exist(self):
269
246
        self.assertRaises(exception.NodeNotFound,
271
248
                          '12345678-9999-0000-aaaa-123456789012')
272
249
 
273
250
    def test_ports_get_destroyed_after_destroying_a_node(self):
274
 
        n = self._create_test_node()
275
 
        node_id = n['id']
276
 
 
277
 
        p = utils.get_test_port(node_id=node_id)
278
 
        p = self.dbapi.create_port(p)
279
 
 
280
 
        self.dbapi.destroy_node(node_id)
 
251
        node = utils.create_test_node()
 
252
 
 
253
        port = utils.create_test_port(node_id=node.id)
 
254
 
 
255
        self.dbapi.destroy_node(node.id)
281
256
 
282
257
        self.assertRaises(exception.PortNotFound,
283
 
                          self.dbapi.get_port_by_id, p.id)
 
258
                          self.dbapi.get_port_by_id, port.id)
284
259
 
285
260
    def test_ports_get_destroyed_after_destroying_a_node_by_uuid(self):
286
 
        n = self._create_test_node()
287
 
        node_id = n['id']
288
 
 
289
 
        p = utils.get_test_port(node_id=node_id)
290
 
        p = self.dbapi.create_port(p)
291
 
 
292
 
        self.dbapi.destroy_node(n['uuid'])
 
261
        node = utils.create_test_node()
 
262
 
 
263
        port = utils.create_test_port(node_id=node.id)
 
264
 
 
265
        self.dbapi.destroy_node(node.uuid)
293
266
 
294
267
        self.assertRaises(exception.PortNotFound,
295
 
                          self.dbapi.get_port_by_id, p.id)
 
268
                          self.dbapi.get_port_by_id, port.id)
296
269
 
297
270
    def test_update_node(self):
298
 
        n = self._create_test_node()
 
271
        node = utils.create_test_node()
299
272
 
300
 
        old_extra = n['extra']
 
273
        old_extra = node.extra
301
274
        new_extra = {'foo': 'bar'}
302
275
        self.assertNotEqual(old_extra, new_extra)
303
276
 
304
 
        res = self.dbapi.update_node(n['id'], {'extra': new_extra})
 
277
        res = self.dbapi.update_node(node.id, {'extra': new_extra})
305
278
        self.assertEqual(new_extra, res.extra)
306
279
 
307
280
    def test_update_node_not_found(self):
311
284
                          node_uuid, {'extra': new_extra})
312
285
 
313
286
    def test_update_node_uuid(self):
314
 
        n = self._create_test_node()
 
287
        node = utils.create_test_node()
315
288
        self.assertRaises(exception.InvalidParameterValue,
316
 
                          self.dbapi.update_node, n['id'],
 
289
                          self.dbapi.update_node, node.id,
317
290
                          {'uuid': ''})
318
291
 
319
292
    def test_update_node_associate_and_disassociate(self):
320
 
        n = self._create_test_node()
 
293
        node = utils.create_test_node()
321
294
        new_i_uuid = ironic_utils.generate_uuid()
322
 
        res = self.dbapi.update_node(n['id'], {'instance_uuid': new_i_uuid})
 
295
        res = self.dbapi.update_node(node.id, {'instance_uuid': new_i_uuid})
323
296
        self.assertEqual(new_i_uuid, res.instance_uuid)
324
 
        res = self.dbapi.update_node(n['id'], {'instance_uuid': None})
 
297
        res = self.dbapi.update_node(node.id, {'instance_uuid': None})
325
298
        self.assertIsNone(res.instance_uuid)
326
299
 
327
300
    def test_update_node_already_associated(self):
328
 
        n = self._create_test_node()
 
301
        node = utils.create_test_node()
329
302
        new_i_uuid_one = ironic_utils.generate_uuid()
330
 
        self.dbapi.update_node(n['id'], {'instance_uuid': new_i_uuid_one})
 
303
        self.dbapi.update_node(node.id, {'instance_uuid': new_i_uuid_one})
331
304
        new_i_uuid_two = ironic_utils.generate_uuid()
332
305
        self.assertRaises(exception.NodeAssociated,
333
306
                          self.dbapi.update_node,
334
 
                          n['id'],
 
307
                          node.id,
335
308
                          {'instance_uuid': new_i_uuid_two})
336
309
 
337
310
    def test_update_node_instance_already_associated(self):
338
 
        n = self._create_test_node(id=1, uuid=ironic_utils.generate_uuid())
 
311
        node1 = utils.create_test_node(uuid=ironic_utils.generate_uuid())
339
312
        new_i_uuid = ironic_utils.generate_uuid()
340
 
        self.dbapi.update_node(n['id'], {'instance_uuid': new_i_uuid})
341
 
        n = self._create_test_node(id=2, uuid=ironic_utils.generate_uuid())
 
313
        self.dbapi.update_node(node1.id, {'instance_uuid': new_i_uuid})
 
314
        node2 = utils.create_test_node(uuid=ironic_utils.generate_uuid())
342
315
        self.assertRaises(exception.InstanceAssociated,
343
316
                          self.dbapi.update_node,
344
 
                          n['id'],
 
317
                          node2.id,
345
318
                          {'instance_uuid': new_i_uuid})
346
319
 
347
320
    @mock.patch.object(timeutils, 'utcnow')
348
321
    def test_update_node_provision(self, mock_utcnow):
349
322
        mocked_time = datetime.datetime(2000, 1, 1, 0, 0)
350
323
        mock_utcnow.return_value = mocked_time
351
 
        n = self._create_test_node()
352
 
        res = self.dbapi.update_node(n['id'], {'provision_state': 'fake'})
 
324
        node = utils.create_test_node()
 
325
        res = self.dbapi.update_node(node.id, {'provision_state': 'fake'})
353
326
        self.assertEqual(mocked_time,
354
327
                         timeutils.normalize_time(res['provision_updated_at']))
355
328
 
356
329
    def test_update_node_no_provision(self):
357
 
        n = self._create_test_node()
358
 
        res = self.dbapi.update_node(n['id'], {'extra': {'foo': 'bar'}})
 
330
        node = utils.create_test_node()
 
331
        res = self.dbapi.update_node(node.id, {'extra': {'foo': 'bar'}})
359
332
        self.assertIsNone(res['provision_updated_at'])
360
333
 
361
334
    def test_reserve_node(self):
362
 
        n = self._create_test_node()
363
 
        uuid = n['uuid']
 
335
        node = utils.create_test_node()
 
336
        uuid = node.uuid
364
337
 
365
338
        r1 = 'fake-reservation'
366
339
 
372
345
        self.assertEqual(r1, res.reservation)
373
346
 
374
347
    def test_release_reservation(self):
375
 
        n = self._create_test_node()
376
 
        uuid = n['uuid']
 
348
        node = utils.create_test_node()
 
349
        uuid = node.uuid
377
350
 
378
351
        r1 = 'fake-reservation'
379
352
        self.dbapi.reserve_node(r1, uuid)
384
357
        self.assertIsNone(res.reservation)
385
358
 
386
359
    def test_reservation_of_reserved_node_fails(self):
387
 
        n = self._create_test_node()
388
 
        uuid = n['uuid']
 
360
        node = utils.create_test_node()
 
361
        uuid = node.uuid
389
362
 
390
363
        r1 = 'fake-reservation'
391
364
        r2 = 'another-reservation'
402
375
                          r2, uuid)
403
376
 
404
377
    def test_reservation_after_release(self):
405
 
        n = self._create_test_node()
406
 
        uuid = n['uuid']
 
378
        node = utils.create_test_node()
 
379
        uuid = node.uuid
407
380
 
408
381
        r1 = 'fake-reservation'
409
382
        r2 = 'another-reservation'
417
390
        self.assertEqual(r2, res.reservation)
418
391
 
419
392
    def test_reservation_in_exception_message(self):
420
 
        n = self._create_test_node()
421
 
        uuid = n['uuid']
 
393
        node = utils.create_test_node()
 
394
        uuid = node.uuid
422
395
 
423
396
        r = 'fake-reservation'
424
397
        self.dbapi.reserve_node(r, uuid)
428
401
            self.assertIn(r, str(e))
429
402
 
430
403
    def test_reservation_non_existent_node(self):
431
 
        n = self._create_test_node()
432
 
        self.dbapi.destroy_node(n['id'])
 
404
        node = utils.create_test_node()
 
405
        self.dbapi.destroy_node(node.id)
433
406
 
434
407
        self.assertRaises(exception.NodeNotFound,
435
 
                          self.dbapi.reserve_node, 'fake', n['id'])
 
408
                          self.dbapi.reserve_node, 'fake', node.id)
436
409
        self.assertRaises(exception.NodeNotFound,
437
 
                          self.dbapi.reserve_node, 'fake', n['uuid'])
 
410
                          self.dbapi.reserve_node, 'fake', node.uuid)
438
411
 
439
412
    def test_release_non_existent_node(self):
440
 
        n = self._create_test_node()
441
 
        self.dbapi.destroy_node(n['id'])
 
413
        node = utils.create_test_node()
 
414
        self.dbapi.destroy_node(node.id)
442
415
 
443
416
        self.assertRaises(exception.NodeNotFound,
444
 
                          self.dbapi.release_node, 'fake', n['id'])
 
417
                          self.dbapi.release_node, 'fake', node.id)
445
418
        self.assertRaises(exception.NodeNotFound,
446
 
                          self.dbapi.release_node, 'fake', n['uuid'])
 
419
                          self.dbapi.release_node, 'fake', node.uuid)
447
420
 
448
421
    def test_release_non_locked_node(self):
449
 
        n = self._create_test_node()
 
422
        node = utils.create_test_node()
450
423
 
451
 
        self.assertEqual(None, n['reservation'])
452
 
        self.assertRaises(exception.NodeNotLocked,
453
 
                          self.dbapi.release_node, 'fake', n['id'])
454
 
        self.assertRaises(exception.NodeNotLocked,
455
 
                          self.dbapi.release_node, 'fake', n['uuid'])
 
424
        self.assertEqual(None, node.reservation)
 
425
        self.assertRaises(exception.NodeNotLocked,
 
426
                          self.dbapi.release_node, 'fake', node.id)
 
427
        self.assertRaises(exception.NodeNotLocked,
 
428
                          self.dbapi.release_node, 'fake', node.uuid)