def fake_compute_get_empty(*args, **kwargs): inst = fakes.stub_instance(1, uuid=UUID3, host="", vm_state=vm_states.ACTIVE, availability_zone='fakeaz') return fake_instance.fake_instance_obj(args[1], **inst)
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__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__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_allocate_for_instance_handles_macs_passed(self): # If a macs argument is supplied to the 'nova-network' API, it is just # ignored. This test checks that the call down to the rpcapi layer # doesn't pass macs down: nova-network doesn't support hypervisor # mac address limits (today anyhow). macs = set(['ab:cd:ef:01:23:34']) self.mox.StubOutWithMock(self.network_api.network_rpcapi, "allocate_for_instance") kwargs = dict( zip([ 'host', 'instance_id', 'project_id', 'requested_networks', 'rxtx_factor', 'vpn', 'macs', 'dhcp_options' ], itertools.repeat(mox.IgnoreArg()))) self.network_api.network_rpcapi.allocate_for_instance( mox.IgnoreArg(), **kwargs).AndReturn([]) self.mox.ReplayAll() flavor = flavors.get_default_flavor() flavor['rxtx_factor'] = 0 sys_meta = flavors.save_flavor_info({}, flavor) instance = dict(id=1, uuid='uuid', project_id='project_id', host='host', system_metadata=utils.dict_to_metadata(sys_meta)) instance = fake_instance.fake_instance_obj( self.context, expected_attrs=['system_metadata'], **instance) self.network_api.allocate_for_instance(self.context, instance, 'vpn', 'requested_networks', macs=macs)
def test_ensure_filtering_rules_for_instance(self, mock_pif, mock_sbf): instance = fake_instance.fake_instance_obj(self.ctx) network_info = utils.get_test_network_info() self.driver.ensure_filtering_rules_for_instance(instance, network_info) mock_sbf.assert_called_once_with(instance, network_info) mock_pif.assert_called_once_with(instance, network_info)
def test_instance_exists(self, mock_call): instance_uuid = 'fake-uuid' instance = fake_instance.fake_instance_obj(self.ctx, uuid=instance_uuid) self.assertTrue(self.driver.instance_exists(instance)) mock_call.assert_called_once_with('node.get_by_instance_uuid', instance_uuid)
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_list_resizing_instances(self): instances = [{ 'image_ref': '1', 'host': CONF.host, 'id': '1', 'uuid': '123', 'vm_state': vm_states.RESIZED, 'task_state': None }] all_instances = [ fake_instance.fake_instance_obj(None, **instance) for instance in instances ] image_cache_manager = imagecache.ImageCacheManager() running = image_cache_manager._list_running_instances( None, all_instances) self.assertEqual(1, len(running['used_images'])) self.assertEqual((1, 0, ['instance-00000001']), running['used_images']['1']) self.assertEqual( set([ 'instance-00000001', '123', 'instance-00000001_resize', '123_resize' ]), running['instance_names']) self.assertEqual(1, len(running['image_popularity'])) self.assertEqual(1, running['image_popularity']['1'])
def test_numa_topology_filter_pass_set_limit(self): self.flags(cpu_allocation_ratio=21) self.flags(ram_allocation_ratio=1.3) instance_topology = hardware.VirtNUMAInstanceTopology(cells=[ hardware.VirtNUMATopologyCell(0, set([1]), 512), hardware.VirtNUMATopologyCell(1, set([3]), 512) ]) instance = fake_instance.fake_instance_obj(self.context) instance.numa_topology = ( objects.InstanceNUMATopology.obj_from_topology(instance_topology)) filter_properties = { 'request_spec': { 'instance_properties': jsonutils.to_primitive(obj_base.obj_to_primitive(instance)) } } host = fakes.FakeHostState('host1', 'node1', {'numa_topology': fakes.NUMA_TOPOLOGY}) filt_cls = self.class_map['NUMATopologyFilter']() self.assertTrue(filt_cls.host_passes(host, filter_properties)) limits_topology = hardware.VirtNUMALimitTopology.from_json( host.limits['numa_topology']) self.assertEqual(limits_topology.cells[0].cpu_limit, 42) self.assertEqual(limits_topology.cells[1].cpu_limit, 42) self.assertEqual(limits_topology.cells[0].memory_limit, 665) self.assertEqual(limits_topology.cells[1].memory_limit, 665)
def setUp(self): super(ServerPasswordTest, self).setUp() fakes.stub_out_nw_api(self.stubs) self.stubs.Set( compute.api.API, 'get', lambda self, ctxt, *a, **kw: fake_instance.fake_instance_obj( ctxt, system_metadata={}, expected_attrs=['system_metadata'])) self.password = '******' def fake_extract_password(instance): return self.password def fake_convert_password(context, password): self.password = password return {} self.stubs.Set(password, 'extract_password', fake_extract_password) self.stubs.Set(password, 'convert_password', fake_convert_password) self.flags( osapi_compute_extension=[ 'nova.api.openstack.compute.contrib.select_extensions'], osapi_compute_ext_list=['Server_password'])
def test_create_vm_invalid_guestid(self, mock_log_warn): """Ensure we warn when create_vm() fails after we passed an unrecognised guestId """ found = [False] def fake_log_warn(msg, values): if not isinstance(values, dict): return if values.get('ostype') == 'invalid_os_type': found[0] = True mock_log_warn.side_effect = fake_log_warn instance_values = {'id': 7, 'name': 'fake-name', 'uuid': uuidutils.generate_uuid(), 'vcpus': 2, 'memory_mb': 2048} instance = fake_instance.fake_instance_obj( context.RequestContext('fake', 'fake', is_admin=False), **instance_values) session = driver.VMwareAPISession() config_spec = vm_util.get_vm_create_spec( session.vim.client.factory, instance, instance.name, 'fake-datastore', [], os_type='invalid_os_type') self.assertRaises(vexc.VMwareDriverException, vm_util.create_vm, session, instance, 'folder', config_spec, 'res-pool') self.assertTrue(found[0])
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__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_macs_for_instance_http_not_found(self, mock_get): mock_get.side_effect = ironic_exception.NotFound() instance = fake_instance.fake_instance_obj( self.ctx, node=uuidutils.generate_uuid()) result = self.driver.macs_for_instance(instance) self.assertEqual([], 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.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_unplug_vifs_no_network_info(self, mock_update): instance = fake_instance.fake_instance_obj(self.ctx) network_info = [] self.driver.unplug_vifs(instance, network_info) # assert port.update() was not called self.assertFalse(mock_update.called)
def _group_filter_with_filter_not_configured(self, policy): self.flags(scheduler_default_filters=['f1', 'f2']) sched = fakes.FakeFilterScheduler() instance = fake_instance.fake_instance_obj(self.context, params={'host': 'hostA'}) group = objects.InstanceGroup() group.uuid = str(uuid.uuid4()) group.members = [instance.uuid] group.policies = [policy] filter_properties = { 'scheduler_hints': { 'group': group.uuid, }, } with contextlib.nested( mock.patch.object(objects.InstanceGroup, 'get_by_uuid', return_value=group), mock.patch.object(objects.InstanceGroup, 'get_hosts', return_value=['hostA']), ) as (get_group, get_hosts): self.assertRaises(exception.NoValidHost, sched._setup_instance_group, self.context, filter_properties)
def test_migrate_disk_and_power_off(self, mock_check_flavor, mock_migrate_disk_files): instance = fake_instance.fake_instance_obj(self.context) flavor = mock.MagicMock() network_info = mock.MagicMock() disk_files = [mock.MagicMock()] volume_drives = [mock.MagicMock()] mock_get_vm_st_path = self._migrationops._vmutils.get_vm_storage_paths mock_get_vm_st_path.return_value = (disk_files, volume_drives) self._migrationops.migrate_disk_and_power_off( self.context, instance, mock.sentinel.FAKE_DEST, flavor, network_info, None, self._FAKE_TIMEOUT, self._FAKE_RETRY_INTERVAL, ) mock_check_flavor.assert_called_once_with(instance, flavor) self._migrationops._vmops.power_off.assert_called_once_with( instance, self._FAKE_TIMEOUT, self._FAKE_RETRY_INTERVAL ) mock_get_vm_st_path.assert_called_once_with(instance.name) mock_migrate_disk_files.assert_called_once_with(instance.name, disk_files, mock.sentinel.FAKE_DEST) self._migrationops._vmops.destroy.assert_called_once_with(instance, destroy_disks=False)
def _test_power_off(self, timeout): instance = fake_instance.fake_instance_obj(self.context) with mock.patch.object(self._vmops, '_set_vm_state') as mock_set_state: self._vmops.power_off(instance, timeout) mock_set_state.assert_called_once_with( instance, constants.HYPERV_VM_STATE_DISABLED)
def test_deallocate_for_instance_with_expected_networks(self): instance = fake_instance.fake_instance_obj(context.get_admin_context()) self._test_network_api('deallocate_for_instance', rpc_method='call', instance=instance, requested_networks={}, version='1.11')
def test_spawn_disk_invalid_disk_size(self, mock_get_datacenter_ref_and_name, mock_get_datastore, mock_get_res_pool_ref): image = { 'id': 'c1c8ce3d-c2e0-4247-890c-ccf5cc1c004c', 'disk_format': 'vmdk', 'size': 999999999 * units.Gi, } self._context = context.RequestContext('fake_user', 'fake_project') instance = fake_instance.fake_instance_obj( self._context, image_ref=nova.tests.image.fake.get_valid_image_id(), uuid='fake_uuid', root_gb=1, node='respool-1001(MyResPoolName)') ops = vmops.VMwareVMOps(mock.Mock(), mock.Mock(), mock.Mock()) self.assertRaises(exception.InstanceUnacceptable, ops.spawn, mock.Mock(), instance, image, injected_files=[], admin_password=None, network_info=None, block_device_info=None)
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_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 fake_compute_get(*args, **kwargs): inst = fakes.stub_instance(1, uuid=UUID3, host="host-fake", node="node-fake") return fake_instance.fake_instance_obj( args[1], expected_attrs=instance_obj.INSTANCE_DEFAULT_FIELDS, **inst)
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_spawn(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = get_test_node(driver='fake', uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) fake_flavor = 'fake-flavor' mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) mock_fg = mock.patch.object(self.driver.virtapi, 'flavor_get').start() mock_fg.return_value = fake_flavor self.addCleanup(mock_fg.stop) mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start() mock_validate.return_value = get_test_validation() self.addCleanup(mock_validate.stop) mock_adf = mock.patch.object(self.driver, '_add_driver_fields').start() self.addCleanup(mock_adf.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_pvifs.stop) with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \ as mock_sps: 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.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(instance, None) mock_sf.assert_called_once_with(instance, None) mock_sps.assert_called_once_with(node_uuid, 'active')
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_setting_instance_uuid_fail(self): instance = fake_instance.fake_instance_obj(self.ctx, node=uuidutils.generate_uuid()) with mock.patch.object(FAKE_CLIENT.node, 'update') as mock_update: mock_update.side_effect = ironic_exception.HTTPBadRequest() self.assertRaises(exception.NovaException, self.driver.spawn, self.ctx, instance, None, [], None)
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_driver_validation_fail(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = get_test_node(driver='fake', uuid=node_uuid) instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) fake_flavor = 'fake-flavor' mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) mock_fg = mock.patch.object(self.driver.virtapi, 'flavor_get').start() mock_fg.return_value = fake_flavor self.addCleanup(mock_fg.stop) mock_adf = mock.patch.object(self.driver, '_add_driver_fields').start() self.addCleanup(mock_adf.stop) with mock.patch.object(FAKE_CLIENT.node, 'validate') as mock_validate: mock_validate.return_value = get_test_validation(power=False, deploy=False) self.assertRaises(exception.ValidationError, 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.assert_called_once_with(self.ctx, instance['instance_type_id']) mock_adf.assert_called_once_with(node, instance, None, fake_flavor)
def fake_compute_get(*args, **kwargs): inst = fakes.stub_instance(1, uuid=UUID3, task_state="kayaking", vm_state="slightly crunchy", power_state=1) return fake_instance.fake_instance_obj(args[1], **inst)
def test_spawn_node_trigger_deploy_fail(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = 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 = get_test_validation() self.addCleanup(mock_validate.stop) mock_fg = mock.patch.object(self.driver.virtapi, 'flavor_get').start() self.addCleanup(mock_fg.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_upvifs = mock.patch.object(self.driver, 'unplug_vifs').start() self.addCleanup(mock_upvifs.stop) mock_stof = mock.patch.object(self.driver, '_stop_firewall').start() self.addCleanup(mock_stof.stop) with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \ as mock_sps: mock_sps.side_effect = ironic_driver.MaximumRetriesReached self.assertRaises(exception.NovaException, 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.assert_called_once_with(self.ctx, instance['instance_type_id']) mock_upvifs.assert_called_once_with(instance, None) mock_stof.assert_called_once_with(instance, None)
def test_group_details_in_filter_properties(self): sched = fakes.FakeFilterScheduler() instance = fake_instance.fake_instance_obj(self.context, params={'host': 'hostA'}) group = instance_group_obj.InstanceGroup() group.uuid = str(uuid.uuid4()) group.members = [instance.uuid] group.policies = ['anti-affinity'] filter_properties = { 'scheduler_hints': { 'group': group.uuid, }, } with contextlib.nested( mock.patch.object(instance_group_obj.InstanceGroup, 'get_by_uuid', return_value=group), mock.patch.object(instance_group_obj.InstanceGroup, 'get_hosts', return_value=['hostA']), ) as (get_group, get_hosts): update_group_hosts = sched._setup_instance_group(self.context, filter_properties) self.assertTrue(update_group_hosts) self.assertEqual(set(['hostA']), filter_properties['group_hosts']) self.assertEqual(['anti-affinity'], filter_properties['group_policies'])
def test_power_off(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid) with mock.patch.object(FAKE_CLIENT.node, 'set_power_state') as mock_sp: self.driver.power_off(instance) mock_sp.assert_called_once_with(node_uuid, 'off')
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_plug_vifs_no_network_info(self): node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' node = get_test_node(uuid=node_uuid) port = get_test_port() mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start() mock_get.return_value = node self.addCleanup(mock_get.stop) mock_uvifs = mock.patch.object(self.driver, 'unplug_vifs').start() self.addCleanup(mock_uvifs.stop) mock_update = mock.patch.object(FAKE_CLIENT.port, 'update').start() self.addCleanup(mock_update.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 = [] self.driver.plug_vifs(instance, network_info) # asserts mock_uvifs.assert_called_once_with(instance, network_info) mock_get.assert_called_once_with(node_uuid) mock_lp.assert_called_once_with(node_uuid) # assert port.update() was not called assert not mock_update.called
def test_blank_attach_volume(self): no_blank_volume = self.blank_bdm.copy() no_blank_volume['volume_id'] = None test_bdm = self.driver_classes['blank'](no_blank_volume) instance = fake_instance.fake_instance_obj(mock.sentinel.ctx, **{'uuid': 'fake-uuid'}) volume_class = self.driver_classes['volume'] volume = {'id': 'fake-volume-id-2', 'display_name': 'fake-uuid-blank-vol'} with contextlib.nested( mock.patch.object(self.volume_api, 'create', return_value=volume), mock.patch.object(volume_class, 'attach') ) as (vol_create, vol_attach): test_bdm.attach(self.context, instance, self.volume_api, self.virt_driver) vol_create.assert_called_once_with(self.context, test_bdm.volume_size, 'fake-uuid-blank-vol', '') vol_attach.assert_called_once_with(self.context, instance, self.volume_api, self.virt_driver, do_check_attach=True) self.assertEqual('fake-volume-id-2', test_bdm.volume_id)
def test_deallocate_for_instance(self): instance = fake_instance.fake_instance_obj(context.get_admin_context()) self._test_network_api('deallocate_for_instance', rpc_method='call', requested_networks=self.DefaultArg(None), instance=instance, version='1.11')
def test_spawn_disk_invalid_disk_size(self, mock_get_datacenter_ref_and_name, mock_get_datastore, mock_get_res_pool_ref): image = { 'id': 'c1c8ce3d-c2e0-4247-890c-ccf5cc1c004c', 'disk_format': 'vmdk', 'size': 999999999 * units.Gi, } self._context = context.RequestContext('fake_user', 'fake_project') instance = fake_instance.fake_instance_obj(self._context, image_ref=nova.tests.image.fake.get_valid_image_id(), uuid='fake_uuid', root_gb=1, node='respool-1001(MyResPoolName)' ) ops = vmops.VMwareVMOps(mock.Mock(), mock.Mock(), mock.Mock()) self.assertRaises(exception.InstanceUnacceptable, ops.spawn, mock.Mock(), instance, image, injected_files=[], admin_password=None, network_info=None, block_device_info=None)
def fake_compute_api_get(self, context, instance_id, **kwargs): want_objects = kwargs.get('want_objects') if want_objects: return fake_instance.fake_instance_obj( context, **{'uuid': instance_id}) else: return {'uuid': instance_id}
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_rebuild_instance(self, _record_action_start, _checks_for_create_and_rebuild, _check_auto_disk_config, _get_image, bdm_get_by_instance_uuid, get_flavor, instance_save): orig_system_metadata = {} instance = fake_instance.fake_instance_obj( self.context, vm_state=vm_states.ACTIVE, cell_name='fake-cell', launched_at=timeutils.utcnow(), system_metadata=orig_system_metadata, expected_attrs=['system_metadata']) get_flavor.return_value = '' image_href = '' image = { "min_ram": 10, "min_disk": 1, "properties": { 'architecture': 'x86_64' } } admin_pass = '' files_to_inject = [] bdms = [] _get_image.return_value = (None, image) bdm_get_by_instance_uuid.return_value = bdms self.compute_api.rebuild(self.context, instance, image_href, admin_pass, files_to_inject) self.assertTrue(self.cells_rpcapi.rebuild_instance.called)
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 fake_compute_api_get(self, context, instance_id, **kwargs): want_objects = kwargs.get('want_objects') if want_objects: return fake_instance.fake_instance_obj(context, **{'uuid': instance_id}) else: return {'uuid': instance_id}
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_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_group_details_in_filter_properties(self): sched = fakes.FakeFilterScheduler() instance = fake_instance.fake_instance_obj(self.context, params={'host': 'hostA'}) group = instance_group_obj.InstanceGroup() group.uuid = str(uuid.uuid4()) group.members = [instance.uuid] group.policies = ['anti-affinity'] filter_properties = { 'scheduler_hints': { 'group': group.uuid, }, } with contextlib.nested( mock.patch.object(instance_group_obj.InstanceGroup, 'get_by_uuid', return_value=group), mock.patch.object(instance_group_obj.InstanceGroup, 'get_hosts', return_value=['hostA']), ) as (get_group, get_hosts): update_group_hosts = sched._setup_instance_group( self.context, filter_properties) self.assertTrue(update_group_hosts) self.assertEqual(set(['hostA']), filter_properties['group_hosts']) self.assertEqual(['anti-affinity'], filter_properties['group_policies'])
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)