← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ironic/tests/drivers/test_deploy_utils.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2014-03-06 13:23:35 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20140306132335-5b49ji56jffxvtn4
Tags: 2014.1~b3-0ubuntu1
* New upstream release:
  - debian/patches/fix-requirements.patch: Dropped no longer needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ironic/tests/drivers/test_deploy_utils.py
1
 
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2
 
 
3
1
#    Copyright (c) 2012 NTT DOCOMO, INC.
4
2
#    Copyright 2011 OpenStack Foundation
5
3
#    Copyright 2011 Ilya Alekseyev
62
60
 
63
61
        self.useFixture(fixtures.MonkeyPatch('time.sleep', noop))
64
62
 
 
63
    def _mock_calls(self, name_list):
 
64
        patch_list = [mock.patch.object(utils, name) for name in name_list]
 
65
        mock_list = [patcher.start() for patcher in patch_list]
 
66
        for patcher in patch_list:
 
67
            self.addCleanup(patcher.stop)
 
68
 
 
69
        parent_mock = mock.MagicMock()
 
70
        for mocker, name in zip(mock_list, name_list):
 
71
            parent_mock.attach_mock(mocker, name)
 
72
        return parent_mock
 
73
 
65
74
    def test_deploy(self):
66
75
        """Check loosely all functions are called with right args."""
67
76
        address = '127.0.0.1'
72
81
        pxe_config_path = '/tmp/abc/pxeconfig'
73
82
        root_mb = 128
74
83
        swap_mb = 64
 
84
        ephemeral_mb = 0
 
85
        ephemeral_format = None
75
86
 
76
87
        dev = '/dev/fake'
77
88
        root_part = '/dev/fake-part1'
79
90
        root_uuid = '12345678-1234-1234-12345678-12345678abcdef'
80
91
 
81
92
        name_list = ['get_dev', 'get_image_mb', 'discovery', 'login_iscsi',
82
 
                     'logout_iscsi', 'make_partitions', 'is_block_device',
83
 
                     'dd', 'mkswap', 'block_uuid', 'switch_pxe_config',
84
 
                     'notify']
85
 
        patch_list = [mock.patch.object(utils, name) for name in name_list]
86
 
        mock_list = [patcher.start() for patcher in patch_list]
87
 
        for patcher in patch_list:
88
 
            self.addCleanup(patcher.stop)
89
 
 
90
 
        parent_mock = mock.MagicMock()
91
 
        for mocker, name in zip(mock_list, name_list):
92
 
            parent_mock.attach_mock(mocker, name)
93
 
 
94
 
        parent_mock.get_dev.return_value = dev
95
 
        parent_mock.get_image_mb.return_value = 1
96
 
        parent_mock.is_block_device.return_value = True
97
 
        parent_mock.block_uuid.return_value = root_uuid
98
 
        calls_expected = [mock.call.get_dev(address, port, iqn, lun),
99
 
                          mock.call.get_image_mb(image_path),
100
 
                          mock.call.discovery(address, port),
101
 
                          mock.call.login_iscsi(address, port, iqn),
102
 
                          mock.call.is_block_device(dev),
103
 
                          mock.call.make_partitions(dev, root_mb, swap_mb),
104
 
                          mock.call.is_block_device(root_part),
105
 
                          mock.call.is_block_device(swap_part),
106
 
                          mock.call.dd(image_path, root_part),
107
 
                          mock.call.mkswap(swap_part),
108
 
                          mock.call.block_uuid(root_part),
109
 
                          mock.call.logout_iscsi(address, port, iqn),
110
 
                          mock.call.switch_pxe_config(pxe_config_path,
111
 
                                                      root_uuid),
112
 
                          mock.call.notify(address, 10000)]
113
 
 
114
 
        utils.deploy(address, port, iqn, lun, image_path, pxe_config_path,
115
 
                     root_mb, swap_mb)
116
 
 
117
 
        self.assertEqual(calls_expected, parent_mock.mock_calls)
118
 
 
119
 
    def test_always_logout_iscsi(self):
120
 
        """logout_iscsi() must be called once login_iscsi() is called."""
