def test__node_resources_unavailable(self): node_dicts = [ # a node in maintenance /w no instance and power OFF { 'uuid': uuidutils.generate_uuid(), 'maintenance': True, 'power_state': ironic_states.POWER_OFF }, # a node in maintenance /w no instance and ERROR power state { 'uuid': uuidutils.generate_uuid(), 'maintenance': True, 'power_state': ironic_states.ERROR }, # a node not in maintenance /w no instance and bad power state { 'uuid': uuidutils.generate_uuid(), 'power_state': ironic_states.NOSTATE }, ] for n in node_dicts: node = ironic_utils.get_test_node(**n) self.assertTrue(self.driver._node_resources_unavailable(node)) avail_node = ironic_utils.get_test_node( power_state=ironic_states.POWER_OFF) self.assertFalse(self.driver._node_resources_unavailable(avail_node))
def test__node_resources_unavailable(self): node_dicts = [ # a node in maintenance /w no instance and power OFF {"uuid": uuidutils.generate_uuid(), "maintenance": True, "power_state": ironic_states.POWER_OFF}, # a node in maintenance /w no instance and ERROR power state {"uuid": uuidutils.generate_uuid(), "maintenance": True, "power_state": ironic_states.ERROR}, # a node not in maintenance /w no instance and bad power state {"uuid": uuidutils.generate_uuid(), "power_state": ironic_states.NOSTATE}, ] for n in node_dicts: node = ironic_utils.get_test_node(**n) self.assertTrue(self.driver._node_resources_unavailable(node)) avail_node = ironic_utils.get_test_node(power_state=ironic_states.POWER_OFF) self.assertFalse(self.driver._node_resources_unavailable(avail_node))
def test__cleanup_deploy_good(self, mock_update, mock_flavor): mock_flavor.return_value = ironic_utils.get_test_flavor(extra_specs={}) node = ironic_utils.get_test_node(driver="fake", instance_uuid="fake-id") instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.driver._cleanup_deploy(node, instance, None) expected_patch = [{"path": "/instance_uuid", "op": "remove"}] mock_update.assert_called_once_with(node.uuid, expected_patch)
def test_spawn( self, mock_sf, mock_pvifs, mock_adf, mock_wait_active, mock_fg_bid, mock_node, mock_looping, mock_save ): node_uuid = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" node = ironic_utils.get_test_node(driver="fake", uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) fake_flavor = {"ephemeral_gb": 0} mock_node.get.return_value = node mock_node.validate.return_value = ironic_utils.get_test_validation() mock_node.get_by_instance_uuid.return_value = node mock_node.set_provision_state.return_value = mock.MagicMock() mock_fg_bid.return_value = fake_flavor fake_looping_call = FakeLoopingCall() mock_looping.return_value = fake_looping_call self.driver.spawn(self.ctx, instance, None, [], None) mock_node.get.assert_called_once_with(node_uuid) mock_node.validate.assert_called_once_with(node_uuid) mock_fg_bid.assert_called_once_with(self.ctx, instance["instance_type_id"]) mock_adf.assert_called_once_with(node, instance, None, fake_flavor) mock_pvifs.assert_called_once_with(node, instance, None) mock_sf.assert_called_once_with(instance, None) mock_node.set_provision_state.assert_called_once_with(node_uuid, "active") self.assertIsNone(instance["default_ephemeral_device"]) self.assertFalse(mock_save.called) mock_looping.assert_called_once_with(mock_wait_active, FAKE_CLIENT_WRAPPER, instance) fake_looping_call.start.assert_called_once_with(interval=CONF.ironic.api_retry_interval) fake_looping_call.wait.assert_called_once()
def test__node_resource_malformed_capabilities(self): props = _get_properties() props["capabilities"] = "test:capability,:no_key,no_val:" node = ironic_utils.get_test_node(properties=props) result = self.driver._node_resource(node) stats = jsonutils.loads(result["stats"]) self.assertEqual("capability", stats.get("test"))
def test_destroy_trigger_undeploy_fail(self, fake_validate, mock_sps): node_uuid = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" node = ironic_utils.get_test_node(driver="fake", uuid=node_uuid, provision_state=ironic_states.ACTIVE) fake_validate.return_value = node instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) mock_sps.side_effect = exception.NovaException() self.assertRaises(exception.NovaException, self.driver.destroy, self.ctx, instance, None, None)
def test_pxe_get_deploy_patch_fail_no_kr_id(self): self.flavor = ironic_utils.get_test_flavor(extra_specs={}) node = ironic_utils.get_test_node(driver='pxe_fake') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.assertRaises(exception.InvalidParameterValue, patcher.create(node).get_deploy_patch, instance, self.image_meta, self.flavor)
def test_pxe_get_cleanup_patch(self): driver_info = {'pxe_image_source': 'fake-image-id', 'pxe_deploy_kernel': 'fake-kernel-id', 'pxe_deploy_ramdisk': 'fake-ramdisk-id', 'pxe_root_gb': '1024', 'pxe_swap_mb': '512', 'pxe_preserve_ephemeral': True, 'pxe_ephemeral_format': 'fake-format'} node = ironic_utils.get_test_node(driver='pxe_fake', driver_info=driver_info) instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) patch = patcher.create(node).get_cleanup_patch(instance, None) expected = [{'path': '/driver_info/pxe_image_source', 'op': 'remove'}, {'path': '/driver_info/pxe_deploy_kernel', 'op': 'remove'}, {'path': '/driver_info/pxe_deploy_ramdisk', 'op': 'remove'}, {'path': '/driver_info/pxe_root_gb', 'op': 'remove'}, {'path': '/driver_info/pxe_swap_mb', 'op': 'remove'}, {'path': '/driver_info/pxe_preserve_ephemeral', 'op': 'remove'}, {'path': '/driver_info/pxe_ephemeral_format', 'op': 'remove'}] self.assertEqual(sorted(expected), sorted(patch))
def test_get_info(self): instance_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' properties = {'memory_mb': 512, 'cpus': 2} power_state = ironic_states.POWER_ON node = ironic_utils.get_test_node(instance_uuid=instance_uuid, properties=properties, power_state=power_state) with mock.patch.object(FAKE_CLIENT.node, 'get_by_instance_uuid') \ as mock_gbiu: mock_gbiu.return_value = node # ironic_states.POWER_ON should me be mapped to # nova_states.RUNNING expected = { 'state': nova_states.RUNNING, 'max_mem': properties['memory_mb'], 'mem': properties['memory_mb'], 'num_cpu': properties['cpus'], 'cpu_time': 0 } instance = fake_instance.fake_instance_obj('fake-context', uuid=instance_uuid) result = self.driver.get_info(instance) self.assertEqual(expected, result)
def test_spawn_node_trigger_deploy_fail2(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start() mock_validate.return_value = ironic_utils.get_test_validation() self.addCleanup(mock_validate.stop) mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start() self.addCleanup(mock_fg_bid.stop) mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start() self.addCleanup(mock_pvifs.stop) mock_sf = mock.patch.object(self.driver, '_start_firewall').start() self.addCleanup(mock_sf.stop) mock_cleanup_deploy = mock.patch.object( self.driver, '_cleanup_deploy').start() self.addCleanup(mock_cleanup_deploy.stop) with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \ as mock_sps: mock_sps.side_effect = ironic_exception.BadRequest self.assertRaises(exception.InstanceDeployFailure, self.driver.spawn, self.ctx, instance, None, [], None) mock_get.assert_called_once_with(node_uuid) mock_validate.assert_called_once_with(node_uuid) mock_fg_bid.assert_called_once_with(self.ctx, instance['instance_type_id']) mock_cleanup_deploy.assert_called_once_with(node, instance, None)
def test_pxe_get_deploy_patch(self): node = ironic_utils.get_test_node(driver='pxe_fake') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) extra_specs = self.flavor['extra_specs'] expected = [{ 'path': '/driver_info/pxe_deploy_kernel', 'value': extra_specs['baremetal:deploy_kernel_id'], 'op': 'add' }, { 'path': '/driver_info/pxe_deploy_ramdisk', 'value': extra_specs['baremetal:deploy_ramdisk_id'], 'op': 'add' }, { 'path': '/driver_info/pxe_image_source', 'value': self.image_meta['id'], 'op': 'add' }, { 'path': '/driver_info/pxe_root_gb', 'value': str(instance['root_gb']), 'op': 'add' }, { 'path': '/driver_info/pxe_swap_mb', 'value': str(self.flavor['swap']), 'op': 'add' }] patch = patcher.create(node).get_deploy_patch(instance, self.image_meta, self.flavor) self.assertEqual(sorted(expected), sorted(patch))
def test__add_driver_fields_fail(self, mock_update): mock_update.side_effect = ironic_exception.HTTPBadRequest() node = ironic_utils.get_test_node(driver='fake') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.assertRaises(exception.InstanceDeployFailure, self.driver._add_driver_fields, node, instance, None, None)
def test__cleanup_deploy_fail(self, mock_update): mock_update.side_effect = ironic_exception.HTTPBadRequest() node = ironic_utils.get_test_node(driver='fake', instance_uuid='fake-id') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.assertRaises(exception.InstanceTerminationFailure, self.driver._cleanup_deploy, node, instance, None)
def test__node_resource_no_instance_uuid(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' cpus = 2 mem = 512 disk = 10 arch = 'x86_64' properties = { 'cpus': cpus, 'memory_mb': mem, 'local_gb': disk, 'cpu_arch': arch } node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=None, properties=properties) result = self.driver._node_resource(node) self.assertEqual(cpus, result['vcpus']) self.assertEqual(0, result['vcpus_used']) self.assertEqual(mem, result['memory_mb']) self.assertEqual(0, result['memory_mb_used']) self.assertEqual(disk, result['local_gb']) self.assertEqual(0, result['local_gb_used']) self.assertEqual(node_uuid, result['hypervisor_hostname']) self.assertEqual( '{"cpu_arch": "x86_64", "ironic_driver": "' 'ironic.nova.virt.ironic.driver.IronicDriver", ' '"test_spec": "test_value"}', result['stats'])
def test_rebuild_failures(self, mock_save, mock_get, mock_driver_fields, mock_fg_bid, mock_set_pstate): node_uuid = uuidutils.generate_uuid() instance_uuid = uuidutils.generate_uuid() node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=instance_uuid, instance_type_id=5) mock_get.return_value = node image_meta = ironic_utils.get_test_image_meta() flavor_id = 5 flavor = {'id': flavor_id, 'name': 'baremetal'} mock_fg_bid.return_value = flavor instance = fake_instance.fake_instance_obj(self.ctx, uuid=instance_uuid, node=node_uuid, instance_type_id=flavor_id) exceptions = [ exception.NovaException(), ironic_exception.BadRequest(), ironic_exception.InternalServerError(), ] for e in exceptions: mock_set_pstate.side_effect = e self.assertRaises(exception.InstanceDeployFailure, self.driver.rebuild, context=self.ctx, instance=instance, image_meta=image_meta, injected_files=None, admin_password=None, bdms=None, detach_block_devices=None, attach_block_devices=None)
def test_get_available_nodes(self, mock_list): node_dicts = [ # a node in maintenance /w no instance and power OFF { 'uuid': uuidutils.generate_uuid(), 'maintenance': True, 'power_state': ironic_states.POWER_OFF }, # a node /w instance and power ON { 'uuid': uuidutils.generate_uuid(), 'instance_uuid': uuidutils.generate_uuid(), 'power_state': ironic_states.POWER_ON }, # a node not in maintenance /w no instance and bad power state { 'uuid': uuidutils.generate_uuid(), 'power_state': ironic_states.ERROR }, ] nodes = [ironic_utils.get_test_node(**n) for n in node_dicts] mock_list.return_value = nodes available_nodes = self.driver.get_available_nodes() expected_uuids = [n['uuid'] for n in node_dicts] self.assertEqual(sorted(expected_uuids), sorted(available_nodes))
def test__node_resource_unavailable_node_res(self, mock_res_unavail): mock_res_unavail.return_value = True node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' cpus = 2 mem = 512 disk = 10 arch = 'x86_64' properties = {'cpus': cpus, 'memory_mb': mem, 'local_gb': disk, 'cpu_arch': arch} node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=None, properties=properties) result = self.driver._node_resource(node) self.assertEqual(0, result['vcpus']) self.assertEqual(0, result['vcpus_used']) self.assertEqual(0, result['memory_mb']) self.assertEqual(0, result['memory_mb_used']) self.assertEqual(0, result['local_gb']) self.assertEqual(0, result['local_gb_used']) self.assertEqual(node_uuid, result['hypervisor_hostname']) self.assertEqual('{"cpu_arch": "x86_64", "ironic_driver": "' 'ironic.nova.virt.ironic.driver.IronicDriver", ' '"test_spec": "test_value"}', result['stats'])
def test_spawn(self, mock_sf, mock_pvifs, mock_adf, mock_cli, mock_fg_bid, mock_node, mock_save): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) fake_flavor = { 'ephemeral_gb': 0 } mock_node.get.return_value = node mock_node.validate.return_value = ironic_utils.get_test_validation() mock_node.get_by_instance_uuid.return_value = node mock_node.set_provision_state.return_value = mock.MagicMock() mock_fg_bid.return_value = fake_flavor node.provision_state = ironic_states.ACTIVE mock_cli.return_value = FAKE_CLIENT self.driver.spawn(self.ctx, instance, None, [], None) mock_node.get.assert_called_once_with(node_uuid) mock_node.validate.assert_called_once_with(node_uuid) mock_fg_bid.assert_called_once_with(self.ctx, instance['instance_type_id']) mock_adf.assert_called_once_with(node, instance, None, fake_flavor) mock_pvifs.assert_called_once_with(node, instance, None) mock_sf.assert_called_once_with(instance, None) mock_node.set_provision_state.assert_called_once_with(node_uuid, 'active') self.assertIsNone(instance['default_ephemeral_device']) self.assertFalse(mock_save.called)
def test__plug_vifs_count_mismatch(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(uuid=node_uuid) port = ironic_utils.get_test_port() mock_uvifs = mock.patch.object(self.driver, '_unplug_vifs').start() self.addCleanup(mock_uvifs.stop) mock_port_udt = mock.patch.object(FAKE_CLIENT.port, 'update').start() self.addCleanup(mock_port_udt.stop) with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp: mock_lp.return_value = [port] instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) # len(network_info) > len(ports) network_info = (utils.get_test_network_info() + utils.get_test_network_info()) self.assertRaises(exception.NovaException, self.driver._plug_vifs, node, instance, network_info) # asserts mock_uvifs.assert_called_once_with(node, instance, network_info) mock_lp.assert_called_once_with(node_uuid) # assert port.update() was not called assert not mock_port_udt.called
def test_unplug_vifs(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(uuid=node_uuid) port = ironic_utils.get_test_port() mock_update = mock.patch.object(FAKE_CLIENT.port, 'update').start() self.addCleanup(mock_update.stop) mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp: mock_lp.return_value = [port] instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) expected_patch = [{'op': 'remove', 'path': '/extra/vif_port_id'}] self.driver.unplug_vifs(instance, utils.get_test_network_info()) # asserts mock_get.assert_called_once_with(node_uuid) mock_lp.assert_called_once_with(node_uuid) mock_update.assert_called_once_with(port.uuid, expected_patch)
def test_node_is_available(self, mock_get): no_guid = None any_guid = uuidutils.generate_uuid() in_maintenance = True is_available = True not_in_maintenance = False not_available = False power_off = ironic_states.POWER_OFF not_power_off = ironic_states.POWER_ON testing_set = { (no_guid, not_in_maintenance, power_off): is_available, (no_guid, not_in_maintenance, not_power_off): not_available, (no_guid, in_maintenance, power_off): not_available, (no_guid, in_maintenance, not_power_off): not_available, (any_guid, not_in_maintenance, power_off): not_available, (any_guid, not_in_maintenance, not_power_off): not_available, (any_guid, in_maintenance, power_off): not_available, (any_guid, in_maintenance, not_power_off): not_available } for key in testing_set.keys(): node = ironic_utils.get_test_node(instance_uuid=key[0], maintenance=key[1], power_state=key[2]) mock_get.return_value = node expected = testing_set[key] observed = self.driver.node_is_available("dummy_nodename") self.assertEqual(expected, observed)
def test__plug_vifs(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(uuid=node_uuid) port = ironic_utils.get_test_port() mock_uvifs = mock.patch.object(self.driver, '_unplug_vifs').start() self.addCleanup(mock_uvifs.stop) mock_port_udt = mock.patch.object(FAKE_CLIENT.port, 'update').start() self.addCleanup(mock_port_udt.stop) with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp: mock_lp.return_value = [port] instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) network_info = utils.get_test_network_info() port_id = unicode(network_info[0]['id']) expected_patch = [{ 'op': 'add', 'path': '/extra/vif_port_id', 'value': port_id }] self.driver._plug_vifs(node, instance, network_info) # asserts mock_uvifs.assert_called_once_with(node, instance, network_info) mock_lp.assert_called_once_with(node_uuid) mock_port_udt.assert_called_with(port.uuid, expected_patch)
def test_spawn_node_trigger_deploy_fail2(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start() mock_validate.return_value = ironic_utils.get_test_validation() self.addCleanup(mock_validate.stop) mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start() self.addCleanup(mock_fg_bid.stop) mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start() self.addCleanup(mock_pvifs.stop) mock_sf = mock.patch.object(self.driver, '_start_firewall').start() self.addCleanup(mock_sf.stop) mock_cleanup_deploy = mock.patch.object(self.driver, '_cleanup_deploy').start() self.addCleanup(mock_cleanup_deploy.stop) with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \ as mock_sps: mock_sps.side_effect = ironic_exception.HTTPBadRequest self.assertRaises(exception.InstanceDeployFailure, self.driver.spawn, self.ctx, instance, None, [], None) mock_get.assert_called_once_with(node_uuid) mock_validate.assert_called_once_with(node_uuid) mock_fg_bid.assert_called_once_with(self.ctx, instance['instance_type_id']) mock_cleanup_deploy.assert_called_once_with(node, instance, None)
def test__node_resource_malformed_capabilities(self): props = _get_properties() props['capabilities'] = 'test:capability,:no_key,no_val:' node = ironic_utils.get_test_node(properties=props) result = self.driver._node_resource(node) stats = jsonutils.loads(result['stats']) self.assertEqual('capability', stats.get('test'))
def test_spawn_node_prepare_for_deploy_fail(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start() mock_validate.return_value = ironic_utils.get_test_validation() self.addCleanup(mock_validate.stop) mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start() self.addCleanup(mock_fg_bid.stop) mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start() self.addCleanup(mock_pvifs.stop) mock_cleanup_deploy = mock.patch.object(self.driver, '_cleanup_deploy').start() self.addCleanup(mock_cleanup_deploy.stop) class TestException(Exception): pass with mock.patch.object(self.driver, '_start_firewall') as mock_sf: mock_sf.side_effect = TestException() self.assertRaises(TestException, self.driver.spawn, self.ctx, instance, None, [], None) mock_get.assert_called_once_with(node_uuid) mock_validate.assert_called_once_with(node_uuid) mock_fg_bid.assert_called_once_with(self.ctx, instance['instance_type_id']) mock_cleanup_deploy.assert_called_with(node, instance, None)
def test_spawn_node_prepare_for_deploy_fail(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start() mock_validate.return_value = ironic_utils.get_test_validation() self.addCleanup(mock_validate.stop) mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start() self.addCleanup(mock_fg_bid.stop) mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start() self.addCleanup(mock_pvifs.stop) mock_cleanup_deploy = mock.patch.object( self.driver, '_cleanup_deploy').start() self.addCleanup(mock_cleanup_deploy.stop) class TestException(Exception): pass with mock.patch.object(self.driver, '_start_firewall') as mock_sf: mock_sf.side_effect = TestException() self.assertRaises(TestException, self.driver.spawn, self.ctx, instance, None, [], None) mock_get.assert_called_once_with(node_uuid) mock_validate.assert_called_once_with(node_uuid) mock_fg_bid.assert_called_once_with(self.ctx, instance['instance_type_id']) mock_cleanup_deploy.assert_called_with(node, instance, None)
def test__cleanup_deploy_good(self, mock_update): node = ironic_utils.get_test_node(driver='fake', instance_uuid='fake-id') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.driver._cleanup_deploy(node, instance, None) expected_patch = [{'path': '/instance_uuid', 'op': 'remove'}] mock_update.assert_called_once_with(node.uuid, expected_patch)
def test_reboot(self, mock_val_inst, mock_set_power): node = ironic_utils.get_test_node() mock_val_inst.return_value = node instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.driver.reboot(self.ctx, instance, None, None) mock_set_power.assert_called_once_with(node.uuid, 'reboot')
def test__plug_vifs(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(uuid=node_uuid) port = ironic_utils.get_test_port() mock_uvifs = mock.patch.object(self.driver, '_unplug_vifs').start() self.addCleanup(mock_uvifs.stop) mock_port_udt = mock.patch.object(FAKE_CLIENT.port, 'update').start() self.addCleanup(mock_port_udt.stop) with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp: mock_lp.return_value = [port] instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) network_info = utils.get_test_network_info() port_id = unicode(network_info[0]['id']) expected_patch = [{'op': 'add', 'path': '/extra/vif_port_id', 'value': port_id}] self.driver._plug_vifs(node, instance, network_info) # asserts mock_uvifs.assert_called_once_with(node, instance, network_info) mock_lp.assert_called_once_with(node_uuid) mock_port_udt.assert_called_with(port.uuid, expected_patch)
def test_node_is_available(self, mock_get): no_guid = None any_guid = uuidutils.generate_uuid() in_maintenance = True is_available = True not_in_maintenance = False not_available = False power_off = ironic_states.POWER_OFF not_power_off = ironic_states.POWER_ON testing_set = {(no_guid, not_in_maintenance, power_off):is_available, (no_guid, not_in_maintenance, not_power_off):not_available, (no_guid, in_maintenance, power_off):not_available, (no_guid, in_maintenance, not_power_off):not_available, (any_guid, not_in_maintenance, power_off):not_available, (any_guid, not_in_maintenance, not_power_off):not_available, (any_guid, in_maintenance, power_off):not_available, (any_guid, in_maintenance, not_power_off):not_available} for key in testing_set.keys(): node = ironic_utils.get_test_node(instance_uuid=key[0], maintenance=key[1], power_state=key[2]) mock_get.return_value = node expected = testing_set[key] observed = self.driver.node_is_available("dummy_nodename") self.assertEqual(expected, observed)
def test_reboot(self, mock_val_inst, mock_set_power, mock_cli): node = ironic_utils.get_test_node() mock_val_inst.return_value = node instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) mock_cli.return_value = FAKE_CLIENT self.driver.reboot(self.ctx, instance, None, None) mock_set_power.assert_called_once_with(node.uuid, 'reboot')
def test__node_resource_exposes_capabilities(self): props = _get_properties() props["capabilities"] = "test:capability" node = ironic_utils.get_test_node(properties=props) result = self.driver._node_resource(node) stats = jsonutils.loads(result["stats"]) self.assertIsNone(stats.get("capabilities")) self.assertEqual("capability", stats.get("test"))
def test__node_resource_exposes_capabilities(self): props = _get_properties() props['capabilities'] = 'test:capability' node = ironic_utils.get_test_node(properties=props) result = self.driver._node_resource(node) stats = jsonutils.loads(result['stats']) self.assertIsNone(stats.get('capabilities')) self.assertEqual('capability', stats.get('test'))
def test_list_instances(self): num_nodes = 2 nodes = [] for n in range(num_nodes): nodes.append(ironic_utils.get_test_node( instance_uuid=uuidutils.generate_uuid())) # append a node w/o instance_uuid which shouldn't be listed nodes.append(ironic_utils.get_test_node(instance_uuid=None)) with mock.patch.object(cw.IronicClientWrapper, 'call') as mock_list: mock_list.return_value = nodes expected = [n for n in nodes if n.instance_uuid] instances = self.driver.list_instances() mock_list.assert_called_with("node.list") self.assertEqual(sorted(expected), sorted(instances)) self.assertEqual(num_nodes, len(instances))
def test_node_is_available(self, mock_get): node = ironic_utils.get_test_node() mock_get.return_value = node self.assertTrue(self.driver.node_is_available(node.uuid)) mock_get.assert_called_with(node.uuid) mock_get.side_effect = ironic_exception.NotFound self.assertFalse(self.driver.node_is_available(node.uuid))
def test_get_available_resource(self, mock_nr, mock_get): node = ironic_utils.get_test_node() fake_resource = 'fake-resource' mock_get.return_value = node mock_nr.return_value = fake_resource result = self.driver.get_available_resource(node.uuid) self.assertEqual(fake_resource, result) mock_nr.assert_called_once_with(node)
def test__cleanup_deploy_fail(self, mock_update): mock_update.side_effect = ironic_exception.BadRequest() node = ironic_utils.get_test_node(driver='fake', instance_uuid='fake-id') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.assertRaises(exception.InstanceTerminationFailure, self.driver._cleanup_deploy, node, instance, None)
def test__add_driver_fields_fail(self, mock_update): mock_update.side_effect = ironic_exception.BadRequest() node = ironic_utils.get_test_node(driver='fake') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.assertRaises(exception.InstanceDeployFailure, self.driver._add_driver_fields, node, instance, None, None)
def test__add_driver_fields_good(self, mock_update): node = ironic_utils.get_test_node(driver='fake') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) self.driver._add_driver_fields(node, instance, None, None) expected_patch = [{'path': '/instance_uuid', 'op': 'add', 'value': instance['uuid']}] mock_update.assert_called_once_with(node.uuid, expected_patch)
def test_pxe_get_cleanup_patch_no_flavor_kernel_ramdisk_ids(self): self.flavor = ironic_utils.get_test_flavor(extra_specs={}) node = ironic_utils.get_test_node(driver='pxe_fake') patch = patcher.create(node).get_cleanup_patch(self.instance, None, self.flavor) # If there's no extra_specs patch should be exactly like a # generic patch self.assertEqual(self._expected_cleanup_patch, patch)
def test_pxe_get_deploy_patch_no_flavor_kernel_ramdisk_ids(self): flavor = ironic_utils.get_test_flavor(extra_specs={}) node = ironic_utils.get_test_node(driver='pxe_fake') patch = patcher.create(node).get_deploy_patch( self.instance, self.image_meta, flavor) # If there's no extra_specs patch should be exactly like a # generic patch self.assertEqual(sorted(self._expected_deploy_patch), sorted(patch))
def test__add_driver_fields_good(self, mock_update, mock_cli): node = ironic_utils.get_test_node(driver='fake') instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) mock_cli.return_value = FAKE_CLIENT self.driver._add_driver_fields(node, instance, None, None) expected_patch = [{'path': '/instance_uuid', 'op': 'add', 'value': instance['uuid']}] mock_update.assert_called_once_with(node.uuid, expected_patch)
def test_macs_for_instance(self, mock_node): node = ironic_utils.get_test_node() port = ironic_utils.get_test_port() mock_node.get.return_value = node mock_node.list_ports.return_value = [port] instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) result = self.driver.macs_for_instance(instance) self.assertEqual([port.address], result) mock_node.list_ports.assert_called_once_with(node.uuid)
def test_get_available_nodes(self): num_nodes = 2 nodes = [] for n in range(num_nodes): nodes.append(ironic_utils.get_test_node( uuid=uuidutils.generate_uuid(), power_state=ironic_states.POWER_OFF)) # append a node w/o power_state which shouldn't be listed nodes.append(ironic_utils.get_test_node(power_state=None)) with mock.patch.object(cw.IronicClientWrapper, 'call') as mock_list: mock_list.return_value = nodes expected = [n.uuid for n in nodes if n.power_state] available_nodes = self.driver.get_available_nodes() mock_list.assert_called_with("node.list") self.assertEqual(sorted(expected), sorted(available_nodes)) self.assertEqual(num_nodes, len(available_nodes))
def test_list_instances(self): num_nodes = 2 nodes = [] for n in range(num_nodes): nodes.append( ironic_utils.get_test_node( instance_uuid=uuidutils.generate_uuid())) # append a node w/o instance_uuid which shouldn't be listed nodes.append(ironic_utils.get_test_node(instance_uuid=None)) with mock.patch.object(cw.IronicClientWrapper, 'call') as mock_list: mock_list.return_value = nodes expected = [n for n in nodes if n.instance_uuid] instances = self.driver.list_instances() mock_list.assert_called_with("node.list") self.assertEqual(sorted(expected), sorted(instances)) self.assertEqual(num_nodes, len(instances))
def test_destroy_trigger_undeploy_fail(self, fake_validate, mock_sps): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid, provision_state=ironic_states.ACTIVE) fake_validate.return_value = node instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) mock_sps.side_effect = exception.NovaException() self.assertRaises(exception.NovaException, self.driver.destroy, self.ctx, instance, None, None)
def test_get_available_nodes(self): num_nodes = 2 nodes = [] for n in range(num_nodes): nodes.append( ironic_utils.get_test_node( uuid=uuidutils.generate_uuid(), power_state=ironic_states.POWER_OFF)) # append a node w/o power_state which shouldn't be listed nodes.append(ironic_utils.get_test_node(power_state=None)) with mock.patch.object(cw.IronicClientWrapper, 'call') as mock_list: mock_list.return_value = nodes expected = [n.uuid for n in nodes if n.power_state] available_nodes = self.driver.get_available_nodes() mock_list.assert_called_with("node.list") self.assertEqual(sorted(expected), sorted(available_nodes)) self.assertEqual(num_nodes, len(available_nodes))
def test_plug_vifs(self, mock__plug_vifs, mock_get): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(uuid=node_uuid) mock_get.return_value = node instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) network_info = utils.get_test_network_info() self.driver.plug_vifs(instance, network_info) mock_get.assert_called_once_with(node_uuid) mock__plug_vifs.assert_called_once_with(node, instance, network_info)
def test_power_off(self, mock_sp, fake_validate): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid) fake_validate.return_value = node instance_uuid = uuidutils.generate_uuid() instance = fake_instance.fake_instance_obj(self.ctx, node=instance_uuid) self.driver.power_off(instance) mock_sp.assert_called_once_with(node_uuid, 'off')
def test_list_instance_uuids(self, mock_call): num_nodes = 2 nodes = [] for n in range(num_nodes): nodes.append(ironic_utils.get_test_node( instance_uuid=uuidutils.generate_uuid())) mock_call.return_value = nodes uuids = self.driver.list_instance_uuids() mock_call.assert_called_with('node.list', associated=True) expected = [n.instance_uuid for n in nodes] self.assertEquals(sorted(expected), sorted(uuids))
def test_validate_instance_and_node(self, mock_gbiui): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' instance_uuid = uuidutils.generate_uuid() node = ironic_utils.get_test_node(uuid=node_uuid, instance_uuid=instance_uuid) instance = fake_instance.fake_instance_obj(self.ctx, uuid=instance_uuid) icli = cw.IronicClientWrapper() mock_gbiui.return_value = node result = ironic_driver.validate_instance_and_node(icli, instance) self.assertEqual(result.uuid, node_uuid)
def test_pxe_get_cleanup_patch_no_flavor_kernel_ramdisk_ids(self): self.flavor = ironic_utils.get_test_flavor(extra_specs={}) driver_info = { 'pxe_deploy_kernel': 'fake-kernel-id', 'pxe_deploy_ramdisk': 'fake-ramdisk-id' } node = ironic_utils.get_test_node(driver='pxe_fake', driver_info=driver_info) instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid) patch = patcher.create(node).get_cleanup_patch(instance, None, self.flavor) self.assertEqual([], patch)