← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ironic/tests/drivers/ilo/test_deploy.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/drivers/ilo/test_deploy.py
15
15
 
16
16
"""Test class for common methods used by iLO modules."""
17
17
 
 
18
import tempfile
 
19
 
18
20
import mock
19
 
import tempfile
20
 
 
21
21
from oslo.config import cfg
22
22
 
23
 
from ironic.common import exception
 
23
from ironic.common import boot_devices
24
24
from ironic.common import images
25
25
from ironic.common import states
26
26
from ironic.common import swift
27
27
from ironic.common import utils
28
28
from ironic.conductor import task_manager
29
29
from ironic.conductor import utils as manager_utils
30
 
from ironic.db import api as dbapi
31
30
from ironic.drivers.modules import agent
32
31
from ironic.drivers.modules import deploy_utils
33
32
from ironic.drivers.modules.ilo import common as ilo_common
52
51
 
53
52
    def setUp(self):
54
53
        super(IloDeployPrivateMethodsTestCase, self).setUp()
55
 
        self.dbapi = dbapi.get_instance()
56
54
        mgr_utils.mock_the_extension_manager(driver="iscsi_ilo")
57
55
        self.node = obj_utils.create_test_node(self.context,
58
56
                driver='iscsi_ilo', driver_info=INFO_DICT)
153
151
                                                             'boot-object')
154
152
 
155
153
    def test__get_single_nic_with_vif_port_id(self):