121
 
        address = '127.0.0.1'
122
 
        port = 3306
123
 
        iqn = 'iqn.xyz'
124
 
        lun = 1
125
 
        image_path = '/tmp/xyz/image'
126
 
        pxe_config_path = '/tmp/abc/pxeconfig'
127
 
        root_mb = 128
128
 
        swap_mb = 64
 
93
                     'logout_iscsi', 'delete_iscsi', 'make_partitions',
 
94
                     'is_block_device', 'dd', 'mkswap', 'block_uuid',
 
95
                     'switch_pxe_config', 'notify']
 
96
        parent_mock = self._mock_calls(name_list)
 
97
        parent_mock.get_dev.return_value = dev
 
98
        parent_mock.get_image_mb.return_value = 1
 
99
        parent_mock.is_block_device.return_value = True
 
100
        parent_mock.block_uuid.return_value = root_uuid
 
101
        calls_expected = [mock.call.get_dev(address, port, iqn, lun),
 
102
                          mock.call.get_image_mb(image_path),
 
103
                          mock.call.discovery(address, port),
 
104
                          mock.call.login_iscsi(address, port, iqn),
 
105
                          mock.call.is_block_device(dev),
 
106
                          mock.call.make_partitions(dev, root_mb, swap_mb,
 
107
                                                    ephemeral_mb),
 
108
                          mock.call.is_block_device(root_part),
 
109
                          mock.call.is_block_device(swap_part),
 
110
                          mock.call.dd(image_path, root_part),
 
111
                          mock.call.mkswap(swap_part),
 
112
                          mock.call.block_uuid(root_part),
 
113
                          mock.call.logout_iscsi(address, port, iqn),
 
114
                          mock.call.delete_iscsi(address, port, iqn),
 
115
                          mock.call.switch_pxe_config(pxe_config_path,
 
116
                                                      root_uuid),
 
117
                          mock.call.notify(address, 10000)]
 
118
 
 
119
        utils.deploy(address, port, iqn, lun, image_path, pxe_config_path,
 
120
                     root_mb, swap_mb, ephemeral_mb, ephemeral_format)
 
121
 
 
122
        self.assertEqual(calls_expected, parent_mock.mock_calls)
 
123
 
 
124
    def test_deploy_with_ephemeral(self):
 
125
        """Check loosely all functions are called with right args."""
 
126
        address = '127.0.0.1'
 
127
        port = 3306
 
128
        iqn = 'iqn.xyz'
 
129
        lun = 1
 
130
        image_path = '/tmp/xyz/image'
 
131
        pxe_config_path = '/tmp/abc/pxeconfig'
 
132
        root_mb = 128
 
133
        swap_mb = 64
 
134
        ephemeral_mb = 256
 
135
        ephemeral_format = 'exttest'
 
136
 
 
137
        dev = '/dev/fake'
 
138
        ephemeral_part = '/dev/fake-part1'
 
139
        swap_part = '/dev/fake-part2'
 
140
        root_part = '/dev/fake-part3'
 
141
        root_uuid = '12345678-1234-1234-12345678-12345678abcdef'
 
142
 
 
143
        name_list = ['get_dev', 'get_image_mb', 'discovery', 'login_iscsi',
 
144
                     'logout_iscsi', 'delete_iscsi', 'make_partitions',
 
145
                     'is_block_device', 'dd', 'mkswap', 'block_uuid',
 
146
                     'switch_pxe_config', 'notify', 'mkfs_ephemeral']
 
147
        parent_mock = self._mock_calls(name_list)
 
148
        parent_mock.get_dev.return_value = dev
 
149
        parent_mock.get_image_mb.return_value = 1
 
150
        parent_mock.is_block_device.return_value = True
 
151
        parent_mock.block_uuid.return_value = root_uuid
 
