openstack
/
ec2-api
Code Issues Proposed changes

move to botocore clients technology 

from https://botocore.readthedocs.org/en/latest/client_upgrades.html#client-upgrades

Version 0.104.0 emitted an ImminentRemovalWarning when using the old interface. This warning is now printed to stderr by default. A user can still turn off these warnings via the warnings module.
The develop branch on github will be updated to completely remove the old interface. At this point the client interface will be the only interface available when using the develop branch on github.
A 1.0 alpha version will be released. By default, pip will not pick up any alpha/beta releases.
A 1.0 beta version will be released.
A GA (1.0) version of botocore will be released.

Change-Id: Id6661e3e1e73de018e9b4de7612972654bb27422
This commit is contained in:
Andrey Pavlov 2015-04-23 17:52:58 +03:00 committed by Andrey Pavlov
parent 60cf5a5184
commit 3947354c37
25 changed files with 1393 additions and 2147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

290
ec2api/tests/functional/api/test_addresses.py
View File

@ -15,6 +15,7 @@
import time import time
import botocore.exceptions
from oslo_log import log from oslo_log import log
from ec2api.tests.functional import base from ec2api.tests.functional import base
@ -31,26 +32,22 @@ class AddressTest(base.EC2TestCase):
kwargs = { kwargs = {
'Domain': 'vpc', 'Domain': 'vpc',
} }
resp, data = self.client.AllocateAddress(*[], **kwargs) data = self.client.allocate_address(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
id = data['AllocationId'] id = data['AllocationId']
res_clean = self.addResourceCleanUp(self.client.ReleaseAddress, res_clean = self.addResourceCleanUp(self.client.release_address,
AllocationId=id) AllocationId=id)
self.assertEqual('vpc', data['Domain']) self.assertEqual('vpc', data['Domain'])
resp, data = self.client.ReleaseAddress(AllocationId=id) data = self.client.release_address(AllocationId=id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_create_delete_standard_address(self): def test_create_delete_standard_address(self):
resp, data = self.client.AllocateAddress() data = self.client.allocate_address()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ip = data['PublicIp'] ip = data['PublicIp']
res_clean = self.addResourceCleanUp(self.client.ReleaseAddress, res_clean = self.addResourceCleanUp(self.client.release_address,
PublicIp=ip) PublicIp=ip)
resp, data = self.client.ReleaseAddress(PublicIp=ip) data = self.client.release_address(PublicIp=ip)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
@base.skip_without_vpc() @base.skip_without_vpc()
@ -58,82 +55,76 @@ class AddressTest(base.EC2TestCase):
kwargs = { kwargs = {
'Domain': 'vpc', 'Domain': 'vpc',
} }
resp, data = self.client.AllocateAddress(*[], **kwargs) data = self.client.allocate_address(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ip = data['PublicIp'] ip = data['PublicIp']
id = data['AllocationId'] id = data['AllocationId']
res_clean = self.addResourceCleanUp(self.client.ReleaseAddress, res_clean = self.addResourceCleanUp(self.client.release_address,
AllocationId=id) AllocationId=id)
self.assertEqual('vpc', data['Domain']) self.assertEqual('vpc', data['Domain'])
resp, data = self.client.ReleaseAddress(PublicIp=ip, AllocationId=id) self.assertRaises('InvalidParameterCombination',
self.assertEqual(400, resp.status_code) self.client.release_address,
self.assertEqual('InvalidParameterCombination', data['Error']['Code']) PublicIp=ip, AllocationId=id)
resp, data = self.client.ReleaseAddress(PublicIp=ip) self.assertRaises('InvalidParameterValue',
self.assertEqual(400, resp.status_code) self.client.release_address,
self.assertEqual('InvalidParameterValue', data['Error']['Code']) PublicIp=ip)
resp, data = self.client.ReleaseAddress(AllocationId=id) data = self.client.release_address(AllocationId=id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
if CONF.aws.run_incompatible_tests: if CONF.aws.run_incompatible_tests:
resp, data = self.client.ReleaseAddress(PublicIp=ip) self.assertRaises('AuthFailure',
self.assertEqual(400, resp.status_code) self.client.release_address,
self.assertEqual('AuthFailure', data['Error']['Code']) PublicIp=ip)
resp, data = self.client.ReleaseAddress(AllocationId=id) self.assertRaises('InvalidAllocationID.NotFound',
self.assertEqual(400, resp.status_code) self.client.release_address,
self.assertEqual('InvalidAllocationID.NotFound', data['Error']['Code']) AllocationId=id)
kwargs = { kwargs = {
"AllocationId": 'eipalloc-00000000', "AllocationId": 'eipalloc-00000000',
} }
resp, data = self.client.ReleaseAddress(*[], **kwargs) self.assertRaises('InvalidAllocationID.NotFound',
self.assertEqual(400, resp.status_code) self.client.release_address,
self.assertEqual('InvalidAllocationID.NotFound', data['Error']['Code']) **kwargs)
if CONF.aws.run_incompatible_tests: if CONF.aws.run_incompatible_tests:
resp, data = self.client.ReleaseAddress(PublicIp='ip') self.assertRaises('InvalidParameterValue',
self.assertEqual(400, resp.status_code) self.client.release_address,
self.assertEqual('InvalidParameterValue', data['Error']['Code']) PublicIp='ip')
def test_invalid_create_address(self): def test_invalid_create_address(self):
kwargs = { kwargs = {
'Domain': 'invalid', 'Domain': 'invalid',
} }
resp, data = self.client.AllocateAddress(*[], **kwargs) try:
if resp.status_code == 200: data = self.client.allocate_address(*[], **kwargs)
allocation_id = data.get('AllocationId') allocation_id = data.get('AllocationId')
if allocation_id: if allocation_id:
self.addResourceCleanUp(self.client.ReleaseAddress, self.client.release_address(AllocationId=allocation_id)
AllocationId=allocation_id)
else: else:
public_ip = data.get('PublicIp') public_ip = data.get('PublicIp')
self.addResourceCleanUp(self.client.ReleaseAddress, self.client.release_address(PublicIp=public_ip)
PublicIp=public_ip) except botocore.exceptions.ClientError as e:
self.assertEqual(400, resp.status_code) self.assertEqual('InvalidParameterValue',
self.assertEqual('InvalidParameterValue', data['Error']['Code']) e.response['Error']['Code'])
@base.skip_without_vpc() @base.skip_without_vpc()
def test_describe_vpc_addresses(self): def test_describe_vpc_addresses(self):
resp, data = self.client.DescribeAddresses(*[], **{}) data = self.client.describe_addresses(*[], **{})
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
start_count = len(data['Addresses']) start_count = len(data['Addresses'])
kwargs = { kwargs = {
'Domain': 'vpc', 'Domain': 'vpc',
} }
resp, data = self.client.AllocateAddress(*[], **kwargs) data = self.client.allocate_address(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ip = data['PublicIp'] ip = data['PublicIp']
id = data['AllocationId'] id = data['AllocationId']
res_clean = self.addResourceCleanUp(self.client.ReleaseAddress, res_clean = self.addResourceCleanUp(self.client.release_address,
AllocationId=id) AllocationId=id)
resp, data = self.client.DescribeAddresses(*[], **{}) data = self.client.describe_addresses(*[], **{})
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(start_count + 1, len(data['Addresses'])) self.assertEqual(start_count + 1, len(data['Addresses']))
for address in data['Addresses']: for address in data['Addresses']:
if address['AllocationId'] == id: if address['AllocationId'] == id:
@ -146,74 +137,65 @@ class AddressTest(base.EC2TestCase):
kwargs = { kwargs = {
'PublicIps': [ip], 'PublicIps': [ip],
} }
resp, data = self.client.DescribeAddresses(*[], **kwargs) data = self.client.describe_addresses(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Addresses'])) self.assertEqual(1, len(data['Addresses']))
self.assertEqual(id, data['Addresses'][0]['AllocationId']) self.assertEqual(id, data['Addresses'][0]['AllocationId'])
kwargs = { kwargs = {
'AllocationIds': [id], 'AllocationIds': [id],
} }
resp, data = self.client.DescribeAddresses(*[], **kwargs) data = self.client.describe_addresses(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Addresses'])) self.assertEqual(1, len(data['Addresses']))
self.assertEqual(ip, data['Addresses'][0]['PublicIp']) self.assertEqual(ip, data['Addresses'][0]['PublicIp'])
kwargs = { kwargs = {
'PublicIps': ['invalidIp'], 'PublicIps': ['invalidIp'],
} }
resp, data = self.client.DescribeAddresses(*[], **kwargs) self.assertRaises('InvalidParameterValue',
self.assertEqual(400, resp.status_code) self.client.describe_addresses,
self.assertEqual('InvalidParameterValue', data['Error']['Code']) **kwargs)
kwargs = { kwargs = {
'AllocationIds': ['eipalloc-00000000'], 'AllocationIds': ['eipalloc-00000000'],
} }
resp, data = self.client.DescribeAddresses(*[], **kwargs) self.assertRaises('InvalidAllocationID.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_addresses,
self.assertEqual('InvalidAllocationID.NotFound', data['Error']['Code']) **kwargs)
kwargs = { kwargs = {
'Domain': 'vpc', 'Domain': 'vpc',
} }
resp, data = self.client.AllocateAddress(*[], **kwargs) data = self.client.allocate_address(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
id2 = data['AllocationId'] id2 = data['AllocationId']
res_clean2 = self.addResourceCleanUp(self.client.ReleaseAddress, res_clean2 = self.addResourceCleanUp(self.client.release_address,
AllocationId=id2) AllocationId=id2)
kwargs = { kwargs = {
'PublicIps': [ip], 'PublicIps': [ip],
'AllocationIds': [id2], 'AllocationIds': [id2],
} }
resp, data = self.client.DescribeAddresses(*[], **kwargs) data = self.client.describe_addresses(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(2, len(data['Addresses'])) self.assertEqual(2, len(data['Addresses']))
# NOTE(andrey-mp): wait abit before releasing # NOTE(andrey-mp): wait abit before releasing
time.sleep(3) time.sleep(3)
resp, data = self.client.ReleaseAddress(AllocationId=id) self.client.release_address(AllocationId=id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
resp, data = self.client.ReleaseAddress(AllocationId=id2) self.client.release_address(AllocationId=id2)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean2) self.cancelResourceCleanUp(res_clean2)
def test_describe_standard_addresses(self): def test_describe_standard_addresses(self):
resp, data = self.client.DescribeAddresses(*[], **{}) data = self.client.describe_addresses(*[], **{})
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
start_count = len(data['Addresses']) start_count = len(data['Addresses'])
resp, data = self.client.AllocateAddress(*[], **{}) data = self.client.allocate_address(*[], **{})
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ip = data['PublicIp'] ip = data['PublicIp']
res_clean = self.addResourceCleanUp(self.client.ReleaseAddress, res_clean = self.addResourceCleanUp(self.client.release_address,
PublicIp=ip) PublicIp=ip)
resp, data = self.client.DescribeAddresses(*[], **{}) data = self.client.describe_addresses(*[], **{})
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(start_count + 1, len(data['Addresses'])) self.assertEqual(start_count + 1, len(data['Addresses']))
for address in data['Addresses']: for address in data['Addresses']:
if address['PublicIp'] == ip: if address['PublicIp'] == ip:
@ -225,23 +207,21 @@ class AddressTest(base.EC2TestCase):
kwargs = { kwargs = {
'PublicIps': [ip], 'PublicIps': [ip],
} }
resp, data = self.client.DescribeAddresses(*[], **kwargs) data = self.client.describe_addresses(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Addresses'])) self.assertEqual(1, len(data['Addresses']))
self.assertEqual(ip, data['Addresses'][0]['PublicIp']) self.assertEqual(ip, data['Addresses'][0]['PublicIp'])
kwargs = { kwargs = {
'PublicIps': ['invalidIp'], 'PublicIps': ['invalidIp'],
} }
resp, data = self.client.DescribeAddresses(*[], **kwargs) self.assertRaises('InvalidParameterValue',
self.assertEqual(400, resp.status_code) self.client.describe_addresses,
self.assertEqual('InvalidParameterValue', data['Error']['Code']) PublicIps=['invalidIp'])
# NOTE(andrey-mp): wait abit before releasing # NOTE(andrey-mp): wait abit before releasing
time.sleep(3) time.sleep(3)
resp, data = self.client.ReleaseAddress(PublicIp=ip) self.client.release_address(PublicIp=ip)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
@base.skip_without_vpc() @base.skip_without_vpc()
@ -253,103 +233,86 @@ class AddressTest(base.EC2TestCase):
raise self.skipException('aws image_id does not provided') raise self.skipException('aws image_id does not provided')
base_net = '10.3.0.0' base_net = '10.3.0.0'
resp, data = self.client.CreateVpc(CidrBlock=base_net + '/20') data = self.client.create_vpc(CidrBlock=base_net + '/20')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
clean_vpc = self.addResourceCleanUp(self.client.DeleteVpc, clean_vpc = self.addResourceCleanUp(self.client.delete_vpc,
VpcId=vpc_id) VpcId=vpc_id)
self.get_vpc_waiter().wait_available(vpc_id) self.get_vpc_waiter().wait_available(vpc_id)
cidr = base_net + '/24' cidr = base_net + '/24'
resp, data = self.client.CreateSubnet(VpcId=vpc_id, CidrBlock=cidr, data = self.client.create_subnet(VpcId=vpc_id, CidrBlock=cidr,
AvailabilityZone=aws_zone) AvailabilityZone=aws_zone)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
clean_subnet = self.addResourceCleanUp(self.client.DeleteSubnet, clean_subnet = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1, ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=subnet_id) MaxCount=1, SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.TerminateInstances, clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.AllocateAddress(Domain='vpc') data = self.client.allocate_address(Domain='vpc')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
alloc_id = data['AllocationId'] alloc_id = data['AllocationId']
clean_a = self.addResourceCleanUp(self.client.ReleaseAddress, clean_a = self.addResourceCleanUp(self.client.release_address,
AllocationId=alloc_id) AllocationId=alloc_id)
resp, data = self.client.AssociateAddress(InstanceId=instance_id, self.assertRaises('Gateway.NotAttached',
AllocationId=alloc_id) self.client.associate_address,
self.assertEqual(400, resp.status_code) InstanceId=instance_id, AllocationId=alloc_id)
self.assertEqual('Gateway.NotAttached', data['Error']['Code'])
# Create internet gateway and try to associate again # Create internet gateway and try to associate again
resp, data = self.client.CreateInternetGateway() data = self.client.create_internet_gateway()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
gw_id = data['InternetGateway']['InternetGatewayId'] gw_id = data['InternetGateway']['InternetGatewayId']
clean_ig = self.addResourceCleanUp(self.client.DeleteInternetGateway, clean_ig = self.addResourceCleanUp(self.client.delete_internet_gateway,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
resp, data = self.client.AttachInternetGateway(VpcId=vpc_id, data = self.client.attach_internet_gateway(VpcId=vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) clean_aig = self.addResourceCleanUp(
clean_aig = self.addResourceCleanUp(self.client.DetachInternetGateway, self.client.detach_internet_gateway,
VpcId=vpc_id, VpcId=vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.AssociateAddress(InstanceId=instance_id, data = self.client.associate_address(InstanceId=instance_id,
AllocationId=alloc_id) AllocationId=alloc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
assoc_id = data['AssociationId'] assoc_id = data['AssociationId']
clean_aa = self.addResourceCleanUp(self.client.DisassociateAddress, clean_aa = self.addResourceCleanUp(self.client.disassociate_address,
AssociationId=assoc_id) AssociationId=assoc_id)
resp, data = self.client.DescribeAddresses(*[], **{}) data = self.client.describe_addresses(*[], **{})
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(instance_id, data['Addresses'][0]['InstanceId']) self.assertEqual(instance_id, data['Addresses'][0]['InstanceId'])
resp, data = self.client.DisassociateAddress(AssociationId=assoc_id) data = self.client.disassociate_address(AssociationId=assoc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_aa) self.cancelResourceCleanUp(clean_aa)
resp, data = self.client.DescribeAddresses(*[], **{}) data = self.client.describe_addresses(*[], **{})
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIsNone(data['Addresses'][0].get('InstanceId')) self.assertIsNone(data['Addresses'][0].get('InstanceId'))
# NOTE(andrey-mp): cleanup # NOTE(andrey-mp): cleanup
time.sleep(3) time.sleep(3)
resp, data = self.client.DetachInternetGateway(VpcId=vpc_id, self.client.detach_internet_gateway(VpcId=vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_aig) self.cancelResourceCleanUp(clean_aig)
resp, data = self.client.DeleteInternetGateway(InternetGatewayId=gw_id) self.client.delete_internet_gateway(InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_ig) self.cancelResourceCleanUp(clean_ig)
resp, data = self.client.ReleaseAddress(AllocationId=alloc_id) self.client.release_address(AllocationId=alloc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_a) self.cancelResourceCleanUp(clean_a)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_i) self.cancelResourceCleanUp(clean_i)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_subnet) self.cancelResourceCleanUp(clean_subnet)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
resp, data = self.client.DeleteVpc(VpcId=vpc_id) self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vpc) self.cancelResourceCleanUp(clean_vpc)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
@ -359,51 +322,43 @@ class AddressTest(base.EC2TestCase):
if not image_id: if not image_id:
raise self.skipException('aws image_id does not provided') raise self.skipException('aws image_id does not provided')
resp, data = self.client.RunInstances(ImageId=image_id, data = self.client.run_instances(ImageId=image_id,
InstanceType=instance_type, InstanceType=instance_type,
MinCount=1, MinCount=1,
MaxCount=1) MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.TerminateInstances, clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.AllocateAddress(*[], **{}) data = self.client.allocate_address(*[], **{})
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ip = data['PublicIp'] ip = data['PublicIp']
clean_a = self.addResourceCleanUp(self.client.ReleaseAddress, clean_a = self.addResourceCleanUp(self.client.release_address,
PublicIp=ip) PublicIp=ip)
resp, data = self.client.AssociateAddress(InstanceId=instance_id, data = self.client.associate_address(InstanceId=instance_id,
PublicIp=ip) PublicIp=ip)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) clean_aa = self.addResourceCleanUp(self.client.disassociate_address,
clean_aa = self.addResourceCleanUp(self.client.DisassociateAddress,
PublicIp=ip) PublicIp=ip)
resp, data = self.client.DescribeAddresses(*[], **{}) data = self.client.describe_addresses(*[], **{})
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(instance_id, data['Addresses'][0]['InstanceId']) self.assertEqual(instance_id, data['Addresses'][0]['InstanceId'])
resp, data = self.client.DisassociateAddress(PublicIp=ip) data = self.client.disassociate_address(PublicIp=ip)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_aa) self.cancelResourceCleanUp(clean_aa)
# NOTE(andrey-mp): Amazon needs some time to diassociate # NOTE(andrey-mp): Amazon needs some time to diassociate
time.sleep(2) time.sleep(2)
resp, data = self.client.DescribeAddresses(*[], **{}) data = self.client.describe_addresses(*[], **{})
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIsNone(data['Addresses'][0].get('InstanceId')) self.assertIsNone(data['Addresses'][0].get('InstanceId'))
time.sleep(3) time.sleep(3)
resp, data = self.client.ReleaseAddress(PublicIp=ip) data = self.client.release_address(PublicIp=ip)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_a) self.cancelResourceCleanUp(clean_a)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_i) self.cancelResourceCleanUp(clean_i)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -412,61 +367,52 @@ class AddressTest(base.EC2TestCase):
aws_zone = CONF.aws.aws_zone aws_zone = CONF.aws.aws_zone
base_net = '10.3.0.0' base_net = '10.3.0.0'
resp, data = self.client.CreateVpc(CidrBlock=base_net + '/20') data = self.client.create_vpc(CidrBlock=base_net + '/20')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
clean_vpc = self.addResourceCleanUp(self.client.DeleteVpc, clean_vpc = self.addResourceCleanUp(self.client.delete_vpc,
VpcId=vpc_id) VpcId=vpc_id)
self.get_vpc_waiter().wait_available(vpc_id) self.get_vpc_waiter().wait_available(vpc_id)
cidr = base_net + '/24' cidr = base_net + '/24'
resp, data = self.client.CreateSubnet(VpcId=vpc_id, CidrBlock=cidr, data = self.client.create_subnet(VpcId=vpc_id, CidrBlock=cidr,
AvailabilityZone=aws_zone) AvailabilityZone=aws_zone)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
clean_subnet = self.addResourceCleanUp(self.client.DeleteSubnet, clean_subnet = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
resp, data = self.client.AllocateAddress(Domain='vpc') data = self.client.allocate_address(Domain='vpc')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
alloc_id = data['AllocationId'] alloc_id = data['AllocationId']
ip = data['PublicIp'] ip = data['PublicIp']
clean_a = self.addResourceCleanUp(self.client.ReleaseAddress, clean_a = self.addResourceCleanUp(self.client.release_address,
AllocationId=alloc_id) AllocationId=alloc_id)
assoc_id = 'eipassoc-00000001' assoc_id = 'eipassoc-00000001'
resp, data = self.client.DisassociateAddress(AssociationId=assoc_id) self.assertRaises('InvalidAssociationID.NotFound',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.disassociate_address,
self.assertEqual('InvalidAssociationID.NotFound', AssociationId=assoc_id)
data['Error']['Code'])
resp, data = self.client.DisassociateAddress(PublicIp=ip) self.assertRaises('InvalidParameterValue',
self.assertEqual('InvalidParameterValue', data['Error']['Code']) self.client.disassociate_address,
PublicIp=ip)
resp, data = self.client.ReleaseAddress(AllocationId=alloc_id) self.client.release_address(AllocationId=alloc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_a) self.cancelResourceCleanUp(clean_a)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_subnet) self.cancelResourceCleanUp(clean_subnet)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
resp, data = self.client.DeleteVpc(VpcId=vpc_id) self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vpc) self.cancelResourceCleanUp(clean_vpc)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
def test_disassociate_not_associated_standard_addresses(self): def test_disassociate_not_associated_standard_addresses(self):
resp, data = self.client.AllocateAddress(Domain='standard') data = self.client.allocate_address(Domain='standard')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ip = data['PublicIp'] ip = data['PublicIp']
clean_a = self.addResourceCleanUp(self.client.ReleaseAddress, clean_a = self.addResourceCleanUp(self.client.release_address,
PublicIp=ip) PublicIp=ip)
resp, data = self.client.DisassociateAddress(PublicIp=ip) data = self.client.disassociate_address(PublicIp=ip)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.ReleaseAddress(PublicIp=ip) data = self.client.release_address(PublicIp=ip)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_a) self.cancelResourceCleanUp(clean_a)

73
ec2api/tests/functional/api/test_dhcp_options.py
View File

@ -48,11 +48,10 @@ class DhcpOptionsTest(base.EC2TestCase):
'Values': ['2']}, 'Values': ['2']},
], ],
} }
resp, data = self.client.CreateDhcpOptions(*[], **kwargs) data = self.client.create_dhcp_options(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
options = data['DhcpOptions'] options = data['DhcpOptions']
id = options['DhcpOptionsId'] id = options['DhcpOptionsId']
res_clean = self.addResourceCleanUp(self.client.DeleteDhcpOptions, res_clean = self.addResourceCleanUp(self.client.delete_dhcp_options,
DhcpOptionsId=id) DhcpOptionsId=id)
self.assertEqual(5, len(options['DhcpConfigurations'])) self.assertEqual(5, len(options['DhcpConfigurations']))
for cfg in options['DhcpConfigurations']: for cfg in options['DhcpConfigurations']:
@ -79,38 +78,35 @@ class DhcpOptionsTest(base.EC2TestCase):
else: else:
self.fail('Unknown key name in result - %s' % cfg['Key']) self.fail('Unknown key name in result - %s' % cfg['Key'])
resp, data = self.client.DeleteDhcpOptions(DhcpOptionsId=id) data = self.client.delete_dhcp_options(DhcpOptionsId=id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_invalid_create_delete(self): def test_invalid_create_delete(self):
def _rollback(fn_data):
self.client.delete_dhcp_options(
DhcpOptionsId=fn_data['DhcpOptions']['DhcpOptionsId'])
kwargs = { kwargs = {
'DhcpConfigurations': [ 'DhcpConfigurations': [
], ],
} }
resp, data = self.client.CreateDhcpOptions(*[], **kwargs) self.assertRaises('MissingParameter',
self.assertEqual(400, resp.status_code) self.client.create_dhcp_options,
self.assertEqual('MissingParameter', data['Error']['Code']) **kwargs)
kwargs = { kwargs = {
'DhcpConfigurations': [{'Key': 'aaa', 'Values': []}], 'DhcpConfigurations': [{'Key': 'aaa', 'Values': []}],
} }
resp, data = self.client.CreateDhcpOptions(*[], **kwargs) self.assertRaises('InvalidParameterValue',
if resp.status_code == 200: self.client.create_dhcp_options, rollback_fn=_rollback,
self.addResourceCleanUp(self.client.DeleteDhcpOptions, **kwargs)
DhcpOptionsId=data['DhcpOptions']['DhcpOptionsId'])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
kwargs = { kwargs = {
'DhcpConfigurations': [{'Key': 'domain-name', 'Values': []}], 'DhcpConfigurations': [{'Key': 'domain-name', 'Values': []}],
} }
resp, data = self.client.CreateDhcpOptions(*[], **kwargs) self.assertRaises('InvalidParameterValue',
if resp.status_code == 200: self.client.create_dhcp_options, rollback_fn=_rollback,
self.addResourceCleanUp(self.client.DeleteDhcpOptions, **kwargs)
DhcpOptionsId=data['DhcpOptions']['DhcpOptionsId'])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
def test_describe_dhcp_options(self): def test_describe_dhcp_options(self):
kwargs = { kwargs = {
@ -119,11 +115,10 @@ class DhcpOptionsTest(base.EC2TestCase):
'Values': ['my.com']}, 'Values': ['my.com']},
], ],
} }
resp, data = self.client.CreateDhcpOptions(*[], **kwargs) data = self.client.create_dhcp_options(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
options = data['DhcpOptions'] options = data['DhcpOptions']
id = options['DhcpOptionsId'] id = options['DhcpOptionsId']
res_clean = self.addResourceCleanUp(self.client.DeleteDhcpOptions, res_clean = self.addResourceCleanUp(self.client.delete_dhcp_options,
DhcpOptionsId=id) DhcpOptionsId=id)
time.sleep(10) time.sleep(10)
@ -131,8 +126,7 @@ class DhcpOptionsTest(base.EC2TestCase):
kwargs = { kwargs = {
'DhcpOptionsIds': [id], 'DhcpOptionsIds': [id],
} }
resp, data = self.client.DescribeDhcpOptions(*[], **kwargs) data = self.client.describe_dhcp_options(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['DhcpOptions'])) self.assertEqual(1, len(data['DhcpOptions']))
options = data['DhcpOptions'][0] options = data['DhcpOptions'][0]
self.assertEqual(id, options['DhcpOptionsId']) self.assertEqual(id, options['DhcpOptionsId'])
@ -143,8 +137,7 @@ class DhcpOptionsTest(base.EC2TestCase):
self.assertEqual(1, len(cfg['Values'])) self.assertEqual(1, len(cfg['Values']))
self.assertIn('my.com', cfg['Values'][0]['Value']) self.assertIn('my.com', cfg['Values'][0]['Value'])
resp, data = self.client.DeleteDhcpOptions(DhcpOptionsId=id) data = self.client.delete_dhcp_options(DhcpOptionsId=id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_associate_dhcp_options(self): def test_associate_dhcp_options(self):
@ -154,35 +147,31 @@ class DhcpOptionsTest(base.EC2TestCase):
'Values': ['my.com']}, 'Values': ['my.com']},
], ],
} }
resp, data = self.client.CreateDhcpOptions(*[], **kwargs) data = self.client.create_dhcp_options(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
options = data['DhcpOptions'] options = data['DhcpOptions']
id = options['DhcpOptionsId'] id = options['DhcpOptionsId']
res_clean = self.addResourceCleanUp(self.client.DeleteDhcpOptions, res_clean = self.addResourceCleanUp(self.client.delete_dhcp_options,
DhcpOptionsId=id) DhcpOptionsId=id)
cidr = '10.0.0.0/24' cidr = '10.0.0.0/24'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(self.client.delete_vpc,
VpcId=vpc_id)
kwargs = { kwargs = {
'DhcpOptionsId': id, 'DhcpOptionsId': id,
'VpcId': vpc_id, 'VpcId': vpc_id,
} }
resp, data = self.client.AssociateDhcpOptions(*[], **kwargs) data = self.client.associate_dhcp_options(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DeleteDhcpOptions(DhcpOptionsId=id) self.assertRaises('DependencyViolation',
self.assertEqual(400, resp.status_code) self.client.delete_dhcp_options,
self.assertEqual('DependencyViolation', data['Error']['Code']) DhcpOptionsId=id)
resp, data = self.client.DeleteVpc(VpcId=vpc_id) data = self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
resp, data = self.client.DeleteDhcpOptions(DhcpOptionsId=id) data = self.client.delete_dhcp_options(DhcpOptionsId=id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)

217
ec2api/tests/functional/api/test_images.py
View File

@ -13,6 +13,7 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import botocore.exceptions
from tempest_lib.common.utils import data_utils from tempest_lib.common.utils import data_utils
import testtools import testtools
@ -27,8 +28,7 @@ class ImageTest(base.EC2TestCase):
@testtools.skipUnless(CONF.aws.ebs_image_id, "EBS image id is not defined") @testtools.skipUnless(CONF.aws.ebs_image_id, "EBS image id is not defined")
def test_check_ebs_image_type(self): def test_check_ebs_image_type(self):
image_id = CONF.aws.ebs_image_id image_id = CONF.aws.ebs_image_id
resp, data = self.client.DescribeImages(ImageIds=[image_id]) data = self.client.describe_images(ImageIds=[image_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Images'])) self.assertEqual(1, len(data['Images']))
image = data['Images'][0] image = data['Images'][0]
self.assertEqual("ebs", image['RootDeviceType'], self.assertEqual("ebs", image['RootDeviceType'],
@ -37,8 +37,7 @@ class ImageTest(base.EC2TestCase):
@testtools.skipUnless(CONF.aws.ebs_image_id, "EBS image id is not defined") @testtools.skipUnless(CONF.aws.ebs_image_id, "EBS image id is not defined")
def test_check_ebs_image_volume_properties(self): def test_check_ebs_image_volume_properties(self):
image_id = CONF.aws.ebs_image_id image_id = CONF.aws.ebs_image_id
resp, data = self.client.DescribeImages(ImageIds=[image_id]) data = self.client.describe_images(ImageIds=[image_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Images'])) self.assertEqual(1, len(data['Images']))
image = data['Images'][0] image = data['Images'][0]
self.assertTrue(image['RootDeviceName']) self.assertTrue(image['RootDeviceName'])
@ -61,19 +60,16 @@ class ImageTest(base.EC2TestCase):
@testtools.skipUnless(CONF.aws.ebs_image_id, "EBS image id is not defined") @testtools.skipUnless(CONF.aws.ebs_image_id, "EBS image id is not defined")
def test_describe_image_with_filters(self): def test_describe_image_with_filters(self):
image_id = CONF.aws.ebs_image_id image_id = CONF.aws.ebs_image_id
resp, data = self.client.DescribeImages(ImageIds=[image_id]) data = self.client.describe_images(ImageIds=[image_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Images'])) self.assertEqual(1, len(data['Images']))
resp, data = self.client.DescribeImages( data = self.client.describe_images(
# NOTE(ft): limit output to prevent timeout over AWS # NOTE(ft): limit output to prevent timeout over AWS
Filters=[{'Name': 'image-type', 'Values': ['kernel', 'ramdisk']}]) Filters=[{'Name': 'image-type', 'Values': ['kernel', 'ramdisk']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
if len(data['Images']) < 2: if len(data['Images']) < 2:
self.skipTest("Insufficient images to check filters") self.skipTest("Insufficient images to check filters")
resp, data = self.client.DescribeImages( data = self.client.describe_images(
Filters=[{'Name': 'image-id', 'Values': [image_id]}]) Filters=[{'Name': 'image-id', 'Values': [image_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Images'])) self.assertEqual(1, len(data['Images']))
self.assertEqual(image_id, data['Images'][0]['ImageId']) self.assertEqual(image_id, data['Images'][0]['ImageId'])
@ -81,146 +77,126 @@ class ImageTest(base.EC2TestCase):
# NOTE(andrey-mp): image_id is a public image created by admin # NOTE(andrey-mp): image_id is a public image created by admin
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.DescribeImageAttribute( self.assertRaises('InvalidRequest',
ImageId=CONF.aws.image_id, Attribute='unsupported') self.client.describe_image_attribute,
self.assertEqual(400, resp.status_code) ImageId=image_id, Attribute='unsupported')
self.assertEqual('InvalidRequest', data['Error']['Code'])
resp, data = self.client.DescribeImageAttribute( self.assertRaises('AuthFailure',
ImageId=CONF.aws.image_id, Attribute='description') self.client.describe_image_attribute,
self.assertEqual(400, resp.status_code)
self.assertEqual('AuthFailure', data['Error']['Code'])
resp, data = self.client.ModifyImageAttribute(
ImageId=CONF.aws.image_id, Attribute='unsupported')
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterCombination', data['Error']['Code'])
resp, data = self.client.ModifyImageAttribute(
ImageId=CONF.aws.image_id, Attribute='blockDeviceMapping')
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameter', data['Error']['Code'])
resp, data = self.client.ModifyImageAttribute(
ImageId=CONF.aws.image_id)
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterCombination', data['Error']['Code'])
resp, data = self.client.ModifyImageAttribute(
ImageId=image_id, Description={'Value': 'fake'})
self.assertEqual(400, resp.status_code)
self.assertEqual('AuthFailure', data['Error']['Code'])
resp, data = self.client.ModifyImageAttribute(
ImageId=image_id, LaunchPermission={'Add': [{'Group': 'all'}]})
self.assertEqual(400, resp.status_code)
self.assertEqual('AuthFailure', data['Error']['Code'])
resp, data = self.client.ModifyImageAttribute(
ImageId=image_id, Attribute='description') ImageId=image_id, Attribute='description')
self.assertEqual(400, resp.status_code)
self.assertEqual('MissingParameter', data['Error']['Code'])
resp, data = self.client.ModifyImageAttribute( self.assertRaises('InvalidParameterCombination',
self.client.modify_image_attribute,
ImageId=image_id, Attribute='unsupported')
self.assertRaises('InvalidParameter',
self.client.modify_image_attribute,
ImageId=image_id, Attribute='blockDeviceMapping')
self.assertRaises('InvalidParameterCombination',
self.client.modify_image_attribute,
ImageId=image_id)
self.assertRaises('AuthFailure',
self.client.modify_image_attribute,
ImageId=image_id, Description={'Value': 'fake'})
self.assertRaises('AuthFailure',
self.client.modify_image_attribute,
ImageId=image_id, LaunchPermission={'Add': [{'Group': 'all'}]})
self.assertRaises('MissingParameter',
self.client.modify_image_attribute,
ImageId=image_id, Attribute='description')
self.assertRaises('InvalidParameterCombination',
self.client.modify_image_attribute,
ImageId=image_id, Attribute='launchPermission') ImageId=image_id, Attribute='launchPermission')
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterCombination', data['Error']['Code'])
resp, data = self.client.ResetImageAttribute( self.assertRaises('InvalidRequest',
self.client.reset_image_attribute,
ImageId=image_id, Attribute='fake') ImageId=image_id, Attribute='fake')
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidRequest', data['Error']['Code'])
resp, data = self.client.ResetImageAttribute( self.assertRaises('AuthFailure',
self.client.reset_image_attribute,
ImageId=image_id, Attribute='launchPermission') ImageId=image_id, Attribute='launchPermission')
self.assertEqual(400, resp.status_code)
self.assertEqual('AuthFailure', data['Error']['Code'])
resp, data = self.client.DeregisterImage(ImageId=image_id) self.assertRaises('AuthFailure',
self.assertEqual(400, resp.status_code) self.client.deregister_image,
self.assertEqual('AuthFailure', data['Error']['Code']) ImageId=image_id)
@testtools.skipUnless(CONF.aws.image_id, 'image id is not defined') @testtools.skipUnless(CONF.aws.image_id, 'image id is not defined')
def test_create_image_from_non_ebs_instance(self): def test_create_image_from_non_ebs_instance(self):
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.DescribeImages(ImageIds=[image_id]) data = self.client.describe_images(ImageIds=[image_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
image = data['Images'][0] image = data['Images'][0]
if 'RootDeviceType' in image and 'ebs' in image['RootDeviceType']: if 'RootDeviceType' in image and 'ebs' in image['RootDeviceType']:
raise self.skipException('image_id should not be EBS image.') raise self.skipException('image_id should not be EBS image.')
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=CONF.aws.instance_type, ImageId=image_id, InstanceType=CONF.aws.instance_type,
Placement={'AvailabilityZone': CONF.aws.aws_zone}, Placement={'AvailabilityZone': CONF.aws.aws_zone},
MinCount=1, MaxCount=1) MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Instances'])) self.assertEqual(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.CreateImage(InstanceId=instance_id, def _rollback(fn_data):
Name='name', Description='desc') self.client.deregister_image(ImageId=fn_data['ImageId'])
if resp.status_code == 200:
image_id = data['ImageId']
self.addResourceCleanUp(self.client.DeregisterImage,
ImageId=image_id)
self.get_image_waiter().wait_available(image_id)
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.assertRaises('InvalidParameterValue',
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.client.create_image, rollback_fn=_rollback,
InstanceId=instance_id, Name='name', Description='desc')
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
def _create_image(self, name, desc): def _create_image(self, name, desc):
image_id = CONF.aws.ebs_image_id image_id = CONF.aws.ebs_image_id
resp, data = self.client.DescribeImages(ImageIds=[image_id]) data = self.client.describe_images(ImageIds=[image_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
image = data['Images'][0] image = data['Images'][0]
self.assertTrue('RootDeviceType' in image self.assertTrue('RootDeviceType' in image
and 'ebs' in image['RootDeviceType']) and 'ebs' in image['RootDeviceType'])
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=CONF.aws.instance_type, ImageId=image_id, InstanceType=CONF.aws.instance_type,
Placement={'AvailabilityZone': CONF.aws.aws_zone}, Placement={'AvailabilityZone': CONF.aws.aws_zone},
MinCount=1, MaxCount=1) MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Instances'])) self.assertEqual(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.CreateImage(InstanceId=instance_id, data = self.client.create_image(InstanceId=instance_id,
Name=name, Description=desc) Name=name, Description=desc)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
image_id = data['ImageId'] image_id = data['ImageId']
image_clean = self.addResourceCleanUp(self.client.DeregisterImage, image_clean = self.addResourceCleanUp(self.client.deregister_image,
ImageId=image_id) ImageId=image_id)
self.get_image_waiter().wait_available(image_id) self.get_image_waiter().wait_available(image_id)
resp, data = self.client.DescribeImages(ImageIds=[image_id]) data = self.client.describe_images(ImageIds=[image_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
for bdm in data['Images'][0].get('BlockDeviceMappings', []): for bdm in data['Images'][0].get('BlockDeviceMappings', []):
if 'Ebs' in bdm and 'SnapshotId' in bdm['Ebs']: if 'Ebs' in bdm and 'SnapshotId' in bdm['Ebs']:
snapshot_id = bdm['Ebs']['SnapshotId'] snapshot_id = bdm['Ebs']['SnapshotId']
kwargs = {'SnapshotIds': [snapshot_id]} kwargs = {'SnapshotIds': [snapshot_id]}
resp, data = self.client.DescribeSnapshots(**kwargs) try:
if resp.status_code == 200: data = self.client.describe_snapshots(**kwargs)
volume_id = data['Snapshots'][0].get('VolumeId') volume_id = data['Snapshots'][0].get('VolumeId')
if volume_id: if volume_id:
self.addResourceCleanUp(self.client.DeleteVolume, self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.addResourceCleanUp(self.client.DeleteSnapshot, except botocore.exceptions.ClientError:
pass
self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -234,9 +210,7 @@ class ImageTest(base.EC2TestCase):
desc = data_utils.rand_name('') desc = data_utils.rand_name('')
image_id, image_clean = self._create_image(name, desc) image_id, image_clean = self._create_image(name, desc)
resp, data = self.client.DescribeImages(ImageIds=[image_id]) data = self.client.describe_images(ImageIds=[image_id])
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Images'])) self.assertEqual(1, len(data['Images']))
image = data['Images'][0] image = data['Images'][0]
@ -249,8 +223,7 @@ class ImageTest(base.EC2TestCase):
for bdm in image['BlockDeviceMappings']: for bdm in image['BlockDeviceMappings']:
self.assertIn('DeviceName', bdm) self.assertIn('DeviceName', bdm)
resp, data = self.client.DeregisterImage(ImageId=image_id) data = self.client.deregister_image(ImageId=image_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(image_clean) self.cancelResourceCleanUp(image_clean)
@testtools.skipUnless(CONF.aws.run_incompatible_tests, @testtools.skipUnless(CONF.aws.run_incompatible_tests,
@ -261,41 +234,32 @@ class ImageTest(base.EC2TestCase):
desc = data_utils.rand_name('desc for image') desc = data_utils.rand_name('desc for image')
image_id, image_clean = self._create_image(name, desc) image_id, image_clean = self._create_image(name, desc)
resp, data = self.client.DescribeImageAttribute( data = self.client.describe_image_attribute(
ImageId=image_id, Attribute='kernel') ImageId=image_id, Attribute='kernel')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('KernelId', data) self.assertIn('KernelId', data)
resp, data = self.client.DescribeImageAttribute( data = self.client.describe_image_attribute(
ImageId=image_id, Attribute='ramdisk') ImageId=image_id, Attribute='ramdisk')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('RamdiskId', data) self.assertIn('RamdiskId', data)
# description # description
resp, data = self.client.DescribeImageAttribute( data = self.client.describe_image_attribute(
ImageId=image_id, Attribute='description') ImageId=image_id, Attribute='description')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('Description', data) self.assertIn('Description', data)
self.assertIn('Value', data['Description']) self.assertIn('Value', data['Description'])
self.assertEqual(desc, data['Description']['Value']) self.assertEqual(desc, data['Description']['Value'])
def _modify_description(**kwargs): def _modify_description(**kwargs):
resp, data = self.client.ModifyImageAttribute( self.client.modify_image_attribute(ImageId=image_id, **kwargs)
ImageId=image_id, **kwargs) data = self.client.describe_image_attribute(
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
resp, data = self.client.DescribeImageAttribute(
ImageId=image_id, Attribute='description') ImageId=image_id, Attribute='description')
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(new_desc, data['Description']['Value']) self.assertEqual(new_desc, data['Description']['Value'])
new_desc = data_utils.rand_name('new desc') new_desc = data_utils.rand_name('new desc')
_modify_description(Attribute='description', Value=new_desc) _modify_description(Attribute='description', Value=new_desc)
_modify_description(Description={'Value': new_desc}) _modify_description(Description={'Value': new_desc})
resp, data = self.client.DeregisterImage(ImageId=image_id) data = self.client.deregister_image(ImageId=image_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(image_clean) self.cancelResourceCleanUp(image_clean)
@testtools.skipUnless(CONF.aws.run_incompatible_tests, @testtools.skipUnless(CONF.aws.run_incompatible_tests,
@ -309,48 +273,33 @@ class ImageTest(base.EC2TestCase):
image_id, image_clean = self._create_image(name, desc) image_id, image_clean = self._create_image(name, desc)
# launch permission # launch permission
resp, data = self.client.DescribeImageAttribute( data = self.client.describe_image_attribute(
ImageId=image_id, Attribute='launchPermission') ImageId=image_id, Attribute='launchPermission')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('LaunchPermissions', data) self.assertIn('LaunchPermissions', data)
self.assertEmpty(data['LaunchPermissions']) self.assertEmpty(data['LaunchPermissions'])
def _modify_launch_permission(**kwargs): def _modify_launch_permission(**kwargs):
resp, data = self.client.ModifyImageAttribute( self.client.modify_image_attribute(ImageId=image_id, **kwargs)
ImageId=image_id, **kwargs) data = self.client.describe_image_attribute(
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
resp, data = self.client.DescribeImageAttribute(
ImageId=image_id, Attribute='launchPermission') ImageId=image_id, Attribute='launchPermission')
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertIn('LaunchPermissions', data) self.assertIn('LaunchPermissions', data)
self.assertNotEmpty(data['LaunchPermissions']) self.assertNotEmpty(data['LaunchPermissions'])
self.assertIn('Group', data['LaunchPermissions'][0]) self.assertIn('Group', data['LaunchPermissions'][0])
self.assertEqual('all', data['LaunchPermissions'][0]['Group']) self.assertEqual('all', data['LaunchPermissions'][0]['Group'])
resp, data = self.client.DescribeImages(ImageIds=[image_id]) data = self.client.describe_images(ImageIds=[image_id])
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertTrue(data['Images'][0]['Public']) self.assertTrue(data['Images'][0]['Public'])
resp, data = self.client.ResetImageAttribute( self.client.reset_image_attribute(
ImageId=image_id, Attribute='launchPermission') ImageId=image_id, Attribute='launchPermission')
self.assertEqual(200, resp.status_code, data = self.client.describe_image_attribute(
base.EC2ErrorConverter(data))
resp, data = self.client.DescribeImageAttribute(
ImageId=image_id, Attribute='launchPermission') ImageId=image_id, Attribute='launchPermission')
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEmpty(data['LaunchPermissions']) self.assertEmpty(data['LaunchPermissions'])
resp, data = self.client.DescribeImages(ImageIds=[image_id]) data = self.client.describe_images(ImageIds=[image_id])
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertFalse(data['Images'][0]['Public']) self.assertFalse(data['Images'][0]['Public'])
_modify_launch_permission(Attribute='launchPermission', _modify_launch_permission(Attribute='launchPermission',
OperationType='add', UserGroups=['all']) OperationType='add', UserGroups=['all'])
_modify_launch_permission(LaunchPermission={'Add': [{'Group': 'all'}]}) _modify_launch_permission(LaunchPermission={'Add': [{'Group': 'all'}]})
resp, data = self.client.DeregisterImage(ImageId=image_id) data = self.client.deregister_image(ImageId=image_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(image_clean) self.cancelResourceCleanUp(image_clean)

129
ec2api/tests/functional/api/test_instances.py
View File

@ -37,26 +37,23 @@ class InstanceTest(base.EC2TestCase):
def test_create_delete_instance(self): def test_create_delete_instance(self):
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.assertEqual(1, len(data['Instances'])) self.assertEqual(1, len(data['Instances']))
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.DescribeInstances(InstanceIds=[instance_id]) data = self.client.describe_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
reservations = data.get('Reservations', []) reservations = data.get('Reservations', [])
self.assertNotEmpty(reservations) self.assertNotEmpty(reservations)
instances = reservations[0].get('Instances', []) instances = reservations[0].get('Instances', [])
self.assertEqual(1, len(instances)) self.assertEqual(1, len(instances))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -68,89 +65,79 @@ class InstanceTest(base.EC2TestCase):
client_token = data_utils.rand_name('t') client_token = data_utils.rand_name('t')
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1, Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1,
ClientToken=client_token) ClientToken=client_token)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.assertEqual(1, len(data['Instances'])) self.assertEqual(1, len(data['Instances']))
reservation_id = data['ReservationId'] reservation_id = data['ReservationId']
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1, Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1,
ClientToken=client_token) ClientToken=client_token)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
# NOTE(andrey-mp): if idempotent run will fail this will terminate # NOTE(andrey-mp): if idempotent run will fail this will terminate
# second instance # second instance
self.addResourceCleanUp(self.client.TerminateInstances, self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[data['Instances'][0]['InstanceId']]) InstanceIds=[data['Instances'][0]['InstanceId']])
self.assertEqual(1, len(data['Instances'])) self.assertEqual(1, len(data['Instances']))
self.assertEqual(reservation_id, data['ReservationId']) self.assertEqual(reservation_id, data['ReservationId'])
self.assertEqual(instance_id, data['Instances'][0]['InstanceId']) self.assertEqual(instance_id, data['Instances'][0]['InstanceId'])
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
def test_describe_instances_filter(self): def test_describe_instances_filter(self):
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
# NOTE(andrey-mp): by real id # NOTE(andrey-mp): by real id
resp, data = self.client.DescribeInstances(InstanceIds=[instance_id]) data = self.client.describe_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self._assert_instance(data, instance_id) self._assert_instance(data, instance_id)
instances = data['Reservations'][0]['Instances'] instances = data['Reservations'][0]['Instances']
private_dns = instances[0]['PrivateDnsName'] private_dns = instances[0]['PrivateDnsName']
private_ip = instances[0]['PrivateIpAddress'] private_ip = instances[0]['PrivateIpAddress']
# NOTE(andrey-mp): by fake id # NOTE(andrey-mp): by fake id
resp, data = self.client.DescribeInstances(InstanceIds=['i-0']) self.assertRaises('InvalidInstanceID.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_instances,
self.assertEqual('InvalidInstanceID.NotFound', data['Error']['Code']) InstanceIds=['i-0'])
# NOTE(andrey-mp): by private ip # NOTE(andrey-mp): by private ip
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'private-ip-address', 'Values': ['1.2.3.4']}]) Filters=[{'Name': 'private-ip-address', 'Values': ['1.2.3.4']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['Reservations'])) self.assertEqual(0, len(data['Reservations']))
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'private-ip-address', 'Values': [private_ip]}]) Filters=[{'Name': 'private-ip-address', 'Values': [private_ip]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self._assert_instance(data, instance_id) self._assert_instance(data, instance_id)
# NOTE(andrey-mp): by private dns # NOTE(andrey-mp): by private dns
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'private-dns-name', 'Values': ['fake.com']}]) Filters=[{'Name': 'private-dns-name', 'Values': ['fake.com']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['Reservations'])) self.assertEqual(0, len(data['Reservations']))
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'private-dns-name', 'Values': [private_dns]}]) Filters=[{'Name': 'private-dns-name', 'Values': [private_dns]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self._assert_instance(data, instance_id) self._assert_instance(data, instance_id)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -164,51 +151,45 @@ class InstanceTest(base.EC2TestCase):
def test_get_password_data_and_console_output(self): def test_get_password_data_and_console_output(self):
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.GetPasswordData(InstanceId=instance_id) data = self.client.get_password_data(InstanceId=instance_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(instance_id, data['InstanceId']) self.assertEqual(instance_id, data['InstanceId'])
self.assertIsNotNone(data['Timestamp']) self.assertIsNotNone(data['Timestamp'])
self.assertIn('PasswordData', data) self.assertIn('PasswordData', data)
waiter = base.EC2Waiter(self.client.GetConsoleOutput) waiter = base.EC2Waiter(self.client.get_console_output)
waiter.wait_no_exception(InstanceId=instance_id) waiter.wait_no_exception(InstanceId=instance_id)
resp, data = self.client.GetConsoleOutput(InstanceId=instance_id) data = self.client.get_console_output(InstanceId=instance_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(instance_id, data['InstanceId']) self.assertEqual(instance_id, data['InstanceId'])
self.assertIsNotNone(data['Timestamp']) self.assertIsNotNone(data['Timestamp'])
self.assertIn('Output', data) self.assertIn('Output', data)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
def test_stop_instance(self): def test_stop_instance(self):
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.StopInstances(InstanceIds=[instance_id]) data = self.client.stop_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
if CONF.aws.run_incompatible_tests: if CONF.aws.run_incompatible_tests:
instances = data['StoppingInstances'] instances = data['StoppingInstances']
self.assertEqual(1, len(instances)) self.assertEqual(1, len(instances))
@ -220,8 +201,7 @@ class InstanceTest(base.EC2TestCase):
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('stopped')) final_set=('stopped'))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -231,13 +211,12 @@ class InstanceTest(base.EC2TestCase):
"""Is public IP assigned to launched instnace?""" """Is public IP assigned to launched instnace?"""
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Instances'])) self.assertEqual(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -248,46 +227,40 @@ class InstanceTest(base.EC2TestCase):
self.assertNotEqual(instance.get('PublicIpAddress'), self.assertNotEqual(instance.get('PublicIpAddress'),
instance.get('PrivateIpAddress')) instance.get('PrivateIpAddress'))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
def test_describe_instance_attributes(self): def test_describe_instance_attributes(self):
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.assertEqual(1, len(data['Instances'])) self.assertEqual(1, len(data['Instances']))
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
if CONF.aws.run_incompatible_tests: if CONF.aws.run_incompatible_tests:
resp, data = self.client.DescribeInstanceAttribute( data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='blockDeviceMapping') InstanceId=instance_id, Attribute='blockDeviceMapping')
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
bdms = data.get('BlockDeviceMappings', []) bdms = data.get('BlockDeviceMappings', [])
self.assertNotEmpty(bdms) self.assertNotEmpty(bdms)
self.assertEqual(1, len(bdms)) self.assertEqual(1, len(bdms))
self.assertIn('DeviceName', bdms[0]) self.assertIn('DeviceName', bdms[0])
self.assertIn('Ebs', bdms[0]) self.assertIn('Ebs', bdms[0])
resp, data = self.client.DescribeInstanceAttribute( data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='disableApiTermination') InstanceId=instance_id, Attribute='disableApiTermination')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('DisableApiTermination', data) self.assertIn('DisableApiTermination', data)
self.assertIn('Value', data['DisableApiTermination']) self.assertIn('Value', data['DisableApiTermination'])
self.assertFalse(data['DisableApiTermination']['Value']) self.assertFalse(data['DisableApiTermination']['Value'])
resp, data = self.client.DescribeInstanceAttribute( data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='groupSet') InstanceId=instance_id, Attribute='groupSet')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('Groups', data) self.assertIn('Groups', data)
self.assertNotEmpty(data['Groups'], data) self.assertNotEmpty(data['Groups'], data)
self.assertTrue('GroupId' in data['Groups'][0] self.assertTrue('GroupId' in data['Groups'][0]
@ -295,32 +268,27 @@ class InstanceTest(base.EC2TestCase):
self.assertTrue(data['Groups'][0].get('GroupId') self.assertTrue(data['Groups'][0].get('GroupId')
or data['Groups'][0].get('GroupName')) or data['Groups'][0].get('GroupName'))
resp, data = self.client.DescribeInstanceAttribute( data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='instanceType') InstanceId=instance_id, Attribute='instanceType')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('InstanceType', data) self.assertIn('InstanceType', data)
self.assertIn('Value', data['InstanceType']) self.assertIn('Value', data['InstanceType'])
self.assertEqual(instance_type, data['InstanceType']['Value']) self.assertEqual(instance_type, data['InstanceType']['Value'])
resp, data = self.client.DescribeInstanceAttribute( data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='kernel') InstanceId=instance_id, Attribute='kernel')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('KernelId', data) self.assertIn('KernelId', data)
resp, data = self.client.DescribeInstanceAttribute( data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='ramdisk') InstanceId=instance_id, Attribute='ramdisk')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('RamdiskId', data) self.assertIn('RamdiskId', data)
resp, data = self.client.DescribeInstanceAttribute( data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='rootDeviceName') InstanceId=instance_id, Attribute='rootDeviceName')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('RootDeviceName', data) self.assertIn('RootDeviceName', data)
self.assertIn('Value', data['RootDeviceName']) self.assertIn('Value', data['RootDeviceName'])
self.assertTrue(data['RootDeviceName']['Value']) self.assertTrue(data['RootDeviceName']['Value'])
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -331,14 +299,13 @@ class InstanceTest(base.EC2TestCase):
"""Launch instance with creating blank volume.""" """Launch instance with creating blank volume."""
device_name = '/dev/xvdh' device_name = '/dev/xvdh'
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=CONF.aws.image_id, InstanceType=instance_type, ImageId=CONF.aws.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1, Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1,
BlockDeviceMappings=[{'DeviceName': device_name, BlockDeviceMappings=[{'DeviceName': device_name,
'Ebs': {'VolumeSize': 1}}]) 'Ebs': {'VolumeSize': 1}}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -349,13 +316,11 @@ class InstanceTest(base.EC2TestCase):
self.assertIsNotNone(volume_id) self.assertIsNotNone(volume_id)
self.assertTrue(bdt['Ebs']['DeleteOnTermination']) self.assertTrue(bdt['Ebs']['DeleteOnTermination'])
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
volume = data['Volumes'][0] volume = data['Volumes'][0]
self.assertEqual(1, volume['Size']) self.assertEqual(1, volume['Size'])
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)

33
ec2api/tests/functional/api/test_instances_ebs.py
View File

@ -34,13 +34,12 @@ class InstanceWithEBSTest(base.EC2TestCase):
def test_create_get_delete_ebs_instance(self): def test_create_get_delete_ebs_instance(self):
"""Launch EBS-backed instance, check results, and terminate it.""" """Launch EBS-backed instance, check results, and terminate it."""
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=self.image_id, InstanceType=CONF.aws.instance_type, ImageId=self.image_id, InstanceType=CONF.aws.instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Instances'])) self.assertEqual(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -63,24 +62,21 @@ class InstanceWithEBSTest(base.EC2TestCase):
self.assertTrue(ebs.get('AttachTime')) self.assertTrue(ebs.get('AttachTime'))
self.assertTrue(ebs.get('DeleteOnTermination')) self.assertTrue(ebs.get('DeleteOnTermination'))
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
def test_create_root_volume_snapshot(self): def test_create_root_volume_snapshot(self):
"""Create snapshot of root volume of EBS-backed instance.""" """Create snapshot of root volume of EBS-backed instance."""
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=self.image_id, InstanceType=CONF.aws.instance_type, ImageId=self.image_id, InstanceType=CONF.aws.instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Instances'])) self.assertEqual(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -90,33 +86,28 @@ class InstanceWithEBSTest(base.EC2TestCase):
volume_id = bdt['Ebs'].get('VolumeId') volume_id = bdt['Ebs'].get('VolumeId')
self.assertIsNotNone(volume_id) self.assertIsNotNone(volume_id)
resp, data = self.client.StopInstances(InstanceIds=[instance_id]) data = self.client.stop_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('stopped')) final_set=('stopped'))
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
kwargs = { kwargs = {
'VolumeId': data['Volumes'][0]['VolumeId'], 'VolumeId': data['Volumes'][0]['VolumeId'],
'Description': 'Description' 'Description': 'Description'
} }
resp, data = self.client.CreateSnapshot(*[], **kwargs) data = self.client.create_snapshot(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
snapshot_id = data['SnapshotId'] snapshot_id = data['SnapshotId']
res_clean_s = self.addResourceCleanUp(self.client.DeleteSnapshot, res_clean_s = self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
self.get_snapshot_waiter().wait_available(snapshot_id, self.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed')) final_set=('completed'))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
resp, data = self.client.DeleteSnapshot(SnapshotId=snapshot_id) data = self.client.delete_snapshot(SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_s) self.cancelResourceCleanUp(res_clean_s)
self.get_snapshot_waiter().wait_delete(snapshot_id) self.get_snapshot_waiter().wait_delete(snapshot_id)

146
ec2api/tests/functional/api/test_instances_vpc.py
View File

@ -39,19 +39,17 @@ class InstanceInVPCTest(base.EC2TestCase):
if not CONF.aws.image_id: if not CONF.aws.image_id:
raise cls.skipException('aws image_id does not provided') raise cls.skipException('aws image_id does not provided')
resp, data = cls.client.CreateVpc(CidrBlock=cls.VPC_CIDR) data = cls.client.create_vpc(CidrBlock=cls.VPC_CIDR)
cls.assertResultStatic(resp, data)
cls.vpc_id = data['Vpc']['VpcId'] cls.vpc_id = data['Vpc']['VpcId']
cls.addResourceCleanUpStatic(cls.client.DeleteVpc, VpcId=cls.vpc_id) cls.addResourceCleanUpStatic(cls.client.delete_vpc, VpcId=cls.vpc_id)
cls.get_vpc_waiter().wait_available(cls.vpc_id) cls.get_vpc_waiter().wait_available(cls.vpc_id)
aws_zone = CONF.aws.aws_zone aws_zone = CONF.aws.aws_zone
resp, data = cls.client.CreateSubnet(VpcId=cls.vpc_id, data = cls.client.create_subnet(VpcId=cls.vpc_id,
CidrBlock=cls.SUBNET_CIDR, CidrBlock=cls.SUBNET_CIDR,
AvailabilityZone=aws_zone) AvailabilityZone=aws_zone)
cls.assertResultStatic(resp, data)
cls.subnet_id = data['Subnet']['SubnetId'] cls.subnet_id = data['Subnet']['SubnetId']
cls.addResourceCleanUpStatic(cls.client.DeleteSubnet, cls.addResourceCleanUpStatic(cls.client.delete_subnet,
SubnetId=cls.subnet_id) SubnetId=cls.subnet_id)
cls.get_subnet_waiter().wait_available(cls.subnet_id) cls.get_subnet_waiter().wait_available(cls.subnet_id)
@ -59,18 +57,16 @@ class InstanceInVPCTest(base.EC2TestCase):
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1, ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=self.subnet_id) MaxCount=1, SubnetId=self.subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.DescribeInstances(InstanceIds=[instance_id]) data = self.client.describe_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
reservations = data.get('Reservations', []) reservations = data.get('Reservations', [])
self.assertNotEmpty(reservations) self.assertNotEmpty(reservations)
instances = reservations[0].get('Instances', []) instances = reservations[0].get('Instances', [])
@ -91,8 +87,7 @@ class InstanceInVPCTest(base.EC2TestCase):
self.assertEqual(self.vpc_id, ni['VpcId']) self.assertEqual(self.vpc_id, ni['VpcId'])
self.assertEqual(self.subnet_id, ni['SubnetId']) self.assertEqual(self.subnet_id, ni['SubnetId'])
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -104,69 +99,58 @@ class InstanceInVPCTest(base.EC2TestCase):
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1, ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=self.subnet_id) MaxCount=1, SubnetId=self.subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.DescribeInstances(InstanceIds=[instance_id]) data = self.client.describe_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assert_instance(data, instance_id) self.assert_instance(data, instance_id)
instances = data['Reservations'][0]['Instances'] instances = data['Reservations'][0]['Instances']
private_dns = instances[0]['PrivateDnsName'] private_dns = instances[0]['PrivateDnsName']
private_ip = instances[0]['PrivateIpAddress'] private_ip = instances[0]['PrivateIpAddress']
# NOTE(andrey-mp): by private ip # NOTE(andrey-mp): by private ip
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'private-ip-address', 'Values': ['1.2.3.4']}]) Filters=[{'Name': 'private-ip-address', 'Values': ['1.2.3.4']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['Reservations'])) self.assertEqual(0, len(data['Reservations']))
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'private-ip-address', 'Values': [private_ip]}]) Filters=[{'Name': 'private-ip-address', 'Values': [private_ip]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assert_instance(data, instance_id) self.assert_instance(data, instance_id)
# NOTE(andrey-mp): by private dns # NOTE(andrey-mp): by private dns
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'private-dns-name', 'Values': ['fake.com']}]) Filters=[{'Name': 'private-dns-name', 'Values': ['fake.com']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['Reservations'])) self.assertEqual(0, len(data['Reservations']))
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'private-dns-name', 'Values': [private_dns]}]) Filters=[{'Name': 'private-dns-name', 'Values': [private_dns]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assert_instance(data, instance_id) self.assert_instance(data, instance_id)
# NOTE(andrey-mp): by subnet id # NOTE(andrey-mp): by subnet id
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'subnet-id', 'Values': ['subnet-0']}]) Filters=[{'Name': 'subnet-id', 'Values': ['subnet-0']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['Reservations'])) self.assertEqual(0, len(data['Reservations']))
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'subnet-id', 'Values': [self.subnet_id]}]) Filters=[{'Name': 'subnet-id', 'Values': [self.subnet_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assert_instance(data, instance_id) self.assert_instance(data, instance_id)
# NOTE(andrey-mp): by vpc id # NOTE(andrey-mp): by vpc id
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'vpc-id', 'Values': ['vpc-0']}]) Filters=[{'Name': 'vpc-id', 'Values': ['vpc-0']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['Reservations'])) self.assertEqual(0, len(data['Reservations']))
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(
Filters=[{'Name': 'vpc-id', 'Values': [self.vpc_id]}]) Filters=[{'Name': 'vpc-id', 'Values': [self.vpc_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assert_instance(data, instance_id) self.assert_instance(data, instance_id)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -187,21 +171,19 @@ class InstanceInVPCTest(base.EC2TestCase):
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id1 = data['NetworkInterface']['NetworkInterfaceId'] ni_id1 = data['NetworkInterface']['NetworkInterfaceId']
clean_ni1 = self.addResourceCleanUp(self.client.DeleteNetworkInterface, clean_ni1 = self.addResourceCleanUp(
NetworkInterfaceId=ni_id1) self.client.delete_network_interface, NetworkInterfaceId=ni_id1)
self.get_network_interface_waiter().wait_available(ni_id1) self.get_network_interface_waiter().wait_available(ni_id1)
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id2 = data['NetworkInterface']['NetworkInterfaceId'] ni_id2 = data['NetworkInterface']['NetworkInterfaceId']
clean_ni2 = self.addResourceCleanUp(self.client.DeleteNetworkInterface, clean_ni2 = self.addResourceCleanUp(
NetworkInterfaceId=ni_id2) self.client.delete_network_interface, NetworkInterfaceId=ni_id2)
self.get_network_interface_waiter().wait_available(ni_id2) self.get_network_interface_waiter().wait_available(ni_id2)
kwargs = { kwargs = {
@ -214,10 +196,9 @@ class InstanceInVPCTest(base.EC2TestCase):
{'NetworkInterfaceId': ni_id2, {'NetworkInterfaceId': ni_id2,
'DeviceIndex': 2}] 'DeviceIndex': 2}]
} }
resp, data = self.client.RunInstances(*[], **kwargs) data = self.client.run_instances(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -226,23 +207,20 @@ class InstanceInVPCTest(base.EC2TestCase):
nis = instance.get('NetworkInterfaces', []) nis = instance.get('NetworkInterfaces', [])
self.assertEqual(2, len(nis)) self.assertEqual(2, len(nis))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
self.get_network_interface_waiter().wait_available(ni_id1) self.get_network_interface_waiter().wait_available(ni_id1)
self.get_network_interface_waiter().wait_available(ni_id2) self.get_network_interface_waiter().wait_available(ni_id2)
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id2) NetworkInterfaceId=ni_id2)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_ni2) self.cancelResourceCleanUp(clean_ni2)
self.get_network_interface_waiter().wait_delete(ni_id2) self.get_network_interface_waiter().wait_delete(ni_id2)
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id1) NetworkInterfaceId=ni_id1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_ni1) self.cancelResourceCleanUp(clean_ni1)
self.get_network_interface_waiter().wait_delete(ni_id1) self.get_network_interface_waiter().wait_delete(ni_id1)
@ -257,10 +235,9 @@ class InstanceInVPCTest(base.EC2TestCase):
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
'PrivateIpAddress': ip 'PrivateIpAddress': ip
} }
resp, data = self.client.RunInstances(*[], **kwargs) data = self.client.run_instances(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -268,12 +245,15 @@ class InstanceInVPCTest(base.EC2TestCase):
instance = self.get_instance(instance_id) instance = self.get_instance(instance_id)
self.assertEqual(ip, instance['PrivateIpAddress']) self.assertEqual(ip, instance['PrivateIpAddress'])
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
def test_create_instance_with_invalid_params(self): def test_create_instance_with_invalid_params(self):
def _rollback(fn_data):
self.client.terminate_instances(
InstanceIds=[fn_data['Instances'][0]['InstanceId']])
kwargs = { kwargs = {
'ImageId': CONF.aws.image_id, 'ImageId': CONF.aws.image_id,
'InstanceType': CONF.aws.instance_type, 'InstanceType': CONF.aws.instance_type,
@ -281,13 +261,9 @@ class InstanceInVPCTest(base.EC2TestCase):
'MaxCount': 1, 'MaxCount': 1,
'PrivateIpAddress': '10.16.1.2' 'PrivateIpAddress': '10.16.1.2'
} }
resp, data = self.client.RunInstances(*[], **kwargs) self.assertRaises('InvalidParameterCombination',
if resp.status_code == 200: self.client.run_instances, rollback_fn=_rollback,
self.addResourceCleanUp( **kwargs)
self.client.TerminateInstances,
InstanceIds=[data['Instances'][0]['InstanceId']])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterCombination', data['Error']['Code'])
kwargs = { kwargs = {
'ImageId': CONF.aws.image_id, 'ImageId': CONF.aws.image_id,
@ -297,31 +273,25 @@ class InstanceInVPCTest(base.EC2TestCase):
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
'PrivateIpAddress': '10.16.1.12' 'PrivateIpAddress': '10.16.1.12'
} }
resp, data = self.client.RunInstances(*[], **kwargs) self.assertRaises('InvalidParameterValue',
if resp.status_code == 200: self.client.run_instances, rollback_fn=_rollback,
self.addResourceCleanUp( **kwargs)
self.client.TerminateInstances,
InstanceIds=[data['Instances'][0]['InstanceId']])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id1 = data['NetworkInterface']['NetworkInterfaceId'] ni_id1 = data['NetworkInterface']['NetworkInterfaceId']
self.addResourceCleanUp(self.client.DeleteNetworkInterface, self.addResourceCleanUp(self.client.delete_network_interface,
NetworkInterfaceId=ni_id1) NetworkInterfaceId=ni_id1)
self.get_network_interface_waiter().wait_available(ni_id1) self.get_network_interface_waiter().wait_available(ni_id1)
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id2 = data['NetworkInterface']['NetworkInterfaceId'] ni_id2 = data['NetworkInterface']['NetworkInterfaceId']
self.addResourceCleanUp(self.client.DeleteNetworkInterface, self.addResourceCleanUp(self.client.delete_network_interface,
NetworkInterfaceId=ni_id2) NetworkInterfaceId=ni_id2)
self.get_network_interface_waiter().wait_available(ni_id2) self.get_network_interface_waiter().wait_available(ni_id2)
@ -336,13 +306,9 @@ class InstanceInVPCTest(base.EC2TestCase):
'DeviceIndex': 0, 'DeviceIndex': 0,
'DeleteOnTermination': True}] 'DeleteOnTermination': True}]
} }
resp, data = self.client.RunInstances(*[], **kwargs) self.assertRaises('InvalidParameterCombination',
if resp.status_code == 200: self.client.run_instances, rollback_fn=_rollback,
self.addResourceCleanUp( **kwargs)
self.client.TerminateInstances,
InstanceIds=[data['Instances'][0]['InstanceId']])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterCombination', data['Error']['Code'])
if CONF.aws.run_incompatible_tests: if CONF.aws.run_incompatible_tests:
# NOTE(andrey-mp): Each network interface requires a device index. # NOTE(andrey-mp): Each network interface requires a device index.
@ -354,10 +320,6 @@ class InstanceInVPCTest(base.EC2TestCase):
'NetworkInterfaces': [{'NetworkInterfaceId': ni_id1}, 'NetworkInterfaces': [{'NetworkInterfaceId': ni_id1},
{'NetworkInterfaceId': ni_id2}] {'NetworkInterfaceId': ni_id2}]
} }
resp, data = self.client.RunInstances(*[], **kwargs) self.assertRaises('InvalidParameterValue',
if resp.status_code == 200: self.client.run_instances, rollback_fn=_rollback,
self.addResourceCleanUp( **kwargs)
self.client.TerminateInstances,
InstanceIds=[data['Instances'][0]['InstanceId']])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])

