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

View File

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

View File

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

View File

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

View File

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

View File

@ -34,13 +34,12 @@ class InstanceWithEBSTest(base.EC2TestCase):
def test_create_get_delete_ebs_instance(self):
"""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,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances,
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
@ -63,24 +62,21 @@ class InstanceWithEBSTest(base.EC2TestCase):
self.assertTrue(ebs.get('AttachTime'))
self.assertTrue(ebs.get('DeleteOnTermination'))
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(1, len(data['Volumes']))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
def test_create_root_volume_snapshot(self):
"""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,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
self.assertEqual(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.TerminateInstances,
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
@ -90,33 +86,28 @@ class InstanceWithEBSTest(base.EC2TestCase):
volume_id = bdt['Ebs'].get('VolumeId')
self.assertIsNotNone(volume_id)
resp, data = self.client.StopInstances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
data = self.client.stop_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('stopped'))
resp, data = self.client.DescribeVolumes(VolumeIds=[volume_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
data = self.client.describe_volumes(VolumeIds=[volume_id])
self.assertEqual(1, len(data['Volumes']))
kwargs = {
'VolumeId': data['Volumes'][0]['VolumeId'],
'Description': 'Description'
}
resp, data = self.client.CreateSnapshot(*[], **kwargs)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
data = self.client.create_snapshot(*[], **kwargs)
snapshot_id = data['SnapshotId']
res_clean_s = self.addResourceCleanUp(self.client.DeleteSnapshot,
res_clean_s = self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id)
self.get_snapshot_waiter().wait_available(snapshot_id,
final_set=('completed'))
resp, data = self.client.TerminateInstances(InstanceIds=[instance_id])
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
resp, data = self.client.DeleteSnapshot(SnapshotId=snapshot_id)
self.assertEqual(200, resp.status_code, base.EC2ErrorConverter(data))
data = self.client.delete_snapshot(SnapshotId=snapshot_id)
self.cancelResourceCleanUp(res_clean_s)
self.get_snapshot_waiter().wait_delete(snapshot_id)

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -1,4 +1,4 @@
# Copyright 2014 OpenStack Foundation
# Copyright 2015 OpenStack Foundation
# All Rights Reserved.
#
# 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
# under the License.
import types
from botocore import session
from oslo_log import log as logging
LOG = logging.getLogger(__name__)
import botocore.session
class BotocoreClientBase(object):
def __init__(self, region, access, secret):
self.region = region
self.connection_data = {
'config_file': (None, 'AWS_CONFIG_FILE', None),
'region': ('region', 'BOTO_DEFAULT_REGION', self.region),
}
if not access or not secret:
raise Exception('Auth params did not provided')
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
def _get_ec2_client(url, region, access, secret):
connection_data = {
'config_file': (None, 'AWS_CONFIG_FILE', None),
'region': ('region', 'BOTO_DEFAULT_REGION', region),
}
session = botocore.session.get_session(connection_data)
return session.create_client(
'ec2', region_name=region, endpoint_url=url,
aws_access_key_id=access, aws_secret_access_key=secret)

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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