156
 
        obj_utils.create_test_port(self.context, node_id=self.node.id, id=6,
 
154
        obj_utils.create_test_port(self.context, node_id=self.node.id,
157
155
                address='aa:bb:cc', uuid=utils.generate_uuid(),
158
156
                extra={'vif_port_id': 'test-vif-A'}, driver='iscsi_ilo')
159
157
        with task_manager.acquire(self.context, self.node.uuid,
166
164
        self.node.driver_info['ilo_deploy_iso'] = 'deploy-iso-uuid'
167
165
        driver_info_expected = {'ilo_deploy_iso': 'deploy-iso-uuid'}
168
166
        driver_info_actual = ilo_deploy._parse_driver_info(self.node)
169
 
        error_msg = 'Error validating iLO virtual media deploy'
 
167
        error_msg = ("Error validating iLO virtual media deploy. Some"
 
168
                     " parameters were missing in node's driver_info")
170
169
        check_params_mock.assert_called_once_with(driver_info_expected,
171
170
                                                  error_msg)
172
171
        self.assertEqual(driver_info_expected, driver_info_actual)
181
180
        self.assertEqual(expected_info, actual_info)
182
181
 
183
182
    @mock.patch.object(manager_utils, 'node_power_action')
184
 
    @mock.patch.object(ilo_common, 'set_boot_device')
 
183
    @mock.patch.object(manager_utils, 'node_set_boot_device')
185
184
    @mock.patch.object(ilo_common, 'setup_vmedia_for_boot')
186
185
    def test__reboot_into(self, setup_vmedia_mock, set_boot_device_mock,
187
186
                          node_power_action_mock):
190
189
            opts = {'a': 'b'}
191
190
            ilo_deploy._reboot_into(task, 'iso', opts)
192
191
            setup_vmedia_mock.assert_called_once_with(task, 'iso', opts)
193
 
            set_boot_device_mock.assert_called_once_with(task.node, 'CDROM')
 
192
            set_boot_device_mock.assert_called_once_with(task,
 
193
                                                         boot_devices.CDROM)
194
194
            node_power_action_mock.assert_called_once_with(task, states.REBOOT)
195
195
 
196
196
 
198
198
 
199
199
    def setUp(self):
200
200
        super(IloVirtualMediaIscsiDeployTestCase, self).setUp()
201
 
        self.dbapi = dbapi.get_instance()
202
201
        mgr_utils.mock_the_extension_manager(driver="iscsi_ilo")
203
202
        self.node = obj_utils.create_test_node(self.context,
204
203
                driver='iscsi_ilo', driver_info=INFO_DICT)
224
223
    @mock.patch.object(ilo_deploy, '_get_single_nic_with_vif_port_id')
225
224
    @mock.patch.object(iscsi_deploy, 'build_deploy_ramdisk_options')
226
225
    @mock.patch.object(manager_utils, 'node_power_action')
227
 
    @mock.patch.object(ilo_common, 'set_boot_device')
228
226
    @mock.patch.object(iscsi_deploy, 'check_image_size')
229
227
    @mock.patch.object(iscsi_deploy, 'cache_instance_image')
230
228
    def test_deploy(self, cache_instance_image_mock, check_image_size_mock,
231
 
                    set_boot_device_mock, node_power_action_mock,
232
 
                    build_opts_mock, get_nic_mock, reboot_into_mock):
 
229
                    node_power_action_mock, build_opts_mock, get_nic_mock,
 
230
                    reboot_into_mock):
233
231
        deploy_opts = {'a': 'b'}
234
232
        build_opts_mock.return_value = deploy_opts
235
233
        get_nic_mock.return_value = '12:34:56:78:90:ab'
274
272
 
275
273
    def setUp(self):
276
274
        super(IloVirtualMediaAgentDeployTestCase, self).setUp()
277
 
        self.dbapi = dbapi.get_instance()
278
275
        mgr_utils.mock_the_extension_manager(driver="agent_ilo")
279
276
        self.node = obj_utils.create_test_node(self.context,
280
277
                driver='agent_ilo', driver_info=INFO_DICT)
326
323
 
327
324
    def setUp(self):
328
325
        super(VendorPassthruTestCase, self).setUp()
329
 
        self.dbapi = dbapi.get_instance()
330
326
        mgr_utils.mock_the_extension_manager(driver="iscsi_ilo")
331
327
        self.node = obj_utils.create_test_node(self.context,
332
328
                driver='iscsi_ilo', driver_info=INFO_DICT)
333
329
 
334
330
    @mock.patch.object(deploy_utils, 'notify_deploy_complete')
335
 
    @mock.patch.object(ilo_common, 'set_boot_device')
 
331
    @mock.patch.object(manager_utils, 'node_set_boot_device')
336
332
    @mock.patch.object(ilo_common, 'setup_vmedia_for_boot')
337
333
    @mock.patch.object(ilo_deploy, '_get_boot_iso')
338
334
    @mock.patch.object(iscsi_deploy, 'continue_deploy')
355
351
            continue_deploy_mock.assert_called_once_with(task, **kwargs)
356
352
            get_boot_iso_mock.assert_called_once_with(task, 'root-uuid')
357
353
            setup_vmedia_mock.assert_called_once_with(task, 'boot-iso')
358
 
            set_boot_device_mock.assert_called_once_with(task.node, 'CDROM')
 
354
            set_boot_device_mock.assert_called_once_with(task,
 
355
                                                         boot_devices.CDROM)
359
356
            self.assertEqual('boot-iso',
360
357
                             task.node.instance_info['ilo_boot_iso'])
361
358
        notify_deploy_complete_mock.assert_called_once_with('123456')
393
390
 
394
391
    def setUp(self):
395
392
        super(IloPXEDeployTestCase, self).setUp()
396
 
        self.dbapi = dbapi.get_instance()
397
393
        mgr_utils.mock_the_extension_manager(driver="pxe_ilo")
398
394
        self.node = obj_utils.create_test_node(self.context,
399
395
                driver='pxe_ilo', driver_info=INFO_DICT)
435
431
            pxe_prepare_mock.assert_called_once_with(task)
436
432
 
437
433
    @mock.patch.object(pxe.PXEDeploy, 'deploy')
438
 
    @mock.patch.object(ilo_common, 'set_boot_device')
 
434
    @mock.patch.object(manager_utils, 'node_set_boot_device')
439
435
    def test_deploy_boot_mode_exists(self, set_persistent_mock,
440
436
                                     pxe_deploy_mock):
441
437
        with task_manager.acquire(self.context, self.node.uuid,
442
438
                                  shared=False) as task:
443
439
            task.driver.deploy.deploy(task)
444
 
            set_persistent_mock.assert_called_with(task.node, 'NETWORK', False)
 
440
            set_persistent_mock.assert_called_with(task, boot_devices.PXE)
445
441
            pxe_deploy_mock.assert_called_once_with(task)
446
442
 
447
443
 
448
 
class IloManagementTestCase(db_base.DbTestCase):
449
 
 
450
 
    def setUp(self):
451
 
        super(IloManagementTestCase, self).setUp()
452
 
        self.dbapi = dbapi.get_instance()
453
 
        mgr_utils.mock_the_extension_manager(driver="pxe_ilo")
454
 
        self.node = obj_utils.create_test_node(self.context,
455
 
                driver='pxe_ilo', driver_info=INFO_DICT)
456
 
 
457
 
    @mock.patch.object(ilo_common, 'set_boot_device')
458
 
    def test_set_boot_device_ok(self, set_persistent_mock):
459
 
        with task_manager.acquire(self.context, self.node.uuid,
460
 
                                  shared=False) as task:
461
 
            task.driver.management.set_boot_device(task, 'pxe', True)
462
 
            set_persistent_mock.assert_called_once_with(task.node,
463
 
                                                           'NETWORK', True)
464
 
 
465
 
    @mock.patch.object(ilo_common, 'set_boot_device')
466
 
    def test_set_boot_device_invalid_device(self, set_persistent_mock):
467
 
        with task_manager.acquire(self.context, self.node.uuid,
468
 
                                  shared=False) as task:
469
 
            self.assertRaises(exception.InvalidParameterValue,
470
 
                    task.driver.management.set_boot_device,
471
 
                    task, 'fake-device')
472
 
 
473
 
 
474
444
class IloPXEVendorPassthruTestCase(db_base.DbTestCase):
475
445
 
476
446
    def setUp(self):
477
447
        super(IloPXEVendorPassthruTestCase, self).setUp()
478
 
        self.dbapi = dbapi.get_instance()
479
448
        mgr_utils.mock_the_extension_manager(driver="pxe_ilo")
480
449
        self.node = obj_utils.create_test_node(self.context,
481
450
                driver='pxe_ilo', driver_info=INFO_DICT)
482
451
 
483
 
    @mock.patch.object(pxe.VendorPassthru, 'vendor_passthru')
484
 
    @mock.patch.object(ilo_common, 'set_boot_device')
485
 
    def test_vendorpassthru(self, set_persistent_mock,
 
452
    def test_vendor_routes(self):
 
453
        expected = ['pass_deploy_info']
 
454
        with task_manager.acquire(self.context, self.node.uuid,
 
455
                                  shared=True) as task:
 
456
            vendor_routes = task.driver.vendor.vendor_routes
 
457
            self.assertIsInstance(vendor_routes, dict)
 
458
            self.assertEqual(expected, list(vendor_routes))
 
459
 
 
460
    def test_driver_routes(self):
 
461
        with task_manager.acquire(self.context, self.node.uuid,
 
462
                                  shared=True) as task:
 
463
            driver_routes = task.driver.vendor.driver_routes
 
464
            self.assertIsInstance(driver_routes, dict)
 
465
            self.assertEqual({}, driver_routes)
 
466
 
 
467
    @mock.patch.object(pxe.VendorPassthru, '_continue_deploy')
 
468
    @mock.patch.object(manager_utils, 'node_set_boot_device')
 
469
    def test_vendorpassthru(self, set_boot_device_mock,
486
470
                            pxe_vendorpassthru_mock):
487
 
        kwargs = {'method': 'pass_deploy_info', 'address': '123456'}
 
471
        kwargs = {'address': '123456'}
488
472
        with task_manager.acquire(self.context, self.node.uuid,
489
473
                                  shared=False) as task:
490
474
            task.node.provision_state = states.DEPLOYWAIT
491
 
            task.driver.vendor.vendor_passthru(task, **kwargs)
492
 
            set_persistent_mock.assert_called_with(task.node, 'NETWORK', True)
 
475
            task.driver.vendor._continue_deploy(task, **kwargs)
 
476
            set_boot_device_mock.assert_called_with(task, boot_devices.PXE,
 
477
                                                    True)
493
478
            pxe_vendorpassthru_mock.assert_called_once_with(task, **kwargs)