def test_get_hosts(self): instance1 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance1.host = 'hostA' instance1.save() instance2 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance2.host = 'hostB' instance2.save() instance3 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance3.host = 'hostB' instance3.save() instance_ids = [instance1.uuid, instance2.uuid, instance3.uuid] values = self._get_default_values() group = self._create_instance_group(self.context, values) instance_group.InstanceGroup.add_members(self.context, group.uuid, instance_ids) group = instance_group.InstanceGroup.get_by_uuid(self.context, group.uuid) hosts = group.get_hosts(self.context) self.assertEqual(2, len(hosts)) self.assertIn('hostA', hosts) self.assertIn('hostB', hosts) hosts = group.get_hosts(self.context, exclude=[instance1.uuid]) self.assertEqual(1, len(hosts)) self.assertIn('hostB', hosts)
def test_count_members_by_user(self): instance1 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance1.user_id = 'user1' instance1.save() instance2 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance2.user_id = 'user2' instance2.save() instance3 = tests_utils.get_test_instance(self.context, flavor=flavors.get_default_flavor(), obj=True) instance3.user_id = 'user2' instance3.save() instance_ids = [instance1.uuid, instance2.uuid, instance3.uuid] values = self._get_default_values() group = self._create_instance_group(self.context, values) instance_group.InstanceGroup.add_members(self.context, group.uuid, instance_ids) group = instance_group.InstanceGroup.get_by_uuid(self.context, group.uuid) count_user1 = group.count_members_by_user(self.context, 'user1') count_user2 = group.count_members_by_user(self.context, 'user2') count_user3 = group.count_members_by_user(self.context, 'user3') self.assertEqual(1, count_user1) self.assertEqual(2, count_user2) self.assertEqual(0, count_user3)
def setUp(self): super(ServerActionsSampleJsonTest, self).setUp() self.actions = fake_server_actions.FAKE_ACTIONS self.events = fake_server_actions.FAKE_EVENTS self.instance = test_utils.get_test_instance() def fake_instance_action_get_by_request_id(context, uuid, request_id): return copy.deepcopy(self.actions[uuid][request_id]) def fake_server_actions_get(context, uuid): return [copy.deepcopy(value) for value in self.actions[uuid].itervalues()] def fake_instance_action_events_get(context, action_id): return copy.deepcopy(self.events[action_id]) def fake_instance_get_by_uuid(context, instance_id): return self.instance def fake_get(self, context, instance_uuid, **kwargs): return {'uuid': instance_uuid} self.stubs.Set(db, 'action_get_by_request_id', fake_instance_action_get_by_request_id) self.stubs.Set(db, 'actions_get', fake_server_actions_get) self.stubs.Set(db, 'action_events_get', fake_instance_action_events_get) self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid) self.stubs.Set(compute_api.API, 'get', fake_get)
def setUp(self): super(ServerActionsSampleJsonTest, self).setUp() self.api.microversion = self.microversion self.actions = fake_server_actions.FAKE_ACTIONS self.events = fake_server_actions.FAKE_EVENTS self.instance = test_utils.get_test_instance(obj=True) def _fake_get(stub_self, context, instance_uuid, expected_attrs=None, want_objects=True): return fake_instance.fake_instance_obj(None, **{"uuid": instance_uuid}) def fake_instance_action_get_by_request_id(context, uuid, request_id): return copy.deepcopy(self.actions[uuid][request_id]) def fake_server_actions_get(context, uuid): return [copy.deepcopy(value) for value in six.itervalues(self.actions[uuid])] def fake_instance_action_events_get(context, action_id): return copy.deepcopy(self.events[action_id]) def fake_instance_get_by_uuid(context, instance_id): return self.instance self.stub_out("nova.db.action_get_by_request_id", fake_instance_action_get_by_request_id) self.stub_out("nova.db.actions_get", fake_server_actions_get) self.stub_out("nova.db.action_events_get", fake_instance_action_events_get) self.stub_out("nova.db.instance_get_by_uuid", fake_instance_get_by_uuid) self.stub_out("nova.compute.api.API.get", _fake_get)
def test_snapshot_not_running(self): instance_ref = test_utils.get_test_instance() img_ref = self.image_service.create(self.ctxt, {'name': 'snap-1'}) self.assertRaises(exception.InstanceNotRunning, self.connection.snapshot, self.ctxt, instance_ref, img_ref['id'], lambda *args, **kwargs: None)
def setUp(self): super(ServerActionsSampleJsonTest, self).setUp() self.api.microversion = self.microversion self.actions = fake_server_actions.FAKE_ACTIONS self.events = fake_server_actions.FAKE_EVENTS self.instance = test_utils.get_test_instance(obj=True) def fake_instance_action_get_by_request_id(context, uuid, request_id): return copy.deepcopy(self.actions[uuid][request_id]) def fake_server_actions_get(context, uuid): return [copy.deepcopy(value) for value in six.itervalues(self.actions[uuid])] def fake_instance_action_events_get(context, action_id): return copy.deepcopy(self.events[action_id]) def fake_instance_get_by_uuid(context, instance_id): return self.instance self.stub_out('nova.db.action_get_by_request_id', fake_instance_action_get_by_request_id) self.stub_out('nova.db.actions_get', fake_server_actions_get) self.stub_out('nova.db.action_events_get', fake_instance_action_events_get) self.stub_out('nova.db.instance_get_by_uuid', fake_instance_get_by_uuid) self.stub_out('nova.compute.api.API.get', self._fake_get)
def setUp(self): super(ServerActionsSampleJsonTest, self).setUp() self.actions = fake_server_actions.FAKE_ACTIONS self.events = fake_server_actions.FAKE_EVENTS self.instance = test_utils.get_test_instance(obj=True) def fake_instance_action_get_by_request_id(context, uuid, request_id): return copy.deepcopy(self.actions[uuid][request_id]) def fake_server_actions_get(context, uuid): return [copy.deepcopy(value) for value in six.itervalues(self.actions[uuid])] def fake_instance_action_events_get(context, action_id): return copy.deepcopy(self.events[action_id]) def fake_instance_get_by_uuid(context, instance_id): return self.instance def fake_get(self, context, instance_uuid, expected_attrs=None, want_objects=True): return fake_instance.fake_instance_obj( None, **{'uuid': instance_uuid}) self.stubs.Set(db, 'action_get_by_request_id', fake_instance_action_get_by_request_id) self.stubs.Set(db, 'actions_get', fake_server_actions_get) self.stubs.Set(db, 'action_events_get', fake_instance_action_events_get) self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid) self.stubs.Set(compute_api.API, 'get', fake_get)
def test_spawn_container(self, image_info=None, instance_href=None, network_info=None): instance_href = utils.get_test_instance() image_info = utils.get_test_image_info(None, instance_href) network_info = utils.get_test_network_info() self.driver.spawn(self.ctxt, instance_href, image_info, 'fake_files', 'fake_password', network_info=network_info)
def _get_running_instance(self, obj=True): instance_ref = test_utils.get_test_instance(obj=obj) network_info = test_utils.get_test_network_info() network_info[0]["network"]["subnets"][0]["meta"]["dhcp_server"] = "1.1.1.1" image_info = test_utils.get_test_image_info(None, instance_ref) self.connection.spawn(self.ctxt, instance_ref, image_info, [], "herp", network_info=network_info) return instance_ref, network_info
def test_create_container_wrong_image(self): instance_href = utils.get_test_instance() image_info = utils.get_test_image_object(None, instance_href) image_info.disk_format = 'raw' image_info.container_format = 'invalid_format' self.assertRaises(exception.InstanceDeployFailure, self.test_create_container, image_info, instance_href)
def setUp(self): super(FixedIpTest, self).setUp() instance = dict(test_utils.get_test_instance(), hostname="openstack", host="host") fake_fixed_ips = [ { "id": 1, "address": "192.168.1.1", "network_id": 1, "virtual_interface_id": 1, "instance_uuid": "1", "allocated": False, "leased": False, "reserved": False, "created_at": None, "deleted_at": None, "updated_at": None, "deleted": None, "instance": instance, "network": test_network.fake_network, "host": None, }, { "id": 2, "address": "192.168.1.2", "network_id": 1, "virtual_interface_id": 2, "instance_uuid": "2", "allocated": False, "leased": False, "reserved": False, "created_at": None, "deleted_at": None, "updated_at": None, "deleted": None, "instance": instance, "network": test_network.fake_network, "host": None, }, ] def fake_fixed_ip_get_by_address(context, address, columns_to_join=None): for fixed_ip in fake_fixed_ips: if fixed_ip["address"] == address: return fixed_ip raise exception.FixedIpNotFoundForAddress(address=address) def fake_fixed_ip_update(context, address, values): fixed_ip = fake_fixed_ip_get_by_address(context, address) if fixed_ip is None: raise exception.FixedIpNotFoundForAddress(address=address) else: for key in values: fixed_ip[key] = values[key] self.stubs.Set(db, "fixed_ip_get_by_address", fake_fixed_ip_get_by_address) self.stubs.Set(db, "fixed_ip_update", fake_fixed_ip_update)
def _get_running_instance(self, obj=True): instance_ref = test_utils.get_test_instance(obj=obj) network_info = test_utils.get_test_network_info() network_info[0]['network']['subnets'][0]['meta']['dhcp_server'] = \ '1.1.1.1' image_info = test_utils.get_test_image_info(None, instance_ref) self.connection.spawn(self.ctxt, instance_ref, image_info, [], 'herp', network_info=network_info) return instance_ref, network_info
def test_find_container_by_uuid(self): instance_href = utils.get_test_instance() image_info = utils.get_test_image_object(None, instance_href) image_info.disk_format = 'raw' image_info.container_format = 'docker' self.connection.spawn(self.context, instance_href, image_info, 'fake_files', 'fake_password') info = self.connection._find_container_by_uuid(instance_href['uuid']) self.assertEqual(instance_href['name'], info['Config'].get('Hostname'))
def test_list_instances(self): instance_href = utils.get_test_instance() image_info = utils.get_test_image_object(None, instance_href) image_info.disk_format = 'raw' image_info.container_format = 'docker' self.connection.spawn(self.context, instance_href, image_info, 'fake_files', 'fake_password') instances = self.connection.list_instances() self.assertIn(instance_href.name, instances)
def test_get_image_name(self): instance_ref = utils.get_test_instance() image_info = utils.get_test_image_object(None, instance_ref) image_info.container_format = 'docker' image_info.name = 'MiXeDcAsE-image' repo = self.connection._get_image_name(self.context, instance_ref, image_info) # image_name = repo.split("/")[1] self.assertEqual(image_info.name, repo)
def test_reboot_container(self, image_info=None, instance_href=None, network_info=None): reboot_type = "SOFT" instance_href = utils.get_test_instance() image_info = utils.get_test_image_info(None, instance_href) network_info = utils.get_test_network_info() self.driver.spawn(self.ctxt, instance_href, image_info, 'fake_files', 'fake_password', network_info=network_info) self.driver.reboot(self.ctxt, instance_href, network_info, reboot_type)
def setUp(self): super(FixedIpTest, self).setUp() instance = dict(test_utils.get_test_instance(), hostname='openstack', host='host') fake_fixed_ips = [{'id': 1, 'address': '192.168.1.1', 'network_id': 1, 'virtual_interface_id': 1, 'instance_uuid': '1', 'allocated': False, 'leased': False, 'reserved': False, 'created_at': None, 'deleted_at': None, 'updated_at': None, 'deleted': None, 'instance': instance, 'network': test_network.fake_network, 'host': None}, {'id': 2, 'address': '192.168.1.2', 'network_id': 1, 'virtual_interface_id': 2, 'instance_uuid': '2', 'allocated': False, 'leased': False, 'reserved': False, 'created_at': None, 'deleted_at': None, 'updated_at': None, 'deleted': None, 'instance': instance, 'network': test_network.fake_network, 'host': None}, ] def fake_fixed_ip_get_by_address(context, address, columns_to_join=None): for fixed_ip in fake_fixed_ips: if fixed_ip['address'] == address: return fixed_ip raise exception.FixedIpNotFoundForAddress(address=address) def fake_fixed_ip_update(context, address, values): fixed_ip = fake_fixed_ip_get_by_address(context, address) if fixed_ip is None: raise exception.FixedIpNotFoundForAddress(address=address) else: for key in values: fixed_ip[key] = values[key] self.stubs.Set(db, "fixed_ip_get_by_address", fake_fixed_ip_get_by_address) self.stubs.Set(db, "fixed_ip_update", fake_fixed_ip_update)
def _get_running_instance(self, obj=True): instance_ref = utils.get_test_instance(obj=obj) network_info = utils.get_test_network_info() network_info[0]['network']['subnets'][0]['meta']['dhcp_server'] = \ '1.1.1.1' image_info = utils.get_test_image_object(None, instance_ref) image_info.disk_format = 'raw' image_info.container_format = 'docker' self.connection.spawn(self.ctxt, instance_ref, image_info, [], 'herp', network_info=network_info) return instance_ref, network_info
def test_list_instances_no_inspect_race(self): """Assures containers that cannot be inspected are not listed.""" instance_href = utils.get_test_instance() image_info = utils.get_test_image_object(None, instance_href) image_info.disk_format = 'raw' image_info.container_format = 'docker' self.connection.spawn(self.context, instance_href, image_info, 'fake_files', 'fake_password') with mock.patch.object(self.mock_client, 'inspect_container', return_value={}): instances = self.connection.list_instances() self.assertFalse(instances)
def test_create_container_empty_cmd(self, image_info=None, instance_href=None, network_info=None): if instance_href is None: instance_href = utils.get_test_instance() if image_info is None: image_info = utils.get_test_image_object(None, instance_href) image_info.disk_format = 'raw' image_info.container_format = 'docker' with mock.patch.object(self.mock_client, 'create_container') as mc: self.connection.spawn(self.context, instance_href, image_info, 'fake_files', 'fake_password', network_info=network_info) self.assertIsNone(mc.call_args[1].get('command'))
def _get_running_instance(self, obj=False, image_name=None, flavor=None): instance_ref = utils.get_test_instance(obj=obj, flavor=flavor) network_info = utils.get_test_network_info() network_info[0]['network']['subnets'][0]['meta']['dhcp_server'] = ( '1.1.1.1') image_info = utils.get_test_image_info(None, instance_ref) image_info['disk_format'] = 'raw' image_info['container_format'] = 'docker' if image_name: image_info['name'] = image_name self.connection.spawn(self.ctxt, jsonutils.to_primitive(instance_ref), image_info, [], 'herp', network_info=network_info) return instance_ref, network_info
def test_create_container(self, image_info=None, instance_href=None, network_info=None): if instance_href is None: instance_href = utils.get_test_instance() if image_info is None: image_info = utils.get_test_image_object(None, instance_href) image_info.disk_format = 'raw' image_info.container_format = 'docker' self.connection.spawn(self.context, instance_href, image_info, 'fake_files', 'fake_password', network_info=network_info) self._assert_cpu_shares(instance_href) self.assertEqual(self.mock_client.name, "nova-{0}".format( instance_href['uuid']))
def test_pull_missing_image_with_shared_dir(self, mock_os): self.fixture.config(shared_directory='/fake_dir', group='docker') instance_ref = utils.get_test_instance() image_info = utils.get_test_image_object(None, instance_ref) image_info.name = 'fake_name' image_info.id = 'fake_id' with mock.patch.object(self.mock_client, 'load_repository_file') as f: with mock.patch.object(self.mock_client, 'inspect_image') as i: i.return_value = 'fake_image' image = self.connection._pull_missing_image(self.context, image_info, instance_ref) f.assert_called_once_with('fake_name', '/fake_dir/fake_id') i.assert_called_once_with('fake_name') self.assertEqual('fake_image', image)
def test_create_container_inject_key(self, mock_inject_key): self.fixture.config(inject_key=True, group='docker') instance_href = utils.get_test_instance() instance_href.key_data = 'my_key' image_info = utils.get_test_image_info(None, instance_href) image_info['disk_format'] = 'raw' image_info['container_format'] = 'docker' with mock.patch.object(self.mock_client, 'create_container'): with mock.patch.object(self.mock_client, 'start') as ms: self.connection.spawn(self.context, instance_href, image_info, 'fake_files', 'fake_password', network_info=None) command = ms.call_args[1] expected = {'binds': {'/tmp/.ssh': {'bind': '/root/.ssh', 'ro': True}}} self.assertEqual(expected, command)
def test_create_container_glance_cmd(self, image_info=None, instance_href=None, network_info=None): if instance_href is None: instance_href = utils.get_test_instance() if image_info is None: image_info = utils.get_test_image_object(None, instance_href) image_info.disk_format = 'raw' image_info.container_format = 'docker' image_info.properties.os_command_line = 'uname' with mock.patch.object(self.mock_client, 'create_container') as mc: self.connection.spawn(self.context, instance_href, image_info, 'fake_files', 'fake_password', network_info=network_info) command = mc.call_args[1]['command'] self.assertEqual('uname', command)
def test_create_container_vcpus_2(self, image_info=None): flavor = utils.get_test_flavor(options={ 'name': 'vcpu_2', 'flavorid': 'vcpu_2', 'vcpus': 2 }) instance_href = utils.get_test_instance(flavor=flavor) if image_info is None: image_info = utils.get_test_image_object(None, instance_href) image_info.disk_format = 'raw' image_info.container_format = 'docker' self.connection.spawn(self.context, instance_href, image_info, 'fake_files', 'fake_password') self._assert_cpu_shares(instance_href, vcpus=2) self.assertEqual(self.mock_client.name, "nova-{0}".format( instance_href['uuid']))
def test_soft_delete_restore_container(self): instance_href = utils.get_test_instance() image_info = utils.get_test_image_object(None, instance_href) image_info.disk_format = 'raw' image_info.container_format = 'docker' self.connection.spawn(self.context, instance_href, image_info, 'fake_files', 'fake_password') container_id = self.connection._find_container_by_uuid( instance_href['uuid']).get('id') self.connection.soft_delete(instance_href) info = self.connection.docker.inspect_container(container_id) self.assertFalse(info['State']['Running']) self.connection.restore(instance_href) info = self.connection.docker.inspect_container(container_id) self.assertTrue(info['State']['Running'])
def test_snapshot(self, byuuid_mock): # Use mix-case to test that mixed-case image names succeed. snapshot_name = 'tEsT-SnAp' expected_calls = [ {'args': (), 'kwargs': {'task_state': task_states.IMAGE_PENDING_UPLOAD}}, {'args': (), 'kwargs': {'task_state': task_states.IMAGE_UPLOADING, 'expected_state': task_states.IMAGE_PENDING_UPLOAD}}] func_call_matcher = matchers.FunctionCallMatcher(expected_calls) instance_ref = utils.get_test_instance() properties = {'instance_id': instance_ref['id'], 'user_id': str(self.context.user_id)} sent_meta = {'name': snapshot_name, 'is_public': False, 'status': 'creating', 'properties': properties} # Because the docker driver doesn't push directly into Glance, we # cannot check that the images are correctly configured in the # fake image service, but we can ensuring naming and other # conventions are accurate. image_service = nova.tests.unit.image.fake.FakeImageService() recv_meta = image_service.create(context, sent_meta) with mock.patch.object(self.mock_client, 'load_image'): with mock.patch.object(self.mock_client, 'get_image'): self.connection.snapshot(self.context, instance_ref, recv_meta['id'], func_call_matcher.call) snapshot = image_service.show(context, recv_meta['id']) self.assertEqual(snapshot['properties']['image_state'], 'available') self.assertEqual(snapshot['status'], 'active') self.assertEqual(snapshot['disk_format'], 'raw') self.assertEqual(snapshot['container_format'], 'docker') self.assertEqual(snapshot['name'], snapshot_name)
def test_unfilter_instance(self): instance_ref = test_utils.get_test_instance() network_info = test_utils.get_test_network_info() self.connection.unfilter_instance(instance_ref, network_info)
def test_get_memory_limit_from_sys_meta_in_db_instance(self): instance = utils.get_test_instance(obj=False) limit = self.connection._get_memory_limit_bytes(instance) self.assertEqual(2048 * units.Mi, limit)
def test_cleanup_container(self, byname_mock, unplug_mock, teardown_mock): instance = utils.get_test_instance() self.connection.cleanup(self.context, instance, 'fake_networkinfo') byname_mock.assert_called_with(instance['name']) teardown_mock.assert_called_with('fake_id')
def test_get_test_instance(self): # get_test_instance's return value looks like an instance_ref. instance_ref = test_utils.get_test_instance() ctxt = test_utils.get_test_admin_context() db.instance_get(ctxt, instance_ref['id'])
def _test_start_container_with_network_events(self, neutron_failure=None): generated_events = [] def wait_timeout(): event = mock.MagicMock() if neutron_failure == 'timeout': raise eventlet.timeout.Timeout() elif neutron_failure == 'error': event.status = 'failed' else: event.status = 'completed' return event def fake_prepare(instance, event_name): m = mock.MagicMock() m.instance = instance m.event_name = event_name m.wait.side_effect = wait_timeout generated_events.append(m) return m virtapi = manager.ComputeVirtAPI(mock.MagicMock()) prepare = virtapi._compute.instance_events.prepare_for_instance_event prepare.side_effect = fake_prepare drvr = novadocker.virt.docker.driver.DockerDriver(virtapi) instance_href = utils.get_test_instance() container_id = self.connection._find_container_by_uuid( instance_href['uuid']).get('id') vifs = [{ 'id': 'vif1', 'active': False }, { 'id': 'vif2', 'active': False }] @mock.patch.object(drvr, '_extract_dns_entries') @mock.patch.object(drvr, 'plug_vifs') @mock.patch.object(drvr, '_attach_vifs') @mock.patch.object(self.mock_client, 'start') @mock.patch.object(self.mock_client, 'kill') @mock.patch.object(self.mock_client, 'remove_container') def test_start(remove_container, kill, start, attach_vif, plug_vifs, extract_dns_entries): drvr._start_container(container_id, instance_href, vifs) plug_vifs.assert_called_with(instance_href, vifs) attach_vif.assert_called_with(instance_href, vifs) if neutron_failure and cfg.CONF.vif_plugging_is_fatal: kill.assert_called_once_with(container_id) remove_container.assert_called_once_with(container_id, Force=True) test_start() if nova.utils.is_neutron() and cfg.CONF.vif_plugging_timeout: prepare.assert_has_calls([ mock.call(instance_href, 'network-vif-plugged-vif1'), mock.call(instance_href, 'network-vif-plugged-vif2') ]) for event in generated_events: if neutron_failure and generated_events.index(event) != 0: self.assertEqual(0, event.call_count) else: self.assertEqual(0, prepare.call_count)
def test_cleanup_container_notfound(self, byuuid_mock, unplug_mock): instance = utils.get_test_instance() self.connection.cleanup(self.context, instance, 'fake_networkinfo') byuuid_mock.assert_called_with(instance['uuid']) unplug_mock.assert_called_once_with(instance, 'fake_networkinfo')
def test_get_memory_limit_from_sys_meta_in_object(self): instance = utils.get_test_instance(obj=True) limit = self.connection._get_memory_limit_bytes(instance) self.assertEqual(512 * units.Mi, limit)
def test_get_info_for_unknown_instance(self): fake_instance = test_utils.get_test_instance(obj=True) self.assertRaises(exception.NotFound, self.connection.get_info, fake_instance)
def test_destroy_container(self, byname_mock, cleanup_mock): instance = utils.get_test_instance() self.connection.destroy(self.context, instance, 'fake_networkinfo') cleanup_mock.assert_called_with(self.context, instance, 'fake_networkinfo', None, True)
def test_ensure_filtering_for_instance(self): instance = test_utils.get_test_instance(obj=True) network_info = test_utils.get_test_network_info() self.connection.ensure_filtering_rules_for_instance( instance, network_info)
def setUp(self): super(FixedIpTest, self).setUp() instance = dict(test_utils.get_test_instance(), hostname='openstack', host='host') fake_fixed_ips = [ { 'id': 1, 'address': '192.168.1.1', 'network_id': 1, 'virtual_interface_id': 1, 'instance_uuid': '1', 'allocated': False, 'leased': False, 'reserved': False, 'created_at': None, 'deleted_at': None, 'updated_at': None, 'deleted': None, 'instance': instance, 'network': test_network.fake_network, 'host': None }, { 'id': 2, 'address': '192.168.1.2', 'network_id': 1, 'virtual_interface_id': 2, 'instance_uuid': '2', 'allocated': False, 'leased': False, 'reserved': False, 'created_at': None, 'deleted_at': None, 'updated_at': None, 'deleted': None, 'instance': instance, 'network': test_network.fake_network, 'host': None }, ] def fake_fixed_ip_get_by_address(context, address, columns_to_join=None): for fixed_ip in fake_fixed_ips: if fixed_ip['address'] == address: return fixed_ip raise exception.FixedIpNotFoundForAddress(address=address) def fake_fixed_ip_get_by_address_detailed(context, address): network = {'id': 1, 'cidr': "192.168.1.0/24"} host = {'host': "host", 'hostname': 'openstack'} for fixed_ip in fake_fixed_ips: if fixed_ip['address'] == address: return (fixed_ip, network, host) raise exception.FixedIpNotFoundForAddress(address=address) def fake_fixed_ip_update(context, address, values): fixed_ip = fake_fixed_ip_get_by_address(context, address) if fixed_ip is None: raise exception.FixedIpNotFoundForAddress(address=address) else: for key in values: fixed_ip[key] = values[key] self.stubs.Set(db, "fixed_ip_get_by_address", fake_fixed_ip_get_by_address) self.stubs.Set(db, "fixed_ip_get_by_address_detailed", fake_fixed_ip_get_by_address_detailed) self.stubs.Set(db, "fixed_ip_update", fake_fixed_ip_update)
def test_destroy_instance_nonexistent(self): fake_instance = test_utils.get_test_instance(obj=True) network_info = test_utils.get_test_network_info() self.connection.destroy(self.ctxt, fake_instance, network_info)
def setUp(self): super(FixedIpTest, self).setUp() self.api.microversion = self.microversion instance = dict(test_utils.get_test_instance(), hostname='compute.host.pvt', host='host') fake_fixed_ips = [ { 'id': 1, 'address': '192.168.1.1', 'network_id': 1, 'virtual_interface_id': 1, 'instance_uuid': uuids.instance_1, 'allocated': False, 'leased': False, 'reserved': False, 'created_at': None, 'deleted_at': None, 'updated_at': None, 'deleted': None, 'instance': instance, 'network': test_network.fake_network, 'host': None }, { 'id': 2, 'address': '192.168.1.2', 'network_id': 1, 'virtual_interface_id': 2, 'instance_uuid': uuids.instance_2, 'allocated': False, 'leased': False, 'reserved': False, 'created_at': None, 'deleted_at': None, 'updated_at': None, 'deleted': None, 'instance': instance, 'network': test_network.fake_network, 'host': None }, ] def fake_fixed_ip_get_by_address(context, address, columns_to_join=None): for fixed_ip in fake_fixed_ips: if fixed_ip['address'] == address: return fixed_ip raise exception.FixedIpNotFoundForAddress(address=address) def fake_fixed_ip_update(context, address, values): fixed_ip = fake_fixed_ip_get_by_address(context, address) if fixed_ip is None: raise exception.FixedIpNotFoundForAddress(address=address) else: for key in values: fixed_ip[key] = values[key] self.stub_out("nova.db.fixed_ip_get_by_address", fake_fixed_ip_get_by_address) self.stub_out("nova.db.fixed_ip_update", fake_fixed_ip_update)