def test_build_proxy_request_headers(self, get_remote_ip, get_context, sign_instance_id): req = mock.Mock(headers={}) req.headers = {'X-Instance-ID': 'fake_instance_id', 'fake_key': 'fake_value'} self.assertThat(self.handler._build_proxy_request_headers(req), matchers.DictMatches(req.headers)) req.headers = {'fake_key': 'fake_value'} get_remote_ip.return_value = 'fake_instance_ip' get_context.return_value = 'fake_context' sign_instance_id.return_value = 'signed' with mock.patch('ec2api.metadata.api.' 'get_os_instance_and_project_id') as get_ids: get_ids.return_value = ('fake_instance_id', 'fake_project_id') self.assertThat(self.handler._build_proxy_request_headers(req), matchers.DictMatches( {'X-Forwarded-For': 'fake_instance_ip', 'X-Instance-ID': 'fake_instance_id', 'X-Tenant-ID': 'fake_project_id', 'X-Instance-ID-Signature': 'signed'})) get_remote_ip.assert_called_with(req) get_context.assert_called_with() sign_instance_id.assert_called_with('fake_instance_id') get_ids.assert_called_with('fake_context', 'fake_instance_ip') get_ids.side_effect = exception.EC2MetadataNotFound() self.assertRaises(exception.EC2MetadataNotFound, self.handler._build_proxy_request_headers, req)
def test_add_item(self): new_item = { 'os_id': fakes.random_os_id(), 'vpc_id': fakes.random_ec2_id('fake_vpc'), 'str_attr': 'fake_str', 'int_attr': 1234, 'bool_attr': True, 'dict_attr': { 'key1': 'val1', 'key2': 'val2' }, 'list_attr': ['fake_str', 1234, True, { 'key': 'val' }, []] } item = db_api.add_item(self.context, 'fake', new_item) self.assertIn('id', item) self.assertIsNotNone(item['id']) item_id = item.pop('id') self.assertTrue(validator.validate_ec2_id(item_id, '', ['fake'])) self.assertThat(item, matchers.DictMatches(new_item, orderless_lists=True)) item = db_api.get_item_by_id(self.context, item_id) new_item['id'] = item_id self.assertThat(item, matchers.DictMatches(new_item, orderless_lists=True))
def test_register_image_by_s3(self, s3_create): s3_create.return_value = fakes.OSImage(fakes.OS_IMAGE_1) self.db_api.add_item.side_effect = (tools.get_db_api_add_item( fakes.ID_EC2_IMAGE_1)) resp = self.execute('RegisterImage', {'ImageLocation': fakes.LOCATION_IMAGE_1}) self.assertThat( resp, matchers.DictMatches({'imageId': fakes.ID_EC2_IMAGE_1})) s3_create.assert_called_once_with( mock.ANY, { 'name': fakes.LOCATION_IMAGE_1, 'properties': { 'image_location': fakes.LOCATION_IMAGE_1 } }) s3_create.reset_mock() resp = self.execute('RegisterImage', { 'ImageLocation': fakes.LOCATION_IMAGE_1, 'Name': 'an image name' }) self.assertThat( resp, matchers.DictMatches({'imageId': fakes.ID_EC2_IMAGE_1})) s3_create.assert_called_once_with( mock.ANY, { 'name': 'an image name', 'properties': { 'image_location': fakes.LOCATION_IMAGE_1 } })
def test_describe_volumes(self): self.cinder.volumes.list.return_value = [ fakes.OSVolume(fakes.OS_VOLUME_1), fakes.OSVolume(fakes.OS_VOLUME_2), fakes.OSVolume(fakes.OS_VOLUME_3) ] self.set_mock_db_items(fakes.DB_VOLUME_1, fakes.DB_VOLUME_2, fakes.DB_INSTANCE_1, fakes.DB_INSTANCE_2, fakes.DB_SNAPSHOT_1, fakes.DB_SNAPSHOT_2) self.db_api.add_item.side_effect = (tools.get_db_api_add_item( fakes.ID_EC2_VOLUME_3)) resp = self.execute('DescribeVolumes', {}) self.assertThat( resp, matchers.DictMatches( { 'volumeSet': [ fakes.EC2_VOLUME_1, fakes.EC2_VOLUME_2, fakes.EC2_VOLUME_3 ] }, orderless_lists=True)) self.db_api.get_items.assert_any_call(mock.ANY, 'vol') self.db_api.get_items_by_ids = tools.CopyingMock( return_value=[fakes.DB_VOLUME_1]) resp = self.execute('DescribeVolumes', {'VolumeId.1': fakes.ID_EC2_VOLUME_1}) self.assertThat( resp, matchers.DictMatches({'volumeSet': [fakes.EC2_VOLUME_1]}, orderless_lists=True)) self.db_api.get_items_by_ids.assert_any_call( mock.ANY, set([fakes.ID_EC2_VOLUME_1])) self.check_filtering( 'DescribeVolumes', 'volumeSet', [ ('availability-zone', fakes.NAME_AVAILABILITY_ZONE), ('create-time', fakes.TIME_CREATE_VOLUME_2), ('encrypted', False), # TODO(ft): declare a constant for the volume size in fakes ('size', 1), ('snapshot-id', fakes.ID_EC2_SNAPSHOT_1), ('status', 'available'), ('volume-id', fakes.ID_EC2_VOLUME_1), # TODO(ft): support filtering by none/empty value # ('volume-type', ''), ('attachment.device', fakes.ROOT_DEVICE_NAME_INSTANCE_2), ('attachment.instance-id', fakes.ID_EC2_INSTANCE_2), ('attachment.status', 'attached') ]) self.check_tag_support('DescribeVolumes', 'volumeSet', fakes.ID_EC2_VOLUME_1, 'volumeId')
def test_format_instance_mapping(self): retval = api._build_block_device_mappings( 'fake_context', fakes.EC2_INSTANCE_1, fakes.ID_OS_INSTANCE_1) self.assertThat(retval, matchers.DictMatches( {'ami': 'vda', 'root': fakes.ROOT_DEVICE_NAME_INSTANCE_1})) retval = api._build_block_device_mappings( 'fake_context', fakes.EC2_INSTANCE_2, fakes.ID_OS_INSTANCE_2) expected = {'ami': 'sdb1', 'root': fakes.ROOT_DEVICE_NAME_INSTANCE_2} expected.update(fakes.EC2_BDM_METADATA_INSTANCE_2) self.assertThat(retval, matchers.DictMatches(expected))
def test_describe_images(self): self._setup_model() resp = self.execute('DescribeImages', {}) self.assertThat( resp, matchers.DictMatches( {'imagesSet': [fakes.EC2_IMAGE_1, fakes.EC2_IMAGE_2]}, orderless_lists=True), verbose=True) self.db_api.get_items.assert_any_call(mock.ANY, 'ami') self.db_api.get_items.assert_any_call(mock.ANY, 'aki') self.db_api.get_items.assert_any_call(mock.ANY, 'ari') self.db_api.get_items_by_ids = tools.CopyingMock( side_effect=self.db_api.get_items_by_ids.side_effect) resp = self.execute('DescribeImages', {'ImageId.1': fakes.ID_EC2_IMAGE_1}) self.assertThat(resp, matchers.DictMatches( {'imagesSet': [fakes.EC2_IMAGE_1]}, orderless_lists=True)) self.db_api.get_items_by_ids.assert_any_call( mock.ANY, set([fakes.ID_EC2_IMAGE_1])) self.check_filtering( 'DescribeImages', 'imagesSet', [('architecture', 'x86_64'), ('block-device-mapping.device-name', '/dev/sdb2'), ('block-device-mapping.snapshot-id', fakes.ID_EC2_SNAPSHOT_1), ('block-device-mapping.volume-size', 22), ('description', 'fake desc'), ('image-id', fakes.ID_EC2_IMAGE_1), ('image-type', 'machine'), ('is-public', True), ('kernel_id', fakes.ID_EC2_IMAGE_AKI_1,), ('name', 'fake_name'), ('owner-id', fakes.ID_OS_PROJECT), ('ramdisk-id', fakes.ID_EC2_IMAGE_ARI_1), ('root-device-name', fakes.ROOT_DEVICE_NAME_IMAGE_1), ('root-device-type', 'instance-store'), ('state', 'available')]) self.check_tag_support( 'DescribeImages', 'imagesSet', fakes.ID_EC2_IMAGE_1, 'imageId', ('ami', 'ari', 'aki'))
def check_response(resp): self.assertThat(fakes.EC2_SUBNET_1, matchers.DictMatches(resp['subnet'])) self.db_api.add_item.assert_called_once_with( mock.ANY, 'subnet', tools.purge_dict(subnet_1, ('id', ))) self.neutron.create_network.assert_called_once_with( {'network': { 'name': 'subnet-0' }}) self.neutron.update_network.assert_called_once_with( fakes.ID_OS_NETWORK_1, {'network': { 'name': fakes.ID_EC2_SUBNET_1 }}) self.neutron.create_subnet.assert_called_once_with({ 'subnet': tools.purge_dict(fakes.OS_SUBNET_1, ('id', 'name', 'gateway_ip')) }) self.neutron.update_subnet.assert_called_once_with( fakes.ID_OS_SUBNET_1, { 'subnet': { 'name': fakes.ID_EC2_SUBNET_1, 'gateway_ip': None } }) self.neutron.add_interface_router.assert_called_once_with( fakes.ID_OS_ROUTER_1, {'subnet_id': fakes.ID_OS_SUBNET_1}) self.vpn_gateway_api._start_vpn_in_subnet.assert_called_once_with( mock.ANY, self.neutron, mock.ANY, subnet_1, fakes.DB_VPC_1, fakes.DB_ROUTE_TABLE_1) self.assertIsInstance( self.vpn_gateway_api._start_vpn_in_subnet.call_args[0][2], common.OnCrashCleaner)
def test_create_volume_from_snapshot(self): self.cinder.volumes.create.return_value = (fakes.OSVolume( fakes.OS_VOLUME_3)) self.db_api.add_item.side_effect = (tools.get_db_api_add_item( fakes.ID_EC2_VOLUME_3)) self.set_mock_db_items(fakes.DB_SNAPSHOT_1) resp = self.execute( 'CreateVolume', { 'AvailabilityZone': fakes.NAME_AVAILABILITY_ZONE, 'SnapshotId': fakes.ID_EC2_SNAPSHOT_1 }) self.assertThat(fakes.EC2_VOLUME_3, matchers.DictMatches(resp)) self.db_api.add_item.assert_called_once_with(mock.ANY, 'vol', tools.purge_dict( fakes.DB_VOLUME_3, ('id', )), project_id=None) self.cinder.volumes.create.assert_called_once_with( None, snapshot_id=fakes.ID_OS_SNAPSHOT_1, volume_type=None, availability_zone=fakes.NAME_AVAILABILITY_ZONE)
def check_response(resp): self.assertThat(fakes.EC2_SUBNET_1, matchers.DictMatches(resp['subnet'])) self.db_api.add_item.assert_called_once_with(mock.ANY, 'subnet', tools.purge_dict( fakes.DB_SUBNET_1, ('id', )), project_id=None) self.neutron.create_network.assert_called_once_with( {'network': {}}) self.neutron.update_network.assert_called_once_with( fakes.ID_OS_NETWORK_1, {'network': { 'name': fakes.ID_EC2_SUBNET_1 }}) self.neutron.create_subnet.assert_called_once_with({ 'subnet': tools.purge_dict(fakes.OS_SUBNET_1, ('id', 'name')) }) self.neutron.update_subnet.assert_called_once_with( fakes.ID_OS_SUBNET_1, {'subnet': { 'name': fakes.ID_EC2_SUBNET_1 }}) self.neutron.add_interface_router.assert_called_once_with( fakes.ID_OS_ROUTER_1, {'subnet_id': fakes.ID_OS_SUBNET_1})
def check_normal_flow(kind, ec2_id): item['id'] = ec2_id res = ec2utils.get_db_item('fake_context', ec2_id) self.assertThat(res, matchers.DictMatches(item)) db_api.get_item_by_id.assert_called_once_with('fake_context', ec2_id) db_api.reset_mock()
def check_response(response): self.assertIn('vpc', response) vpc = resp['vpc'] self.assertThat(fakes.EC2_VPC_1, matchers.DictMatches(vpc)) create_vpc.assert_called_once_with(mock.ANY, fakes.CIDR_VPC_1) create_vpc.reset_mock()
def test_register_image_by_bdm(self, get_os_image): self.glance.images.create.return_value = (fakes.OSImage( fakes.OS_IMAGE_2)) self.db_api.add_item.side_effect = (tools.get_db_api_add_item( fakes.ID_EC2_IMAGE_2)) self.set_mock_db_items(fakes.DB_SNAPSHOT_1, fakes.DB_IMAGE_AKI_1, fakes.DB_IMAGE_ARI_1) get_os_image.side_effect = [ fakes.OSImage(fakes.OS_IMAGE_AKI_1), fakes.OSImage(fakes.OS_IMAGE_ARI_1) ] resp = self.execute( 'RegisterImage', { 'RootDeviceName': fakes.ROOT_DEVICE_NAME_IMAGE_2, 'Name': 'fake_name', 'KernelId': fakes.ID_EC2_IMAGE_AKI_1, 'RamdiskId': fakes.ID_EC2_IMAGE_ARI_1, 'BlockDeviceMapping.1.DeviceName': fakes.ROOT_DEVICE_NAME_IMAGE_2, 'BlockDeviceMapping.1.Ebs.SnapshotId': fakes.ID_EC2_SNAPSHOT_1 }) self.assertThat( resp, matchers.DictMatches({'imageId': fakes.ID_EC2_IMAGE_2})) self.db_api.add_item.assert_called_once_with( mock.ANY, 'ami', { 'os_id': fakes.ID_OS_IMAGE_2, 'is_public': False, 'description': None }, project_id=None) self.assertEqual(1, self.glance.images.create.call_count) self.assertEqual((), self.glance.images.create.call_args[0]) self.assertIn('properties', self.glance.images.create.call_args[1]) self.assertIsInstance( self.glance.images.create.call_args[1]['properties'], dict) bdm = self.glance.images.create.call_args[1]['properties'].pop( 'block_device_mapping', None) self.assertEqual( { 'is_public': False, 'size': 0, 'name': 'fake_name', 'properties': { 'root_device_name': fakes.ROOT_DEVICE_NAME_IMAGE_2, 'kernel_id': fakes.ID_OS_IMAGE_AKI_1, 'ramdisk_id': fakes.ID_OS_IMAGE_ARI_1 } }, self.glance.images.create.call_args[1]) self.assertEqual([{ 'device_name': fakes.ROOT_DEVICE_NAME_IMAGE_2, 'delete_on_termination': True, 'snapshot_id': fakes.ID_OS_SNAPSHOT_1 }], json.loads(bdm)) get_os_image.assert_has_calls([ mock.call(mock.ANY, fakes.ID_EC2_IMAGE_AKI_1), mock.call(mock.ANY, fakes.ID_EC2_IMAGE_ARI_1) ])
def do_check(attr, ec2_image_id, response): resp = self.execute('DescribeImageAttribute', { 'ImageId': ec2_image_id, 'Attribute': attr }) response['imageId'] = ec2_image_id self.assertThat( resp, matchers.DictMatches(response, orderless_lists=True))
def test_describe_snapshots(self): self.cinder.volume_snapshots.list.return_value = [ fakes.OSSnapshot(fakes.OS_SNAPSHOT_1), fakes.OSSnapshot(fakes.OS_SNAPSHOT_2) ] self.set_mock_db_items(fakes.DB_SNAPSHOT_1, fakes.DB_SNAPSHOT_2, fakes.DB_VOLUME_2) resp = self.execute('DescribeSnapshots', {}) self.assertThat( resp, matchers.DictMatches( {'snapshotSet': [fakes.EC2_SNAPSHOT_1, fakes.EC2_SNAPSHOT_2]}, orderless_lists=True)) self.db_api.get_items.assert_any_call(mock.ANY, 'vol') self.db_api.get_items_by_ids = tools.CopyingMock( return_value=[fakes.DB_SNAPSHOT_1]) resp = self.execute('DescribeSnapshots', {'SnapshotId.1': fakes.ID_EC2_SNAPSHOT_1}) self.assertThat( resp, matchers.DictMatches({'snapshotSet': [fakes.EC2_SNAPSHOT_1]}, orderless_lists=True)) self.db_api.get_items_by_ids.assert_called_once_with( mock.ANY, set([fakes.ID_EC2_SNAPSHOT_1])) self.check_filtering( 'DescribeSnapshots', 'snapshotSet', [ # TODO(ft): declare a constant for the description in fakes ('description', 'fake description'), ('owner-id', fakes.ID_OS_PROJECT), ('progress', '100%'), ('snapshot-id', fakes.ID_EC2_SNAPSHOT_1), ('start-time', fakes.TIME_CREATE_SNAPSHOT_2), ('status', 'completed'), ('volume-id', fakes.ID_EC2_VOLUME_2), # TODO(ft): declare a constant for the volume size in fakes ('volume-size', 1) ]) self.check_tag_support('DescribeSnapshots', 'snapshotSet', fakes.ID_EC2_SNAPSHOT_1, 'snapshotId')
def test_deregister_image(self): self._setup_model() resp = self.execute('DeregisterImage', {'ImageId': fakes.ID_EC2_IMAGE_1}) self.assertThat(resp, matchers.DictMatches({'return': True})) self.db_api.delete_item.assert_called_once_with( mock.ANY, fakes.ID_EC2_IMAGE_1) self.glance.images.delete.assert_called_once_with(fakes.ID_OS_IMAGE_1)
def test_create_igw(self): self.db_api.add_item.return_value = fakes.DB_IGW_2 resp = self.execute('CreateInternetGateway', {}) self.assertIn('internetGateway', resp) igw = resp['internetGateway'] self.assertThat(fakes.EC2_IGW_2, matchers.DictMatches(igw)) self.db_api.add_item.assert_called_with(mock.ANY, 'igw', {})
def test_describe_volumes_auto_remove(self): self.cinder.volumes.list.return_value = [] self.set_mock_db_items(fakes.DB_VOLUME_1, fakes.DB_VOLUME_2) resp = self.execute('DescribeVolumes', {}) self.assertThat(resp, matchers.DictMatches({'volumeSet': []})) self.db_api.delete_item.assert_any_call(mock.ANY, fakes.ID_EC2_VOLUME_1) self.db_api.delete_item.assert_any_call(mock.ANY, fakes.ID_EC2_VOLUME_2)
def do_check(new_item): item = db_api.add_item(self.context, 'fake', new_item) item_id = item.pop('id') if 'id' in new_item: new_item_id = new_item.pop('id') self.assertNotEqual(new_item_id, item_id) new_item.setdefault('os_id', None) new_item.setdefault('vpc_id', None) self.assertThat( item, matchers.DictMatches(new_item, orderless_lists=True))
def _compare_aws_xml(self, root_tag, xmlns, request_id, dict_data, observed): # NOTE(ft): we cann't use matchers.XMLMatches since it makes comparison # based on the order of tags xml = etree.fromstring(observed) self.assertEqual(xmlns, xml.nsmap.get(None)) observed_data = tools.parse_xml(observed) expected = {root_tag: tools.update_dict(dict_data, {'requestId': request_id})} self.assertThat(observed_data, matchers.DictMatches(expected))
def test_s3_parse_manifest(self): db_api = self.mock_db() glance = self.mock_glance() db_api.set_mock_items(fakes.DB_IMAGE_AKI_1, fakes.DB_IMAGE_ARI_1) glance.images.get.side_effect = (tools.get_by_1st_arg_getter({ fakes.ID_OS_IMAGE_AKI_1: fakes.OSImage(fakes.OS_IMAGE_AKI_1), fakes.ID_OS_IMAGE_ARI_1: fakes.OSImage(fakes.OS_IMAGE_ARI_1) })) metadata, image_parts, key, iv = image_api._s3_parse_manifest( base.create_context(), AMI_MANIFEST_XML) expected_metadata = { 'disk_format': 'ami', 'container_format': 'ami', 'properties': { 'architecture': 'x86_64', 'kernel_id': fakes.ID_OS_IMAGE_AKI_1, 'ramdisk_id': fakes.ID_OS_IMAGE_ARI_1, 'mappings': [{ "device": "sda1", "virtual": "ami" }, { "device": "/dev/sda1", "virtual": "root" }, { "device": "sda2", "virtual": "ephemeral0" }, { "device": "sda3", "virtual": "swap" }] } } self.assertThat( metadata, matchers.DictMatches(expected_metadata, orderless_lists=True)) self.assertThat(image_parts, matchers.ListMatches(['foo'])) self.assertEqual('foo', key) self.assertEqual('foo', iv) db_api.get_items_ids.assert_any_call( mock.ANY, 'aki', item_ids=(fakes.ID_EC2_IMAGE_AKI_1, ), item_os_ids=None) db_api.get_items_ids.assert_any_call( mock.ANY, 'ari', item_ids=(fakes.ID_EC2_IMAGE_ARI_1, ), item_os_ids=None)
def test_build_proxy_request_headers(self, sign_instance_id): sign_instance_id.return_value = mock.sentinel.signed requester = {'os_instance_id': mock.sentinel.os_instance_id, 'project_id': mock.sentinel.project_id, 'private_ip': mock.sentinel.private_ip} result = self.handler._build_proxy_request_headers(requester) expected = {'X-Forwarded-For': mock.sentinel.private_ip, 'X-Instance-ID': mock.sentinel.os_instance_id, 'X-Tenant-ID': mock.sentinel.project_id, 'X-Instance-ID-Signature': mock.sentinel.signed} self.assertThat(result, matchers.DictMatches(expected))
def check(ec2_fake, db_fake): self.db_api.add_item.return_value = db_fake resp = self.execute('CreateDhcpOptions', gen_ec2_param_dhcp_options(ec2_fake)) self.assertThat( ec2_fake, matchers.DictMatches(resp['dhcpOptions'], orderless_lists=True)) self.assert_any_call(self.db_api.add_item, mock.ANY, 'dopt', tools.purge_dict(db_fake, ('id', ))) self.db_api.reset_mock()
def test_modify_image_attributes(self): self._setup_model() resp = self.execute('ModifyImageAttribute', {'imageId': fakes.ID_EC2_IMAGE_1, 'attribute': 'launchPermission', 'operationType': 'add', 'userGroup.1': 'all'}) self.assertThat(resp, matchers.DictMatches({'return': True})) self.glance.images.update.assert_called_once_with( fakes.ID_OS_IMAGE_1, visibility='public')
def test_get_router_objects(self): self.set_mock_db_items(fakes.DB_IGW_1, fakes.DB_NETWORK_INTERFACE_2) host_routes = route_table._get_router_objects('fake_context', fakes.DB_ROUTE_TABLE_2) self.assertThat( host_routes, matchers.DictMatches({ fakes.ID_EC2_IGW_1: fakes.DB_IGW_1, fakes.ID_EC2_NETWORK_INTERFACE_2: fakes.DB_NETWORK_INTERFACE_2 }))
def test_format_instance_mapping(self): self.instance_api._block_device_strip_dev.return_value = 'vda' retval = api._build_block_device_mappings( 'fake_context', fakes.EC2_INSTANCE_1, fakes.ID_OS_INSTANCE_1) self.assertThat(retval, matchers.DictMatches( {'ami': 'vda', 'root': fakes.ROOT_DEVICE_NAME_INSTANCE_1})) self.instance_api._block_device_strip_dev.assert_called_with( fakes.EC2_INSTANCE_1['rootDeviceName']) self.instance_api._block_device_strip_dev.return_value = 'sdb1' retval = api._build_block_device_mappings( 'fake_context', fakes.EC2_INSTANCE_2, fakes.ID_OS_INSTANCE_2) expected = {'ami': 'sdb1', 'root': fakes.ROOT_DEVICE_NAME_INSTANCE_2} expected.update(fakes.EC2_BDM_METADATA_INSTANCE_2) self.assertThat(retval, matchers.DictMatches(expected)) self.instance_api._block_device_strip_dev.assert_called_with( fakes.EC2_INSTANCE_2['rootDeviceName'])
def test_import_key_pair(self): self.nova.keypairs.create.return_value = (fakes.NovaKeyPair( fakes.OS_KEY_PAIR)) resp = self.execute( 'ImportKeyPair', { 'KeyName': fakes.NAME_KEY_PAIR, 'PublicKeyMaterial': base64.b64encode( fakes.PUBLIC_KEY_KEY_PAIR) }) self.assertThat(tools.purge_dict(fakes.EC2_KEY_PAIR, {'keyMaterial'}), matchers.DictMatches(resp)) self.nova.keypairs.create.assert_called_once_with( fakes.NAME_KEY_PAIR, fakes.PUBLIC_KEY_KEY_PAIR)
def test_format_vpn_connection(self): db_vpn_connection_1 = tools.update_dict(fakes.DB_VPN_CONNECTION_1, {'cidrs': []}) ec2_vpn_connection_1 = tools.patch_dict(fakes.EC2_VPN_CONNECTION_1, { 'routes': [], 'vgwTelemetry': [] }, ('customerGatewayConfiguration', )) formatted = vpn_connection_api._format_vpn_connection( db_vpn_connection_1, {fakes.ID_EC2_CUSTOMER_GATEWAY_1: fakes.DB_CUSTOMER_GATEWAY_1}, {}, {}, {}, {}) formatted.pop('customerGatewayConfiguration') self.assertThat(ec2_vpn_connection_1, matchers.DictMatches(formatted))
def test_modify_image_attributes(self, osimage_update): self._setup_model() resp = self.execute( 'ModifyImageAttribute', { 'imageId': fakes.ID_EC2_IMAGE_1, 'attribute': 'launchPermission', 'operationType': 'add', 'userGroup.1': 'all' }) self.assertThat(resp, matchers.DictMatches({'return': True})) osimage_update.assert_called_once_with(mock.ANY, is_public=True) self.assertEqual(fakes.ID_OS_IMAGE_1, osimage_update.call_args[0][0].id)
def test_deregister_image(self): self._setup_model() # normal flow resp = self.execute('DeregisterImage', {'ImageId': fakes.ID_EC2_IMAGE_1}) self.assertThat(resp, matchers.DictMatches({'return': True})) self.db_api.delete_item.assert_called_once_with( mock.ANY, fakes.ID_EC2_IMAGE_1) self.glance.images.delete.assert_called_once_with(fakes.ID_OS_IMAGE_1) # deregister image which failed on asynchronously creation self.glance.reset_mock() image_id = fakes.random_ec2_id('ami') self.add_mock_db_items({ 'id': image_id, 'os_id': None, 'state': 'failed' }) resp = self.execute('DeregisterImage', {'ImageId': image_id}) self.assertThat(resp, matchers.DictMatches({'return': True})) self.db_api.delete_item.assert_called_with(mock.ANY, image_id) self.assertFalse(self.glance.images.delete.called)
def test_describe_snapshots_auto_remove(self): self.cinder.volume_snapshots.list.return_value = [] self.set_mock_db_items(fakes.DB_SNAPSHOT_1, fakes.DB_VOLUME_2) resp = self.execute('DescribeSnapshots', {}) self.assertThat( resp, matchers.DictMatches({'snapshotSet': []}, orderless_lists=True)) self.db_api.get_items.assert_any_call(mock.ANY, 'vol') self.db_api.get_items.assert_any_call(mock.ANY, 'snap') self.db_api.delete_item.assert_any_call(mock.ANY, fakes.ID_EC2_SNAPSHOT_1)