152
        calls_expected = [mock.call.get_dev(address, port, iqn, lun),
 
153
                          mock.call.get_image_mb(image_path),
 
154
                          mock.call.discovery(address, port),
 
155
                          mock.call.login_iscsi(address, port, iqn),
 
156
                          mock.call.is_block_device(dev),
 
157
                          mock.call.make_partitions(dev, root_mb, swap_mb,
 
158
                                                    ephemeral_mb),
 
159
                          mock.call.is_block_device(root_part),
 
160
                          mock.call.is_block_device(swap_part),
 
161
                          mock.call.is_block_device(ephemeral_part),
 
162
                          mock.call.dd(image_path, root_part),
 
163
                          mock.call.mkswap(swap_part),
 
164
                          mock.call.mkfs_ephemeral(ephemeral_part,
 
165
                                                   ephemeral_format),
 
166
                          mock.call.block_uuid(root_part),
 
167
                          mock.call.logout_iscsi(address, port, iqn),
 
168
                          mock.call.delete_iscsi(address, port, iqn),
 
169
                          mock.call.switch_pxe_config(pxe_config_path,
 
170
                                                      root_uuid),
 
171
                          mock.call.notify(address, 10000)]
 
172
 
 
173
        utils.deploy(address, port, iqn, lun, image_path, pxe_config_path,
 
174
                     root_mb, swap_mb, ephemeral_mb, ephemeral_format)
 
175
 
 
176
        self.assertEqual(calls_expected, parent_mock.mock_calls)
 
177
 
 
178
    def test_deploy_preserve_ephemeral(self):
 
179
        """Check if all functions are called with right args."""
 
180
        address = '127.0.0.1'
 
181
        port = 3306
 
182
        iqn = 'iqn.xyz'
 
183
        lun = 1
 
184
        image_path = '/tmp/xyz/image'
 
185
        pxe_config_path = '/tmp/abc/pxeconfig'
 
186
        root_mb = 128
 
187
        swap_mb = 64
 
188
        ephemeral_mb = 256
 
189
        ephemeral_format = 'exttest'
 
190
 
 
191
        dev = '/dev/fake'
 
192
        ephemeral_part = '/dev/fake-part1'
 
193
        swap_part = '/dev/fake-part2'
 
194
        root_part = '/dev/fake-part3'
 
195
        root_uuid = '12345678-1234-1234-12345678-12345678abcdef'
 
196
 
 
197
        mock_mkfs_eph = mock.patch.object(utils, 'mkfs_ephemeral').start()
 
198
        self.addCleanup(mock_mkfs_eph.stop)
 
199
 
 
200
        name_list = ['get_dev', 'get_image_mb', 'discovery', 'login_iscsi',
 
201
                     'logout_iscsi', 'delete_iscsi', 'make_partitions',
 
202
                     'is_block_device', 'dd', 'mkswap', 'block_uuid',
 
203
                     'switch_pxe_config', 'notify']
 
204
        parent_mock = self._mock_calls(name_list)
 
205
        parent_mock.get_dev.return_value = dev
 
206
        parent_mock.get_image_mb.return_value = 1
 
207
        parent_mock.is_block_device.return_value = True
 
208
        parent_mock.block_uuid.return_value = root_uuid
 
209
        calls_expected = [mock.call.get_dev(address, port, iqn, lun),
 
210
                          mock.call.get_image_mb(image_path),
 
211
                          mock.call.discovery(address, port),
 
212
                          mock.call.login_iscsi(address, port, iqn),
 
213
                          mock.call.is_block_device(dev),
 
214
                          mock.call.make_partitions(dev, root_mb, swap_mb,
 
215
                                                    ephemeral_mb),
 
216
                          mock.call.is_block_device(root_part),
 
217
                          mock.call.is_block_device(swap_part),
 
218
                          mock.call.is_block_device(ephemeral_part),
 
219
                          mock.call.dd(image_path, root_part),
 
220
                          mock.call.mkswap(swap_part),
 
221
                          mock.call.block_uuid(root_part),
 
222
                          mock.call.logout_iscsi(address, port, iqn),
 
223
                          mock.call.delete_iscsi(address, port, iqn),
 
224
                          mock.call.switch_pxe_config(pxe_config_path,
 
225
                                                      root_uuid),
 
226
                          mock.call.notify(address, 10000)]
 