181
ec2api/tests/functional/api/test_internet_gateways.py
View File

@ -39,218 +39,177 @@ class InternetGatewayTest(base.EC2TestCase):
if not base.TesterStateHolder().get_vpc_enabled(): if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled') raise cls.skipException('VPC is disabled')
resp, data = cls.client.CreateVpc(CidrBlock=cls.VPC_CIDR) data = cls.client.create_vpc(CidrBlock=cls.VPC_CIDR)
cls.assertResultStatic(resp, data)
cls.vpc_id = data['Vpc']['VpcId'] cls.vpc_id = data['Vpc']['VpcId']
cls.get_vpc_waiter().wait_available(cls.vpc_id) cls.get_vpc_waiter().wait_available(cls.vpc_id)
cls.addResourceCleanUpStatic(cls.client.DeleteVpc, VpcId=cls.vpc_id) cls.addResourceCleanUpStatic(cls.client.delete_vpc, VpcId=cls.vpc_id)
resp, data = cls.client.CreateVpc(CidrBlock=cls.VPC_CIDR_ALT) data = cls.client.create_vpc(CidrBlock=cls.VPC_CIDR_ALT)
cls.assertResultStatic(resp, data)
cls.vpc_id_alt = data['Vpc']['VpcId'] cls.vpc_id_alt = data['Vpc']['VpcId']
cls.get_vpc_waiter().wait_available(cls.vpc_id_alt) cls.get_vpc_waiter().wait_available(cls.vpc_id_alt)
cls.addResourceCleanUpStatic(cls.client.DeleteVpc, cls.addResourceCleanUpStatic(cls.client.delete_vpc,
VpcId=cls.vpc_id_alt) VpcId=cls.vpc_id_alt)
def test_create_attach_internet_gateway(self): def test_create_attach_internet_gateway(self):
resp, data = self.client.CreateInternetGateway() data = self.client.create_internet_gateway()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
gw_id = data['InternetGateway']['InternetGatewayId'] gw_id = data['InternetGateway']['InternetGatewayId']
res_clean = self.addResourceCleanUp(self.client.DeleteInternetGateway, res_clean = self.addResourceCleanUp(
InternetGatewayId=gw_id) self.client.delete_internet_gateway, InternetGatewayId=gw_id)
self.assertEmpty(data['InternetGateway'].get('Attachments', [])) self.assertEmpty(data['InternetGateway'].get('Attachments', []))
resp, data = self.client.AttachInternetGateway(VpcId=self.vpc_id, data = self.client.attach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DetachInternetGateway(VpcId=self.vpc_id, data = self.client.detach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DeleteInternetGateway(InternetGatewayId=gw_id) data = self.client.delete_internet_gateway(InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
resp, data = self.client.DescribeInternetGateways( self.assertRaises('InvalidInternetGatewayID.NotFound',
self.client.describe_internet_gateways,
InternetGatewayIds=[gw_id]) InternetGatewayIds=[gw_id])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidInternetGatewayID.NotFound',
data['Error']['Code'])
def test_delete_attached_internet_gateway(self): def test_delete_attached_internet_gateway(self):
resp, data = self.client.CreateInternetGateway() data = self.client.create_internet_gateway()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
gw_id = data['InternetGateway']['InternetGatewayId'] gw_id = data['InternetGateway']['InternetGatewayId']
res_clean = self.addResourceCleanUp(self.client.DeleteInternetGateway, res_clean = self.addResourceCleanUp(
InternetGatewayId=gw_id) self.client.delete_internet_gateway, InternetGatewayId=gw_id)
self.assertEmpty(data['InternetGateway'].get('Attachments', [])) self.assertEmpty(data['InternetGateway'].get('Attachments', []))
resp, data = self.client.AttachInternetGateway(VpcId=self.vpc_id, data = self.client.attach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DeleteInternetGateway(InternetGatewayId=gw_id) self.assertRaises('DependencyViolation',
self.assertEqual(400, resp.status_code) self.client.delete_internet_gateway,
self.assertEqual('DependencyViolation', data['Error']['Code'])
resp, data = self.client.DetachInternetGateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DeleteInternetGateway(InternetGatewayId=gw_id) data = self.client.detach_internet_gateway(VpcId=self.vpc_id,
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) InternetGatewayId=gw_id)
data = self.client.delete_internet_gateway(InternetGatewayId=gw_id)
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
@testtools.skipUnless(CONF.aws.run_incompatible_tests, @testtools.skipUnless(CONF.aws.run_incompatible_tests,
"Another error code returned - InvalidParameterValue") "Another error code returned - InvalidParameterValue")
def test_attach_detach_invalid_internet_gateway(self): def test_attach_detach_invalid_internet_gateway(self):
gw_id = "gw-1" gw_id = "gw-1"
resp, data = self.client.AttachInternetGateway(VpcId=self.vpc_id, self.assertRaises('InvalidInternetGatewayID.NotFound',
InternetGatewayId=gw_id) self.client.attach_internet_gateway,
self.assertEqual(400, resp.status_code) VpcId=self.vpc_id, InternetGatewayId=gw_id)
self.assertEqual('InvalidInternetGatewayID.NotFound',
data['Error']['Code'])
resp, data = self.client.DetachInternetGateway(VpcId=self.vpc_id, self.assertRaises('InvalidInternetGatewayID.NotFound',
InternetGatewayId=gw_id) self.client.detach_internet_gateway,
self.assertEqual(400, resp.status_code) VpcId=self.vpc_id, InternetGatewayId=gw_id)
self.assertEqual('InvalidInternetGatewayID.NotFound',
data['Error']['Code'])
def test_double_attach_internet_gateway(self): def test_double_attach_internet_gateway(self):
resp, data = self.client.CreateInternetGateway() data = self.client.create_internet_gateway()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
gw_id = data['InternetGateway']['InternetGatewayId'] gw_id = data['InternetGateway']['InternetGatewayId']
res_clean = self.addResourceCleanUp(self.client.DeleteInternetGateway, res_clean = self.addResourceCleanUp(
InternetGatewayId=gw_id) self.client.delete_internet_gateway, InternetGatewayId=gw_id)
self.assertEmpty(data['InternetGateway'].get('Attachments', [])) self.assertEmpty(data['InternetGateway'].get('Attachments', []))
resp, data = self.client.AttachInternetGateway(VpcId=self.vpc_id, data = self.client.attach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.AttachInternetGateway(VpcId=self.vpc_id, self.assertRaises('Resource.AlreadyAssociated',
self.client.attach_internet_gateway,
VpcId=self.vpc_id, InternetGatewayId=gw_id)
data = self.client.detach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(400, resp.status_code)
self.assertEqual('Resource.AlreadyAssociated', data['Error']['Code'])
resp, data = self.client.DetachInternetGateway(VpcId=self.vpc_id, data = self.client.delete_internet_gateway(InternetGatewayId=gw_id)
InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DeleteInternetGateway(InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_attach_one_internet_gateway_to_two_vpcs(self): def test_attach_one_internet_gateway_to_two_vpcs(self):
resp, data = self.client.CreateInternetGateway() data = self.client.create_internet_gateway()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
gw_id = data['InternetGateway']['InternetGatewayId'] gw_id = data['InternetGateway']['InternetGatewayId']
res_clean = self.addResourceCleanUp(self.client.DeleteInternetGateway, res_clean = self.addResourceCleanUp(
InternetGatewayId=gw_id) self.client.delete_internet_gateway, InternetGatewayId=gw_id)
self.assertEmpty(data['InternetGateway'].get('Attachments', [])) self.assertEmpty(data['InternetGateway'].get('Attachments', []))
resp, data = self.client.AttachInternetGateway(VpcId=self.vpc_id, data = self.client.attach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.AttachInternetGateway(VpcId=self.vpc_id_alt, self.assertRaises('Resource.AlreadyAssociated',
self.client.attach_internet_gateway,
VpcId=self.vpc_id_alt, InternetGatewayId=gw_id)
data = self.client.detach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(400, resp.status_code)
self.assertEqual('Resource.AlreadyAssociated', data['Error']['Code'])
resp, data = self.client.DetachInternetGateway(VpcId=self.vpc_id, data = self.client.delete_internet_gateway(InternetGatewayId=gw_id)
InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DeleteInternetGateway(InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_describe_internet_gateways_base(self): def test_describe_internet_gateways_base(self):
resp, data = self.client.CreateInternetGateway() data = self.client.create_internet_gateway()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
gw_id = data['InternetGateway']['InternetGatewayId'] gw_id = data['InternetGateway']['InternetGatewayId']
res_clean = self.addResourceCleanUp(self.client.DeleteInternetGateway, res_clean = self.addResourceCleanUp(
InternetGatewayId=gw_id) self.client.delete_internet_gateway, InternetGatewayId=gw_id)
self.assertEmpty(data['InternetGateway'].get('Attachments', [])) self.assertEmpty(data['InternetGateway'].get('Attachments', []))
resp, data = self.client.AttachInternetGateway(VpcId=self.vpc_id, data = self.client.attach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.addResourceCleanUp(self.client.detach_internet_gateway,
self.addResourceCleanUp(self.client.DetachInternetGateway,
VpcId=self.vpc_id, VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
time.sleep(2) time.sleep(2)
# NOTE(andrey-mp): by real id # NOTE(andrey-mp): by real id
resp, data = self.client.DescribeInternetGateways( data = self.client.describe_internet_gateways(
InternetGatewayIds=[gw_id]) InternetGatewayIds=[gw_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['InternetGateways'])) self.assertEqual(1, len(data['InternetGateways']))
# NOTE(andrey-mp): by fake id # NOTE(andrey-mp): by fake id
resp, data = self.client.DescribeInternetGateways( self.assertRaises('InvalidInternetGatewayID.NotFound',
self.client.describe_internet_gateways,
InternetGatewayIds=['igw-0']) InternetGatewayIds=['igw-0'])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidInternetGatewayID.NotFound',
data['Error']['Code'])
resp, data = self.client.DetachInternetGateway(VpcId=self.vpc_id, data = self.client.detach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DeleteInternetGateway(InternetGatewayId=gw_id) data = self.client.delete_internet_gateway(InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_describe_internet_gateways_filters(self): def test_describe_internet_gateways_filters(self):
# NOTE(andrey-mp): by filter real vpc-id before creation # NOTE(andrey-mp): by filter real vpc-id before creation
resp, data = self.client.DescribeInternetGateways( data = self.client.describe_internet_gateways(
Filters=[{'Name': 'attachment.vpc-id', 'Values': [self.vpc_id]}]) Filters=[{'Name': 'attachment.vpc-id', 'Values': [self.vpc_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['InternetGateways'])) self.assertEqual(0, len(data['InternetGateways']))
resp, data = self.client.CreateInternetGateway() data = self.client.create_internet_gateway()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
gw_id = data['InternetGateway']['InternetGatewayId'] gw_id = data['InternetGateway']['InternetGatewayId']
res_clean = self.addResourceCleanUp(self.client.DeleteInternetGateway, res_clean = self.addResourceCleanUp(
InternetGatewayId=gw_id) self.client.delete_internet_gateway, InternetGatewayId=gw_id)
self.assertEmpty(data['InternetGateway'].get('Attachments', [])) self.assertEmpty(data['InternetGateway'].get('Attachments', []))
resp, data = self.client.AttachInternetGateway(VpcId=self.vpc_id, data = self.client.attach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.addResourceCleanUp(self.client.detach_internet_gateway,
self.addResourceCleanUp(self.client.DetachInternetGateway,
VpcId=self.vpc_id, VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
time.sleep(2) time.sleep(2)
# NOTE(andrey-mp): by filter real vpc-id # NOTE(andrey-mp): by filter real vpc-id
resp, data = self.client.DescribeInternetGateways( data = self.client.describe_internet_gateways(
Filters=[{'Name': 'attachment.vpc-id', 'Values': [self.vpc_id]}]) Filters=[{'Name': 'attachment.vpc-id', 'Values': [self.vpc_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['InternetGateways'])) self.assertEqual(1, len(data['InternetGateways']))
self.assertEqual(gw_id, self.assertEqual(gw_id,
data['InternetGateways'][0]['InternetGatewayId']) data['InternetGateways'][0]['InternetGatewayId'])
# NOTE(andrey-mp): by filter fake vpc-id # NOTE(andrey-mp): by filter fake vpc-id
resp, data = self.client.DescribeInternetGateways( data = self.client.describe_internet_gateways(
Filters=[{'Name': 'attachment.vpc-id', 'Values': ['vpc-0']}]) Filters=[{'Name': 'attachment.vpc-id', 'Values': ['vpc-0']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['InternetGateways'])) self.assertEqual(0, len(data['InternetGateways']))
# NOTE(andrey-mp): by fake filter # NOTE(andrey-mp): by fake filter
resp, data = self.client.DescribeInternetGateways( self.assertRaises('InvalidParameterValue',
self.client.describe_internet_gateways,
Filters=[{'Name': 'fake', 'Values': ['fake']}]) Filters=[{'Name': 'fake', 'Values': ['fake']}])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
resp, data = self.client.DetachInternetGateway(VpcId=self.vpc_id, data = self.client.detach_internet_gateway(VpcId=self.vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DeleteInternetGateway(InternetGatewayId=gw_id) data = self.client.delete_internet_gateway(InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)

90
ec2api/tests/functional/api/test_key_pairs.py
View File

@ -25,9 +25,8 @@ class KeyPairTest(base.EC2TestCase):
def test_create_delete_key_pair(self): def test_create_delete_key_pair(self):
keyName = 'Test key' keyName = 'Test key'
resp, data = self.client.CreateKeyPair(KeyName=keyName) data = self.client.create_key_pair(KeyName=keyName)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) res_clean = self.addResourceCleanUp(self.client.delete_key_pair,
res_clean = self.addResourceCleanUp(self.client.DeleteKeyPair,
KeyName=keyName) KeyName=keyName)
self.assertEqual(keyName, data['KeyName']) self.assertEqual(keyName, data['KeyName'])
@ -35,37 +34,32 @@ class KeyPairTest(base.EC2TestCase):
self.assertGreater(len(data['KeyFingerprint']), 0) self.assertGreater(len(data['KeyFingerprint']), 0)
self.assertGreater(len(data.get('KeyMaterial')), 0) self.assertGreater(len(data.get('KeyMaterial')), 0)
resp, data = self.client.DeleteKeyPair(KeyName=keyName) data = self.client.delete_key_pair(KeyName=keyName)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_create_duplicate_key_pair(self): def test_create_duplicate_key_pair(self):
keyName = 'Test key' keyName = 'Test key'
resp, data = self.client.CreateKeyPair(KeyName=keyName) self.client.create_key_pair(KeyName=keyName)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) res_clean = self.addResourceCleanUp(self.client.delete_key_pair,
res_clean = self.addResourceCleanUp(self.client.DeleteKeyPair,
KeyName=keyName) KeyName=keyName)
resp, data = self.client.CreateKeyPair(KeyName=keyName) self.assertRaises('InvalidKeyPair.Duplicate',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.create_key_pair,
self.assertEqual('InvalidKeyPair.Duplicate', data['Error']['Code']) KeyName=keyName)
resp, data = self.client.DeleteKeyPair(KeyName=keyName) self.client.delete_key_pair(KeyName=keyName)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_describe_key_pairs(self): def test_describe_key_pairs(self):
keyName = 'Test key' keyName = 'Test key'
resp, data = self.client.CreateKeyPair(KeyName=keyName) data = self.client.create_key_pair(KeyName=keyName)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) res_clean = self.addResourceCleanUp(self.client.delete_key_pair,
res_clean = self.addResourceCleanUp(self.client.DeleteKeyPair,
KeyName=keyName) KeyName=keyName)
self.assertIsNotNone(data.get('KeyFingerprint')) self.assertIsNotNone(data.get('KeyFingerprint'))
self.assertGreater(len(data['KeyFingerprint']), 0) self.assertGreater(len(data['KeyFingerprint']), 0)
fingerprint = data.get('KeyFingerprint') fingerprint = data.get('KeyFingerprint')
resp, data = self.client.DescribeKeyPairs(KeyNames=[keyName]) data = self.client.describe_key_pairs(KeyNames=[keyName])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data.get('KeyPairs'))) self.assertEqual(1, len(data.get('KeyPairs')))
data = data['KeyPairs'][0] data = data['KeyPairs'][0]
self.assertEqual(keyName, data['KeyName']) self.assertEqual(keyName, data['KeyName'])
@ -73,55 +67,55 @@ class KeyPairTest(base.EC2TestCase):
self.assertGreater(len(data['KeyFingerprint']), 0) self.assertGreater(len(data['KeyFingerprint']), 0)
self.assertIsNone(data.get('KeyMaterial')) self.assertIsNone(data.get('KeyMaterial'))
resp, data = self.client.DescribeKeyPairs( data = self.client.describe_key_pairs(
Filters=[{'Name': 'key-name', 'Values': [keyName]}]) Filters=[{'Name': 'key-name', 'Values': [keyName]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data.get('KeyPairs'))) self.assertEqual(1, len(data.get('KeyPairs')))
self.assertEqual(keyName, data['KeyPairs'][0]['KeyName']) self.assertEqual(keyName, data['KeyPairs'][0]['KeyName'])
resp, data = self.client.DescribeKeyPairs( data = self.client.describe_key_pairs(
Filters=[{'Name': 'fingerprint', 'Values': [fingerprint]}]) Filters=[{'Name': 'fingerprint', 'Values': [fingerprint]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data.get('KeyPairs'))) self.assertEqual(1, len(data.get('KeyPairs')))
self.assertEqual(keyName, data['KeyPairs'][0]['KeyName']) self.assertEqual(keyName, data['KeyPairs'][0]['KeyName'])
resp, data = self.client.DescribeKeyPairs(KeyNames=['fake key']) self.assertRaises('InvalidKeyPair.NotFound',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.describe_key_pairs,
self.assertEqual('InvalidKeyPair.NotFound', data['Error']['Code']) KeyNames=['fake key'])
resp, data = self.client.DeleteKeyPair(KeyName=keyName) data = self.client.delete_key_pair(KeyName=keyName)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
resp, data = self.client.DescribeKeyPairs(KeyNames=[keyName]) self.assertRaises('InvalidKeyPair.NotFound',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.describe_key_pairs,
self.assertEqual('InvalidKeyPair.NotFound', data['Error']['Code']) KeyNames=[keyName])
# NOTE(andrey-mp): Amazon allows to delete absent key and returns 200 # NOTE(andrey-mp): Amazon allows to delete absent key and returns 200
resp, data = self.client.DeleteKeyPair(KeyName=keyName) self.client.delete_key_pair(KeyName=keyName)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
def test_import_empty_key_pair(self): def test_import_empty_key_pair(self):
keyName = 'Test key' keyName = 'Test key'
publicKey = '' publicKey = ''
resp, data = self.client.ImportKeyPair(KeyName=keyName,
PublicKeyMaterial=publicKey) def _rollback(fn_data):
if resp.status_code == 200: self.client.delete_key_pair(KeyName=keyName)
self.addResourceCleanUp(self.client.DeleteKeyPair, KeyName=keyName)
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.assertRaises('MissingParameter',
self.assertEqual('MissingParameter', data['Error']['Code']) self.client.import_key_pair,
rollback_fn=_rollback,
KeyName=keyName, PublicKeyMaterial=publicKey)
@testtools.skipUnless(CONF.aws.run_incompatible_tests, @testtools.skipUnless(CONF.aws.run_incompatible_tests,
"Different error code") "Different error code")
def test_import_invalid_key_pair(self): def test_import_invalid_key_pair(self):
keyName = 'Test key' keyName = 'Test key'
publicKey = 'ssh-rsa JUNK test@ubuntu' publicKey = 'ssh-rsa JUNK test@ubuntu'
resp, data = self.client.ImportKeyPair(KeyName=keyName,
PublicKeyMaterial=publicKey) def _rollback():
if resp.status_code == 200: self.client.delete_key_pair(KeyName=keyName)
self.addResourceCleanUp(self.client.DeleteKeyPair, KeyName=keyName)
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.assertRaises('InvalidKey.Format',
self.assertEqual('InvalidKey.Format', data['Error']['Code']) self.client.import_key_pair,
rollback_fn=_rollback,
KeyName=keyName, PublicKeyMaterial=publicKey)
def test_import_key_pair(self): def test_import_key_pair(self):
keyName = 'Test key' keyName = 'Test key'
@ -134,10 +128,9 @@ class KeyPairTest(base.EC2TestCase):
"LOeB1kYMOBaiUPLQTWXR3JpckqFIQwhIH0zoHlJvZE8hh90" "LOeB1kYMOBaiUPLQTWXR3JpckqFIQwhIH0zoHlJvZE8hh90"
"XcPojYN56tI0OlrGqojbediJYD0rUsJu4weZpbn8vilb3JuDY+jws" "XcPojYN56tI0OlrGqojbediJYD0rUsJu4weZpbn8vilb3JuDY+jws"
"snSA8wzBx3A/8y9Pp1B test@ubuntu") "snSA8wzBx3A/8y9Pp1B test@ubuntu")
resp, data = self.client.ImportKeyPair(KeyName=keyName, data = self.client.import_key_pair(KeyName=keyName,
PublicKeyMaterial=publicKey) PublicKeyMaterial=publicKey)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) res_clean = self.addResourceCleanUp(self.client.delete_key_pair,
res_clean = self.addResourceCleanUp(self.client.DeleteKeyPair,
KeyName=keyName) KeyName=keyName)
self.assertEqual(keyName, data['KeyName']) self.assertEqual(keyName, data['KeyName'])
@ -145,6 +138,5 @@ class KeyPairTest(base.EC2TestCase):
self.assertGreater(len(data['KeyFingerprint']), 0) self.assertGreater(len(data['KeyFingerprint']), 0)
self.assertIsNone(data.get('KeyMaterial')) self.assertIsNone(data.get('KeyMaterial'))
resp, data = self.client.DeleteKeyPair(KeyName=keyName) self.client.delete_key_pair(KeyName=keyName)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)

285
ec2api/tests/functional/api/test_network_interfaces.py
View File

@ -15,6 +15,7 @@
import time import time
import botocore.exceptions
from oslo_log import log from oslo_log import log
from tempest_lib.common.utils import data_utils from tempest_lib.common.utils import data_utils
@ -40,33 +41,30 @@ class NetworkInterfaceTest(base.EC2TestCase):
if not base.TesterStateHolder().get_vpc_enabled(): if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled') raise cls.skipException('VPC is disabled')
resp, data = cls.client.CreateVpc(CidrBlock=cls.VPC_CIDR) data = cls.client.create_vpc(CidrBlock=cls.VPC_CIDR)
cls.assertResultStatic(resp, data)
cls.vpc_id = data['Vpc']['VpcId'] cls.vpc_id = data['Vpc']['VpcId']
cls.addResourceCleanUpStatic(cls.client.DeleteVpc, VpcId=cls.vpc_id) cls.addResourceCleanUpStatic(cls.client.delete_vpc, VpcId=cls.vpc_id)
cls.get_vpc_waiter().wait_available(cls.vpc_id) cls.get_vpc_waiter().wait_available(cls.vpc_id)
aws_zone = CONF.aws.aws_zone aws_zone = CONF.aws.aws_zone
resp, data = cls.client.CreateSubnet(VpcId=cls.vpc_id, data = cls.client.create_subnet(VpcId=cls.vpc_id,
CidrBlock=cls.SUBNET_CIDR, CidrBlock=cls.SUBNET_CIDR,
AvailabilityZone=aws_zone) AvailabilityZone=aws_zone)
cls.assertResultStatic(resp, data)
cls.subnet_id = data['Subnet']['SubnetId'] cls.subnet_id = data['Subnet']['SubnetId']
cls.addResourceCleanUpStatic(cls.client.DeleteSubnet, cls.addResourceCleanUpStatic(cls.client.delete_subnet,
SubnetId=cls.subnet_id) SubnetId=cls.subnet_id)
cls.get_subnet_waiter().wait_available(cls.subnet_id) cls.get_subnet_waiter().wait_available(cls.subnet_id)
def _wait_assignment(self, ni_id, resp, data): def _wait_assignment(self, ni_id, data):
# NOTE(andrey-mp): Amazon don't do it quickly and there is no way # NOTE(andrey-mp): Amazon don't do it quickly and there is no way
# to wait this request # to wait this request
time.sleep(5) time.sleep(5)
def test_delete_subnet_with_network_interface(self): def test_delete_subnet_with_network_interface(self):
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, data = self.client.create_subnet(VpcId=self.vpc_id,
CidrBlock='10.7.1.0/28') CidrBlock='10.7.1.0/28')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
res_clean_subnet = self.addResourceCleanUp(self.client.DeleteSubnet, res_clean_subnet = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
self.get_subnet_waiter().wait_available(subnet_id) self.get_subnet_waiter().wait_available(subnet_id)
@ -74,25 +72,22 @@ class NetworkInterfaceTest(base.EC2TestCase):
'SubnetId': subnet_id, 'SubnetId': subnet_id,
'Description': data_utils.rand_name('ni') 'Description': data_utils.rand_name('ni')
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
res_clean_ni = self.addResourceCleanUp( res_clean_ni = self.addResourceCleanUp(
self.client.DeleteNetworkInterface, NetworkInterfaceId=ni_id) self.client.delete_network_interface, NetworkInterfaceId=ni_id)
self.get_network_interface_waiter().wait_available(ni_id) self.get_network_interface_waiter().wait_available(ni_id)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) self.assertRaises('DependencyViolation',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.delete_subnet,
self.assertEqual('DependencyViolation', data['Error']['Code']) SubnetId=subnet_id)
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_ni) self.cancelResourceCleanUp(res_clean_ni)
self.get_network_interface_waiter().wait_delete(ni_id) self.get_network_interface_waiter().wait_delete(ni_id)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) data = self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_subnet) self.cancelResourceCleanUp(res_clean_subnet)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
@ -101,11 +96,10 @@ class NetworkInterfaceTest(base.EC2TestCase):
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
'Description': data_utils.rand_name('ni') 'Description': data_utils.rand_name('ni')
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
res_clean = self.addResourceCleanUp(self.client.DeleteNetworkInterface, res_clean = self.addResourceCleanUp(
NetworkInterfaceId=ni_id) self.client.delete_network_interface, NetworkInterfaceId=ni_id)
ni = data['NetworkInterface'] ni = data['NetworkInterface']
self.assertEqual(self.vpc_id, ni['VpcId']) self.assertEqual(self.vpc_id, ni['VpcId'])
self.assertEqual(self.subnet_id, ni['SubnetId']) self.assertEqual(self.subnet_id, ni['SubnetId'])
@ -129,17 +123,14 @@ class NetworkInterfaceTest(base.EC2TestCase):
self.get_network_interface_waiter().wait_available(ni_id) self.get_network_interface_waiter().wait_available(ni_id)
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_network_interface_waiter().wait_delete(ni_id) self.get_network_interface_waiter().wait_delete(ni_id)
resp, data = self.client.DescribeNetworkInterfaces( self.assertRaises('InvalidNetworkInterfaceID.NotFound',
self.client.describe_network_interfaces,
NetworkInterfaceIds=[ni_id]) NetworkInterfaceIds=[ni_id])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidNetworkInterfaceID.NotFound',
data['Error']['Code'])
# TODO(andrey-mp): add creation with addresses # TODO(andrey-mp): add creation with addresses
@ -148,28 +139,26 @@ class NetworkInterfaceTest(base.EC2TestCase):
# for this subnet(that are deleting after previous test) # for this subnet(that are deleting after previous test)
time.sleep(5) time.sleep(5)
resp, data = self.client.DescribeSubnets(SubnetIds=[self.subnet_id]) data = self.client.describe_subnets(SubnetIds=[self.subnet_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
count_before = data['Subnets'][0]['AvailableIpAddressCount'] count_before = data['Subnets'][0]['AvailableIpAddressCount']
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
addresses = [] addresses = []
while True: while True:
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) try:
if resp.status_code != 200: data = self.client.create_network_interface(*[], **kwargs)
except botocore.exceptions.ClientError as e:
error_code = e.response['Error']['Code']
self.assertEqual('NetworkInterfaceLimitExceeded', error_code)
break break
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
res_clean = self.addResourceCleanUp( res_clean = self.addResourceCleanUp(
self.client.DeleteNetworkInterface, self.client.delete_network_interface,
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
addresses.append((ni_id, res_clean)) addresses.append((ni_id, res_clean))
self.assertEqual(400, resp.status_code)
self.assertEqual('NetworkInterfaceLimitExceeded',
data['Error']['Code'])
resp, data = self.client.DescribeSubnets(SubnetIds=[self.subnet_id]) data = self.client.describe_subnets(SubnetIds=[self.subnet_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
count_after = data['Subnets'][0]['AvailableIpAddressCount'] count_after = data['Subnets'][0]['AvailableIpAddressCount']
# NOTE(andrey-mp): This is strange but Amazon can't create last NI # NOTE(andrey-mp): This is strange but Amazon can't create last NI
# and Openstack can # and Openstack can
@ -180,9 +169,7 @@ class NetworkInterfaceTest(base.EC2TestCase):
kwargs = { kwargs = {
'NetworkInterfaceId': addr[0], 'NetworkInterfaceId': addr[0],
} }
resp, data = self.client.DeleteNetworkInterface(*[], **kwargs) data = self.client.delete_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(addr[1]) self.cancelResourceCleanUp(addr[1])
self.get_network_interface_waiter().wait_delete(addr[0]) self.get_network_interface_waiter().wait_delete(addr[0])
@ -190,54 +177,46 @@ class NetworkInterfaceTest(base.EC2TestCase):
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
res_clean = self.addResourceCleanUp(self.client.DeleteNetworkInterface, res_clean = self.addResourceCleanUp(
NetworkInterfaceId=ni_id) self.client.delete_network_interface, NetworkInterfaceId=ni_id)
primary_address = data['NetworkInterface'].get('PrivateIpAddress') primary_address = data['NetworkInterface'].get('PrivateIpAddress')
self.get_network_interface_waiter().wait_available(ni_id) self.get_network_interface_waiter().wait_available(ni_id)
resp, data = self.client.UnassignPrivateIpAddresses( self.assertRaises('InvalidParameterValue',
self.client.unassign_private_ip_addresses,
NetworkInterfaceId=ni_id, NetworkInterfaceId=ni_id,
PrivateIpAddresses=[primary_address]) PrivateIpAddresses=[primary_address])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_network_interface_waiter().wait_delete(ni_id) self.get_network_interface_waiter().wait_delete(ni_id)
def test_assign_unassign_private_addresses_by_count(self): def test_assign_unassign_private_addresses_by_count(self):
resp, data = self.client.DescribeSubnets(SubnetIds=[self.subnet_id]) data = self.client.describe_subnets(SubnetIds=[self.subnet_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
count = data['Subnets'][0]['AvailableIpAddressCount'] count = data['Subnets'][0]['AvailableIpAddressCount']
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
res_clean = self.addResourceCleanUp(self.client.DeleteNetworkInterface, res_clean = self.addResourceCleanUp(
NetworkInterfaceId=ni_id) self.client.delete_network_interface, NetworkInterfaceId=ni_id)
self.get_network_interface_waiter().wait_available(ni_id) self.get_network_interface_waiter().wait_available(ni_id)
resp, data = self.client.AssignPrivateIpAddresses( data = self.client.assign_private_ip_addresses(
NetworkInterfaceId=ni_id, NetworkInterfaceId=ni_id,
SecondaryPrivateIpAddressCount=2) SecondaryPrivateIpAddressCount=2)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self._wait_assignment(ni_id, data)
self._wait_assignment(ni_id, resp, data)
resp, data = self.client.DescribeSubnets(SubnetIds=[self.subnet_id]) data = self.client.describe_subnets(SubnetIds=[self.subnet_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
count_after = data['Subnets'][0]['AvailableIpAddressCount'] count_after = data['Subnets'][0]['AvailableIpAddressCount']
self.assertEqual(count - 3, count_after) self.assertEqual(count - 3, count_after)
resp, data = self.client.DescribeNetworkInterfaces( data = self.client.describe_network_interfaces(
NetworkInterfaceIds=[ni_id]) NetworkInterfaceIds=[ni_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
addresses = [] addresses = []
for addr in data['NetworkInterfaces'][0]['PrivateIpAddresses']: for addr in data['NetworkInterfaces'][0]['PrivateIpAddresses']:
@ -245,53 +224,45 @@ class NetworkInterfaceTest(base.EC2TestCase):
addresses.append(addr['PrivateIpAddress']) addresses.append(addr['PrivateIpAddress'])
self.assertEqual(2, len(addresses)) self.assertEqual(2, len(addresses))
resp, data = self.client.UnassignPrivateIpAddresses( data = self.client.unassign_private_ip_addresses(
NetworkInterfaceId=ni_id, NetworkInterfaceId=ni_id,
PrivateIpAddresses=addresses) PrivateIpAddresses=addresses)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self._wait_assignment(ni_id, data)
self._wait_assignment(ni_id, resp, data)
resp, data = self.client.DescribeSubnets(SubnetIds=[self.subnet_id]) data = self.client.describe_subnets(SubnetIds=[self.subnet_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
count_after = data['Subnets'][0]['AvailableIpAddressCount'] count_after = data['Subnets'][0]['AvailableIpAddressCount']
self.assertEqual(count - 1, count_after) self.assertEqual(count - 1, count_after)
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_network_interface_waiter().wait_delete(ni_id) self.get_network_interface_waiter().wait_delete(ni_id)
def test_assign_unassign_private_addresses_by_addresses(self): def test_assign_unassign_private_addresses_by_addresses(self):
resp, data = self.client.DescribeSubnets(SubnetIds=[self.subnet_id]) data = self.client.describe_subnets(SubnetIds=[self.subnet_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
count = data['Subnets'][0]['AvailableIpAddressCount'] count = data['Subnets'][0]['AvailableIpAddressCount']
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
res_clean = self.addResourceCleanUp(self.client.DeleteNetworkInterface, res_clean = self.addResourceCleanUp(
NetworkInterfaceId=ni_id) self.client.delete_network_interface, NetworkInterfaceId=ni_id)
self.get_network_interface_waiter().wait_available(ni_id) self.get_network_interface_waiter().wait_available(ni_id)
addresses = ['10.7.0.10', '10.7.0.11'] addresses = ['10.7.0.10', '10.7.0.11']
resp, data = self.client.AssignPrivateIpAddresses( data = self.client.assign_private_ip_addresses(
NetworkInterfaceId=ni_id, NetworkInterfaceId=ni_id,
PrivateIpAddresses=addresses) PrivateIpAddresses=addresses)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self._wait_assignment(ni_id, data)
self._wait_assignment(ni_id, resp, data)
resp, data = self.client.DescribeSubnets(SubnetIds=[self.subnet_id]) data = self.client.describe_subnets(SubnetIds=[self.subnet_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
count_after = data['Subnets'][0]['AvailableIpAddressCount'] count_after = data['Subnets'][0]['AvailableIpAddressCount']
# NOTE(Alex): Amazon misses 1 IP address by some reason. # NOTE(Alex): Amazon misses 1 IP address by some reason.
self.assertIn(count_after, [count - 3, count - 4]) self.assertIn(count_after, [count - 3, count - 4])
resp, data = self.client.DescribeNetworkInterfaces( data = self.client.describe_network_interfaces(
NetworkInterfaceIds=[ni_id]) NetworkInterfaceIds=[ni_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
assigned_addresses = [] assigned_addresses = []
for addr in data['NetworkInterfaces'][0]['PrivateIpAddresses']: for addr in data['NetworkInterfaces'][0]['PrivateIpAddresses']:
@ -300,20 +271,17 @@ class NetworkInterfaceTest(base.EC2TestCase):
assigned_addresses.append(addr['PrivateIpAddress']) assigned_addresses.append(addr['PrivateIpAddress'])
self.assertEqual(2, len(assigned_addresses)) self.assertEqual(2, len(assigned_addresses))
resp, data = self.client.UnassignPrivateIpAddresses( data = self.client.unassign_private_ip_addresses(
NetworkInterfaceId=ni_id, NetworkInterfaceId=ni_id,
PrivateIpAddresses=addresses) PrivateIpAddresses=addresses)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self._wait_assignment(ni_id, data)
self._wait_assignment(ni_id, resp, data)
resp, data = self.client.DescribeSubnets(SubnetIds=[self.subnet_id]) data = self.client.describe_subnets(SubnetIds=[self.subnet_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
count_after = data['Subnets'][0]['AvailableIpAddressCount'] count_after = data['Subnets'][0]['AvailableIpAddressCount']
self.assertIn(count_after, [count - 1, count - 2]) self.assertIn(count_after, [count - 1, count - 2])
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_network_interface_waiter().wait_delete(ni_id) self.get_network_interface_waiter().wait_delete(ni_id)
@ -323,17 +291,15 @@ class NetworkInterfaceTest(base.EC2TestCase):
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
'Description': desc 'Description': desc
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
res_clean = self.addResourceCleanUp(self.client.DeleteNetworkInterface, res_clean = self.addResourceCleanUp(
NetworkInterfaceId=ni_id) self.client.delete_network_interface, NetworkInterfaceId=ni_id)
self.get_network_interface_waiter().wait_available(ni_id) self.get_network_interface_waiter().wait_available(ni_id)
resp, data = self.client.DescribeNetworkInterfaceAttribute( data = self.client.describe_network_interface_attribute(
NetworkInterfaceId=ni_id, NetworkInterfaceId=ni_id,
attribute='description') Attribute='description')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(desc, data['Description']['Value']) self.assertEqual(desc, data['Description']['Value'])
new_desc = data_utils.rand_name('new-ni') new_desc = data_utils.rand_name('new-ni')
@ -341,42 +307,36 @@ class NetworkInterfaceTest(base.EC2TestCase):
'NetworkInterfaceId': ni_id, 'NetworkInterfaceId': ni_id,
'Description': {'Value': new_desc} 'Description': {'Value': new_desc}
} }
resp, data = self.client.ModifyNetworkInterfaceAttribute(*[], **kwargs) data = self.client.modify_network_interface_attribute(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DescribeNetworkInterfaceAttribute( data = self.client.describe_network_interface_attribute(
NetworkInterfaceId=ni_id, NetworkInterfaceId=ni_id,
attribute='description') Attribute='description')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(new_desc, data['Description']['Value']) self.assertEqual(new_desc, data['Description']['Value'])
kwargs = { kwargs = {
'NetworkInterfaceId': ni_id, 'NetworkInterfaceId': ni_id,
'SourceDestCheck': {'Value': False} 'SourceDestCheck': {'Value': False}
} }
resp, data = self.client.ModifyNetworkInterfaceAttribute(*[], **kwargs) data = self.client.modify_network_interface_attribute(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DescribeNetworkInterfaceAttribute( data = self.client.describe_network_interface_attribute(
NetworkInterfaceId=ni_id, NetworkInterfaceId=ni_id,
attribute='sourceDestCheck') Attribute='sourceDestCheck')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(False, data['SourceDestCheck']['Value']) self.assertEqual(False, data['SourceDestCheck']['Value'])
# NOTE(andrey-mp): ResetNetworkInterfaceAttribute has inadequate json # NOTE(andrey-mp): ResetNetworkInterfaceAttribute had inadequate json
# scheme in botocore. # scheme in botocore.
kwargs = { kwargs = {
'NetworkInterfaceId': ni_id, 'NetworkInterfaceId': ni_id,
'SourceDestCheck': {'Value': True} 'SourceDestCheck': {'Value': True}
} }
resp, data = self.client.ModifyNetworkInterfaceAttribute(*[], **kwargs) data = self.client.modify_network_interface_attribute(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DescribeNetworkInterfaceAttribute( data = self.client.describe_network_interface_attribute(
NetworkInterfaceId=ni_id, NetworkInterfaceId=ni_id,
attribute='sourceDestCheck') Attribute='sourceDestCheck')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(True, data['SourceDestCheck']['Value']) self.assertEqual(True, data['SourceDestCheck']['Value'])
kwargs = { kwargs = {
@ -385,9 +345,9 @@ class NetworkInterfaceTest(base.EC2TestCase):
'AttachmentId': 'fake' 'AttachmentId': 'fake'
} }
} }
resp, data = self.client.ModifyNetworkInterfaceAttribute(*[], **kwargs) self.assertRaises('MissingParameter',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.modify_network_interface_attribute,
self.assertEqual('MissingParameter', data['Error']['Code']) **kwargs)
kwargs = { kwargs = {
'NetworkInterfaceId': ni_id, 'NetworkInterfaceId': ni_id,
@ -396,13 +356,12 @@ class NetworkInterfaceTest(base.EC2TestCase):
'DeleteOnTermination': True 'DeleteOnTermination': True
} }
} }
resp, data = self.client.ModifyNetworkInterfaceAttribute(*[], **kwargs) self.assertRaises('InvalidAttachmentID.NotFound',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.modify_network_interface_attribute,
self.assertEqual('InvalidAttachmentID.NotFound', data['Error']['Code']) **kwargs)
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_network_interface_waiter().wait_delete(ni_id) self.get_network_interface_waiter().wait_delete(ni_id)
@ -415,22 +374,20 @@ class NetworkInterfaceTest(base.EC2TestCase):
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
self.addResourceCleanUp(self.client.DeleteNetworkInterface, self.addResourceCleanUp(self.client.delete_network_interface,
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
ni = data['NetworkInterface'] ni = data['NetworkInterface']
address = ni.get('PrivateIpAddress') address = ni.get('PrivateIpAddress')
self.assertIsNotNone(address) self.assertIsNotNone(address)
self.get_network_interface_waiter().wait_available(ni_id) self.get_network_interface_waiter().wait_available(ni_id)
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1, ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=self.subnet_id) MaxCount=1, SubnetId=self.subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -441,17 +398,16 @@ class NetworkInterfaceTest(base.EC2TestCase):
'InstanceId': instance_id, 'InstanceId': instance_id,
'NetworkInterfaceId': ni_id 'NetworkInterfaceId': ni_id
} }
resp, data = self.client.AttachNetworkInterface(*[], **kwargs) self.assertRaises('InvalidParameterValue',
self.assertEqual(400, resp.status_code) self.client.attach_network_interface,
self.assertEqual('InvalidParameterValue', data['Error']['Code']) **kwargs)
kwargs = { kwargs = {
'DeviceIndex': 2, 'DeviceIndex': 2,
'InstanceId': instance_id, 'InstanceId': instance_id,
'NetworkInterfaceId': ni_id 'NetworkInterfaceId': ni_id
} }
resp, data = self.client.AttachNetworkInterface(*[], **kwargs) data = self.client.attach_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
attachment_id = data['AttachmentId'] attachment_id = data['AttachmentId']
instance = self.get_instance(instance_id) instance = self.get_instance(instance_id)
@ -461,19 +417,16 @@ class NetworkInterfaceTest(base.EC2TestCase):
nis[1]['Attachment']['AttachmentId']] nis[1]['Attachment']['AttachmentId']]
self.assertIn(attachment_id, ids) self.assertIn(attachment_id, ids)
resp, data = self.client.DeleteNetworkInterface( self.assertRaises('InvalidParameterValue',
self.client.delete_network_interface,
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
kwargs = { kwargs = {
'AttachmentId': attachment_id, 'AttachmentId': attachment_id,
} }
resp, data = self.client.DetachNetworkInterface(*[], **kwargs) data = self.client.detach_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -483,12 +436,11 @@ class NetworkInterfaceTest(base.EC2TestCase):
if not image_id: if not image_id:
raise self.skipException('aws image_id does not provided') raise self.skipException('aws image_id does not provided')
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1, ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=self.subnet_id) MaxCount=1, SubnetId=self.subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -507,27 +459,24 @@ class NetworkInterfaceTest(base.EC2TestCase):
'DeleteOnTermination': False, 'DeleteOnTermination': False,
} }
} }
resp, data = self.client.ModifyNetworkInterfaceAttribute(*[], **kwargs) data = self.client.modify_network_interface_attribute(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) clean_ni = self.addResourceCleanUp(
clean_ni = self.addResourceCleanUp(self.client.DeleteNetworkInterface, self.client.delete_network_interface, NetworkInterfaceId=ni_id)
NetworkInterfaceId=ni_id)
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id2 = data['NetworkInterface']['NetworkInterfaceId'] ni_id2 = data['NetworkInterface']['NetworkInterfaceId']
clean_ni2 = self.addResourceCleanUp(self.client.DeleteNetworkInterface, clean_ni2 = self.addResourceCleanUp(
NetworkInterfaceId=ni_id2) self.client.delete_network_interface, NetworkInterfaceId=ni_id2)
self.get_network_interface_waiter().wait_available(ni_id2) self.get_network_interface_waiter().wait_available(ni_id2)
kwargs = { kwargs = {
'DeviceIndex': 2, 'DeviceIndex': 2,
'InstanceId': instance_id, 'InstanceId': instance_id,
'NetworkInterfaceId': ni_id2 'NetworkInterfaceId': ni_id2
} }
resp, data = self.client.AttachNetworkInterface(*[], **kwargs) data = self.client.attach_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
attachment_id = data['AttachmentId'] attachment_id = data['AttachmentId']
instance = self.get_instance(instance_id) instance = self.get_instance(instance_id)
@ -539,23 +488,20 @@ class NetworkInterfaceTest(base.EC2TestCase):
self.assertEqual(attachment_id, ni['Attachment']['AttachmentId']) self.assertEqual(attachment_id, ni['Attachment']['AttachmentId'])
self.assertFalse(ni['Attachment']['DeleteOnTermination']) self.assertFalse(ni['Attachment']['DeleteOnTermination'])
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
self.get_network_interface_waiter().wait_available(ni_id) self.get_network_interface_waiter().wait_available(ni_id)
self.get_network_interface_waiter().wait_available(ni_id2) self.get_network_interface_waiter().wait_available(ni_id2)
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_ni) self.cancelResourceCleanUp(clean_ni)
self.get_network_interface_waiter().wait_delete(ni_id) self.get_network_interface_waiter().wait_delete(ni_id)
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id2) NetworkInterfaceId=ni_id2)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_ni2) self.cancelResourceCleanUp(clean_ni2)
self.get_network_interface_waiter().wait_delete(ni_id2) self.get_network_interface_waiter().wait_delete(ni_id2)
@ -565,12 +511,11 @@ class NetworkInterfaceTest(base.EC2TestCase):
if not image_id: if not image_id:
raise self.skipException('aws image_id does not provided') raise self.skipException('aws image_id does not provided')
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1, ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=self.subnet_id) MaxCount=1, SubnetId=self.subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -584,10 +529,9 @@ class NetworkInterfaceTest(base.EC2TestCase):
kwargs = { kwargs = {
'SubnetId': self.subnet_id, 'SubnetId': self.subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id2 = data['NetworkInterface']['NetworkInterfaceId'] ni_id2 = data['NetworkInterface']['NetworkInterfaceId']
self.addResourceCleanUp(self.client.DeleteNetworkInterface, self.addResourceCleanUp(self.client.delete_network_interface,
NetworkInterfaceId=ni_id2) NetworkInterfaceId=ni_id2)
self.get_network_interface_waiter().wait_available(ni_id2) self.get_network_interface_waiter().wait_available(ni_id2)
kwargs = { kwargs = {
@ -595,8 +539,7 @@ class NetworkInterfaceTest(base.EC2TestCase):
'InstanceId': instance_id, 'InstanceId': instance_id,
'NetworkInterfaceId': ni_id2 'NetworkInterfaceId': ni_id2
} }
resp, data = self.client.AttachNetworkInterface(*[], **kwargs) data = self.client.attach_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
attachment_id = data['AttachmentId'] attachment_id = data['AttachmentId']
kwargs = { kwargs = {
@ -606,11 +549,9 @@ class NetworkInterfaceTest(base.EC2TestCase):
'DeleteOnTermination': True, 'DeleteOnTermination': True,
} }
} }
resp, data = self.client.ModifyNetworkInterfaceAttribute(*[], **kwargs) data = self.client.modify_network_interface_attribute(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)

6
ec2api/tests/functional/api/test_regions.py
View File

@ -22,8 +22,7 @@ CONF = config.CONF
class RegionTest(base.EC2TestCase): class RegionTest(base.EC2TestCase):
def test_describe_regions(self): def test_describe_regions(self):
resp, data = self.client.DescribeRegions() data = self.client.describe_regions()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertNotEmpty(data['Regions']) self.assertNotEmpty(data['Regions'])
region = CONF.aws.aws_region region = CONF.aws.aws_region
@ -34,8 +33,7 @@ class RegionTest(base.EC2TestCase):
self.assertIn(region, regions) self.assertIn(region, regions)
def test_describe_zones(self): def test_describe_zones(self):
resp, data = self.client.DescribeAvailabilityZones() data = self.client.describe_availability_zones()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertNotEmpty(data['AvailabilityZones']) self.assertNotEmpty(data['AvailabilityZones'])
region = CONF.aws.aws_region region = CONF.aws.aws_region

214
ec2api/tests/functional/api/test_routes.py
View File

@ -35,17 +35,15 @@ class RouteTest(base.EC2TestCase):
if not base.TesterStateHolder().get_vpc_enabled(): if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled') raise cls.skipException('VPC is disabled')
resp, data = cls.client.CreateVpc(CidrBlock=cls.VPC_CIDR) data = cls.client.create_vpc(CidrBlock=cls.VPC_CIDR)
cls.assertResultStatic(resp, data)
cls.vpc_id = data['Vpc']['VpcId'] cls.vpc_id = data['Vpc']['VpcId']
cls.addResourceCleanUpStatic(cls.client.DeleteVpc, VpcId=cls.vpc_id) cls.addResourceCleanUpStatic(cls.client.delete_vpc, VpcId=cls.vpc_id)
cls.get_vpc_waiter().wait_available(cls.vpc_id) cls.get_vpc_waiter().wait_available(cls.vpc_id)
def test_create_delete_route_table(self): def test_create_delete_route_table(self):
resp, data = self.client.CreateRouteTable(VpcId=self.vpc_id) data = self.client.create_route_table(VpcId=self.vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
rt_id = data['RouteTable']['RouteTableId'] rt_id = data['RouteTable']['RouteTableId']
res_clean = self.addResourceCleanUp(self.client.DeleteRouteTable, res_clean = self.addResourceCleanUp(self.client.delete_route_table,
RouteTableId=rt_id) RouteTableId=rt_id)
rt = data['RouteTable'] rt = data['RouteTable']
self.assertEqual(self.vpc_id, rt['VpcId']) self.assertEqual(self.vpc_id, rt['VpcId'])
@ -54,148 +52,127 @@ class RouteTest(base.EC2TestCase):
self.assertEqual(self.VPC_CIDR, route['DestinationCidrBlock']) self.assertEqual(self.VPC_CIDR, route['DestinationCidrBlock'])
self.assertEqual('active', route['State']) self.assertEqual('active', route['State'])
resp, data = self.client.DeleteRouteTable(RouteTableId=rt_id) data = self.client.delete_route_table(RouteTableId=rt_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
resp, data = self.client.DescribeRouteTables(RouteTableIds=[rt_id]) self.assertRaises('InvalidRouteTableID.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_route_tables,
self.assertEqual('InvalidRouteTableID.NotFound', data['Error']['Code']) RouteTableIds=[rt_id])
resp, data = self.client.DeleteRouteTable(RouteTableId=rt_id) self.assertRaises('InvalidRouteTableID.NotFound',
self.assertEqual(400, resp.status_code) self.client.delete_route_table,
self.assertEqual('InvalidRouteTableID.NotFound', data['Error']['Code']) RouteTableId=rt_id)
def test_describe_route_tables_base(self): def test_describe_route_tables_base(self):
resp, data = self.client.CreateRouteTable(VpcId=self.vpc_id) data = self.client.create_route_table(VpcId=self.vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
rt_id = data['RouteTable']['RouteTableId'] rt_id = data['RouteTable']['RouteTableId']
res_clean = self.addResourceCleanUp(self.client.DeleteRouteTable, res_clean = self.addResourceCleanUp(self.client.delete_route_table,
RouteTableId=rt_id) RouteTableId=rt_id)
# NOTE(andrey-mp): by real id # NOTE(andrey-mp): by real id
resp, data = self.client.DescribeRouteTables(RouteTableIds=[rt_id]) data = self.client.describe_route_tables(RouteTableIds=[rt_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['RouteTables'])) self.assertEqual(1, len(data['RouteTables']))
# NOTE(andrey-mp): by fake id # NOTE(andrey-mp): by fake id
resp, data = self.client.DescribeRouteTables(RouteTableIds=['rtb-0']) self.assertRaises('InvalidRouteTableID.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_route_tables,
self.assertEqual('InvalidRouteTableID.NotFound', data['Error']['Code']) RouteTableIds=['rtb-0'])
resp, data = self.client.DeleteRouteTable(RouteTableId=rt_id) data = self.client.delete_route_table(RouteTableId=rt_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_describe_route_tables_filters(self): def test_describe_route_tables_filters(self):
resp, data = self.client.CreateRouteTable(VpcId=self.vpc_id) data = self.client.create_route_table(VpcId=self.vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
rt_id = data['RouteTable']['RouteTableId'] rt_id = data['RouteTable']['RouteTableId']
self.addResourceCleanUp(self.client.DeleteRouteTable, self.addResourceCleanUp(self.client.delete_route_table,
RouteTableId=rt_id) RouteTableId=rt_id)
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, data = self.client.create_subnet(VpcId=self.vpc_id,
CidrBlock=self.SUBNET_CIDR) CidrBlock=self.SUBNET_CIDR)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
self.addResourceCleanUp(self.client.DeleteSubnet, self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
self.get_subnet_waiter().wait_available(subnet_id) self.get_subnet_waiter().wait_available(subnet_id)
resp, data = self.client.AssociateRouteTable(RouteTableId=rt_id, data = self.client.associate_route_table(RouteTableId=rt_id,
SubnetId=subnet_id) SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
assoc_id = data['AssociationId'] assoc_id = data['AssociationId']
self.addResourceCleanUp(self.client.DisassociateRouteTable, self.addResourceCleanUp(self.client.disassociate_route_table,
AssociationId=assoc_id) AssociationId=assoc_id)
# NOTE(andrey-mp): by association_id # NOTE(andrey-mp): by association_id
resp, data = self.client.DescribeRouteTables( data = self.client.describe_route_tables(
Filters=[{'Name': 'association.route-table-association-id', Filters=[{'Name': 'association.route-table-association-id',
'Values': [assoc_id]}]) 'Values': [assoc_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['RouteTables'])) self.assertEqual(1, len(data['RouteTables']))
# NOTE(andrey-mp): by route table id # NOTE(andrey-mp): by route table id
resp, data = self.client.DescribeRouteTables( data = self.client.describe_route_tables(
Filters=[{'Name': 'association.route-table-id', Filters=[{'Name': 'association.route-table-id',
'Values': [rt_id]}]) 'Values': [rt_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['RouteTables'])) self.assertEqual(1, len(data['RouteTables']))
# NOTE(andrey-mp): by subnet id # NOTE(andrey-mp): by subnet id
resp, data = self.client.DescribeRouteTables( data = self.client.describe_route_tables(
Filters=[{'Name': 'association.subnet-id', Filters=[{'Name': 'association.subnet-id',
'Values': [subnet_id]}]) 'Values': [subnet_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['RouteTables'])) self.assertEqual(1, len(data['RouteTables']))
# NOTE(andrey-mp): by filter real vpc # NOTE(andrey-mp): by filter real vpc
resp, data = self.client.DescribeRouteTables( data = self.client.describe_route_tables(
Filters=[{'Name': 'vpc-id', 'Values': [self.vpc_id]}]) Filters=[{'Name': 'vpc-id', 'Values': [self.vpc_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertLess(0, len(data['RouteTables'])) self.assertLess(0, len(data['RouteTables']))
# NOTE(andrey-mp): by filter fake vpc # NOTE(andrey-mp): by filter fake vpc
resp, data = self.client.DescribeRouteTables( data = self.client.describe_route_tables(
Filters=[{'Name': 'vpc-id', 'Values': ['vpc-0']}]) Filters=[{'Name': 'vpc-id', 'Values': ['vpc-0']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['RouteTables'])) self.assertEqual(0, len(data['RouteTables']))
# NOTE(andrey-mp): by fake filter # NOTE(andrey-mp): by fake filter
resp, data = self.client.DescribeRouteTables( self.assertRaises('InvalidParameterValue',
self.client.describe_route_tables,
Filters=[{'Name': 'fake', 'Values': ['fake']}]) Filters=[{'Name': 'fake', 'Values': ['fake']}])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
def test_associate_disassociate_route_table(self): def test_associate_disassociate_route_table(self):
resp, data = self.client.CreateRouteTable(VpcId=self.vpc_id) data = self.client.create_route_table(VpcId=self.vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
rt_id = data['RouteTable']['RouteTableId'] rt_id = data['RouteTable']['RouteTableId']
res_clean_rt = self.addResourceCleanUp(self.client.DeleteRouteTable, res_clean_rt = self.addResourceCleanUp(self.client.delete_route_table,
RouteTableId=rt_id) RouteTableId=rt_id)
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, data = self.client.create_subnet(VpcId=self.vpc_id,
CidrBlock=self.SUBNET_CIDR) CidrBlock=self.SUBNET_CIDR)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
res_clean_subnet = self.addResourceCleanUp(self.client.DeleteSubnet, res_clean_subnet = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
self.get_subnet_waiter().wait_available(subnet_id) self.get_subnet_waiter().wait_available(subnet_id)
resp, data = self.client.AssociateRouteTable(RouteTableId=rt_id, data = self.client.associate_route_table(RouteTableId=rt_id,
SubnetId=subnet_id) SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
assoc_id = data['AssociationId'] assoc_id = data['AssociationId']
res_clean = self.addResourceCleanUp(self.client.DisassociateRouteTable, res_clean = self.addResourceCleanUp(
AssociationId=assoc_id) self.client.disassociate_route_table, AssociationId=assoc_id)
resp, data = self.client.DisassociateRouteTable(AssociationId=assoc_id) data = self.client.disassociate_route_table(AssociationId=assoc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) data = self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_subnet) self.cancelResourceCleanUp(res_clean_subnet)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
resp, data = self.client.DeleteRouteTable(RouteTableId=rt_id) data = self.client.delete_route_table(RouteTableId=rt_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_rt) self.cancelResourceCleanUp(res_clean_rt)
def test_replace_route_table(self): def test_replace_route_table(self):
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, data = self.client.create_subnet(VpcId=self.vpc_id,
CidrBlock=self.SUBNET_CIDR) CidrBlock=self.SUBNET_CIDR)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
res_clean_subnet = self.addResourceCleanUp(self.client.DeleteSubnet, res_clean_subnet = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
self.get_subnet_waiter().wait_available(subnet_id) self.get_subnet_waiter().wait_available(subnet_id)
# NOTE(andrey-mp): by vpc id # NOTE(andrey-mp): by vpc id
resp, data = self.client.DescribeRouteTables( data = self.client.describe_route_tables(
Filters=[{'Name': 'vpc-id', 'Values': [self.vpc_id]}]) Filters=[{'Name': 'vpc-id', 'Values': [self.vpc_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['RouteTables'])) self.assertEqual(1, len(data['RouteTables']))
self.assertEqual(1, len(data['RouteTables'][0]['Associations'])) self.assertEqual(1, len(data['RouteTables'][0]['Associations']))
default_rt_id = data['RouteTables'][0]['RouteTableId'] default_rt_id = data['RouteTables'][0]['RouteTableId']
@ -203,25 +180,22 @@ class RouteTest(base.EC2TestCase):
self.assertTrue(main_assoc['Main']) self.assertTrue(main_assoc['Main'])
main_assoc_id = main_assoc['RouteTableAssociationId'] main_assoc_id = main_assoc['RouteTableAssociationId']
resp, data = self.client.CreateRouteTable(VpcId=self.vpc_id) data = self.client.create_route_table(VpcId=self.vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
rt_id = data['RouteTable']['RouteTableId'] rt_id = data['RouteTable']['RouteTableId']
res_clean_rt = self.addResourceCleanUp(self.client.DeleteRouteTable, res_clean_rt = self.addResourceCleanUp(self.client.delete_route_table,
RouteTableId=rt_id) RouteTableId=rt_id)
resp, data = self.client.ReplaceRouteTableAssociation( data = self.client.replace_route_table_association(
RouteTableId=rt_id, AssociationId=main_assoc_id) RouteTableId=rt_id, AssociationId=main_assoc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
assoc_id = data['NewAssociationId'] assoc_id = data['NewAssociationId']
res_clean = self.addResourceCleanUp( res_clean = self.addResourceCleanUp(
self.client.ReplaceRouteTableAssociation, self.client.replace_route_table_association,
RouteTableId=default_rt_id, RouteTableId=default_rt_id,
AssociationId=assoc_id) AssociationId=assoc_id)
# NOTE(andrey-mp): by vpc id # NOTE(andrey-mp): by vpc id
resp, data = self.client.DescribeRouteTables( data = self.client.describe_route_tables(
Filters=[{'Name': 'vpc-id', 'Values': [self.vpc_id]}]) Filters=[{'Name': 'vpc-id', 'Values': [self.vpc_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(2, len(data['RouteTables'])) self.assertEqual(2, len(data['RouteTables']))
for rt in data['RouteTables']: for rt in data['RouteTables']:
if rt['RouteTableId'] == rt_id: if rt['RouteTableId'] == rt_id:
@ -230,52 +204,46 @@ class RouteTest(base.EC2TestCase):
else: else:
self.assertEmpty(rt.get('Associations', [])) self.assertEmpty(rt.get('Associations', []))
resp, data = self.client.DeleteRouteTable(RouteTableId=rt_id) self.assertRaises('DependencyViolation',
self.assertEqual(400, resp.status_code) self.client.delete_route_table,
self.assertEqual('DependencyViolation', data['Error']['Code']) RouteTableId=rt_id)
resp, data = self.client.DisassociateRouteTable(AssociationId=assoc_id) self.assertRaises('InvalidParameterValue',
self.assertEqual(400, resp.status_code) self.client.disassociate_route_table,
self.assertEqual('InvalidParameterValue', data['Error']['Code']) AssociationId=assoc_id)
resp, data = self.client.ReplaceRouteTableAssociation( data = self.client.replace_route_table_association(
RouteTableId=default_rt_id, RouteTableId=default_rt_id,
AssociationId=assoc_id) AssociationId=assoc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
resp, data = self.client.DeleteRouteTable(RouteTableId=rt_id) data = self.client.delete_route_table(RouteTableId=rt_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_rt) self.cancelResourceCleanUp(res_clean_rt)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) data = self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_subnet) self.cancelResourceCleanUp(res_clean_subnet)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
def test_create_delete_route(self): def test_create_delete_route(self):
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, data = self.client.create_subnet(VpcId=self.vpc_id,
CidrBlock=self.SUBNET_CIDR) CidrBlock=self.SUBNET_CIDR)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
res_clean_subnet = self.addResourceCleanUp(self.client.DeleteSubnet, res_clean_subnet = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
self.get_subnet_waiter().wait_available(subnet_id) self.get_subnet_waiter().wait_available(subnet_id)
kwargs = { kwargs = {
'SubnetId': subnet_id, 'SubnetId': subnet_id,
} }
resp, data = self.client.CreateNetworkInterface(*[], **kwargs) data = self.client.create_network_interface(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
res_clean_ni = self.addResourceCleanUp( res_clean_ni = self.addResourceCleanUp(
self.client.DeleteNetworkInterface, self.client.delete_network_interface,
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
resp, data = self.client.CreateRouteTable(VpcId=self.vpc_id) data = self.client.create_route_table(VpcId=self.vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
rt_id = data['RouteTable']['RouteTableId'] rt_id = data['RouteTable']['RouteTableId']
res_clean_rt = self.addResourceCleanUp(self.client.DeleteRouteTable, res_clean_rt = self.addResourceCleanUp(self.client.delete_route_table,
RouteTableId=rt_id) RouteTableId=rt_id)
kwargs = { kwargs = {
@ -283,9 +251,9 @@ class RouteTest(base.EC2TestCase):
'RouteTableId': rt_id, 'RouteTableId': rt_id,
'NetworkInterfaceId': ni_id 'NetworkInterfaceId': ni_id
} }
resp, data = self.client.CreateRoute(*[], **kwargs) self.assertRaises('InvalidParameterValue',
self.assertEqual(400, resp.status_code) self.client.create_route,
self.assertEqual('InvalidParameterValue', data['Error']['Code']) **kwargs)
# can create wider route # can create wider route
kwargs = { kwargs = {
@ -293,19 +261,16 @@ class RouteTest(base.EC2TestCase):
'RouteTableId': rt_id, 'RouteTableId': rt_id,
'NetworkInterfaceId': ni_id 'NetworkInterfaceId': ni_id
} }
resp, data = self.client.CreateRoute(*[], **kwargs) data = self.client.create_route(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
# can create to another vpc # can create to another vpc
kwargs = { kwargs = {
'DestinationCidrBlock': '10.15.0.0/20', 'DestinationCidrBlock': '10.15.0.0/20',
'RouteTableId': rt_id, 'RouteTableId': rt_id,
'NetworkInterfaceId': ni_id 'NetworkInterfaceId': ni_id
} }
resp, data = self.client.CreateRoute(*[], **kwargs) data = self.client.create_route(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DescribeRouteTables(RouteTableIds=[rt_id]) data = self.client.describe_route_tables(RouteTableIds=[rt_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['RouteTables'])) self.assertEqual(1, len(data['RouteTables']))
self.assertEqual(3, len(data['RouteTables'][0]['Routes'])) self.assertEqual(3, len(data['RouteTables'][0]['Routes']))
@ -313,59 +278,54 @@ class RouteTest(base.EC2TestCase):
'DestinationCidrBlock': '10.15.0.0/24', 'DestinationCidrBlock': '10.15.0.0/24',
'RouteTableId': rt_id, 'RouteTableId': rt_id,
} }
resp, data = self.client.DeleteRoute(*[], **kwargs) self.assertRaises('InvalidRoute.NotFound',
self.assertEqual(400, resp.status_code) self.client.delete_route,
self.assertEqual('InvalidRoute.NotFound', data['Error']['Code']) **kwargs)
kwargs = { kwargs = {
'DestinationCidrBlock': self.VPC_CIDR, 'DestinationCidrBlock': self.VPC_CIDR,
'RouteTableId': rt_id, 'RouteTableId': rt_id,
} }
resp, data = self.client.DeleteRoute(*[], **kwargs) self.assertRaises('InvalidParameterValue',
self.assertEqual(400, resp.status_code) self.client.delete_route,
self.assertEqual('InvalidParameterValue', data['Error']['Code']) **kwargs)
kwargs = { kwargs = {
'DestinationCidrBlock': self.SUBNET_CIDR, 'DestinationCidrBlock': self.SUBNET_CIDR,
'RouteTableId': rt_id, 'RouteTableId': rt_id,
} }
resp, data = self.client.DeleteRoute(*[], **kwargs) self.assertRaises('InvalidRoute.NotFound',
self.assertEqual(400, resp.status_code) self.client.delete_route,
self.assertEqual('InvalidRoute.NotFound', data['Error']['Code']) **kwargs)
kwargs = { kwargs = {
'DestinationCidrBlock': '10.16.0.0/24', 'DestinationCidrBlock': '10.16.0.0/24',
'RouteTableId': rt_id, 'RouteTableId': rt_id,
} }
resp, data = self.client.DeleteRoute(*[], **kwargs) self.assertRaises('InvalidRoute.NotFound',
self.assertEqual(400, resp.status_code) self.client.delete_route,
self.assertEqual('InvalidRoute.NotFound', data['Error']['Code']) **kwargs)
kwargs = { kwargs = {
'DestinationCidrBlock': '10.15.0.0/20', 'DestinationCidrBlock': '10.15.0.0/20',
'RouteTableId': rt_id, 'RouteTableId': rt_id,
} }
resp, data = self.client.DeleteRoute(*[], **kwargs) data = self.client.delete_route(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
kwargs = { kwargs = {
'DestinationCidrBlock': '10.14.0.0/19', 'DestinationCidrBlock': '10.14.0.0/19',
'RouteTableId': rt_id, 'RouteTableId': rt_id,
} }
resp, data = self.client.DeleteRoute(*[], **kwargs) data = self.client.delete_route(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DeleteRouteTable(RouteTableId=rt_id) data = self.client.delete_route_table(RouteTableId=rt_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_rt) self.cancelResourceCleanUp(res_clean_rt)
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_ni) self.cancelResourceCleanUp(res_clean_ni)
self.get_network_interface_waiter().wait_delete(ni_id) self.get_network_interface_waiter().wait_delete(ni_id)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) data = self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_subnet) self.cancelResourceCleanUp(res_clean_subnet)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)

85
ec2api/tests/functional/api/test_security_groups.py
View File

@ -39,86 +39,77 @@ class SecurityGroupTest(base.EC2TestCase):
if not base.TesterStateHolder().get_vpc_enabled(): if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled') raise cls.skipException('VPC is disabled')
resp, data = cls.client.CreateVpc(CidrBlock=cls.VPC_CIDR) data = cls.client.create_vpc(CidrBlock=cls.VPC_CIDR)
cls.assertResultStatic(resp, data)
cls.vpc_id = data['Vpc']['VpcId'] cls.vpc_id = data['Vpc']['VpcId']
cls.addResourceCleanUpStatic(cls.client.DeleteVpc, VpcId=cls.vpc_id) cls.addResourceCleanUpStatic(cls.client.delete_vpc, VpcId=cls.vpc_id)
cls.get_vpc_waiter().wait_available(cls.vpc_id) cls.get_vpc_waiter().wait_available(cls.vpc_id)
def test_create_delete_security_group(self): def test_create_delete_security_group(self):
name = data_utils.rand_name('sgName') name = data_utils.rand_name('sgName')
desc = data_utils.rand_name('sgDesc') desc = data_utils.rand_name('sgDesc')
resp, data = self.client.CreateSecurityGroup(VpcId=self.vpc_id, data = self.client.create_security_group(VpcId=self.vpc_id,
GroupName=name, GroupName=name,
Description=desc) Description=desc)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
group_id = data['GroupId'] group_id = data['GroupId']
res_clean = self.addResourceCleanUp(self.client.DeleteSecurityGroup, res_clean = self.addResourceCleanUp(self.client.delete_security_group,
GroupId=group_id) GroupId=group_id)
time.sleep(2) time.sleep(2)
resp, data = self.client.DeleteSecurityGroup(GroupId=group_id) data = self.client.delete_security_group(GroupId=group_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
resp, data = self.client.DescribeSecurityGroups(GroupIds=[group_id]) self.assertRaises('InvalidGroup.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_security_groups,
self.assertEqual('InvalidGroup.NotFound', data['Error']['Code']) GroupIds=[group_id])
resp, data = self.client.DeleteSecurityGroup(GroupId=group_id) self.assertRaises('InvalidGroup.NotFound',
self.assertEqual(400, resp.status_code) self.client.delete_security_group,
self.assertEqual('InvalidGroup.NotFound', data['Error']['Code']) GroupId=group_id)
@testtools.skipUnless(CONF.aws.run_incompatible_tests, @testtools.skipUnless(CONF.aws.run_incompatible_tests,
"MismatchError: 'InvalidParameterValue' != 'ValidationError'") "MismatchError: 'InvalidParameterValue' != 'ValidationError'")
def test_create_invalid_name_desc(self): def test_create_invalid_name_desc(self):
valid = data_utils.rand_name('sgName') valid = data_utils.rand_name('sgName')
invalid = 'name%"' invalid = 'name%"'
resp, data = self.client.CreateSecurityGroup(VpcId=self.vpc_id, self.assertRaises('InvalidParameterValue',
GroupName=invalid, self.client.create_security_group,
VpcId=self.vpc_id, GroupName=invalid,
Description=valid) Description=valid)
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
resp, data = self.client.CreateSecurityGroup(VpcId=self.vpc_id, self.assertRaises('InvalidParameterValue',
GroupName=valid, self.client.create_security_group,
VpcId=self.vpc_id, GroupName=valid,
Description=invalid) Description=invalid)
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
resp, data = self.client.CreateSecurityGroup(VpcId=self.vpc_id, self.assertRaises('MissingParameter',
GroupName=valid) self.client.create_security_group,
self.assertEqual(400, resp.status_code) VpcId=self.vpc_id, GroupName=valid, Description='')
self.assertEqual('MissingParameter', data['Error']['Code'])
resp, data = self.client.CreateSecurityGroup(VpcId=self.vpc_id, self.assertRaises('MissingParameter',
Description=valid) self.client.create_security_group,
self.assertEqual(400, resp.status_code) VpcId=self.vpc_id, GroupName='', Description=valid)
self.assertEqual('MissingParameter', data['Error']['Code'])
def test_ingress_rules(self): def test_ingress_rules(self):
self._test_rules(self.client.AuthorizeSecurityGroupIngress, self._test_rules(self.client.authorize_security_group_ingress,
self.client.RevokeSecurityGroupIngress, self.client.revoke_security_group_ingress,
'IpPermissions') 'IpPermissions')
def test_egress_rules(self): def test_egress_rules(self):
self._test_rules(self.client.AuthorizeSecurityGroupEgress, self._test_rules(self.client.authorize_security_group_egress,
self.client.RevokeSecurityGroupEgress, self.client.revoke_security_group_egress,
'IpPermissionsEgress') 'IpPermissionsEgress')
def _test_rules(self, add_func, del_func, field): def _test_rules(self, add_func, del_func, field):
name = data_utils.rand_name('sgName') name = data_utils.rand_name('sgName')
desc = data_utils.rand_name('sgDesc') desc = data_utils.rand_name('sgDesc')
resp, data = self.client.CreateSecurityGroup(VpcId=self.vpc_id, data = self.client.create_security_group(VpcId=self.vpc_id,
GroupName=name, GroupName=name,
Description=desc) Description=desc)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
group_id = data['GroupId'] group_id = data['GroupId']
res_clean = self.addResourceCleanUp(self.client.DeleteSecurityGroup, res_clean = self.addResourceCleanUp(self.client.delete_security_group,
GroupId=group_id) GroupId=group_id)
time.sleep(2) time.sleep(2)
resp, data = self.client.DescribeSecurityGroups(GroupIds=[group_id]) data = self.client.describe_security_groups(GroupIds=[group_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
count = len(data['SecurityGroups'][0][field]) count = len(data['SecurityGroups'][0][field])
kwargs = { kwargs = {
@ -132,11 +123,9 @@ class SecurityGroupTest(base.EC2TestCase):
}], }],
}] }]
} }
resp, data = add_func(*[], **kwargs) data = add_func(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DescribeSecurityGroups(GroupIds=[group_id]) data = self.client.describe_security_groups(GroupIds=[group_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['SecurityGroups'])) self.assertEqual(1, len(data['SecurityGroups']))
self.assertEqual(count + 1, len(data['SecurityGroups'][0][field])) self.assertEqual(count + 1, len(data['SecurityGroups'][0][field]))
found = False found = False
@ -150,13 +139,9 @@ class SecurityGroupTest(base.EC2TestCase):
found = True found = True
self.assertTrue(found) self.assertTrue(found)
resp, data = del_func(*[], **kwargs) data = del_func(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = del_func(*[], **kwargs) self.assertRaises('InvalidPermission.NotFound', del_func, **kwargs)
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidPermission.NotFound', data['Error']['Code'])
resp, data = self.client.DeleteSecurityGroup(GroupId=group_id) data = self.client.delete_security_group(GroupId=group_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)

112
ec2api/tests/functional/api/test_snapshots.py
View File

@ -28,10 +28,9 @@ class SnapshotTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
clean_vol = self.addResourceCleanUp(self.client.DeleteVolume, clean_vol = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
@ -40,10 +39,9 @@ class SnapshotTest(base.EC2TestCase):
'VolumeId': volume_id, 'VolumeId': volume_id,
'Description': desc 'Description': desc
} }
resp, data = self.client.CreateSnapshot(*[], **kwargs) data = self.client.create_snapshot(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
snapshot_id = data['SnapshotId'] snapshot_id = data['SnapshotId']
res_clean = self.addResourceCleanUp(self.client.DeleteSnapshot, res_clean = self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
self.get_snapshot_waiter().wait_available(snapshot_id, self.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed')) final_set=('completed'))
@ -56,13 +54,11 @@ class SnapshotTest(base.EC2TestCase):
self.assertFalse(data['Encrypted']) self.assertFalse(data['Encrypted'])
self.assertIsNotNone(data['StartTime']) self.assertIsNotNone(data['StartTime'])
resp, data = self.client.DeleteSnapshot(SnapshotId=snapshot_id) data = self.client.delete_snapshot(SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_snapshot_waiter().wait_delete(snapshot_id) self.get_snapshot_waiter().wait_delete(snapshot_id)
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vol) self.cancelResourceCleanUp(clean_vol)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
@ -71,10 +67,9 @@ class SnapshotTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
clean_vol = self.addResourceCleanUp(self.client.DeleteVolume, clean_vol = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
@ -83,11 +78,10 @@ class SnapshotTest(base.EC2TestCase):
'VolumeId': volume_id, 'VolumeId': volume_id,
'Description': desc 'Description': desc
} }
resp, data = self.client.CreateSnapshot(*[], **kwargs) data = self.client.create_snapshot(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
snapshot_id = data['SnapshotId'] snapshot_id = data['SnapshotId']
ownerId = data['OwnerId'] ownerId = data['OwnerId']
res_clean = self.addResourceCleanUp(self.client.DeleteSnapshot, res_clean = self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
self.get_snapshot_waiter().wait_available(snapshot_id, self.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed')) final_set=('completed'))
@ -100,8 +94,7 @@ class SnapshotTest(base.EC2TestCase):
self.assertFalse(data['Encrypted']) self.assertFalse(data['Encrypted'])
self.assertIsNotNone(data['StartTime']) self.assertIsNotNone(data['StartTime'])
resp, data = self.client.DescribeSnapshots(SnapshotIds=[snapshot_id]) data = self.client.describe_snapshots(SnapshotIds=[snapshot_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Snapshots'])) self.assertEqual(1, len(data['Snapshots']))
data = data['Snapshots'][0] data = data['Snapshots'][0]
self.assertEqual(snapshot_id, data['SnapshotId']) self.assertEqual(snapshot_id, data['SnapshotId'])
@ -113,22 +106,19 @@ class SnapshotTest(base.EC2TestCase):
self.assertFalse(data['Encrypted']) self.assertFalse(data['Encrypted'])
self.assertIsNotNone(data['StartTime']) self.assertIsNotNone(data['StartTime'])
resp, data = self.client.DescribeSnapshots(OwnerIds=[ownerId]) data = self.client.describe_snapshots(OwnerIds=[ownerId])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
data = [s for s in data['Snapshots'] if s['SnapshotId'] == snapshot_id] data = [s for s in data['Snapshots'] if s['SnapshotId'] == snapshot_id]
self.assertEqual(1, len(data)) self.assertEqual(1, len(data))
resp, data = self.client.DeleteSnapshot(SnapshotId=snapshot_id) data = self.client.delete_snapshot(SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_snapshot_waiter().wait_delete(snapshot_id) self.get_snapshot_waiter().wait_delete(snapshot_id)
resp, data = self.client.DescribeSnapshots(SnapshotIds=[snapshot_id]) self.assertRaises('InvalidSnapshot.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_snapshots,
self.assertEqual('InvalidSnapshot.NotFound', data['Error']['Code']) SnapshotIds=[snapshot_id])
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vol) self.cancelResourceCleanUp(clean_vol)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
@ -137,10 +127,9 @@ class SnapshotTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
clean_vol = self.addResourceCleanUp(self.client.DeleteVolume, clean_vol = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
vol1 = data vol1 = data
@ -150,10 +139,9 @@ class SnapshotTest(base.EC2TestCase):
'VolumeId': volume_id, 'VolumeId': volume_id,
'Description': desc 'Description': desc
} }
resp, data = self.client.CreateSnapshot(*[], **kwargs) data = self.client.create_snapshot(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
snapshot_id = data['SnapshotId'] snapshot_id = data['SnapshotId']
res_clean = self.addResourceCleanUp(self.client.DeleteSnapshot, res_clean = self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
self.get_snapshot_waiter().wait_available(snapshot_id, self.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed')) final_set=('completed'))
@ -162,10 +150,9 @@ class SnapshotTest(base.EC2TestCase):
'SnapshotId': snapshot_id, 'SnapshotId': snapshot_id,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id2 = data['VolumeId'] volume_id2 = data['VolumeId']
clean_vol2 = self.addResourceCleanUp(self.client.DeleteVolume, clean_vol2 = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id2) VolumeId=volume_id2)
self.get_volume_waiter().wait_available(volume_id2) self.get_volume_waiter().wait_available(volume_id2)
@ -173,24 +160,20 @@ class SnapshotTest(base.EC2TestCase):
self.assertEqual(vol1['Size'], data['Size']) self.assertEqual(vol1['Size'], data['Size'])
self.assertEqual(snapshot_id, data['SnapshotId']) self.assertEqual(snapshot_id, data['SnapshotId'])
resp, data = self.client.DescribeVolumes( data = self.client.describe_volumes(
Filters=[{'Name': 'snapshot-id', 'Values': [snapshot_id]}]) Filters=[{'Name': 'snapshot-id', 'Values': [snapshot_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
self.assertEqual(volume_id2, data['Volumes'][0]['VolumeId']) self.assertEqual(volume_id2, data['Volumes'][0]['VolumeId'])
resp, data = self.client.DeleteSnapshot(SnapshotId=snapshot_id) data = self.client.delete_snapshot(SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_snapshot_waiter().wait_delete(snapshot_id) self.get_snapshot_waiter().wait_delete(snapshot_id)
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vol) self.cancelResourceCleanUp(clean_vol)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
resp, data = self.client.DeleteVolume(VolumeId=volume_id2) data = self.client.delete_volume(VolumeId=volume_id2)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vol2) self.cancelResourceCleanUp(clean_vol2)
self.get_volume_waiter().wait_delete(volume_id2) self.get_volume_waiter().wait_delete(volume_id2)
@ -199,23 +182,20 @@ class SnapshotTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
clean_vol = self.addResourceCleanUp(self.client.DeleteVolume, clean_vol = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
vol1 = data
desc = 'test snapshot' desc = 'test snapshot'
kwargs = { kwargs = {
'VolumeId': volume_id, 'VolumeId': volume_id,
'Description': desc 'Description': desc
} }
resp, data = self.client.CreateSnapshot(*[], **kwargs) data = self.client.create_snapshot(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
snapshot_id = data['SnapshotId'] snapshot_id = data['SnapshotId']
res_clean = self.addResourceCleanUp(self.client.DeleteSnapshot, res_clean = self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
self.get_snapshot_waiter().wait_available(snapshot_id, self.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed')) final_set=('completed'))
@ -225,10 +205,9 @@ class SnapshotTest(base.EC2TestCase):
'SnapshotId': snapshot_id, 'SnapshotId': snapshot_id,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id2 = data['VolumeId'] volume_id2 = data['VolumeId']
clean_vol2 = self.addResourceCleanUp(self.client.DeleteVolume, clean_vol2 = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id2) VolumeId=volume_id2)
self.get_volume_waiter().wait_available(volume_id2) self.get_volume_waiter().wait_available(volume_id2)
@ -236,18 +215,15 @@ class SnapshotTest(base.EC2TestCase):
self.assertEqual(2, data['Size']) self.assertEqual(2, data['Size'])
self.assertEqual(snapshot_id, data['SnapshotId']) self.assertEqual(snapshot_id, data['SnapshotId'])
resp, data = self.client.DeleteSnapshot(SnapshotId=snapshot_id) data = self.client.delete_snapshot(SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_snapshot_waiter().wait_delete(snapshot_id) self.get_snapshot_waiter().wait_delete(snapshot_id)
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vol) self.cancelResourceCleanUp(clean_vol)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
resp, data = self.client.DeleteVolume(VolumeId=volume_id2) data = self.client.delete_volume(VolumeId=volume_id2)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vol2) self.cancelResourceCleanUp(clean_vol2)
self.get_volume_waiter().wait_delete(volume_id2) self.get_volume_waiter().wait_delete(volume_id2)
@ -258,10 +234,9 @@ class SnapshotTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
clean_vol = self.addResourceCleanUp(self.client.DeleteVolume, clean_vol = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
@ -270,20 +245,17 @@ class SnapshotTest(base.EC2TestCase):
'VolumeId': volume_id, 'VolumeId': volume_id,
'Description': desc 'Description': desc
} }
resp, data = self.client.CreateSnapshot(*[], **kwargs) data = self.client.create_snapshot(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
snapshot_id = data['SnapshotId'] snapshot_id = data['SnapshotId']
res_clean = self.addResourceCleanUp(self.client.DeleteSnapshot, res_clean = self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
self.get_snapshot_waiter().wait_available(snapshot_id, self.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed')) final_set=('completed'))
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vol) self.cancelResourceCleanUp(clean_vol)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
resp, data = self.client.DeleteSnapshot(SnapshotId=snapshot_id) data = self.client.delete_snapshot(SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_snapshot_waiter().wait_delete(snapshot_id) self.get_snapshot_waiter().wait_delete(snapshot_id)

140
ec2api/tests/functional/api/test_subnets.py
View File

@ -36,65 +36,58 @@ class SubnetTest(base.EC2TestCase):
if not base.TesterStateHolder().get_vpc_enabled(): if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled') raise cls.skipException('VPC is disabled')
resp, data = cls.client.CreateVpc(CidrBlock=cls.VPC_CIDR) data = cls.client.create_vpc(CidrBlock=cls.VPC_CIDR)
cls.assertResultStatic(resp, data)
cls.vpc_id = data['Vpc']['VpcId'] cls.vpc_id = data['Vpc']['VpcId']
cls.addResourceCleanUpStatic(cls.client.DeleteVpc, VpcId=cls.vpc_id) cls.addResourceCleanUpStatic(cls.client.delete_vpc, VpcId=cls.vpc_id)
cls.get_vpc_waiter().wait_available(cls.vpc_id) cls.get_vpc_waiter().wait_available(cls.vpc_id)
def test_create_delete_subnet(self): def test_create_delete_subnet(self):
cidr = self.BASE_CIDR + '/24' cidr = self.BASE_CIDR + '/24'
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, data = self.client.create_subnet(VpcId=self.vpc_id,
CidrBlock=cidr) CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
res_clean = self.addResourceCleanUp(self.client.DeleteSubnet, res_clean = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
self.assertEqual(cidr, data['Subnet']['CidrBlock']) self.assertEqual(cidr, data['Subnet']['CidrBlock'])
self.assertIsNotNone(data['Subnet'].get('AvailableIpAddressCount')) self.assertIsNotNone(data['Subnet'].get('AvailableIpAddressCount'))
self.get_subnet_waiter().wait_available(subnet_id) self.get_subnet_waiter().wait_available(subnet_id)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) data = self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
resp, data = self.client.DescribeSubnets(SubnetIds=[subnet_id]) self.assertRaises('InvalidSubnetID.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_subnets,
self.assertEqual('InvalidSubnetID.NotFound', data['Error']['Code']) SubnetIds=[subnet_id])
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) self.assertRaises('InvalidSubnetID.NotFound',
self.assertEqual(400, resp.status_code) self.client.delete_subnet,
self.assertEqual('InvalidSubnetID.NotFound', data['Error']['Code']) SubnetId=subnet_id)
def test_dependency_subnet_to_vpc(self): def test_dependency_subnet_to_vpc(self):
resp, data = self.client.CreateVpc(CidrBlock=self.VPC_CIDR) data = self.client.create_vpc(CidrBlock=self.VPC_CIDR)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
vpc_clean = self.addResourceCleanUp(self.client.DeleteVpc, vpc_clean = self.addResourceCleanUp(self.client.delete_vpc,
VpcId=vpc_id) VpcId=vpc_id)
self.get_vpc_waiter().wait_available(vpc_id) self.get_vpc_waiter().wait_available(vpc_id)
cidr = self.BASE_CIDR + '/24' cidr = self.BASE_CIDR + '/24'
resp, data = self.client.CreateSubnet(VpcId=vpc_id, data = self.client.create_subnet(VpcId=vpc_id, CidrBlock=cidr)
CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
res_clean = self.addResourceCleanUp(self.client.DeleteSubnet, res_clean = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
self.get_subnet_waiter().wait_available(subnet_id) self.get_subnet_waiter().wait_available(subnet_id)
resp, data = self.client.DeleteVpc(VpcId=vpc_id) self.assertRaises('DependencyViolation',
self.assertEqual(400, resp.status_code) self.client.delete_vpc,
self.assertEqual('DependencyViolation', data['Error']['Code']) VpcId=vpc_id)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) data = self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
self.client.DeleteVpc(VpcId=vpc_id) self.client.delete_vpc(VpcId=vpc_id)
self.cancelResourceCleanUp(vpc_clean) self.cancelResourceCleanUp(vpc_clean)
@testtools.skipUnless( @testtools.skipUnless(
@ -102,113 +95,90 @@ class SubnetTest(base.EC2TestCase):
"bug with overlapped subnets") "bug with overlapped subnets")
def test_create_overlapped_subnet(self): def test_create_overlapped_subnet(self):
cidr = self.BASE_CIDR + '/24' cidr = self.BASE_CIDR + '/24'
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, data = self.client.create_subnet(VpcId=self.vpc_id, CidrBlock=cidr)
CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
res_clean = self.addResourceCleanUp(self.client.DeleteSubnet, res_clean = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
self.get_subnet_waiter().wait_available(subnet_id) self.get_subnet_waiter().wait_available(subnet_id)
cidr = '10.2.0.128/26' cidr = '10.2.0.128/26'
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id,
CidrBlock=cidr)
if resp.status_code == 200:
self.addResourceCleanUp(self.client.DeleteSubnet,
SubnetId=data['Subnet']['SubnetId'])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidSubnet.Conflict', data['Error']['Code'])
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) def _rollback(fn_data):
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.client.delete_subnet(SubnetId=data['Subnet']['SubnetId'])
self.assertRaises('InvalidSubnet.Conflict',
self.client.create_subnet, rollback_fn=_rollback,
VpcId=self.vpc_id, CidrBlock=cidr)
data = self.client.delete_subnet(SubnetId=subnet_id)
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
def test_create_subnet_invalid_cidr(self): def test_create_subnet_invalid_cidr(self):
def _rollback(fn_data):
self.client.delete_subnet(SubnetId=fn_data['Subnet']['SubnetId'])
# NOTE(andrey-mp): another cidr than VPC has # NOTE(andrey-mp): another cidr than VPC has
cidr = '10.1.0.0/24' cidr = '10.1.0.0/24'
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, self.assertRaises('InvalidSubnet.Range',
CidrBlock=cidr) self.client.create_subnet, rollback_fn=_rollback,
if resp.status_code == 200: VpcId=self.vpc_id, CidrBlock=cidr)
self.addResourceCleanUp(self.client.DeleteSubnet,
SubnetId=data['Subnet']['SubnetId'])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidSubnet.Range', data['Error']['Code'])
# NOTE(andrey-mp): bigger cidr than VPC has # NOTE(andrey-mp): bigger cidr than VPC has
cidr = self.BASE_CIDR + '/19' cidr = self.BASE_CIDR + '/19'
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, self.assertRaises('InvalidSubnet.Range',
CidrBlock=cidr) self.client.create_subnet, rollback_fn=_rollback,
if resp.status_code == 200: VpcId=self.vpc_id, CidrBlock=cidr)
self.addResourceCleanUp(self.client.DeleteSubnet,
SubnetId=data['Subnet']['SubnetId'])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidSubnet.Range', data['Error']['Code'])
# NOTE(andrey-mp): too small cidr # NOTE(andrey-mp): too small cidr
cidr = self.BASE_CIDR + '/29' cidr = self.BASE_CIDR + '/29'
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, self.assertRaises('InvalidSubnet.Range',
CidrBlock=cidr) self.client.create_subnet, rollback_fn=_rollback,
if resp.status_code == 200: VpcId=self.vpc_id, CidrBlock=cidr)
self.addResourceCleanUp(self.client.DeleteSubnet,
SubnetId=data['Subnet']['SubnetId'])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidSubnet.Range', data['Error']['Code'])
def test_describe_subnets_base(self): def test_describe_subnets_base(self):
cidr = self.BASE_CIDR + '/24' cidr = self.BASE_CIDR + '/24'
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, data = self.client.create_subnet(VpcId=self.vpc_id, CidrBlock=cidr)
CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
res_clean = self.addResourceCleanUp(self.client.DeleteSubnet, res_clean = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
self.get_subnet_waiter().wait_available(subnet_id) self.get_subnet_waiter().wait_available(subnet_id)
# NOTE(andrey-mp): by real id # NOTE(andrey-mp): by real id
resp, data = self.client.DescribeSubnets(SubnetIds=[subnet_id]) data = self.client.describe_subnets(SubnetIds=[subnet_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Subnets'])) self.assertEqual(1, len(data['Subnets']))
# NOTE(andrey-mp): by fake id # NOTE(andrey-mp): by fake id
resp, data = self.client.DescribeSubnets(SubnetIds=['subnet-0']) self.assertRaises('InvalidSubnetID.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_subnets,
self.assertEqual('InvalidSubnetID.NotFound', data['Error']['Code']) SubnetIds=['subnet-0'])
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) data = self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
def test_describe_subnets_filters(self): def test_describe_subnets_filters(self):
cidr = self.BASE_CIDR + '/24' cidr = self.BASE_CIDR + '/24'
resp, data = self.client.CreateSubnet(VpcId=self.vpc_id, data = self.client.create_subnet(VpcId=self.vpc_id, CidrBlock=cidr)
CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
res_clean = self.addResourceCleanUp(self.client.DeleteSubnet, res_clean = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
self.get_subnet_waiter().wait_available(subnet_id) self.get_subnet_waiter().wait_available(subnet_id)
# NOTE(andrey-mp): by filter real cidr # NOTE(andrey-mp): by filter real cidr
resp, data = self.client.DescribeSubnets( data = self.client.describe_subnets(
Filters=[{'Name': 'cidr', 'Values': [cidr]}]) Filters=[{'Name': 'cidr', 'Values': [cidr]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Subnets'])) self.assertEqual(1, len(data['Subnets']))
# NOTE(andrey-mp): by filter fake cidr # NOTE(andrey-mp): by filter fake cidr
resp, data = self.client.DescribeSubnets( data = self.client.describe_subnets(
Filters=[{'Name': 'cidr', 'Values': ['123.0.0.0/16']}]) Filters=[{'Name': 'cidr', 'Values': ['123.0.0.0/16']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['Subnets'])) self.assertEqual(0, len(data['Subnets']))
# NOTE(andrey-mp): by fake filter # NOTE(andrey-mp): by fake filter
resp, data = self.client.DescribeSubnets( self.assertRaises('InvalidParameterValue',
self.client.describe_subnets,
Filters=[{'Name': 'fake', 'Values': ['fake']}]) Filters=[{'Name': 'fake', 'Values': ['fake']}])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) data = self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)

263
ec2api/tests/functional/api/test_tags.py
View File

@ -31,49 +31,42 @@ class TagTest(base.EC2TestCase):
super(TagTest, cls).setUpClass() super(TagTest, cls).setUpClass()
cls.zone = CONF.aws.aws_zone cls.zone = CONF.aws.aws_zone
resp, data = cls.client.CreateVolume( data = cls.client.create_volume(
Size=1, AvailabilityZone=cls.zone) Size=1, AvailabilityZone=cls.zone)
cls.assertResultStatic(resp, data)
cls.volume_id = data['VolumeId'] cls.volume_id = data['VolumeId']
cls.addResourceCleanUpStatic(cls.client.DeleteVolume, cls.addResourceCleanUpStatic(cls.client.delete_volume,
VolumeId=cls.volume_id) VolumeId=cls.volume_id)
cls.get_volume_waiter().wait_available(cls.volume_id) cls.get_volume_waiter().wait_available(cls.volume_id)
def test_create_get_delete_tag(self): def test_create_get_delete_tag(self):
tag_key = data_utils.rand_name('tag-key') tag_key = data_utils.rand_name('tag-key')
resp, data = self.client.CreateTags(Resources=[self.volume_id], data = self.client.create_tags(Resources=[self.volume_id],
Tags=[{'Key': tag_key, 'Value': 'fake_value'}]) Tags=[{'Key': tag_key, 'Value': 'fake_value'}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.addResourceCleanUp(self.client.delete_tags,
self.addResourceCleanUp(self.client.DeleteTags,
Resources=[self.volume_id], Resources=[self.volume_id],
Tags=[{'Key': tag_key}]) Tags=[{'Key': tag_key}])
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}]) Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Tags'])) self.assertEqual(1, len(data['Tags']))
resp, data = self.client.DeleteTags(Resources=[self.volume_id], data = self.client.delete_tags(Resources=[self.volume_id],
Tags=[{'Key': tag_key}]) Tags=[{'Key': tag_key}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}]) Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['Tags'])) self.assertEqual(0, len(data['Tags']))
def test_describe_tags(self): def test_describe_tags(self):
tag_key = data_utils.rand_name('tag-key') tag_key = data_utils.rand_name('tag-key')
resp, data = self.client.CreateTags(Resources=[self.volume_id], data = self.client.create_tags(Resources=[self.volume_id],
Tags=[{'Key': tag_key, 'Value': 'fake_value'}]) Tags=[{'Key': tag_key, 'Value': 'fake_value'}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.addResourceCleanUp(self.client.delete_tags,
self.addResourceCleanUp(self.client.DeleteTags,
Resources=[self.volume_id], Resources=[self.volume_id],
Tags=[{'Key': tag_key}]) Tags=[{'Key': tag_key}])
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}]) Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Tags'])) self.assertEqual(1, len(data['Tags']))
tag = data['Tags'][0] tag = data['Tags'][0]
self.assertEqual('volume', tag.get('ResourceType')) self.assertEqual('volume', tag.get('ResourceType'))
@ -81,93 +74,79 @@ class TagTest(base.EC2TestCase):
self.assertEqual(tag_key, tag.get('Key')) self.assertEqual(tag_key, tag.get('Key'))
self.assertEqual('fake_value', tag.get('Value')) self.assertEqual('fake_value', tag.get('Value'))
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}, Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]},
{'Name': 'key', 'Values': [tag_key]}]) {'Name': 'key', 'Values': [tag_key]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Tags'])) self.assertEqual(1, len(data['Tags']))
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'key', 'Values': [tag_key]}]) Filters=[{'Name': 'key', 'Values': [tag_key]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn(tag_key, [k.get('Key') for k in data['Tags']]) self.assertIn(tag_key, [k.get('Key') for k in data['Tags']])
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'value', 'Values': ['fake_value']}]) Filters=[{'Name': 'value', 'Values': ['fake_value']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn('fake_value', [k.get('Value') for k in data['Tags']]) self.assertIn('fake_value', [k.get('Value') for k in data['Tags']])
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'key', 'Values': ['fake_value']}]) Filters=[{'Name': 'key', 'Values': ['fake_value']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
items = [k.get('Key') for k in data['Tags']] items = [k.get('Key') for k in data['Tags']]
self.assertNotIn(tag_key, items) self.assertNotIn(tag_key, items)
self.assertNotIn('fake_value', items) self.assertNotIn('fake_value', items)
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-type', 'Values': ['volume']}]) Filters=[{'Name': 'resource-type', 'Values': ['volume']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn(tag_key, [k.get('Key') for k in data['Tags']]) self.assertIn(tag_key, [k.get('Key') for k in data['Tags']])
resp, data = self.client.DeleteTags(Resources=[self.volume_id], data = self.client.delete_tags(Resources=[self.volume_id],
Tags=[{'Key': tag_key}]) Tags=[{'Key': tag_key}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}]) Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['Tags'])) self.assertEqual(0, len(data['Tags']))
def _test_tag_resource(self, resource_id, res_type, describe_func): def _test_tag_resource(self, resource_id, res_type, describe_func):
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [resource_id]}]) Filters=[{'Name': 'resource-id', 'Values': [resource_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
origin_count = len(data['Tags']) origin_count = len(data['Tags'])
tag_key = data_utils.rand_name('tag-key') tag_key = data_utils.rand_name('tag-key')
resp, data = self.client.CreateTags(Resources=[resource_id], data = self.client.create_tags(Resources=[resource_id],
Tags=[{'Key': tag_key, 'Value': 'fake_value'}]) Tags=[{'Key': tag_key, 'Value': 'fake_value'}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.addResourceCleanUp(self.client.delete_tags,
self.addResourceCleanUp(self.client.DeleteTags,
Resources=[resource_id], Resources=[resource_id],
Tags=[{'Key': tag_key}]) Tags=[{'Key': tag_key}])
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [resource_id]}]) Filters=[{'Name': 'resource-id', 'Values': [resource_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(origin_count + 1, len(data['Tags'])) self.assertEqual(origin_count + 1, len(data['Tags']))
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-type', 'Values': [res_type]}]) Filters=[{'Name': 'resource-type', 'Values': [res_type]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertIn(tag_key, [k.get('Key') for k in data['Tags']]) self.assertIn(tag_key, [k.get('Key') for k in data['Tags']])
describe_func(Filters=[{'Name': 'tag-key', 'Values': [tag_key]}]) describe_func(Filters=[{'Name': 'tag-key', 'Values': [tag_key]}])
resp, data = self.client.DeleteTags(Resources=[resource_id], data = self.client.delete_tags(Resources=[resource_id],
Tags=[{'Key': tag_key}]) Tags=[{'Key': tag_key}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [resource_id]}]) Filters=[{'Name': 'resource-id', 'Values': [resource_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(origin_count, len(data['Tags'])) self.assertEqual(origin_count, len(data['Tags']))
def _test_tag_resource_negative(self, resource_id): def _test_tag_resource_negative(self, resource_id):
resp, data = self.client.DescribeTags( data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [resource_id]}]) Filters=[{'Name': 'resource-id', 'Values': [resource_id]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEmpty(data['Tags']) self.assertEmpty(data['Tags'])
tag_key = data_utils.rand_name('tag-key') def _rollback(fn_data):
resp, data = self.client.CreateTags(Resources=[resource_id], self.client.delete_tags(Resources=[resource_id],
Tags=[{'Key': tag_key, 'Value': 'fake_value'}])
if resp.status_code == 200:
self.addResourceCleanUp(self.client.DeleteTags,
Resources=[resource_id],
Tags=[{'Key': tag_key}]) Tags=[{'Key': tag_key}])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidID', data['Error']['Code']) tag_key = data_utils.rand_name('tag-key')
self.assertRaises('InvalidID',
self.client.create_tags, rollback_fn=_rollback,
Resources=[resource_id],
Tags=[{'Key': tag_key, 'Value': 'fake_value'}])
def test_tag_image(self): def test_tag_image(self):
image_id = CONF.aws.ebs_image_id image_id = CONF.aws.ebs_image_id
@ -177,16 +156,13 @@ class TagTest(base.EC2TestCase):
raise self.skipException('aws or ebs image_id does not provided') raise self.skipException('aws or ebs image_id does not provided')
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeImages(*args, **kwargs) data = self.client.describe_images(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Images'])) self.assertEqual(1, len(data['Images']))
self.assertEqual(image_id, data['Images'][0]['ImageId']) self.assertEqual(image_id, data['Images'][0]['ImageId'])
self._test_tag_resource(image_id, 'image', describe_func) self._test_tag_resource(image_id, 'image', describe_func)
resp, data = self.client.DescribeImages(ImageIds=[image_id]) data = self.client.describe_images(ImageIds=[image_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
image = data['Images'][0] image = data['Images'][0]
if 'KernelId' in image: if 'KernelId' in image:
image_id = image['KernelId'] image_id = image['KernelId']
@ -203,31 +179,25 @@ class TagTest(base.EC2TestCase):
'Values': ['my.com']}, 'Values': ['my.com']},
], ],
} }
resp, data = self.client.CreateDhcpOptions(*[], **kwargs) data = self.client.create_dhcp_options(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
options = data['DhcpOptions'] options = data['DhcpOptions']
res_id = options['DhcpOptionsId'] res_id = options['DhcpOptionsId']
res_clean = self.addResourceCleanUp(self.client.DeleteDhcpOptions, res_clean = self.addResourceCleanUp(self.client.delete_dhcp_options,
DhcpOptionsId=res_id) DhcpOptionsId=res_id)
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeDhcpOptions(*args, **kwargs) data = self.client.describe_dhcp_options(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['DhcpOptions'])) self.assertEqual(1, len(data['DhcpOptions']))
self.assertEqual(res_id, data['DhcpOptions'][0]['DhcpOptionsId']) self.assertEqual(res_id, data['DhcpOptions'][0]['DhcpOptionsId'])
self._test_tag_resource(res_id, 'dhcp-options', describe_func) self._test_tag_resource(res_id, 'dhcp-options', describe_func)
resp, data = self.client.DeleteDhcpOptions(DhcpOptionsId=res_id) data = self.client.delete_dhcp_options(DhcpOptionsId=res_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_tag_volume(self): def test_tag_volume(self):
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeVolumes(*args, **kwargs) data = self.client.describe_volumes(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
self.assertEqual(self.volume_id, data['Volumes'][0]['VolumeId']) self.assertEqual(self.volume_id, data['Volumes'][0]['VolumeId'])
@ -238,36 +208,31 @@ class TagTest(base.EC2TestCase):
kwargs = { kwargs = {
'Domain': 'vpc', 'Domain': 'vpc',
} }
resp, data = self.client.AllocateAddress(*[], **kwargs) data = self.client.allocate_address(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
res_id = data['AllocationId'] res_id = data['AllocationId']
res_clean = self.addResourceCleanUp(self.client.ReleaseAddress, res_clean = self.addResourceCleanUp(self.client.release_address,
AllocationId=res_id) AllocationId=res_id)
self.assertEqual('vpc', data['Domain']) self.assertEqual('vpc', data['Domain'])
self._test_tag_resource_negative(res_id) self._test_tag_resource_negative(res_id)
resp, data = self.client.ReleaseAddress(AllocationId=res_id) data = self.client.release_address(AllocationId=res_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
def test_tag_instance(self): def test_tag_instance(self):
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeInstances(*args, **kwargs) data = self.client.describe_instances(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Reservations'])) self.assertEqual(1, len(data['Reservations']))
self.assertEqual(1, len(data['Reservations'][0]['Instances'])) self.assertEqual(1, len(data['Reservations'][0]['Instances']))
self.assertEqual(instance_id, self.assertEqual(instance_id,
@ -275,229 +240,195 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource(instance_id, 'instance', describe_func) self._test_tag_resource(instance_id, 'instance', describe_func)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@base.skip_without_vpc() @base.skip_without_vpc()
def test_tag_internet_gateway(self): def test_tag_internet_gateway(self):
resp, data = self.client.CreateInternetGateway() data = self.client.create_internet_gateway()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
gw_id = data['InternetGateway']['InternetGatewayId'] gw_id = data['InternetGateway']['InternetGatewayId']
res_clean = self.addResourceCleanUp(self.client.DeleteInternetGateway, res_clean = self.addResourceCleanUp(
InternetGatewayId=gw_id) self.client.delete_internet_gateway, InternetGatewayId=gw_id)
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeInternetGateways(*args, **kwargs) data = self.client.describe_internet_gateways(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['InternetGateways'])) self.assertEqual(1, len(data['InternetGateways']))
self.assertEqual(gw_id, self.assertEqual(gw_id,
data['InternetGateways'][0]['InternetGatewayId']) data['InternetGateways'][0]['InternetGatewayId'])
self._test_tag_resource(gw_id, 'internet-gateway', describe_func) self._test_tag_resource(gw_id, 'internet-gateway', describe_func)
resp, data = self.client.DeleteInternetGateway(InternetGatewayId=gw_id) data = self.client.delete_internet_gateway(InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
@base.skip_without_vpc() @base.skip_without_vpc()
def test_tag_network_interface(self): def test_tag_network_interface(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(
self.client.delete_vpc, VpcId=vpc_id)
cidr = '10.1.0.0/24' cidr = '10.1.0.0/24'
resp, data = self.client.CreateSubnet(VpcId=vpc_id, data = self.client.create_subnet(VpcId=vpc_id,
CidrBlock=cidr) CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
subnet_clean = self.addResourceCleanUp(self.client.DeleteSubnet, subnet_clean = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
resp, data = self.client.CreateNetworkInterface(SubnetId=subnet_id, data = self.client.create_network_interface(SubnetId=subnet_id,
Description=data_utils.rand_name('ni')) Description=data_utils.rand_name('ni'))
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
res_clean = self.addResourceCleanUp(self.client.DeleteNetworkInterface, res_clean = self.addResourceCleanUp(
NetworkInterfaceId=ni_id) self.client.delete_network_interface, NetworkInterfaceId=ni_id)
self.get_network_interface_waiter().wait_available(ni_id) self.get_network_interface_waiter().wait_available(ni_id)
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeNetworkInterfaces(*args, **kwargs) data = self.client.describe_network_interfaces(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['NetworkInterfaces'])) self.assertEqual(1, len(data['NetworkInterfaces']))
self.assertEqual(ni_id, self.assertEqual(ni_id,
data['NetworkInterfaces'][0]['NetworkInterfaceId']) data['NetworkInterfaces'][0]['NetworkInterfaceId'])
self._test_tag_resource(ni_id, 'network-interface', describe_func) self._test_tag_resource(ni_id, 'network-interface', describe_func)
resp, data = self.client.DeleteNetworkInterface( data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_network_interface_waiter().wait_delete(ni_id) self.get_network_interface_waiter().wait_delete(ni_id)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) data = self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(subnet_clean) self.cancelResourceCleanUp(subnet_clean)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
resp, data = self.client.DeleteVpc(VpcId=vpc_id) data = self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
@base.skip_without_vpc() @base.skip_without_vpc()
def test_tag_route_table(self): def test_tag_route_table(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(
self.client.delete_vpc, VpcId=vpc_id)
resp, data = self.client.CreateRouteTable(VpcId=vpc_id) data = self.client.create_route_table(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
rt_id = data['RouteTable']['RouteTableId'] rt_id = data['RouteTable']['RouteTableId']
res_clean = self.addResourceCleanUp(self.client.DeleteRouteTable, res_clean = self.addResourceCleanUp(self.client.delete_route_table,
RouteTableId=rt_id) RouteTableId=rt_id)
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeRouteTables(*args, **kwargs) data = self.client.describe_route_tables(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['RouteTables'])) self.assertEqual(1, len(data['RouteTables']))
self.assertEqual(rt_id, data['RouteTables'][0]['RouteTableId']) self.assertEqual(rt_id, data['RouteTables'][0]['RouteTableId'])
self._test_tag_resource(rt_id, 'route-table', describe_func) self._test_tag_resource(rt_id, 'route-table', describe_func)
resp, data = self.client.DeleteRouteTable(RouteTableId=rt_id) data = self.client.delete_route_table(RouteTableId=rt_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
resp, data = self.client.DeleteVpc(VpcId=vpc_id) data = self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
@base.skip_without_vpc() @base.skip_without_vpc()
def test_tag_security_group(self): def test_tag_security_group(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(
self.client.delete_vpc, VpcId=vpc_id)
name = data_utils.rand_name('sgName') name = data_utils.rand_name('sgName')
desc = data_utils.rand_name('sgDesc') desc = data_utils.rand_name('sgDesc')
resp, data = self.client.CreateSecurityGroup(VpcId=vpc_id, data = self.client.create_security_group(VpcId=vpc_id,
GroupName=name, GroupName=name,
Description=desc) Description=desc)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
group_id = data['GroupId'] group_id = data['GroupId']
res_clean = self.addResourceCleanUp(self.client.DeleteSecurityGroup, res_clean = self.addResourceCleanUp(self.client.delete_security_group,
GroupId=group_id) GroupId=group_id)
time.sleep(2) time.sleep(2)
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeSecurityGroups(*args, **kwargs) data = self.client.describe_security_groups(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['SecurityGroups'])) self.assertEqual(1, len(data['SecurityGroups']))
self.assertEqual(group_id, self.assertEqual(group_id,
data['SecurityGroups'][0]['GroupId']) data['SecurityGroups'][0]['GroupId'])
self._test_tag_resource(group_id, 'security-group', describe_func) self._test_tag_resource(group_id, 'security-group', describe_func)
resp, data = self.client.DeleteSecurityGroup(GroupId=group_id) data = self.client.delete_security_group(GroupId=group_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
resp, data = self.client.DeleteVpc(VpcId=vpc_id) data = self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
def test_tag_snapshot(self): def test_tag_snapshot(self):
resp, data = self.client.CreateSnapshot(VolumeId=self.volume_id) data = self.client.create_snapshot(VolumeId=self.volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
snapshot_id = data['SnapshotId'] snapshot_id = data['SnapshotId']
res_clean = self.addResourceCleanUp(self.client.DeleteSnapshot, res_clean = self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
self.get_snapshot_waiter().wait_available(snapshot_id, self.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed')) final_set=('completed'))
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeSnapshots(*args, **kwargs) data = self.client.describe_snapshots(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Snapshots'])) self.assertEqual(1, len(data['Snapshots']))
self.assertEqual(snapshot_id, data['Snapshots'][0]['SnapshotId']) self.assertEqual(snapshot_id, data['Snapshots'][0]['SnapshotId'])
self._test_tag_resource(snapshot_id, 'snapshot', describe_func) self._test_tag_resource(snapshot_id, 'snapshot', describe_func)
resp, data = self.client.DeleteSnapshot(SnapshotId=snapshot_id) data = self.client.delete_snapshot(SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_snapshot_waiter().wait_delete(snapshot_id) self.get_snapshot_waiter().wait_delete(snapshot_id)
@base.skip_without_vpc() @base.skip_without_vpc()
def test_tag_subnet(self): def test_tag_subnet(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(
self.client.delete_vpc, VpcId=vpc_id)
cidr = '10.1.0.0/24' cidr = '10.1.0.0/24'
resp, data = self.client.CreateSubnet(VpcId=vpc_id, data = self.client.create_subnet(VpcId=vpc_id,
CidrBlock=cidr) CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
res_clean = self.addResourceCleanUp(self.client.DeleteSubnet, res_clean = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id) SubnetId=subnet_id)
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeSubnets(*args, **kwargs) data = self.client.describe_subnets(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Subnets'])) self.assertEqual(1, len(data['Subnets']))
self.assertEqual(subnet_id, data['Subnets'][0]['SubnetId']) self.assertEqual(subnet_id, data['Subnets'][0]['SubnetId'])
self._test_tag_resource(subnet_id, 'subnet', describe_func) self._test_tag_resource(subnet_id, 'subnet', describe_func)
resp, data = self.client.DeleteSubnet(SubnetId=subnet_id) data = self.client.delete_subnet(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_subnet_waiter().wait_delete(subnet_id) self.get_subnet_waiter().wait_delete(subnet_id)
resp, data = self.client.DeleteVpc(VpcId=vpc_id) data = self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
@base.skip_without_vpc() @base.skip_without_vpc()
def test_tag_vpc(self): def test_tag_vpc(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(
self.client.delete_vpc, VpcId=vpc_id)
def describe_func(*args, **kwargs): def describe_func(*args, **kwargs):
resp, data = self.client.DescribeVpcs(*args, **kwargs) data = self.client.describe_vpcs(*args, **kwargs)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Vpcs'])) self.assertEqual(1, len(data['Vpcs']))
self.assertEqual(vpc_id, data['Vpcs'][0]['VpcId']) self.assertEqual(vpc_id, data['Vpcs'][0]['VpcId'])
self._test_tag_resource(vpc_id, 'vpc', describe_func) self._test_tag_resource(vpc_id, 'vpc', describe_func)
resp, data = self.client.DeleteVpc(VpcId=vpc_id) data = self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)

227
ec2api/tests/functional/api/test_volumes.py
View File

@ -28,10 +28,9 @@ class VolumeTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
res_clean = self.addResourceCleanUp(self.client.DeleteVolume, res_clean = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
@ -46,18 +45,17 @@ class VolumeTest(base.EC2TestCase):
self.assertIsNotNone(data['CreateTime']) self.assertIsNotNone(data['CreateTime'])
self.assertEqual(CONF.aws.aws_zone, data['AvailabilityZone']) self.assertEqual(CONF.aws.aws_zone, data['AvailabilityZone'])
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) self.assertRaises('InvalidVolume.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_volumes,
self.assertEqual('InvalidVolume.NotFound', data['Error']['Code']) VolumeIds=[volume_id])
resp, data = self.client.DeleteVolume(VolumeId=volume_id) self.assertRaises('InvalidVolume.NotFound',
self.assertEqual(400, resp.status_code) self.client.delete_volume,
self.assertEqual('InvalidVolume.NotFound', data['Error']['Code']) VolumeId=volume_id)
@testtools.skipUnless(CONF.aws.run_incompatible_tests, @testtools.skipUnless(CONF.aws.run_incompatible_tests,
"Encryption is not implemented") "Encryption is not implemented")
@ -67,18 +65,16 @@ class VolumeTest(base.EC2TestCase):
'AvailabilityZone': CONF.aws.aws_zone, 'AvailabilityZone': CONF.aws.aws_zone,
'Encrypted': True, 'Encrypted': True,
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
res_clean = self.addResourceCleanUp(self.client.DeleteVolume, res_clean = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
self.assertTrue(data['Encrypted']) self.assertTrue(data['Encrypted'])
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
@ -87,22 +83,19 @@ class VolumeTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
res_clean = self.addResourceCleanUp(self.client.DeleteVolume, res_clean = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id_ext = data['VolumeId'] volume_id_ext = data['VolumeId']
res_clean_ext = self.addResourceCleanUp(self.client.DeleteVolume, res_clean_ext = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id_ext) VolumeId=volume_id_ext)
self.get_volume_waiter().wait_available(volume_id_ext) self.get_volume_waiter().wait_available(volume_id_ext)
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code)
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
volume = data['Volumes'][0] volume = data['Volumes'][0]
@ -115,13 +108,11 @@ class VolumeTest(base.EC2TestCase):
if 'SnapshotId' in volume: if 'SnapshotId' in volume:
self.assertIsNone(volume['SnapshotId']) self.assertIsNone(volume['SnapshotId'])
resp, data = self.client.DeleteVolume(VolumeId=volume_id_ext) data = self.client.delete_volume(VolumeId=volume_id_ext)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_ext) self.cancelResourceCleanUp(res_clean_ext)
self.get_volume_waiter().wait_delete(volume_id_ext) self.get_volume_waiter().wait_delete(volume_id_ext)
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
@ -132,16 +123,14 @@ class VolumeTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
res_clean = self.addResourceCleanUp(self.client.DeleteVolume, res_clean = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
resp, data = self.client.DescribeVolumeStatus(VolumeIds=[volume_id]) data = self.client.describe_volume_status(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code)
self.assertEqual(1, len(data['VolumeStatuses'])) self.assertEqual(1, len(data['VolumeStatuses']))
volume_status = data['VolumeStatuses'][0] volume_status = data['VolumeStatuses'][0]
@ -149,8 +138,7 @@ class VolumeTest(base.EC2TestCase):
self.assertIn('Events', volume_status) self.assertIn('Events', volume_status)
self.assertIn('VolumeStatus', volume_status) self.assertIn('VolumeStatus', volume_status)
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
@ -167,10 +155,9 @@ class VolumeTest(base.EC2TestCase):
'MaxCount': 1, 'MaxCount': 1,
'Placement': {'AvailabilityZone': CONF.aws.aws_zone} 'Placement': {'AvailabilityZone': CONF.aws.aws_zone}
} }
resp, data = self.client.RunInstances(*[], **kwargs) data = self.client.run_instances(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.TerminateInstances, clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -179,10 +166,9 @@ class VolumeTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
clean_v = self.addResourceCleanUp(self.client.DeleteVolume, clean_v = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
@ -191,15 +177,13 @@ class VolumeTest(base.EC2TestCase):
'InstanceId': instance_id, 'InstanceId': instance_id,
'VolumeId': volume_id, 'VolumeId': volume_id,
} }
resp, data = self.client.AttachVolume(*[], **kwargs) data = self.client.attach_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) clean_vi = self.addResourceCleanUp(self.client.detach_volume,
clean_vi = self.addResourceCleanUp(self.client.DetachVolume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_attachment_waiter().wait_available( self.get_volume_attachment_waiter().wait_available(
volume_id, final_set=('attached')) volume_id, final_set=('attached'))
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code)
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
volume = data['Volumes'][0] volume = data['Volumes'][0]
self.assertEqual('in-use', volume['State']) self.assertEqual('in-use', volume['State'])
@ -211,8 +195,7 @@ class VolumeTest(base.EC2TestCase):
self.assertEqual(instance_id, attachment['InstanceId']) self.assertEqual(instance_id, attachment['InstanceId'])
self.assertEqual(volume_id, attachment['VolumeId']) self.assertEqual(volume_id, attachment['VolumeId'])
resp, data = self.client.DescribeInstances(InstanceIds=[instance_id]) data = self.client.describe_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code)
self.assertEqual(1, len(data.get('Reservations', []))) self.assertEqual(1, len(data.get('Reservations', [])))
self.assertEqual(1, len(data['Reservations'][0].get('Instances', []))) self.assertEqual(1, len(data['Reservations'][0].get('Instances', [])))
bdms = data['Reservations'][0]['Instances'][0]['BlockDeviceMappings'] bdms = data['Reservations'][0]['Instances'][0]['BlockDeviceMappings']
@ -220,25 +203,21 @@ class VolumeTest(base.EC2TestCase):
self.assertIn('DeviceName', bdms[0]) self.assertIn('DeviceName', bdms[0])
self.assertIn('Ebs', bdms[0]) self.assertIn('Ebs', bdms[0])
resp, data = self.client.DetachVolume(VolumeId=volume_id) data = self.client.detach_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vi) self.cancelResourceCleanUp(clean_vi)
self.get_volume_attachment_waiter().wait_delete(volume_id) self.get_volume_attachment_waiter().wait_delete(volume_id)
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code)
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
volume = data['Volumes'][0] volume = data['Volumes'][0]
self.assertEqual('available', volume['State']) self.assertEqual('available', volume['State'])
self.assertEqual(0, len(volume['Attachments'])) self.assertEqual(0, len(volume['Attachments']))
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_v) self.cancelResourceCleanUp(clean_v)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_i) self.cancelResourceCleanUp(clean_i)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -255,53 +234,48 @@ class VolumeTest(base.EC2TestCase):
'MaxCount': 1, 'MaxCount': 1,
'Placement': {'AvailabilityZone': CONF.aws.aws_zone} 'Placement': {'AvailabilityZone': CONF.aws.aws_zone}
} }
resp, data = self.client.RunInstances(*[], **kwargs) data = self.client.run_instances(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.TerminateInstances, clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.CreateVolume( data = self.client.create_volume(
AvailabilityZone=CONF.aws.aws_zone, Size=1) AvailabilityZone=CONF.aws.aws_zone, Size=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
clean_v = self.addResourceCleanUp(self.client.DeleteVolume, clean_v = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
device_name = '/dev/xvdh'
kwargs = { kwargs = {
'Device': '/dev/vdh', 'Device': device_name,
'InstanceId': instance_id, 'InstanceId': instance_id,
'VolumeId': volume_id, 'VolumeId': volume_id,
} }
resp, data = self.client.AttachVolume(*[], **kwargs) data = self.client.attach_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) clean_vi = self.addResourceCleanUp(self.client.detach_volume,
clean_vi = self.addResourceCleanUp(self.client.DetachVolume,
VolumeId=volume_id) VolumeId=volume_id)
self.assertEqual('attaching', data['State']) self.assertEqual('attaching', data['State'])
if CONF.aws.run_incompatible_tests: if CONF.aws.run_incompatible_tests:
bdt = self.get_instance_bdm(instance_id, '/dev/vdh') bdt = self.get_instance_bdm(instance_id, device_name)
self.assertIsNotNone(bdt) self.assertIsNotNone(bdt)
self.assertEqual('attaching', bdt['Ebs']['Status']) self.assertEqual('attaching', bdt['Ebs']['Status'])
self.get_volume_attachment_waiter().wait_available( self.get_volume_attachment_waiter().wait_available(
volume_id, final_set=('attached')) volume_id, final_set=('attached'))
resp, data = self.client.DetachVolume(VolumeId=volume_id) data = self.client.detach_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vi) self.cancelResourceCleanUp(clean_vi)
self.get_volume_attachment_waiter().wait_delete(volume_id) self.get_volume_attachment_waiter().wait_delete(volume_id)
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_v) self.cancelResourceCleanUp(clean_v)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_i) self.cancelResourceCleanUp(clean_i)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -320,10 +294,9 @@ class VolumeTest(base.EC2TestCase):
'MaxCount': 1, 'MaxCount': 1,
'Placement': {'AvailabilityZone': CONF.aws.aws_zone} 'Placement': {'AvailabilityZone': CONF.aws.aws_zone}
} }
resp, data = self.client.RunInstances(*[], **kwargs) data = self.client.run_instances(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.TerminateInstances, clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -332,10 +305,9 @@ class VolumeTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
clean_v = self.addResourceCleanUp(self.client.DeleteVolume, clean_v = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
@ -344,46 +316,42 @@ class VolumeTest(base.EC2TestCase):
'InstanceId': instance_id, 'InstanceId': instance_id,
'VolumeId': volume_id, 'VolumeId': volume_id,
} }
resp, data = self.client.AttachVolume(*[], **kwargs) data = self.client.attach_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) clean_vi = self.addResourceCleanUp(self.client.detach_volume,
clean_vi = self.addResourceCleanUp(self.client.DetachVolume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_attachment_waiter().wait_available( self.get_volume_attachment_waiter().wait_available(
volume_id, final_set=('attached')) volume_id, final_set=('attached'))
resp, data = self.client.AttachVolume(*[], **kwargs) self.assertRaises('VolumeInUse',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.attach_volume,
self.assertEqual('VolumeInUse', data['Error']['Code']) **kwargs)
kwargs['Device'] = '/dev/sdi' kwargs['Device'] = '/dev/sdi'
resp, data = self.client.AttachVolume(*[], **kwargs) self.assertRaises('VolumeInUse',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.attach_volume,
self.assertEqual('VolumeInUse', data['Error']['Code']) **kwargs)
resp, data = self.client.DeleteVolume(VolumeId=volume_id) self.assertRaises('VolumeInUse',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.delete_volume,
self.assertEqual('VolumeInUse', data['Error']['Code']) VolumeId=volume_id)
resp, data = self.client.DetachVolume(VolumeId=volume_id) data = self.client.detach_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_vi) self.cancelResourceCleanUp(clean_vi)
self.get_volume_attachment_waiter().wait_delete(volume_id) self.get_volume_attachment_waiter().wait_delete(volume_id)
resp, data = self.client.DetachVolume(VolumeId=volume_id) self.assertRaises('IncorrectState',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.detach_volume,
self.assertEqual('IncorrectState', data['Error']['Code']) VolumeId=volume_id)
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_v) self.cancelResourceCleanUp(clean_v)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
resp, data = self.client.DetachVolume(VolumeId=volume_id) self.assertRaises('InvalidVolume.NotFound',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.detach_volume,
self.assertEqual('InvalidVolume.NotFound', data['Error']['Code']) VolumeId=volume_id)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_i) self.cancelResourceCleanUp(clean_i)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -400,10 +368,9 @@ class VolumeTest(base.EC2TestCase):
'MaxCount': 1, 'MaxCount': 1,
'Placement': {'AvailabilityZone': CONF.aws.aws_zone} 'Placement': {'AvailabilityZone': CONF.aws.aws_zone}
} }
resp, data = self.client.RunInstances(*[], **kwargs) data = self.client.run_instances(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.TerminateInstances, clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -412,10 +379,9 @@ class VolumeTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
clean_v = self.addResourceCleanUp(self.client.DeleteVolume, clean_v = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
@ -424,32 +390,28 @@ class VolumeTest(base.EC2TestCase):
'InstanceId': instance_id, 'InstanceId': instance_id,
'VolumeId': volume_id, 'VolumeId': volume_id,
} }
resp, data = self.client.AttachVolume(*[], **kwargs) data = self.client.attach_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.addResourceCleanUp(self.client.detach_volume, VolumeId=volume_id)
self.addResourceCleanUp(self.client.DetachVolume, VolumeId=volume_id)
self.get_volume_attachment_waiter().wait_available( self.get_volume_attachment_waiter().wait_available(
volume_id, final_set=('attached')) volume_id, final_set=('attached'))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_i) self.cancelResourceCleanUp(clean_i)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code)
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
volume = data['Volumes'][0] volume = data['Volumes'][0]
self.assertEqual('available', volume['State']) self.assertEqual('available', volume['State'])
if 'Attachments' in volume: if 'Attachments' in volume:
self.assertEqual(0, len(volume['Attachments'])) self.assertEqual(0, len(volume['Attachments']))
resp, data = self.client.DeleteVolume(VolumeId=volume_id) data = self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_v) self.cancelResourceCleanUp(clean_v)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
@testtools.skipUnless(CONF.aws.run_incompatible_tests, @testtools.skipUnless(CONF.aws.run_incompatible_tests,
"ModifyInstanceAttribute is not implemented") "modify_instance_attribute is not implemented")
def test_volume_auto_termination_swithed_on(self): def test_volume_auto_termination_swithed_on(self):
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id image_id = CONF.aws.image_id
@ -463,10 +425,9 @@ class VolumeTest(base.EC2TestCase):
'MaxCount': 1, 'MaxCount': 1,
'Placement': {'AvailabilityZone': CONF.aws.aws_zone} 'Placement': {'AvailabilityZone': CONF.aws.aws_zone}
} }
resp, data = self.client.RunInstances(*[], **kwargs) data = self.client.run_instances(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.TerminateInstances, clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -475,10 +436,9 @@ class VolumeTest(base.EC2TestCase):
'Size': 1, 'Size': 1,
'AvailabilityZone': CONF.aws.aws_zone 'AvailabilityZone': CONF.aws.aws_zone
} }
resp, data = self.client.CreateVolume(*[], **kwargs) data = self.client.create_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id = data['VolumeId'] volume_id = data['VolumeId']
self.addResourceCleanUp(self.client.DeleteVolume, VolumeId=volume_id) self.addResourceCleanUp(self.client.delete_volume, VolumeId=volume_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
kwargs = { kwargs = {
@ -486,9 +446,8 @@ class VolumeTest(base.EC2TestCase):
'InstanceId': instance_id, 'InstanceId': instance_id,
'VolumeId': volume_id, 'VolumeId': volume_id,
} }
resp, data = self.client.AttachVolume(*[], **kwargs) data = self.client.attach_volume(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.addResourceCleanUp(self.client.detach_volume, VolumeId=volume_id)
self.addResourceCleanUp(self.client.DetachVolume, VolumeId=volume_id)
self.get_volume_attachment_waiter().wait_available( self.get_volume_attachment_waiter().wait_available(
volume_id, final_set=('attached')) volume_id, final_set=('attached'))
@ -498,14 +457,12 @@ class VolumeTest(base.EC2TestCase):
'Ebs': {'VolumeId': volume_id, 'Ebs': {'VolumeId': volume_id,
'DeleteOnTermination': True}}], 'DeleteOnTermination': True}}],
} }
resp, data = self.client.ModifyInstanceAttribute(*[], **kwargs) data = self.client.modify_instance_attribute(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) data = self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_i) self.cancelResourceCleanUp(clean_i)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) self.assertRaises('InvalidVolume.NotFound',
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) self.client.describe_volumes,
self.assertEqual('InvalidVolume.NotFound', data['Error']['Code']) VolumeIds=[volume_id])

161
ec2api/tests/functional/api/test_vpcs.py
View File

@ -32,10 +32,10 @@ class VPCTest(base.EC2TestCase):
def test_create_delete_vpc(self): def test_create_delete_vpc(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(self.client.delete_vpc,
VpcId=vpc_id)
self.assertEqual(cidr, data['Vpc']['CidrBlock']) self.assertEqual(cidr, data['Vpc']['CidrBlock'])
if CONF.aws.run_incompatible_tests: if CONF.aws.run_incompatible_tests:
@ -45,103 +45,90 @@ class VPCTest(base.EC2TestCase):
self.get_vpc_waiter().wait_available(vpc_id) self.get_vpc_waiter().wait_available(vpc_id)
resp, data = self.client.DeleteVpc(VpcId=vpc_id) self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
resp, data = self.client.DescribeVpcs(VpcIds=[vpc_id]) self.assertRaises('InvalidVpcID.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_vpcs,
self.assertEqual('InvalidVpcID.NotFound', data['Error']['Code']) VpcIds=[vpc_id])
resp, data = self.client.DeleteVpc(VpcId=vpc_id) self.assertRaises('InvalidVpcID.NotFound',
self.assertEqual(400, resp.status_code) self.client.delete_vpc,
self.assertEqual('InvalidVpcID.NotFound', data['Error']['Code']) VpcId=vpc_id)
def test_create_more_than_one_vpc(self): def test_create_more_than_one_vpc(self):
cidr = '10.0.0.0/16' cidr = '10.0.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id1 = data['Vpc']['VpcId'] vpc_id1 = data['Vpc']['VpcId']
rc1 = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id1) rc1 = self.addResourceCleanUp(self.client.delete_vpc, VpcId=vpc_id1)
self.get_vpc_waiter().wait_available(vpc_id1) self.get_vpc_waiter().wait_available(vpc_id1)
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id2 = data['Vpc']['VpcId'] vpc_id2 = data['Vpc']['VpcId']
rc2 = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id2) rc2 = self.addResourceCleanUp(self.client.delete_vpc, VpcId=vpc_id2)
self.get_vpc_waiter().wait_available(vpc_id2) self.get_vpc_waiter().wait_available(vpc_id2)
resp, data = self.client.DeleteVpc(VpcId=vpc_id1) self.client.delete_vpc(VpcId=vpc_id1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(rc1) self.cancelResourceCleanUp(rc1)
self.get_vpc_waiter().wait_delete(vpc_id1) self.get_vpc_waiter().wait_delete(vpc_id1)
resp, data = self.client.DeleteVpc(VpcId=vpc_id2) self.client.delete_vpc(VpcId=vpc_id2)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(rc2) self.cancelResourceCleanUp(rc2)
self.get_vpc_waiter().wait_delete(vpc_id2) self.get_vpc_waiter().wait_delete(vpc_id2)
def test_describe_vpcs_base(self): def test_describe_vpcs_base(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(self.client.delete_vpc,
VpcId=vpc_id)
self.get_vpc_waiter().wait_available(vpc_id) self.get_vpc_waiter().wait_available(vpc_id)
# NOTE(andrey-mp): by real id # NOTE(andrey-mp): by real id
resp, data = self.client.DescribeVpcs(VpcIds=[vpc_id]) data = self.client.describe_vpcs(VpcIds=[vpc_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Vpcs'])) self.assertEqual(1, len(data['Vpcs']))
# NOTE(andrey-mp): by fake id # NOTE(andrey-mp): by fake id
resp, data = self.client.DescribeVpcs(VpcIds=['vpc-0']) self.assertRaises('InvalidVpcID.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_vpcs,
self.assertEqual('InvalidVpcID.NotFound', data['Error']['Code']) VpcIds=['vpc-0'])
resp, data = self.client.DeleteVpc(VpcId=vpc_id) self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
def test_describe_vpcs_filters(self): def test_describe_vpcs_filters(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(self.client.delete_vpc,
VpcId=vpc_id)
self.get_vpc_waiter().wait_available(vpc_id) self.get_vpc_waiter().wait_available(vpc_id)
# NOTE(andrey-mp): by filter real cidr # NOTE(andrey-mp): by filter real cidr
resp, data = self.client.DescribeVpcs( data = self.client.describe_vpcs(
Filters=[{'Name': 'cidr', 'Values': [cidr]}]) Filters=[{'Name': 'cidr', 'Values': [cidr]}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Vpcs'])) self.assertEqual(1, len(data['Vpcs']))
# NOTE(andrey-mp): by filter fake cidr # NOTE(andrey-mp): by filter fake cidr
resp, data = self.client.DescribeVpcs( data = self.client.describe_vpcs(
Filters=[{'Name': 'cidr', 'Values': ['123.0.0.0/16']}]) Filters=[{'Name': 'cidr', 'Values': ['123.0.0.0/16']}])
self.assertEqual(200, resp.status_code)
self.assertEqual(0, len(data['Vpcs'])) self.assertEqual(0, len(data['Vpcs']))
if CONF.aws.run_incompatible_tests: if CONF.aws.run_incompatible_tests:
# NOTE(andrey-mp): describe no attributes # NOTE(andrey-mp): describe no attributes
resp, data = self.client.DescribeVpcAttribute(VpcId=vpc_id) self.assertRaises('InvalidParameterCombination',
self.assertEqual(400, resp.status_code) self.client.describe_vpc_attribute,
self.assertEqual('InvalidParameterCombination', VpcId=vpc_id)
data['Error']['Code'])
# NOTE(andrey-mp): by fake filter # NOTE(andrey-mp): by fake filter
resp, data = self.client.DescribeVpcs( self.assertRaises('InvalidParameterValue',
self.client.describe_vpcs,
Filters=[{'Name': 'fake', 'Values': ['fake']}]) Filters=[{'Name': 'fake', 'Values': ['fake']}])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue',
data['Error']['Code'])
resp, data = self.client.DeleteVpc(VpcId=vpc_id) data = self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
@ -149,100 +136,88 @@ class VPCTest(base.EC2TestCase):
"Invalid request on checking vpc atributes.") "Invalid request on checking vpc atributes.")
def test_vpc_attributes(self): def test_vpc_attributes(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(self.client.delete_vpc,
VpcId=vpc_id)
self.get_vpc_waiter().wait_available(vpc_id) self.get_vpc_waiter().wait_available(vpc_id)
self._check_attribute(vpc_id, 'EnableDnsHostnames') self._check_attribute(vpc_id, 'EnableDnsHostnames')
self._check_attribute(vpc_id, 'EnableDnsSupport') self._check_attribute(vpc_id, 'EnableDnsSupport')
resp, data = self.client.DeleteVpc(VpcId=vpc_id) data = self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
def _check_attribute(self, vpc_id, attribute): def _check_attribute(self, vpc_id, attribute):
req_attr = attribute[0].lower() + attribute[1:] req_attr = attribute[0].lower() + attribute[1:]
resp, data = self.client.DescribeVpcAttribute(VpcId=vpc_id, data = self.client.describe_vpc_attribute(VpcId=vpc_id,
Attribute=req_attr) Attribute=req_attr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
attr = data[attribute].get('Value') attr = data[attribute].get('Value')
self.assertIsNotNone(attr) self.assertIsNotNone(attr)
kwargs = {'VpcId': vpc_id, attribute: {'Value': not attr}} kwargs = {'VpcId': vpc_id, attribute: {'Value': not attr}}
resp, data = self.client.ModifyVpcAttribute(*[], **kwargs) data = self.client.modify_vpc_attribute(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) data = self.client.describe_vpc_attribute(VpcId=vpc_id,
resp, data = self.client.DescribeVpcAttribute(VpcId=vpc_id,
Attribute=req_attr) Attribute=req_attr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertNotEqual(attr, data[attribute].get('Value')) self.assertNotEqual(attr, data[attribute].get('Value'))
@testtools.skipUnless(CONF.aws.run_incompatible_tests, @testtools.skipUnless(CONF.aws.run_incompatible_tests,
"InvalidParameterCombination' != 'InvalidRequest") "InvalidParameterCombination' != 'InvalidRequest")
def test_describe_invalid_attributes(self): def test_describe_invalid_attributes(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(self.client.delete_vpc,
VpcId=vpc_id)
self.get_vpc_waiter().wait_available(vpc_id) self.get_vpc_waiter().wait_available(vpc_id)
# NOTE(andrey-mp): describe no attributes # NOTE(andrey-mp): describe no attributes
resp, data = self.client.DescribeVpcAttribute(VpcId=vpc_id) self.assertRaises('InvalidParameterCombination',
self.assertEqual(400, resp.status_code) self.client.describe_vpc_attribute,
self.assertEqual('InvalidParameterCombination', VpcId=vpc_id)
data['Error']['Code'])
resp, data = self.client.DeleteVpc(VpcId=vpc_id) data = self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)
def test_create_with_invalid_cidr(self): def test_create_with_invalid_cidr(self):
def _rollback(fn_data):
self.client.delete_vpc(VpcId=fn_data['Vpc']['VpcId'])
# NOTE(andrey-mp): The largest uses a /16 netmask # NOTE(andrey-mp): The largest uses a /16 netmask
resp, data = self.client.CreateVpc(CidrBlock='10.0.0.0/15') self.assertRaises('InvalidVpc.Range',
if resp.status_code == 200: self.client.create_vpc, rollback_fn=_rollback,
self.addResourceCleanUp(self.client.DeleteVpc, CidrBlock='10.0.0.0/15')
VpcId=data['Vpc']['VpcId'])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidVpc.Range', data['Error']['Code'])
# NOTE(andrey-mp): The smallest VPC you can create uses a /28 netmask # NOTE(andrey-mp): The smallest VPC you can create uses a /28 netmask
resp, data = self.client.CreateVpc(CidrBlock='10.0.0.0/29') self.assertRaises('InvalidVpc.Range',
if resp.status_code == 200: self.client.create_vpc, rollback_fn=_rollback,
self.addResourceCleanUp(self.client.DeleteVpc, CidrBlock='10.0.0.0/29')
VpcId=data['Vpc']['VpcId'])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidVpc.Range', data['Error']['Code'])
def test_describe_non_existing_vpc_by_id(self): def test_describe_non_existing_vpc_by_id(self):
vpc_id = 'vpc-00000000' vpc_id = 'vpc-00000000'
resp, data = self.client.DescribeVpcs(VpcIds=[vpc_id]) self.assertRaises('InvalidVpcID.NotFound',
self.assertEqual(400, resp.status_code) self.client.describe_vpcs,
self.assertEqual('InvalidVpcID.NotFound', data['Error']['Code']) VpcIds=[vpc_id])
def test_describe_non_existing_vpc_by_cidr(self): def test_describe_non_existing_vpc_by_cidr(self):
resp, data = self.client.DescribeVpcs( data = self.client.describe_vpcs(
Filters=[{'Name': 'cidr', 'Values': ['123.0.0.0/16']}]) Filters=[{'Name': 'cidr', 'Values': ['123.0.0.0/16']}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(0, len(data['Vpcs'])) self.assertEqual(0, len(data['Vpcs']))
def test_describe_with_invalid_filter(self): def test_describe_with_invalid_filter(self):
cidr = '10.1.0.0/16' cidr = '10.1.0.0/16'
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
dv_clean = self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) dv_clean = self.addResourceCleanUp(self.client.delete_vpc,
VpcId=vpc_id)
self.get_vpc_waiter().wait_available(vpc_id) self.get_vpc_waiter().wait_available(vpc_id)
resp, data = self.client.DescribeVpcs( self.assertRaises('InvalidParameterValue',
self.client.describe_vpcs,
Filters=[{'Name': 'unknown', 'Values': ['unknown']}]) Filters=[{'Name': 'unknown', 'Values': ['unknown']}])
self.assertEqual(400, resp.status_code)
self.assertEqual('InvalidParameterValue', data['Error']['Code'])
resp, data = self.client.DeleteVpc(VpcId=vpc_id) data = self.client.delete_vpc(VpcId=vpc_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(dv_clean) self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id) self.get_vpc_waiter().wait_delete(vpc_id)

240
ec2api/tests/functional/base.py
View File

@ -19,8 +19,8 @@ import sys
import time import time
import traceback import traceback
import botocore.exceptions
from oslo_log import log from oslo_log import log
import six
from tempest_lib import base from tempest_lib import base
from tempest_lib import exceptions from tempest_lib import exceptions
import testtools import testtools
@ -37,35 +37,6 @@ logging.getLogger(
).setLevel(logging.WARNING) ).setLevel(logging.WARNING)
class EC2ErrorConverter(object):
_data = ''
def __init__(self, data, *args, **kwargs):
self._data = data
def __str__(self):
if isinstance(self._data, six.string_types):
return self._data
if isinstance(self._data, dict) and 'Error' in self._data:
result = ''
if 'Message' in self._data['Error']:
result = self._data['Error']['Message']
if 'Code' in self._data['Error']:
result += ' (' + self._data['Error']['Code'] + ')'
return result
return str(self._data)
class EC2ResponceException(Exception):
def __init__(self, resp, data):
self.resp = resp
self.data = data
def __str__(self):
return str(self.data)
class EC2Waiter(object): class EC2Waiter(object):
def __init__(self, wait_func): def __init__(self, wait_func):
@ -167,16 +138,13 @@ def safe_setup(f):
try: try:
f(cls) f(cls)
except Exception as se: except Exception as se:
etype, value, trace = sys.exc_info() exc_info = sys.exc_info()
LOG.exception("setUpClass failed: %s" % se) LOG.exception("setUpClass failed: %s" % se)
try: try:
cls.tearDownClass() cls.tearDownClass()
except Exception as te: except Exception as te:
LOG.exception("tearDownClass failed: %s" % te) LOG.exception("tearDownClass failed: %s" % te)
try: raise exc_info[1], None, exc_info[2]
raise etype(value), None, trace
finally:
del trace # for avoiding circular refs
return decorator return decorator
@ -199,8 +167,7 @@ class TesterStateHolder(object):
return self._vpc_enabled return self._vpc_enabled
self._vpc_enabled = False self._vpc_enabled = False
resp, data = self.ec2_client.DescribeAccountAttributes() data = self.ec2_client.describe_account_attributes()
if resp.status_code == 200:
for item in data.get('AccountAttributes', []): for item in data.get('AccountAttributes', []):
if item['AttributeName'] == 'supported-platforms': if item['AttributeName'] == 'supported-platforms':
for value in item['AttributeValues']: for value in item['AttributeValues']:
@ -235,17 +202,11 @@ class EC2TestCase(base.BaseTestCase):
@safe_setup @safe_setup
def setUpClass(cls): def setUpClass(cls):
super(EC2TestCase, cls).setUpClass() super(EC2TestCase, cls).setUpClass()
cls.client = botocoreclient.APIClientEC2( cls.client = botocoreclient._get_ec2_client(
CONF.aws.ec2_url, CONF.aws.aws_region, CONF.aws.ec2_url, CONF.aws.aws_region,
CONF.aws.aws_access, CONF.aws.aws_secret) CONF.aws.aws_access, CONF.aws.aws_secret)
TesterStateHolder().ec2_client = cls.client TesterStateHolder().ec2_client = cls.client
@classmethod
def assertResultStatic(cls, resp, data):
if resp.status_code != 200:
LOG.error(EC2ErrorConverter(data))
assert 200 == resp.status_code
@classmethod @classmethod
def addResourceCleanUpStatic(cls, function, *args, **kwargs): def addResourceCleanUpStatic(cls, function, *args, **kwargs):
"""Adds CleanUp callable, used by tearDownClass. """Adds CleanUp callable, used by tearDownClass.
@ -297,28 +258,28 @@ class EC2TestCase(base.BaseTestCase):
] ]
_CLEANUP_WAITERS = { _CLEANUP_WAITERS = {
'DeleteVpc': ( 'delete_vpc': (
'get_vpc_waiter', 'get_vpc_waiter',
lambda kwargs: kwargs['VpcId']), lambda kwargs: kwargs['VpcId']),
'DeleteSubnet': ( 'delete_subnet': (
'get_subnet_waiter', 'get_subnet_waiter',
lambda kwargs: kwargs['SubnetId']), lambda kwargs: kwargs['SubnetId']),
'DeleteNetworkInterface': ( 'delete_network_interface': (
'get_network_interface_waiter', 'get_network_interface_waiter',
lambda kwargs: kwargs['NetworkInterfaceId']), lambda kwargs: kwargs['NetworkInterfaceId']),
'TerminateInstances': ( 'terminate_instances': (
'get_instance_waiter', 'get_instance_waiter',
lambda kwargs: kwargs['InstanceIds'][0]), lambda kwargs: kwargs['InstanceIds'][0]),
'DeleteVolume': ( 'delete_volume': (
'get_volume_waiter', 'get_volume_waiter',
lambda kwargs: kwargs['VolumeId']), lambda kwargs: kwargs['VolumeId']),
'DetachVolume': ( 'detach_volume': (
'get_volume_attachment_waiter', 'get_volume_attachment_waiter',
lambda kwargs: kwargs['VolumeId']), lambda kwargs: kwargs['VolumeId']),
'DeleteSnapshot': ( 'delete_snapshot': (
'get_snapshot_waiter', 'get_snapshot_waiter',
lambda kwargs: kwargs['SnapshotId']), lambda kwargs: kwargs['SnapshotId']),
'DeregisterImage': ( 'deregister_image': (
'get_image_waiter', 'get_image_waiter',
lambda kwargs: kwargs['ImageId']), lambda kwargs: kwargs['ImageId']),
} }
@ -356,25 +317,20 @@ class EC2TestCase(base.BaseTestCase):
@classmethod @classmethod
def cleanUpItem(cls, function, pos_args, kw_args): def cleanUpItem(cls, function, pos_args, kw_args):
resp, data = function(*pos_args, **kw_args) try:
if resp.status_code != 200: function(*pos_args, **kw_args)
error = data.get('Error', {}) if function.__name__ in cls._CLEANUP_WAITERS:
error_code = error.get('Code')
for err in cls._VALID_CLEANUP_ERRORS:
if err in error_code:
break
else:
err_msg = (error if isinstance(error, basestring)
else error.get('Message'))
msg = ("Cleanup failed with status %d and message"
" '%s'(Code = %s)"
% (resp.status_code, err_msg, error_code))
LOG.error(msg)
elif function.__name__ in cls._CLEANUP_WAITERS:
(waiter, obj_id) = cls._CLEANUP_WAITERS[function.__name__] (waiter, obj_id) = cls._CLEANUP_WAITERS[function.__name__]
waiter = getattr(cls, waiter) waiter = getattr(cls, waiter)
obj_id = obj_id(kw_args) obj_id = obj_id(kw_args)
waiter().wait_delete(obj_id) waiter().wait_delete(obj_id)
except botocore.exceptions.ClientError as e:
error_code = e.response['Error']['Code']
for err in cls._VALID_CLEANUP_ERRORS:
if err in error_code:
break
else:
LOG.error("Cleanup failed: %s", e, exc_info=True)
@classmethod @classmethod
def friendly_function_name_simple(cls, call_able): def friendly_function_name_simple(cls, call_able):
@ -397,16 +353,16 @@ class EC2TestCase(base.BaseTestCase):
@classmethod @classmethod
def _vpc_get_state(cls, vpc_id): def _vpc_get_state(cls, vpc_id):
resp, data = cls.client.DescribeVpcs(VpcIds=[vpc_id]) try:
if resp.status_code == 200: data = cls.client.describe_vpcs(VpcIds=[vpc_id])
return data['Vpcs'][0]['State'] if not data['Vpcs']:
if resp.status_code == 400:
error = data['Error']
if error['Code'] == 'InvalidVpcID.NotFound':
raise exceptions.NotFound() raise exceptions.NotFound()
return data['Vpcs'][0]['State']
raise EC2ResponceException(resp, data) except botocore.exceptions.ClientError:
error_code = sys.exc_info()[1].response['Error']['Code']
if error_code == 'InvalidVpcID.NotFound':
raise exceptions.NotFound()
raise
@classmethod @classmethod
def get_vpc_waiter(cls): def get_vpc_waiter(cls):
@ -414,16 +370,16 @@ class EC2TestCase(base.BaseTestCase):
@classmethod @classmethod
def _subnet_get_state(cls, subnet_id): def _subnet_get_state(cls, subnet_id):
resp, data = cls.client.DescribeSubnets(SubnetIds=[subnet_id]) try:
if resp.status_code == 200: data = cls.client.describe_subnets(SubnetIds=[subnet_id])
return data['Subnets'][0]['State'] if not data['Subnets']:
if resp.status_code == 400:
error = data['Error']
if error['Code'] == 'InvalidSubnetID.NotFound':
raise exceptions.NotFound() raise exceptions.NotFound()
return data['Subnets'][0]['State']
raise EC2ResponceException(resp, data) except botocore.exceptions.ClientError:
error_code = sys.exc_info()[1].response['Error']['Code']
if error_code == 'InvalidSubnetID.NotFound':
raise exceptions.NotFound()
raise
@classmethod @classmethod
def get_subnet_waiter(cls): def get_subnet_waiter(cls):
@ -431,19 +387,21 @@ class EC2TestCase(base.BaseTestCase):
@classmethod @classmethod
def _instance_get_state(cls, instance_id): def _instance_get_state(cls, instance_id):
resp, data = cls.client.DescribeInstances(InstanceIds=[instance_id]) try:
if resp.status_code == 200: data = cls.client.describe_instances(InstanceIds=[instance_id])
if not data['Reservations']:
raise exceptions.NotFound()
if not data['Reservations'][0]['Instances']:
raise exceptions.NotFound()
state = data['Reservations'][0]['Instances'][0]['State']['Name'] state = data['Reservations'][0]['Instances'][0]['State']['Name']
if state != 'terminated': if state != 'terminated':
return state return state
raise exceptions.NotFound() raise exceptions.NotFound()
except botocore.exceptions.ClientError:
if resp.status_code == 400: error_code = sys.exc_info()[1].response['Error']['Code']
error = data['Error'] if error_code == 'InvalidInstanceID.NotFound':
if error['Code'] == 'InvalidInstanceID.NotFound':
raise exceptions.NotFound() raise exceptions.NotFound()
raise
raise EC2ResponceException(resp, data)
@classmethod @classmethod
def get_instance_waiter(cls): def get_instance_waiter(cls):
@ -451,17 +409,17 @@ class EC2TestCase(base.BaseTestCase):
@classmethod @classmethod
def _network_interface_get_state(cls, ni_id): def _network_interface_get_state(cls, ni_id):
resp, data = cls.client.DescribeNetworkInterfaces( try:
data = cls.client.describe_network_interfaces(
NetworkInterfaceIds=[ni_id]) NetworkInterfaceIds=[ni_id])
if resp.status_code == 200: if not data['NetworkInterfaces']:
return data['NetworkInterfaces'][0]['Status']
if resp.status_code == 400:
error = data['Error']
if error['Code'] == 'InvalidNetworkInterfaceID.NotFound':
raise exceptions.NotFound() raise exceptions.NotFound()
return data['NetworkInterfaces'][0]['Status']
raise EC2ResponceException(resp, data) except botocore.exceptions.ClientError:
error_code = sys.exc_info()[1].response['Error']['Code']
if error_code == 'InvalidNetworkInterfaceID.NotFound':
raise exceptions.NotFound()
raise
@classmethod @classmethod
def get_network_interface_waiter(cls): def get_network_interface_waiter(cls):
@ -469,16 +427,16 @@ class EC2TestCase(base.BaseTestCase):
@classmethod @classmethod
def _volume_get_state(cls, volume_id): def _volume_get_state(cls, volume_id):
resp, data = cls.client.DescribeVolumes(VolumeIds=[volume_id]) try:
if resp.status_code == 200: data = cls.client.describe_volumes(VolumeIds=[volume_id])
return data['Volumes'][0]['State'] if not data['Volumes']:
if resp.status_code == 400:
error = data['Error']
if error['Code'] == 'InvalidVolume.NotFound':
raise exceptions.NotFound() raise exceptions.NotFound()
return data['Volumes'][0]['State']
raise EC2ResponceException(resp, data) except botocore.exceptions.ClientError:
error_code = sys.exc_info()[1].response['Error']['Code']
if error_code == 'InvalidVolume.NotFound':
raise exceptions.NotFound()
raise
@classmethod @classmethod
def get_volume_waiter(cls): def get_volume_waiter(cls):
@ -486,19 +444,17 @@ class EC2TestCase(base.BaseTestCase):
@classmethod @classmethod
def _volume_attachment_get_state(cls, volume_id): def _volume_attachment_get_state(cls, volume_id):
resp, data = cls.client.DescribeVolumes(VolumeIds=[volume_id]) try:
if resp.status_code == 200: data = cls.client.describe_volumes(VolumeIds=[volume_id])
volume = data['Volumes'][0] volume = data['Volumes'][0]
if 'Attachments' in volume and len(volume['Attachments']) > 0: if 'Attachments' in volume and len(volume['Attachments']) > 0:
return volume['Attachments'][0]['State'] return volume['Attachments'][0]['State']
raise exceptions.NotFound() raise exceptions.NotFound()
except botocore.exceptions.ClientError:
if resp.status_code == 400: error_code = sys.exc_info()[1].response['Error']['Code']
error = data['Error'] if error_code == 'InvalidVolume.NotFound':
if error['Code'] == 'InvalidVolume.NotFound':
raise exceptions.NotFound() raise exceptions.NotFound()
raise
raise EC2ResponceException(resp, data)
@classmethod @classmethod
def get_volume_attachment_waiter(cls): def get_volume_attachment_waiter(cls):
@ -506,16 +462,16 @@ class EC2TestCase(base.BaseTestCase):
@classmethod @classmethod
def _snapshot_get_state(cls, volume_id): def _snapshot_get_state(cls, volume_id):
resp, data = cls.client.DescribeSnapshots(SnapshotIds=[volume_id]) try:
if resp.status_code == 200: data = cls.client.describe_snapshots(SnapshotIds=[volume_id])
return data['Snapshots'][0]['State'] if not data['Snapshots']:
if resp.status_code == 400:
error = data['Error']
if error['Code'] == 'InvalidSnapshot.NotFound':
raise exceptions.NotFound() raise exceptions.NotFound()
return data['Snapshots'][0]['State']
raise EC2ResponceException(resp, data) except botocore.exceptions.ClientError:
error_code = sys.exc_info()[1].response['Error']['Code']
if error_code == 'InvalidSnapshot.NotFound':
raise exceptions.NotFound()
raise
@classmethod @classmethod
def get_snapshot_waiter(cls): def get_snapshot_waiter(cls):
@ -523,18 +479,16 @@ class EC2TestCase(base.BaseTestCase):
@classmethod @classmethod
def _image_get_state(cls, image_id): def _image_get_state(cls, image_id):
resp, data = cls.client.DescribeImages(ImageIds=[image_id]) try:
if resp.status_code == 200: data = cls.client.describe_images(ImageIds=[image_id])
if not data['Images']: if not data['Images']:
raise exceptions.NotFound() raise exceptions.NotFound()
return data['Images'][0]['State'] return data['Images'][0]['State']
except botocore.exceptions.ClientError:
if resp.status_code == 400: error_code = sys.exc_info()[1].response['Error']['Code']
error = data['Error'] if error_code == 'InvalidAMIID.NotFound':
if error['Code'] == 'InvalidAMIID.NotFound':
raise exceptions.NotFound() raise exceptions.NotFound()
raise
raise EC2ResponceException(resp, data)
@classmethod @classmethod
def get_image_waiter(cls): def get_image_waiter(cls):
@ -546,12 +500,20 @@ class EC2TestCase(base.BaseTestCase):
def assertNotEmpty(self, list_obj, msg=None): def assertNotEmpty(self, list_obj, msg=None):
self.assertTrue(len(list_obj) > 0, msg) self.assertTrue(len(list_obj) > 0, msg)
def assertRaises(self, error_code, fn, rollback_fn=None, **kwargs):
try:
fn_data = fn(**kwargs)
try:
rollback_fn(fn_data)
except Exception:
LOG.exception()
except botocore.exceptions.ClientError as e:
self.assertEqual(error_code, e.response['Error']['Code'])
# NOTE(andrey-mp): Helpers zone # NOTE(andrey-mp): Helpers zone
def get_instance(self, instance_id): def get_instance(self, instance_id):
resp, data = self.client.DescribeInstances( data = self.client.describe_instances(InstanceIds=[instance_id])
InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, EC2ErrorConverter(data))
self.assertEqual(1, len(data.get('Reservations', []))) self.assertEqual(1, len(data.get('Reservations', [])))
instances = data['Reservations'][0].get('Instances', []) instances = data['Reservations'][0].get('Instances', [])
self.assertEqual(1, len(instances)) self.assertEqual(1, len(instances))

58
ec2api/tests/functional/botocoreclient.py
View File

@ -1,4 +1,4 @@
# Copyright 2014 OpenStack Foundation # Copyright 2015 OpenStack Foundation
# All Rights Reserved. # All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # Licensed under the Apache License, Version 2.0 (the "License"); you may
@ -13,55 +13,15 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import types import botocore.session
from botocore import session
from oslo_log import log as logging
LOG = logging.getLogger(__name__)
class BotocoreClientBase(object): def _get_ec2_client(url, region, access, secret):
connection_data = {
def __init__(self, region, access, secret):
self.region = region
self.connection_data = {
'config_file': (None, 'AWS_CONFIG_FILE', None), 'config_file': (None, 'AWS_CONFIG_FILE', None),
'region': ('region', 'BOTO_DEFAULT_REGION', self.region), 'region': ('region', 'BOTO_DEFAULT_REGION', region),
} }
session = botocore.session.get_session(connection_data)
if not access or not secret: return session.create_client(
raise Exception('Auth params did not provided') 'ec2', region_name=region, endpoint_url=url,
aws_access_key_id=access, aws_secret_access_key=secret)
self.session = session.get_session(self.connection_data)
self.session.set_credentials(access, secret)
def __getattr__(self, name):
"""Automatically creates methods for the allowed methods set."""
op = self.service.get_operation(name)
if not op:
raise AttributeError(name)
def func(self, *args, **kwargs):
return op.call(self.endpoint, *args, **kwargs)
func.__name__ = name
setattr(self, name, types.MethodType(func, self, self.__class__))
return getattr(self, name)
class APIClientEC2(BotocoreClientBase):
url = None
def __init__(self, url, region, access, secret, *args, **kwargs):
super(APIClientEC2, self).__init__(region, access, secret,
*args, **kwargs)
self.url = url
self.service = self.session.get_service('ec2')
self.endpoint = self.service.get_endpoint(
region_name=self.region,
endpoint_url=url)
def get_url(self):
return self.url

69
ec2api/tests/functional/scenario/base.py
View File

@ -33,10 +33,9 @@ class BaseScenarioTest(base.EC2TestCase):
kwargs.setdefault('Placement', {'AvailabilityZone': CONF.aws.aws_zone}) kwargs.setdefault('Placement', {'AvailabilityZone': CONF.aws.aws_zone})
kwargs['MinCount'] = 1 kwargs['MinCount'] = 1
kwargs['MaxCount'] = 1 kwargs['MaxCount'] = 1
resp, data = self.client.RunInstances(*[], **kwargs) data = self.client.run_instances(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
self.addResourceCleanUp(self.client.TerminateInstances, self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -55,13 +54,12 @@ class BaseScenarioTest(base.EC2TestCase):
kwargs['AllocationId'] = alloc_id kwargs['AllocationId'] = alloc_id
else: else:
kwargs['PublicIp'] = public_ip kwargs['PublicIp'] = public_ip
resp, data = self.client.AssociateAddress(*[], **kwargs) data = self.client.associate_address(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
if 'VpcId' in instance: if 'VpcId' in instance:
self.addResourceCleanUp(self.client.DisassociateAddress, self.addResourceCleanUp(self.client.disassociate_address,
AssociationId=data['AssociationId']) AssociationId=data['AssociationId'])
else: else:
self.addResourceCleanUp(self.client.DisassociateAddress, self.addResourceCleanUp(self.client.disassociate_address,
PublicIp=public_ip) PublicIp=public_ip)
return public_ip return public_ip
@ -70,32 +68,29 @@ class BaseScenarioTest(base.EC2TestCase):
kwargs = dict() kwargs = dict()
if is_vpc: if is_vpc:
kwargs['Domain'] = 'vpc' kwargs['Domain'] = 'vpc'
resp, data = self.client.AllocateAddress(*[], **kwargs) data = self.client.allocate_address(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
alloc_id = data.get('AllocationId') alloc_id = data.get('AllocationId')
public_ip = data['PublicIp'] public_ip = data['PublicIp']
if is_vpc: if is_vpc:
self.addResourceCleanUp(self.client.ReleaseAddress, self.addResourceCleanUp(self.client.release_address,
AllocationId=alloc_id) AllocationId=alloc_id)
else: else:
self.addResourceCleanUp(self.client.ReleaseAddress, self.addResourceCleanUp(self.client.release_address,
PublicIp=public_ip) PublicIp=public_ip)
return alloc_id, public_ip return alloc_id, public_ip
def create_key_pair(self, key_name): def create_key_pair(self, key_name):
resp, data = self.client.CreateKeyPair(KeyName=key_name) data = self.client.create_key_pair(KeyName=key_name)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.addResourceCleanUp(self.client.delete_key_pair, KeyName=key_name)
self.addResourceCleanUp(self.client.DeleteKeyPair, KeyName=key_name)
return data.get('KeyMaterial') return data.get('KeyMaterial')
def create_standard_security_group(self): def create_standard_security_group(self):
name = data_utils.rand_name('sgName') name = data_utils.rand_name('sgName')
desc = data_utils.rand_name('sgDesc') desc = data_utils.rand_name('sgDesc')
kwargs = {'GroupName': name, 'Description': desc} kwargs = {'GroupName': name, 'Description': desc}
resp, data = self.client.CreateSecurityGroup(*[], **kwargs) self.client.create_security_group(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.addResourceCleanUp(self.client.delete_security_group,
self.addResourceCleanUp(self.client.DeleteSecurityGroup,
GroupName=name) GroupName=name)
time.sleep(2) time.sleep(2)
@ -117,15 +112,13 @@ class BaseScenarioTest(base.EC2TestCase):
}], }],
}] }]
} }
resp, data = self.client.AuthorizeSecurityGroupIngress(*[], **kwargs) self.client.authorize_security_group_ingress(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
return name return name
def prepare_vpc_default_security_group(self, vpc_id): def prepare_vpc_default_security_group(self, vpc_id):
resp, data = self.client.DescribeSecurityGroups( data = self.client.describe_security_groups(
Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]) Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}])
self.assertEqual(200, resp.status_code)
self.assertEqual(1, len(data['SecurityGroups'])) self.assertEqual(1, len(data['SecurityGroups']))
group_id = data['SecurityGroups'][0]['GroupId'] group_id = data['SecurityGroups'][0]['GroupId']
kwargs = { kwargs = {
@ -139,13 +132,11 @@ class BaseScenarioTest(base.EC2TestCase):
}], }],
}] }]
} }
resp, data = self.client.AuthorizeSecurityGroupIngress(*[], **kwargs) self.client.authorize_security_group_ingress(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
def prepare_route(self, vpc_id, gw_id): def prepare_route(self, vpc_id, gw_id):
resp, data = self.client.DescribeRouteTables( data = self.client.describe_route_tables(
Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]) Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}])
self.assertEqual(200, resp.status_code)
self.assertEqual(1, len(data['RouteTables'])) self.assertEqual(1, len(data['RouteTables']))
kwargs = { kwargs = {
@ -153,44 +144,38 @@ class BaseScenarioTest(base.EC2TestCase):
'RouteTableId': data['RouteTables'][0]['RouteTableId'], 'RouteTableId': data['RouteTables'][0]['RouteTableId'],
'GatewayId': gw_id 'GatewayId': gw_id
} }
resp, data = self.client.CreateRoute(*[], **kwargs) self.client.create_route(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
def create_vpc_and_subnet(self, cidr): def create_vpc_and_subnet(self, cidr):
resp, data = self.client.CreateVpc(CidrBlock=cidr) data = self.client.create_vpc(CidrBlock=cidr)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
self.addResourceCleanUp(self.client.DeleteVpc, VpcId=vpc_id) self.addResourceCleanUp(self.client.delete_vpc, VpcId=vpc_id)
self.get_vpc_waiter().wait_available(vpc_id) self.get_vpc_waiter().wait_available(vpc_id)
resp, data = self.client.CreateSubnet(VpcId=vpc_id, CidrBlock=cidr, data = self.client.create_subnet(VpcId=vpc_id, CidrBlock=cidr,
AvailabilityZone=CONF.aws.aws_zone) AvailabilityZone=CONF.aws.aws_zone)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
self.addResourceCleanUp(self.client.DeleteSubnet, SubnetId=subnet_id) self.addResourceCleanUp(self.client.delete_subnet, SubnetId=subnet_id)
return vpc_id, subnet_id return vpc_id, subnet_id
def create_network_interface(self, subnet_id): def create_network_interface(self, subnet_id):
resp, data = self.client.CreateNetworkInterface(SubnetId=subnet_id) data = self.client.create_network_interface(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
self.addResourceCleanUp(self.client.DeleteNetworkInterface, self.addResourceCleanUp(self.client.delete_network_interface,
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
self.get_network_interface_waiter().wait_available(ni_id) self.get_network_interface_waiter().wait_available(ni_id)
return ni_id return ni_id
def create_and_attach_internet_gateway(self, vpc_id): def create_and_attach_internet_gateway(self, vpc_id):
resp, data = self.client.CreateInternetGateway() data = self.client.create_internet_gateway()
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
gw_id = data['InternetGateway']['InternetGatewayId'] gw_id = data['InternetGateway']['InternetGatewayId']
self.addResourceCleanUp(self.client.DeleteInternetGateway, self.addResourceCleanUp(self.client.delete_internet_gateway,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
resp, data = self.client.AttachInternetGateway(VpcId=vpc_id, data = self.client.attach_internet_gateway(VpcId=vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) self.addResourceCleanUp(self.client.detach_internet_gateway,
self.addResourceCleanUp(self.client.DetachInternetGateway,
VpcId=vpc_id, VpcId=vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)

166
ec2api/tests/functional/scenario/test_ebs_instances.py
View File

@ -43,8 +43,7 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
cls.image_id = CONF.aws.ebs_image_id cls.image_id = CONF.aws.ebs_image_id
cls.zone = CONF.aws.aws_zone cls.zone = CONF.aws.aws_zone
resp, data = cls.client.DescribeImages(ImageIds=[cls.image_id]) data = cls.client.describe_images(ImageIds=[cls.image_id])
cls.assertResultStatic(resp, data)
assert 1 == len(data['Images']) assert 1 == len(data['Images'])
image = data['Images'][0] image = data['Images'][0]
cls.root_device_name = image['RootDeviceName'] cls.root_device_name = image['RootDeviceName']
@ -55,8 +54,7 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
cls.root_device_size = ebs.get('VolumeSize') cls.root_device_size = ebs.get('VolumeSize')
if not cls.root_device_size: if not cls.root_device_size:
snapshotId = ebs.get('SnapshotId') snapshotId = ebs.get('SnapshotId')
resp, data = cls.client.DescribeSnapshots(SnapshotIds=[snapshotId]) data = cls.client.describe_snapshots(SnapshotIds=[snapshotId])
cls.assertResultStatic(resp, data)
assert 1 == len(data['Snapshots']) assert 1 == len(data['Snapshots'])
cls.root_device_size = data['Snapshots'][0]['VolumeSize'] cls.root_device_size = data['Snapshots'][0]['VolumeSize']
@ -70,14 +68,13 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
Launch EBS-backed instance with left root device after termination Launch EBS-backed instance with left root device after termination
""" """
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=self.image_id, InstanceType=instance_type, ImageId=self.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1, Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1,
BlockDeviceMappings=[{'DeviceName': self.root_device_name, BlockDeviceMappings=[{'DeviceName': self.root_device_name,
'Ebs': {'DeleteOnTermination': False}}]) 'Ebs': {'DeleteOnTermination': False}}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -85,25 +82,22 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
bdt = self.get_instance_bdm(instance_id, self.root_device_name) bdt = self.get_instance_bdm(instance_id, self.root_device_name)
self.assertIsNotNone(bdt) self.assertIsNotNone(bdt)
volume_id = bdt['Ebs'].get('VolumeId') volume_id = bdt['Ebs'].get('VolumeId')
res_clean_vol = self.addResourceCleanUp(self.client.DeleteVolume, res_clean_vol = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id) VolumeId=volume_id)
self.assertIsNotNone(volume_id) self.assertIsNotNone(volume_id)
self.assertFalse(bdt['Ebs']['DeleteOnTermination']) self.assertFalse(bdt['Ebs']['DeleteOnTermination'])
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
self.get_volume_waiter().wait_available(volume_id) self.get_volume_waiter().wait_available(volume_id)
resp, data = self.client.DeleteVolume(VolumeId=volume_id) self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean_vol) self.cancelResourceCleanUp(res_clean_vol)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
@ -116,14 +110,13 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
new_size = int(math.ceil(self.root_device_size * 1.1)) new_size = int(math.ceil(self.root_device_size * 1.1))
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=self.image_id, InstanceType=instance_type, ImageId=self.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1, Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1,
BlockDeviceMappings=[{'DeviceName': self.root_device_name, BlockDeviceMappings=[{'DeviceName': self.root_device_name,
'Ebs': {'VolumeSize': new_size}}]) 'Ebs': {'VolumeSize': new_size}}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -134,14 +127,12 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
self.assertIsNotNone(volume_id) self.assertIsNotNone(volume_id)
self.assertTrue(bdt['Ebs']['DeleteOnTermination']) self.assertTrue(bdt['Ebs']['DeleteOnTermination'])
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
volume = data['Volumes'][0] volume = data['Volumes'][0]
self.assertEqual(new_size, volume['Size']) self.assertEqual(new_size, volume['Size'])
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -155,14 +146,13 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
device_name = device_name_prefix + 'd' device_name = device_name_prefix + 'd'
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=self.image_id, InstanceType=instance_type, ImageId=self.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1, Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1,
BlockDeviceMappings=[{'DeviceName': device_name, BlockDeviceMappings=[{'DeviceName': device_name,
'Ebs': {'VolumeSize': 1}}]) 'Ebs': {'VolumeSize': 1}}])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -173,14 +163,12 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
self.assertIsNotNone(volume_id) self.assertIsNotNone(volume_id)
self.assertTrue(bdt['Ebs']['DeleteOnTermination']) self.assertTrue(bdt['Ebs']['DeleteOnTermination'])
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
volume = data['Volumes'][0] volume = data['Volumes'][0]
self.assertEqual(1, volume['Size']) self.assertEqual(1, volume['Size'])
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
@ -213,8 +201,7 @@ class EC2_EBSInstanceAttaching(base.EC2TestCase):
cls.image_id = CONF.aws.ebs_image_id cls.image_id = CONF.aws.ebs_image_id
cls.zone = CONF.aws.aws_zone cls.zone = CONF.aws.aws_zone
resp, data = cls.client.DescribeImages(ImageIds=[cls.image_id]) data = cls.client.describe_images(ImageIds=[cls.image_id])
cls.assertResultStatic(resp, data)
assert 1 == len(data['Images']) assert 1 == len(data['Images'])
image = data['Images'][0] image = data['Images'][0]
root_device_name = image['RootDeviceName'] root_device_name = image['RootDeviceName']
@ -223,18 +210,16 @@ class EC2_EBSInstanceAttaching(base.EC2TestCase):
cls.full_device_name_prefix = device_name_prefix cls.full_device_name_prefix = device_name_prefix
cls.short_device_name_prefix = device_name_prefix[len("/dev/"):] cls.short_device_name_prefix = device_name_prefix[len("/dev/"):]
resp, data = cls.client.CreateVolume(AvailabilityZone=cls.zone, data = cls.client.create_volume(AvailabilityZone=cls.zone,
Size=1) Size=1)
cls.assertResultStatic(resp, data)
cls.volume_id = data['VolumeId'] cls.volume_id = data['VolumeId']
cls.addResourceCleanUpStatic(cls.client.DeleteVolume, cls.addResourceCleanUpStatic(cls.client.delete_volume,
VolumeId=cls.volume_id) VolumeId=cls.volume_id)
cls.get_volume_waiter().wait_available(cls.volume_id) cls.get_volume_waiter().wait_available(cls.volume_id)
resp, data = cls.client.CreateSnapshot(VolumeId=cls.volume_id) data = cls.client.create_snapshot(VolumeId=cls.volume_id)
cls.assertResultStatic(resp, data)
cls.snapshot_id = data['SnapshotId'] cls.snapshot_id = data['SnapshotId']
cls.addResourceCleanUpStatic(cls.client.DeleteSnapshot, cls.addResourceCleanUpStatic(cls.client.delete_snapshot,
SnapshotId=cls.snapshot_id) SnapshotId=cls.snapshot_id)
cls.get_snapshot_waiter().wait_available(cls.snapshot_id, cls.get_snapshot_waiter().wait_available(cls.snapshot_id,
final_set=('completed')) final_set=('completed'))
@ -242,7 +227,7 @@ class EC2_EBSInstanceAttaching(base.EC2TestCase):
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
cls.device1_name = cls.full_device_name_prefix + "d" cls.device1_name = cls.full_device_name_prefix + "d"
cls.device2_name = cls.short_device_name_prefix + "h" cls.device2_name = cls.short_device_name_prefix + "h"
resp, data = cls.client.RunInstances( data = cls.client.run_instances(
ImageId=cls.image_id, InstanceType=instance_type, ImageId=cls.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': cls.zone}, MinCount=1, MaxCount=1, Placement={'AvailabilityZone': cls.zone}, MinCount=1, MaxCount=1,
BlockDeviceMappings=[{'DeviceName': cls.device1_name, BlockDeviceMappings=[{'DeviceName': cls.device1_name,
@ -251,16 +236,14 @@ class EC2_EBSInstanceAttaching(base.EC2TestCase):
{'DeviceName': cls.device2_name, {'DeviceName': cls.device2_name,
'Ebs': {'SnapshotId': cls.snapshot_id, 'Ebs': {'SnapshotId': cls.snapshot_id,
'DeleteOnTermination': True}}]) 'DeleteOnTermination': True}}])
cls.assertResultStatic(resp, data)
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
cls.instance_id = instance_id cls.instance_id = instance_id
cls.addResourceCleanUpStatic(cls.client.TerminateInstances, cls.addResourceCleanUpStatic(cls.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
cls.get_instance_waiter().wait_available(instance_id, cls.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = cls.client.DescribeInstances(InstanceIds=[instance_id]) data = cls.client.describe_instances(InstanceIds=[instance_id])
cls.assertResultStatic(resp, data)
assert 1 == len(data.get('Reservations', [])) assert 1 == len(data.get('Reservations', []))
instances = data['Reservations'][0].get('Instances', []) instances = data['Reservations'][0].get('Instances', [])
assert 1 == len(instances) assert 1 == len(instances)
@ -281,41 +264,37 @@ class EC2_EBSInstanceAttaching(base.EC2TestCase):
# reattaching volume, so we need delete them manually # reattaching volume, so we need delete them manually
for volume_id in [cls.volume_id1, cls.volume_id2]: for volume_id in [cls.volume_id1, cls.volume_id2]:
try: try:
cls.cleanUpItem(cls.client.DeleteVolume, [], cls.cleanUpItem(cls.client.delete_volume, [],
{'VolumeId': volume_id}) {'VolumeId': volume_id})
except BaseException: except BaseException:
LOG.exception('EBSInstanceAttaching.tearDownClass failure') LOG.exception('EBSInstanceAttaching.tearDownClass failure')
def _test_attaching(self, volume_id, device_name, device_prefix, def _test_attaching(self, volume_id, device_name, device_prefix,
new_device_name_letter): new_device_name_letter):
resp, data = self.client.DetachVolume(VolumeId=volume_id) self.client.detach_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) clean_v = self.addResourceCleanUp(self.client.delete_volume,
clean_v = self.addResourceCleanUp(self.client.DeleteVolume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_attachment_waiter().wait_delete(volume_id) self.get_volume_attachment_waiter().wait_delete(volume_id)
bdt = self.get_instance_bdm(self.instance_id, device_name) bdt = self.get_instance_bdm(self.instance_id, device_name)
self.assertIsNone(bdt) self.assertIsNone(bdt)
resp, data = self.client.AttachVolume(InstanceId=self.instance_id, self.client.attach_volume(InstanceId=self.instance_id,
VolumeId=volume_id, VolumeId=volume_id,
Device=device_name) Device=device_name)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_v) self.cancelResourceCleanUp(clean_v)
self.get_volume_attachment_waiter().wait_available( self.get_volume_attachment_waiter().wait_available(
volume_id, final_set=('attached')) volume_id, final_set=('attached'))
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code)
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
self.assertEqual('in-use', data['Volumes'][0]['State']) self.assertEqual('in-use', data['Volumes'][0]['State'])
bdt = self.get_instance_bdm(self.instance_id, device_name) bdt = self.get_instance_bdm(self.instance_id, device_name)
self.assertIsNotNone(bdt) self.assertIsNotNone(bdt)
resp, data = self.client.DetachVolume(VolumeId=volume_id) self.client.detach_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) clean_v = self.addResourceCleanUp(self.client.delete_volume,
clean_v = self.addResourceCleanUp(self.client.DeleteVolume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_attachment_waiter().wait_delete(volume_id) self.get_volume_attachment_waiter().wait_delete(volume_id)
@ -323,16 +302,14 @@ class EC2_EBSInstanceAttaching(base.EC2TestCase):
self.assertIsNone(bdt) self.assertIsNone(bdt)
new_device_name = device_prefix + new_device_name_letter new_device_name = device_prefix + new_device_name_letter
resp, data = self.client.AttachVolume(InstanceId=self.instance_id, self.client.attach_volume(InstanceId=self.instance_id,
VolumeId=volume_id, VolumeId=volume_id,
Device=new_device_name) Device=new_device_name)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_v) self.cancelResourceCleanUp(clean_v)
self.get_volume_attachment_waiter().wait_available( self.get_volume_attachment_waiter().wait_available(
volume_id, final_set=('attached')) volume_id, final_set=('attached'))
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id]) data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code)
self.assertEqual(1, len(data['Volumes'])) self.assertEqual(1, len(data['Volumes']))
self.assertEqual('in-use', data['Volumes'][0]['State']) self.assertEqual('in-use', data['Volumes'][0]['State'])
@ -371,12 +348,11 @@ class EC2_EBSInstanceSnapshot(base.EC2TestCase):
"""Create snapshot of EBS-backed instance and check it.""" """Create snapshot of EBS-backed instance and check it."""
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=self.image_id, InstanceType=instance_type, ImageId=self.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -387,20 +363,17 @@ class EC2_EBSInstanceSnapshot(base.EC2TestCase):
volume_id = bdt['Ebs'].get('VolumeId') volume_id = bdt['Ebs'].get('VolumeId')
self.assertIsNotNone(volume_id) self.assertIsNotNone(volume_id)
resp, data = self.client.StopInstances(InstanceIds=[instance_id]) self.client.stop_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('stopped')) final_set=('stopped'))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
resp, data = self.client.CreateSnapshot(VolumeId=volume_id) data = self.client.create_snapshot(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
snapshot_id = data['SnapshotId'] snapshot_id = data['SnapshotId']
clean_s = self.addResourceCleanUp(self.client.DeleteSnapshot, clean_s = self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
self.get_snapshot_waiter().wait_available(snapshot_id, self.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed')) final_set=('completed'))
@ -418,36 +391,31 @@ class EC2_EBSInstanceSnapshot(base.EC2TestCase):
kwargs['KernelId'] = instance['KernelId'] kwargs['KernelId'] = instance['KernelId']
if 'RamdiskId' in instance: if 'RamdiskId' in instance:
kwargs['RamdiskId'] = instance['RamdiskId'] kwargs['RamdiskId'] = instance['RamdiskId']
resp, data = self.client.RegisterImage(*[], **kwargs) data = self.client.register_image(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
image_id = data['ImageId'] image_id = data['ImageId']
clean_i = self.addResourceCleanUp(self.client.DeregisterImage, clean_i = self.addResourceCleanUp(self.client.deregister_image,
ImageId=image_id) ImageId=image_id)
self.get_image_waiter().wait_available(image_id) self.get_image_waiter().wait_available(image_id)
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
# NOTE(andrey-mp): if instance will run then test will pass # NOTE(andrey-mp): if instance will run then test will pass
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
resp, data = self.client.DeregisterImage(ImageId=image_id) self.client.deregister_image(ImageId=image_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_i) self.cancelResourceCleanUp(clean_i)
resp, data = self.client.DeleteSnapshot(SnapshotId=snapshot_id) self.client.delete_snapshot(SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_s) self.cancelResourceCleanUp(clean_s)
@ -475,13 +443,12 @@ class EC2_EBSInstanceResizeRootDevice(base.EC2TestCase):
def test_resize_root_ebs_device(self): def test_resize_root_ebs_device(self):
"""Resize root device of launched instance.""" """Resize root device of launched instance."""
instance_type = CONF.aws.instance_type instance_type = CONF.aws.instance_type
resp, data = self.client.RunInstances( data = self.client.run_instances(
ImageId=self.image_id, InstanceType=instance_type, ImageId=self.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1) Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance = data['Instances'][0] instance = data['Instances'][0]
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
@ -491,67 +458,58 @@ class EC2_EBSInstanceResizeRootDevice(base.EC2TestCase):
volume_id = bdt['Ebs'].get('VolumeId') volume_id = bdt['Ebs'].get('VolumeId')
self.assertIsNotNone(volume_id) self.assertIsNotNone(volume_id)
resp, data = self.client.StopInstances(InstanceIds=[instance_id]) self.client.stop_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('stopped')) final_set=('stopped'))
resp, data = self.client.DetachVolume(VolumeId=volume_id) self.client.detach_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data)) clean_v = self.addResourceCleanUp(self.client.delete_volume,
clean_v = self.addResourceCleanUp(self.client.DeleteVolume,
VolumeId=volume_id) VolumeId=volume_id)
self.get_volume_attachment_waiter().wait_delete(volume_id) self.get_volume_attachment_waiter().wait_delete(volume_id)
resp, data = self.client.CreateSnapshot(VolumeId=volume_id) data = self.client.create_snapshot(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
snapshot_id = data['SnapshotId'] snapshot_id = data['SnapshotId']
clean_s = self.addResourceCleanUp(self.client.DeleteSnapshot, clean_s = self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
self.get_snapshot_waiter().wait_available(snapshot_id, self.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed')) final_set=('completed'))
new_size = int(math.ceil(data['VolumeSize'] * 1.1)) new_size = int(math.ceil(data['VolumeSize'] * 1.1))
resp, data = self.client.CreateVolume(AvailabilityZone=self.zone, data = self.client.create_volume(AvailabilityZone=self.zone,
Size=new_size, Size=new_size,
SnapshotId=snapshot_id) SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
volume_id2 = data['VolumeId'] volume_id2 = data['VolumeId']
clean_v2 = self.addResourceCleanUp(self.client.DeleteVolume, clean_v2 = self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id2) VolumeId=volume_id2)
self.get_volume_waiter().wait_available(volume_id2) self.get_volume_waiter().wait_available(volume_id2)
resp, data = self.client.DeleteSnapshot(SnapshotId=snapshot_id) self.client.delete_snapshot(SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_s) self.cancelResourceCleanUp(clean_s)
resp, data = self.client.DeleteVolume(VolumeId=volume_id) self.client.delete_volume(VolumeId=volume_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_v) self.cancelResourceCleanUp(clean_v)
self.get_volume_waiter().wait_delete(volume_id) self.get_volume_waiter().wait_delete(volume_id)
resp, data = self.client.AttachVolume( self.client.attach_volume(
InstanceId=instance_id, VolumeId=volume_id2, InstanceId=instance_id, VolumeId=volume_id2,
Device=instance['RootDeviceName']) Device=instance['RootDeviceName'])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.get_volume_attachment_waiter().wait_available( self.get_volume_attachment_waiter().wait_available(
volume_id2, final_set=('attached')) volume_id2, final_set=('attached'))
# NOTE(andrey-mp): move this cleanup operation to the end of trash # NOTE(andrey-mp): move this cleanup operation to the end of trash
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
res_clean = self.addResourceCleanUp(self.client.TerminateInstances, res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
resp, data = self.client.StartInstances(InstanceIds=[instance_id]) self.client.start_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
# NOTE(andrey-mp): if instance will run then test will pass # NOTE(andrey-mp): if instance will run then test will pass
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(res_clean) self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
self.client.DeleteVolume(VolumeId=volume_id) self.client.delete_volume(VolumeId=volume_id2)
self.cancelResourceCleanUp(clean_v2) self.cancelResourceCleanUp(clean_v2)

9
ec2api/tests/functional/scenario/test_instances.py
View File

@ -45,9 +45,8 @@ class InstancesTest(scenario_base.BaseScenarioTest):
instance_id = self.run_instance(KeyName=key_name, UserData=user_data, instance_id = self.run_instance(KeyName=key_name, UserData=user_data,
SecurityGroups=[sec_group_name]) SecurityGroups=[sec_group_name])
resp, data = self.client.DescribeInstanceAttribute( data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='userData') InstanceId=instance_id, Attribute='userData')
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(data['UserData']['Value'], self.assertEqual(data['UserData']['Value'],
base64.b64encode(user_data)) base64.b64encode(user_data))
@ -75,13 +74,11 @@ class InstancesTest(scenario_base.BaseScenarioTest):
cmd = 'sudo sh -c "echo \\"%s\\" >/dev/console"' % data_to_check cmd = 'sudo sh -c "echo \\"%s\\" >/dev/console"' % data_to_check
ssh_client.exec_command(cmd) ssh_client.exec_command(cmd)
waiter = base.EC2Waiter(self.client.GetConsoleOutput) waiter = base.EC2Waiter(self.client.get_console_output)
waiter.wait_no_exception(InstanceId=instance_id) waiter.wait_no_exception(InstanceId=instance_id)
def _compare_console_output(): def _compare_console_output():
resp, data = self.client.GetConsoleOutput(InstanceId=instance_id) data = self.client.get_console_output(InstanceId=instance_id)
self.assertEqual(200, resp.status_code,
base.EC2ErrorConverter(data))
self.assertEqual(instance_id, data['InstanceId']) self.assertEqual(instance_id, data['InstanceId'])
self.assertIsNotNone(data['Timestamp']) self.assertIsNotNone(data['Timestamp'])
self.assertIn('Output', data) self.assertIn('Output', data)

62
ec2api/tests/functional/scenario/test_vpc_addresses.py
View File

@ -39,11 +39,10 @@ class VpcAddressTest(scenario_base.BaseScenarioTest):
alloc_id1, public_ip1 = self.allocate_address(True) alloc_id1, public_ip1 = self.allocate_address(True)
alloc_id2, _ = self.allocate_address(True) alloc_id2, _ = self.allocate_address(True)
resp, data = self.client.CreateNetworkInterface(SubnetId=subnet_id) data = self.client.create_network_interface(SubnetId=subnet_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
ni_id2 = data['NetworkInterface']['NetworkInterfaceId'] ni_id2 = data['NetworkInterface']['NetworkInterfaceId']
clean_ni2 = self.addResourceCleanUp(self.client.DeleteNetworkInterface, clean_ni2 = self.addResourceCleanUp(
NetworkInterfaceId=ni_id2) self.client.delete_network_interface, NetworkInterfaceId=ni_id2)
self.get_network_interface_waiter().wait_available(ni_id2) self.get_network_interface_waiter().wait_available(ni_id2)
kwargs = { kwargs = {
@ -54,39 +53,33 @@ class VpcAddressTest(scenario_base.BaseScenarioTest):
'NetworkInterfaces': [ 'NetworkInterfaces': [
{'NetworkInterfaceId': ni_id1, 'DeviceIndex': 0}] {'NetworkInterfaceId': ni_id1, 'DeviceIndex': 0}]
} }
resp, data = self.client.RunInstances(*[], **kwargs) data = self.client.run_instances(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
instance_id = data['Instances'][0]['InstanceId'] instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.TerminateInstances, clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id]) InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id, self.get_instance_waiter().wait_available(instance_id,
final_set=('running')) final_set=('running'))
resp, data = self.client.AttachNetworkInterface(DeviceIndex=1, data = self.client.attach_network_interface(DeviceIndex=1,
InstanceId=instance_id, NetworkInterfaceId=ni_id2) InstanceId=instance_id, NetworkInterfaceId=ni_id2)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
attachment_id = data['AttachmentId'] attachment_id = data['AttachmentId']
# There are multiple interfaces attached to instance 'i-5310c5af'. # There are multiple interfaces attached to instance 'i-5310c5af'.
# Please specify an interface ID for the operation instead. # Please specify an interface ID for the operation instead.
resp, data = self.client.AssociateAddress(InstanceId=instance_id, self.assertRaises('InvalidInstanceID',
AllocationId=alloc_id1) self.client.associate_address,
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data)) InstanceId=instance_id, AllocationId=alloc_id1)
self.assertEqual('InvalidInstanceID', data['Error']['Code'])
# The networkInterface ID 'eni-ffffffff' does not exist # The networkInterface ID 'eni-ffffffff' does not exist
resp, data = self.client.AssociateAddress( self.assertRaises('InvalidNetworkInterfaceID.NotFound',
self.client.associate_address,
AllocationId=alloc_id1, NetworkInterfaceId='eni-ffffffff') AllocationId=alloc_id1, NetworkInterfaceId='eni-ffffffff')
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual('InvalidNetworkInterfaceID.NotFound',
data['Error']['Code'])
# NOTE(andrey-mp): Amazon needs only network interface if several # NOTE(andrey-mp): Amazon needs only network interface if several
# present in instance. Error will be there if instance is passed. # present in instance. Error will be there if instance is passed.
resp, data = self.client.AssociateAddress( data = self.client.associate_address(
AllocationId=alloc_id1, NetworkInterfaceId=ni_id1) AllocationId=alloc_id1, NetworkInterfaceId=ni_id1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
assoc_id1 = data['AssociationId'] assoc_id1 = data['AssociationId']
clean_aa1 = self.addResourceCleanUp(self.client.DisassociateAddress, clean_aa1 = self.addResourceCleanUp(self.client.disassociate_address,
AssociationId=assoc_id1) AssociationId=assoc_id1)
instance = self.get_instance(instance_id) instance = self.get_instance(instance_id)
@ -101,20 +94,18 @@ class VpcAddressTest(scenario_base.BaseScenarioTest):
else: else:
self.assertTrue(False, 'Unknown interface found: ' + str(ni)) self.assertTrue(False, 'Unknown interface found: ' + str(ni))
resp, data = self.client.DescribeNetworkInterfaces( data = self.client.describe_network_interfaces(
NetworkInterfaceIds=[ni_id1, ni_id2]) NetworkInterfaceIds=[ni_id1, ni_id2])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(2, len(data['NetworkInterfaces'])) self.assertEqual(2, len(data['NetworkInterfaces']))
self.assertEqual('in-use', data['NetworkInterfaces'][0]['Status']) self.assertEqual('in-use', data['NetworkInterfaces'][0]['Status'])
self.assertEqual('in-use', data['NetworkInterfaces'][1]['Status']) self.assertEqual('in-use', data['NetworkInterfaces'][1]['Status'])
# NOTE(andrery-mp): associate second address and set delete on # NOTE(andrery-mp): associate second address and set delete on
# termination to True for interface # termination to True for interface
resp, data = self.client.AssociateAddress( data = self.client.associate_address(
AllocationId=alloc_id2, NetworkInterfaceId=ni_id2) AllocationId=alloc_id2, NetworkInterfaceId=ni_id2)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
assoc_id2 = data['AssociationId'] assoc_id2 = data['AssociationId']
clean_aa2 = self.addResourceCleanUp(self.client.DisassociateAddress, clean_aa2 = self.addResourceCleanUp(self.client.disassociate_address,
AssociationId=assoc_id2) AssociationId=assoc_id2)
kwargs = { kwargs = {
@ -124,43 +115,36 @@ class VpcAddressTest(scenario_base.BaseScenarioTest):
'DeleteOnTermination': True, 'DeleteOnTermination': True,
} }
} }
resp, data = self.client.ModifyNetworkInterfaceAttribute(*[], **kwargs) self.client.modify_network_interface_attribute(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
# NOTE(andrey-mp): cleanup # NOTE(andrey-mp): cleanup
time.sleep(3) time.sleep(3)
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id]) self.client.terminate_instances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_i) self.cancelResourceCleanUp(clean_i)
self.get_instance_waiter().wait_delete(instance_id) self.get_instance_waiter().wait_delete(instance_id)
resp, data = self.client.DescribeNetworkInterfaces( self.assertRaises('InvalidNetworkInterfaceID.NotFound',
self.client.describe_network_interfaces,
NetworkInterfaceIds=[ni_id2]) NetworkInterfaceIds=[ni_id2])
self.assertEqual(400, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual('InvalidNetworkInterfaceID.NotFound',
data['Error']['Code'])
self.cancelResourceCleanUp(clean_ni2) self.cancelResourceCleanUp(clean_ni2)
self.cancelResourceCleanUp(clean_aa2) self.cancelResourceCleanUp(clean_aa2)
resp, data = self.client.DescribeNetworkInterfaces( data = self.client.describe_network_interfaces(
NetworkInterfaceIds=[ni_id1]) NetworkInterfaceIds=[ni_id1])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['NetworkInterfaces'])) self.assertEqual(1, len(data['NetworkInterfaces']))
self.assertEqual('available', data['NetworkInterfaces'][0]['Status']) self.assertEqual('available', data['NetworkInterfaces'][0]['Status'])
ni = data['NetworkInterfaces'][0] ni = data['NetworkInterfaces'][0]
self.assertIsNotNone(ni.get('Association')) self.assertIsNotNone(ni.get('Association'))
self.assertEqual(public_ip1, ni['Association']['PublicIp']) self.assertEqual(public_ip1, ni['Association']['PublicIp'])
resp, data = self.client.DescribeAddresses(AllocationIds=[alloc_id1, data = self.client.describe_addresses(AllocationIds=[alloc_id1,
alloc_id2]) alloc_id2])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
for address in data['Addresses']: for address in data['Addresses']:
if address['AllocationId'] == alloc_id1: if address['AllocationId'] == alloc_id1:
self.assertIsNotNone(address.get('AssociationId')) self.assertIsNotNone(address.get('AssociationId'))
elif address['AllocationId'] == alloc_id2: elif address['AllocationId'] == alloc_id2:
self.assertIsNone(address.get('AssociationId')) self.assertIsNone(address.get('AssociationId'))
resp, data = self.client.DisassociateAddress(AssociationId=assoc_id1) self.client.disassociate_address(AssociationId=assoc_id1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.cancelResourceCleanUp(clean_aa1) self.cancelResourceCleanUp(clean_aa1)

125
rally-scenarios/plugins/context_plugin_ec2_objects.py
View File

@ -20,7 +20,6 @@ from rally.common import log as logging
from rally.common import utils as rutils from rally.common import utils as rutils
from rally import consts from rally import consts
from ec2api.tests.functional import base as ec2_tests_base
from ec2api.tests.functional import botocoreclient from ec2api.tests.functional import botocoreclient
@ -48,10 +47,7 @@ class EC2Objects(base.Context):
if self.config.get("run_in_vpc", False): if self.config.get("run_in_vpc", False):
subnet_id = self.prepare_network(tenant_id, client) subnet_id = self.prepare_network(tenant_id, client)
kwargs["SubnetId"] = subnet_id kwargs["SubnetId"] = subnet_id
resp, data = client.RunInstances(*[], **kwargs) data = client.run_instances(*[], **kwargs)
if resp.status_code != 200:
LOG.error(ec2_tests_base.EC2ErrorConverter(data))
assert 200 == resp.status_code
ids = [s['InstanceId'] for s in data['Instances']] ids = [s['InstanceId'] for s in data['Instances']]
self.context["tenants"][tenant_id]["servers"] += ids self.context["tenants"][tenant_id]["servers"] += ids
servers_per_tenant -= servers_per_run servers_per_tenant -= servers_per_run
@ -61,10 +57,7 @@ class EC2Objects(base.Context):
ids = self.context["tenants"][tenant_id]["servers"] ids = self.context["tenants"][tenant_id]["servers"]
start_time = time.time() start_time = time.time()
while True: while True:
resp, data = client.DescribeInstances(InstanceIds=ids) data = client.describe_instances(InstanceIds=ids)
if resp.status_code != 200:
LOG.error(ec2_tests_base.EC2ErrorConverter(data))
assert 200 == resp.status_code
for instance in data['Reservations'][0]['Instances']: for instance in data['Reservations'][0]['Instances']:
assert 'error' != instance['State']['Name'] assert 'error' != instance['State']['Name']
if instance['State']['Name'] != 'running': if instance['State']['Name'] != 'running':
@ -80,42 +73,27 @@ class EC2Objects(base.Context):
result = dict() result = dict()
self.context["tenants"][tenant_id]["networks"].append(result) self.context["tenants"][tenant_id]["networks"].append(result)
resp, data = client.CreateVpc(CidrBlock=self.CIDR) data = client.create_vpc(CidrBlock=self.CIDR)
if resp.status_code != 200:
LOG.error(ec2_tests_base.EC2ErrorConverter(data))
assert 200 == resp.status_code
vpc_id = data['Vpc']['VpcId'] vpc_id = data['Vpc']['VpcId']
result["vpc_id"] = vpc_id result["vpc_id"] = vpc_id
resp, data = client.CreateSubnet(VpcId=vpc_id, data = client.create_subnet(VpcId=vpc_id,
CidrBlock=self.CIDR, AvailabilityZone=self.AWS_ZONE) CidrBlock=self.CIDR, AvailabilityZone=self.AWS_ZONE)
if resp.status_code != 200:
LOG.error(ec2_tests_base.EC2ErrorConverter(data))
assert 200 == resp.status_code
subnet_id = data['Subnet']['SubnetId'] subnet_id = data['Subnet']['SubnetId']
result["subnet_id"] = subnet_id result["subnet_id"] = subnet_id
result["ni_ids"] = list() result["ni_ids"] = list()
for dummy in xrange(0, ni_count): for dummy in xrange(0, ni_count):
resp, data = client.CreateNetworkInterface(SubnetId=subnet_id) data = client.create_network_interface(SubnetId=subnet_id)
if resp.status_code != 200:
LOG.error(ec2_tests_base.EC2ErrorConverter(data))
assert 200 == resp.status_code
ni_id = data['NetworkInterface']['NetworkInterfaceId'] ni_id = data['NetworkInterface']['NetworkInterfaceId']
result["ni_ids"].append(ni_id) result["ni_ids"].append(ni_id)
time.sleep(1) time.sleep(1)
if self.config.get('assign_floating_ip', False): if self.config.get('assign_floating_ip', False):
resp, data = client.CreateInternetGateway() data = client.create_internet_gateway()
if resp.status_code != 200:
LOG.error(ec2_tests_base.EC2ErrorConverter(data))
assert 200 == resp.status_code
gw_id = data['InternetGateway']['InternetGatewayId'] gw_id = data['InternetGateway']['InternetGatewayId']
result["gw_id"] = gw_id result["gw_id"] = gw_id
resp, data = client.AttachInternetGateway(VpcId=vpc_id, data = client.attach_internet_gateway(VpcId=vpc_id,
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
if resp.status_code != 200:
LOG.error(ec2_tests_base.EC2ErrorConverter(data))
assert 200 == resp.status_code
return subnet_id return subnet_id
@ -134,10 +112,7 @@ class EC2Objects(base.Context):
kwargs = dict() kwargs = dict()
if is_vpc: if is_vpc:
kwargs['Domain'] = 'vpc' kwargs['Domain'] = 'vpc'
resp, data = client.AllocateAddress(*[], **kwargs) data = client.allocate_address(*[], **kwargs)
if resp.status_code != 200:
LOG.warning(ec2_tests_base.EC2ErrorConverter(data))
return
alloc_id = data.get('AllocationId') alloc_id = data.get('AllocationId')
public_ip = data['PublicIp'] public_ip = data['PublicIp']
if is_vpc: if is_vpc:
@ -152,15 +127,14 @@ class EC2Objects(base.Context):
kwargs['AllocationId'] = alloc_id kwargs['AllocationId'] = alloc_id
else: else:
kwargs['PublicIp'] = public_ip kwargs['PublicIp'] = public_ip
resp, data = client.AssociateAddress(*[], **kwargs) try:
if resp.status_code != 200: data = client.associate_address(*[], **kwargs)
LOG.error(ec2_tests_base.EC2ErrorConverter(data)) except Exception:
LOG.exception()
if is_vpc: if is_vpc:
resp, data = client.ReleaseAddress(AllocationId=alloc_id) data = client.release_address(AllocationId=alloc_id)
else: else:
resp, data = client.ReleaseAddress(PublicIp=public_ip) data = client.release_address(PublicIp=public_ip)
if resp.status_code != 200:
LOG.error(ec2_tests_base.EC2ErrorConverter(data))
def terminate_instances_and_wait(self, tenant_id, client): def terminate_instances_and_wait(self, tenant_id, client):
ids = self.context["tenants"][tenant_id].get("servers", []) ids = self.context["tenants"][tenant_id].get("servers", [])
@ -168,20 +142,18 @@ class EC2Objects(base.Context):
mod = len(ids) / servers_per_run mod = len(ids) / servers_per_run
for i in xrange(0, mod): for i in xrange(0, mod):
part_ids = ids[i * servers_per_run:(i + 1) * servers_per_run] part_ids = ids[i * servers_per_run:(i + 1) * servers_per_run]
resp, data = client.TerminateInstances(InstanceIds=part_ids) data = client.terminate_instances(InstanceIds=part_ids)
if resp.status_code != 200:
LOG.warning(ec2_tests_base.EC2ErrorConverter(data))
part_ids = ids[mod * servers_per_run:] part_ids = ids[mod * servers_per_run:]
if part_ids: if part_ids:
resp, data = client.TerminateInstances(InstanceIds=part_ids) data = client.terminate_instances(InstanceIds=part_ids)
if resp.status_code != 200:
LOG.warning(ec2_tests_base.EC2ErrorConverter(data))
start_time = time.time() start_time = time.time()
while True: while True:
resp, data = client.DescribeInstances(InstanceIds=ids) try:
if (resp.status_code == 400 data = client.describe_instances(InstanceIds=ids)
or len(data['Reservations']) == 0 except Exception:
break
if (len(data['Reservations']) == 0
or len(data['Reservations'][0]['Instances']) == 0): or len(data['Reservations'][0]['Instances']) == 0):
break break
for instance in data['Reservations'][0]['Instances']: for instance in data['Reservations'][0]['Instances']:
@ -198,9 +170,7 @@ class EC2Objects(base.Context):
LOG.info("Cleanup addresses") LOG.info("Cleanup addresses")
kwargss = self.context["tenants"][tenant_id].get("addresses", []) kwargss = self.context["tenants"][tenant_id].get("addresses", [])
for kwargs in kwargss: for kwargs in kwargss:
resp, data = client.ReleaseAddress(*[], **kwargs) data = client.release_address(*[], **kwargs)
if resp.status_code != 200:
LOG.warning(ec2_tests_base.EC2ErrorConverter(data))
def cleanup_networks(self, tenant_id, client): def cleanup_networks(self, tenant_id, client):
LOG.info("Cleanup networks") LOG.info("Cleanup networks")
@ -209,34 +179,39 @@ class EC2Objects(base.Context):
vpc_id = network.get("vpc_id") vpc_id = network.get("vpc_id")
gw_id = network.get("gw_id") gw_id = network.get("gw_id")
if gw_id: if gw_id:
resp, data = client.DetachInternetGateway( try:
data = client.detach_internet_gateway(
VpcId=vpc_id, InternetGatewayId=gw_id) VpcId=vpc_id, InternetGatewayId=gw_id)
if resp.status_code != 200: except Exception:
LOG.warning(ec2_tests_base.EC2ErrorConverter(data)) LOG.exception()
time.sleep(1) time.sleep(1)
resp, data = client.DeleteInternetGateway( try:
data = client.delete_internet_gateway(
InternetGatewayId=gw_id) InternetGatewayId=gw_id)
if resp.status_code != 200: except Exception:
LOG.warning(ec2_tests_base.EC2ErrorConverter(data)) LOG.exception()
time.sleep(1) time.sleep(1)
ni_ids = network.get("ni_ids") ni_ids = network.get("ni_ids")
if ni_ids: if ni_ids:
for ni_id in ni_ids: for ni_id in ni_ids:
resp, data = client.DeleteNetworkInterface( try:
data = client.delete_network_interface(
NetworkInterfaceId=ni_id) NetworkInterfaceId=ni_id)
if resp.status_code != 200: except Exception:
LOG.warning(ec2_tests_base.EC2ErrorConverter(data)) LOG.exception()
time.sleep(1) time.sleep(1)
subnet_id = network.get("subnet_id") subnet_id = network.get("subnet_id")
if subnet_id: if subnet_id:
resp, data = client.DeleteSubnet(SubnetId=subnet_id) try:
if resp.status_code != 200: data = client.delete_subnet(SubnetId=subnet_id)
LOG.warning(ec2_tests_base.EC2ErrorConverter(data)) except Exception:
LOG.exception()
time.sleep(1) time.sleep(1)
if vpc_id: if vpc_id:
resp, data = client.DeleteVpc(VpcId=vpc_id) try:
if resp.status_code != 200: data = client.delete_vpc(VpcId=vpc_id)
LOG.warning(ec2_tests_base.EC2ErrorConverter(data)) except Exception:
LOG.exception()
@base.context(name="ec2_networks", order=451) @base.context(name="ec2_networks", order=451)
@ -275,7 +250,7 @@ class FakeNetworkGenerator(EC2Objects):
% (user["tenant_id"])) % (user["tenant_id"]))
args = user['ec2args'] args = user['ec2args']
client = botocoreclient.APIClientEC2( client = botocoreclient._get_ec2_client(
args['url'], args['region'], args['access'], args['secret']) args['url'], args['region'], args['access'], args['secret'])
self.context["tenants"][tenant_id]["networks"] = list() self.context["tenants"][tenant_id]["networks"] = list()
@ -289,10 +264,8 @@ class FakeNetworkGenerator(EC2Objects):
for user, tenant_id in rutils.iterate_per_tenants( for user, tenant_id in rutils.iterate_per_tenants(
self.context["users"]): self.context["users"]):
args = user['ec2args'] args = user['ec2args']
client = botocoreclient.APIClientEC2( client = botocoreclient._get_ec2_client(
args['url'], args['region'], args['access'], args['secret']) args['url'], args['region'], args['access'], args['secret'])
ids = self.context["tenants"][tenant_id].get("servers", [])
self.cleanup_networks(tenant_id, client) self.cleanup_networks(tenant_id, client)
@ -353,16 +326,13 @@ class FakeServerGenerator(EC2Objects):
% (user["tenant_id"])) % (user["tenant_id"]))
args = user['ec2args'] args = user['ec2args']
client = botocoreclient.APIClientEC2( client = botocoreclient._get_ec2_client(
args['url'], args['region'], args['access'], args['secret']) args['url'], args['region'], args['access'], args['secret'])
if image_id is None: if image_id is None:
resp, data = client.DescribeImages( data = client.describe_images(
Filters=[{'Name': 'name', 'Values': [image]}, Filters=[{'Name': 'name', 'Values': [image]},
{'Name': 'image-type', 'Values': ['machine']}]) {'Name': 'image-type', 'Values': ['machine']}])
if resp.status_code != 200:
LOG.error(ec2_tests_base.EC2ErrorConverter(data))
assert 200 == resp.status_code
image_id = data['Images'][0]['ImageId'] image_id = data['Images'][0]['ImageId']
self.context["tenants"][tenant_id]["servers"] = list() self.context["tenants"][tenant_id]["servers"] = list()
@ -376,9 +346,8 @@ class FakeServerGenerator(EC2Objects):
for user, tenant_id in rutils.iterate_per_tenants( for user, tenant_id in rutils.iterate_per_tenants(
self.context["users"]): self.context["users"]):
args = user['ec2args'] args = user['ec2args']
client = botocoreclient.APIClientEC2( client = botocoreclient._get_ec2_client(
args['url'], args['region'], args['access'], args['secret']) args['url'], args['region'], args['access'], args['secret'])
ids = self.context["tenants"][tenant_id].get("servers", [])
self.terminate_instances_and_wait(tenant_id, client) self.terminate_instances_and_wait(tenant_id, client)
self.release_addresses(tenant_id, client) self.release_addresses(tenant_id, client)

37
rally-scenarios/plugins/ec2api_plugin.py
View File

@ -40,7 +40,7 @@ class EC2APIPlugin(base.Scenario):
def _get_client(self, is_nova): def _get_client(self, is_nova):
args = self.context['user']['ec2args'] args = self.context['user']['ec2args']
url = args['nova_url'] if is_nova else args['url'] url = args['nova_url'] if is_nova else args['url']
client = botocoreclient.APIClientEC2( client = botocoreclient._get_ec2_client(
url, args['region'], args['access'], args['secret']) url, args['region'], args['access'], args['secret'])
return client return client
@ -68,67 +68,57 @@ class EC2APIPlugin(base.Scenario):
@base.scenario() @base.scenario()
@_runner(_run_both) @_runner(_run_both)
def describe_instances(self, client): def describe_instances(self, client):
resp, data = client.DescribeInstances() data = client.describe_instances()
assert 200 == resp.status_code
@base.scenario() @base.scenario()
@_runner(_run_both) @_runner(_run_both)
def describe_addresses(self, client): def describe_addresses(self, client):
resp, data = client.DescribeAddresses() data = client.describe_addresses()
assert 200 == resp.status_code
@base.scenario() @base.scenario()
@_runner(_run_both) @_runner(_run_both)
def describe_security_groups(self, client): def describe_security_groups(self, client):
resp, data = client.DescribeSecurityGroups() data = client.describe_security_groups()
assert 200 == resp.status_code
@base.scenario() @base.scenario()
@_runner(_run_both) @_runner(_run_both)
def describe_regions(self, client): def describe_regions(self, client):
resp, data = client.DescribeRegions() data = client.describe_regions()
assert 200 == resp.status_code
@base.scenario() @base.scenario()
@_runner(_run_both) @_runner(_run_both)
def describe_images(self, client): def describe_images(self, client):
resp, data = client.DescribeImages() data = client.describe_images()
assert 200 == resp.status_code
@base.scenario() @base.scenario()
@_runner(_run_ec2) @_runner(_run_ec2)
def describe_vpcs(self, client): def describe_vpcs(self, client):
resp, data = client.DescribeVpcs() data = client.describe_vpcs()
assert 200 == resp.status_code
@base.scenario() @base.scenario()
@_runner(_run_ec2) @_runner(_run_ec2)
def describe_subnets(self, client): def describe_subnets(self, client):
resp, data = client.DescribeSubnets() data = client.describe_subnets()
assert 200 == resp.status_code
@base.scenario() @base.scenario()
@_runner(_run_ec2) @_runner(_run_ec2)
def describe_network_interfaces(self, client): def describe_network_interfaces(self, client):
resp, data = client.DescribeNetworkInterfaces() data = client.describe_network_interfaces()
assert 200 == resp.status_code
@base.scenario() @base.scenario()
@_runner(_run_ec2) @_runner(_run_ec2)
def describe_route_tables(self, client): def describe_route_tables(self, client):
resp, data = client.DescribeRouteTables() data = client.describe_route_tables()
assert 200 == resp.status_code
_instance_id_by_client = dict() _instance_id_by_client = dict()
@base.scenario() @base.scenario()
@_runner(_run_both) @_runner(_run_both)
def describe_one_instance(self, client): def describe_one_instance(self, client):
client_id = client.get_url() client_id = client._endpoint
instance_id = self._instance_id_by_client.get(client_id) instance_id = self._instance_id_by_client.get(client_id)
if not instance_id: if not instance_id:
resp, data = client.DescribeInstances() data = client.describe_instances()
assert 200 == resp.status_code
instances = data['Reservations'][0]['Instances'] instances = data['Reservations'][0]['Instances']
index = len(instances) / 3 index = len(instances) / 3
instance_id = instances[index]['InstanceId'] instance_id = instances[index]['InstanceId']
@ -136,8 +126,7 @@ class EC2APIPlugin(base.Scenario):
LOG.info("found instance = %s for client %s" LOG.info("found instance = %s for client %s"
% (instance_id, client_id)) % (instance_id, client_id))
resp, data = client.DescribeInstances(InstanceIds=[instance_id]) data = client.describe_instances(InstanceIds=[instance_id])
assert 200 == resp.status_code
@base.scenario() @base.scenario()
def describe_all_in_one(self): def describe_all_in_one(self):