227
 
 
228
        utils.deploy(address, port, iqn, lun, image_path, pxe_config_path,
 
229
                     root_mb, swap_mb, ephemeral_mb, ephemeral_format,
 
230
                     preserve_ephemeral=True)
 
231
        self.assertEqual(calls_expected, parent_mock.mock_calls)
 
232
        # mkfs_ephemeral should not be called
 
233
        self.assertFalse(mock_mkfs_eph.called)
 
234
 
 
235
    def test_always_logout_and_delete_iscsi(self):
 
236
        """Check if logout_iscsi() and delete_iscsi() are called.
 
237
 
 
238
        Make sure that logout_iscsi() and delete_iscsi() are called once
 
239
        login_iscsi() is invoked.
 
240
 
 
241
        """
 
242
        address = '127.0.0.1'
 
243
        port = 3306
 
244
        iqn = 'iqn.xyz'
 
245
        lun = 1
 
246
        image_path = '/tmp/xyz/image'
 
247
        pxe_config_path = '/tmp/abc/pxeconfig'
 
248
        root_mb = 128
 
249
        swap_mb = 64
 
250
        ephemeral_mb = 256
 
251
        ephemeral_format = 'exttest'
129
252
 
130
253
        dev = '/dev/fake'
131
254
 
133
256
            pass
134
257
 
135
258
        name_list = ['get_dev', 'get_image_mb', 'discovery', 'login_iscsi',
136
 
                     'logout_iscsi', 'work_on_disk']
 
259
                     'logout_iscsi', 'delete_iscsi', 'work_on_disk']
137
260
        patch_list = [mock.patch.object(utils, name) for name in name_list]
138
261
        mock_list = [patcher.start() for patcher in patch_list]
139
262
        for patcher in patch_list:
151
274
                          mock.call.discovery(address, port),
152
275
                          mock.call.login_iscsi(address, port, iqn),
153
276
                          mock.call.work_on_disk(dev, root_mb, swap_mb,
154
 
                                                 image_path),
155
 
                          mock.call.logout_iscsi(address, port, iqn)]
 
277
                                                 ephemeral_mb,
 
278
                                                 ephemeral_format, image_path,
 
279
                                                 False),
 
280
                          mock.call.logout_iscsi(address, port, iqn),
 
281
                          mock.call.delete_iscsi(address, port, iqn)]
156
282
 
157
 
        self.assertRaises(TestException,
158
 
                         utils.deploy,
159
 
                         address, port, iqn, lun, image_path,
160
 
                         pxe_config_path, root_mb, swap_mb)
 
283
        self.assertRaises(TestException, utils.deploy,
 
284
                          address, port, iqn, lun, image_path,
 
285
                          pxe_config_path, root_mb, swap_mb, ephemeral_mb,
 
286
                          ephemeral_format)
161
287
 
162
288
        self.assertEqual(calls_expected, parent_mock.mock_calls)
163
289
 
175
301
                               '12345678-1234-1234-1234-1234567890abcdef')
176
302
        with open(self.fname, 'r') as f:
177
303
            pxeconf = f.read()
178
 
        self.assertEqual(pxeconf, _PXECONF_BOOT)
 
304
        self.assertEqual(_PXECONF_BOOT, pxeconf)
179
305
 
180
306
 
181
307
class OtherFunctionTestCase(tests_base.TestCase):
193
319
 
194
320
        self.useFixture(fixtures.MonkeyPatch('os.path.getsize', fake_getsize))
195
321
        size = 0
196
 
        self.assertEqual(utils.get_image_mb('x'), 0)
 
322
        self.assertEqual(0, utils.get_image_mb('x'))
197
323
        size = 1
198
 
        self.assertEqual(utils.get_image_mb('x'), 1)
 
324
        self.assertEqual(1, utils.get_image_mb('x'))
199
325
        size = mb
200
 
        self.assertEqual(utils.get_image_mb('x'), 1)
 
326
        self.assertEqual(1, utils.get_image_mb('x'))
201
327
        size = mb + 1
202
 
        self.assertEqual(utils.get_image_mb('x'), 2)
 
328
        self.assertEqual(2, utils.get_image_mb('x'))
203
329
 
204
330
 
205
331
class WorkOnDiskTestCase(tests_base.TestCase):
209
335
        self.image_path = '/tmp/xyz/image'
210
336
        self.root_mb = 128
211
337
        self.swap_mb = 64
 
338
        self.ephemeral_mb = 0
 
339
        self.ephemeral_format = None
212
340
        self.dev = '/dev/fake'
213
341
        self.root_part = '/dev/fake-part1'
214
342
        self.swap_part = '/dev/fake-part2'
222
350
        self.mock_ibd.return_value = False
223
351
        self.assertRaises(exception.InstanceDeployFailure,
224
352
                          utils.work_on_disk, self.dev, self.root_mb,
225
 
                          self.swap_mb, self.image_path)
 
353
                          self.swap_mb, self.ephemeral_mb,
 
354
                          self.ephemeral_format, self.image_path, False)
226
355
        self.mock_ibd.assert_called_once_with(self.dev)
227
 
        self.mock_mp.assert_not_called()
 
356
        self.assertFalse(self.mock_mp.called,
 
357
                         "make_partitions mock was unexpectedly called.")
228
358
 
229
359
    def test_no_root_partition(self):
230
360
        self.mock_ibd.side_effect = [True, False]
232
362
                 mock.call(self.root_part)]
233
363
        self.assertRaises(exception.InstanceDeployFailure,
234
364
                          utils.work_on_disk, self.dev, self.root_mb,
235
 
                          self.swap_mb, self.image_path)
 
365
                          self.swap_mb, self.ephemeral_mb,
 
366
                          self.ephemeral_format, self.image_path, False)
236
367
        self.assertEqual(self.mock_ibd.call_args_list, calls)
237
368
        self.mock_mp.assert_called_once_with(self.dev, self.root_mb,
238
 
                                             self.swap_mb)
 
369
                                             self.swap_mb, self.ephemeral_mb)
239
370
 
240
371
    def test_no_swap_partition(self):
241
372
        self.mock_ibd.side_effect = [True, True, False]
244
375
                 mock.call(self.swap_part)]
245
376
        self.assertRaises(exception.InstanceDeployFailure,
246
377
                          utils.work_on_disk, self.dev, self.root_mb,
247
 
                          self.swap_mb, self.image_path)
248
 
        self.assertEqual(self.mock_ibd.call_args_list, calls)
249
 
        self.mock_mp.assert_called_once_with(self.dev, self.root_mb,
250
 
                                             self.swap_mb)
 
378
                          self.swap_mb, self.ephemeral_mb,
 
379
                          self.ephemeral_format, self.image_path, False)
 
380
        self.assertEqual(self.mock_ibd.call_args_list, calls)
 
381
        self.mock_mp.assert_called_once_with(self.dev, self.root_mb,
 
382
                                             self.swap_mb, self.ephemeral_mb)
 
383
 
 
384
    def test_no_ephemeral_partition(self):
 
385
        ephemeral_part = '/dev/fake-part1'
 
386
        swap_part = '/dev/fake-part2'
 
387
        root_part = '/dev/fake-part3'
 
388
        ephemeral_mb = 256
 
389
        ephemeral_format = 'exttest'
 
390
 
 
391
        self.mock_ibd.side_effect = [True, True, True, False]
 
392
        calls = [mock.call(self.dev),
 
393
                 mock.call(root_part),
 
394
                 mock.call(swap_part),
 
395
                 mock.call(ephemeral_part)]
 
396
        self.assertRaises(exception.InstanceDeployFailure,
 
397
                          utils.work_on_disk, self.dev, self.root_mb,
 
398
                          self.swap_mb, ephemeral_mb, ephemeral_format,
 
399
                          self.image_path, False)
 
400
        self.assertEqual(self.mock_ibd.call_args_list, calls)
 
401
        self.mock_mp.assert_called_once_with(self.dev, self.root_mb,
 
402
                                             self.swap_mb, ephemeral_mb)