openstack
/
ec2-api
Code Issues Proposed changes

add EBS volume deletion to tests. 

tests should delete EBS volume by themselves due to OpenStack bug.

Change-Id: Ic32992c54b75e2bdea196cc8073e422e868189f8
This commit is contained in:
Andrey Pavlov 2015-05-08 22:17:44 +03:00
parent 8b13458b19
commit 21e63c3309
14 changed files with 192 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ec2api/tests/contrib/post_test_hook.sh
View File

@ -22,6 +22,11 @@ sudo apt-get install euca2ools -fy
export TEST_CONFIG_DIR=$(readlink -f .)
export TEST_CONFIG="functional_tests.conf"
# save original creds(admin) for later usage
OLD_OS_TENANT_NAME=$OS_TENANT_NAME
OLD_OS_USERNAME=$OS_USERNAME
OLD_OS_PASSWORD=$OS_PASSWORD
if [[ ! -f $TEST_CONFIG_DIR/$TEST_CONFIG ]]; then
openstack catalog list
@ -142,4 +147,17 @@ RETVAL=$?
# Here can be some commands for log archiving, etc...
# list resources to check what left after tests
euca-describe-instances
euca-describe-images
euca-describe-volumes
euca-describe-snapshots
export OS_TENANT_NAME=$OLD_OS_TENANT_NAME
export OS_USERNAME=$OLD_OS_USERNAME
export OS_PASSWORD=$OLD_OS_PASSWORD
nova list --all-tenants
cinder list --all-tenants
cinder snapshot-list --all-tenants
glance image-list --all-tenants
exit $RETVAL

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

@ -17,6 +17,7 @@ import time
import botocore.exceptions
from oslo_log import log
import testtools
from ec2api.tests.functional import base
from ec2api.tests.functional import config
@ -225,12 +226,9 @@ class AddressTest(base.EC2TestCase):
self.cancelResourceCleanUp(res_clean)
@base.skip_without_vpc()
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_associate_disassociate_vpc_addresses(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
aws_zone = CONF.aws.aws_zone
if not image_id:
raise self.skipException('aws image_id does not provided')
base_net = '10.3.0.0'
data = self.client.create_vpc(CidrBlock=base_net + '/20')
@ -246,14 +244,7 @@ class AddressTest(base.EC2TestCase):
clean_subnet = self.addResourceCleanUp(self.client.delete_subnet,
SubnetId=subnet_id)
data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=subnet_id)
instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(SubnetId=subnet_id)
data = self.client.allocate_address(Domain='vpc')
alloc_id = data['AllocationId']
@ -305,7 +296,6 @@ class AddressTest(base.EC2TestCase):
self.cancelResourceCleanUp(clean_a)
self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(clean_i)
self.get_instance_waiter().wait_delete(instance_id)
self.client.delete_subnet(SubnetId=subnet_id)
@ -316,21 +306,9 @@ class AddressTest(base.EC2TestCase):
self.cancelResourceCleanUp(clean_vpc)
self.get_vpc_waiter().wait_delete(vpc_id)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_associate_disassociate_standard_addresses(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
if not image_id:
raise self.skipException('aws image_id does not provided')
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.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance()
data = self.client.allocate_address(*[], **{})
ip = data['PublicIp']
@ -359,7 +337,6 @@ class AddressTest(base.EC2TestCase):
self.cancelResourceCleanUp(clean_a)
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(clean_i)
self.get_instance_waiter().wait_delete(instance_id)
@base.skip_without_vpc()

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

@ -13,7 +13,6 @@
# 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
@ -133,16 +132,7 @@ class ImageTest(base.EC2TestCase):
if 'RootDeviceType' in image and 'ebs' in image['RootDeviceType']:
raise self.skipException('image_id should not be EBS image.')
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(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(ImageId=image_id)
def _rollback(fn_data):
self.client.deregister_image(ImageId=fn_data['ImageId'])
@ -152,7 +142,6 @@ class ImageTest(base.EC2TestCase):
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):
@ -162,16 +151,7 @@ class ImageTest(base.EC2TestCase):
self.assertTrue('RootDeviceType' in image
and 'ebs' in image['RootDeviceType'])
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(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(ImageId=image_id)
data = self.client.create_image(InstanceId=instance_id,
Name=name, Description=desc)
@ -184,20 +164,10 @@ class ImageTest(base.EC2TestCase):
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]}
try:
data = self.client.describe_snapshots(**kwargs)
volume_id = data['Snapshots'][0].get('VolumeId')
if volume_id:
self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id)
except botocore.exceptions.ClientError:
pass
self.addResourceCleanUp(self.client.delete_snapshot,
SnapshotId=snapshot_id)
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
return image_id, image_clean

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

@ -231,27 +231,19 @@ class InstanceTest(base.EC2TestCase):
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
@testtools.skipUnless(CONF.aws.ebs_image_id, "EBS image id is not defined")
def test_describe_instance_attributes(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
instance_id = data['Instances'][0]['InstanceId']
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'))
image_id = CONF.aws.ebs_image_id
instance_id = self.run_instance(ImageId=image_id)
if CONF.aws.run_incompatible_tests:
data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='blockDeviceMapping')
bdms = data.get('BlockDeviceMappings', [])
self.assertNotEmpty(bdms)
self.assertEqual(1, len(bdms))
self.assertIn('DeviceName', bdms[0])
self.assertIn('Ebs', bdms[0])
data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='blockDeviceMapping')
bdms = data.get('BlockDeviceMappings', [])
self.assertNotEmpty(bdms)
self.assertEqual(1, len(bdms))
self.assertIn('DeviceName', bdms[0])
self.assertIn('Ebs', bdms[0])
data = self.client.describe_instance_attribute(
InstanceId=instance_id, Attribute='disableApiTermination')
@ -289,7 +281,6 @@ class InstanceTest(base.EC2TestCase):
self.assertTrue(data['RootDeviceName']['Value'])
self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
@testtools.skipUnless(CONF.aws.run_incompatible_tests,

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

@ -14,6 +14,7 @@
# under the License.
from oslo_log import log
import testtools
from ec2api.tests.functional import base
from ec2api.tests.functional import config
@ -23,27 +24,11 @@ LOG = log.getLogger(__name__)
class InstanceWithEBSTest(base.EC2TestCase):
@classmethod
@base.safe_setup
def setUpClass(cls):
super(InstanceWithEBSTest, cls).setUpClass()
if not CONF.aws.ebs_image_id:
raise cls.skipException('aws EBS image does not provided')
cls.image_id = CONF.aws.ebs_image_id
cls.zone = CONF.aws.aws_zone
@testtools.skipUnless(CONF.aws.ebs_image_id, "EBS image id is not defined")
def test_create_get_delete_ebs_instance(self):
"""Launch EBS-backed instance, check results, and terminate it."""
data = self.client.run_instances(
ImageId=self.image_id, InstanceType=CONF.aws.instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(ImageId=CONF.aws.ebs_image_id)
instance = self.get_instance(instance_id)
self.assertEqual('ebs', instance.get('RootDeviceType'))
@ -66,27 +51,19 @@ class InstanceWithEBSTest(base.EC2TestCase):
self.assertEqual(1, len(data['Volumes']))
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
@testtools.skipUnless(CONF.aws.ebs_image_id, "EBS image id is not defined")
def test_create_root_volume_snapshot(self):
"""Create snapshot of root volume of EBS-backed instance."""
data = self.client.run_instances(
ImageId=self.image_id, InstanceType=CONF.aws.instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
self.assertEqual(1, len(data['Instances']))
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(ImageId=CONF.aws.ebs_image_id)
bdt = self.get_instance_bdm(instance_id, None)
self.assertIsNotNone(bdt)
volume_id = bdt['Ebs'].get('VolumeId')
self.assertIsNotNone(volume_id)
data = self.client.stop_instances(InstanceIds=[instance_id])
self.client.stop_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('stopped'))
@ -105,7 +82,6 @@ class InstanceWithEBSTest(base.EC2TestCase):
final_set=('completed'))
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
data = self.client.delete_snapshot(SnapshotId=snapshot_id)

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

@ -36,8 +36,6 @@ class InstanceInVPCTest(base.EC2TestCase):
super(InstanceInVPCTest, cls).setUpClass()
if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled')
if not CONF.aws.image_id:
raise cls.skipException('aws image_id does not provided')
data = cls.client.create_vpc(CidrBlock=cls.VPC_CIDR)
cls.vpc_id = data['Vpc']['VpcId']
@ -53,18 +51,9 @@ class InstanceInVPCTest(base.EC2TestCase):
SubnetId=cls.subnet_id)
cls.get_subnet_waiter().wait_available(cls.subnet_id)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_create_delete_instance(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=self.subnet_id)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(SubnetId=self.subnet_id)
data = self.client.describe_instances(InstanceIds=[instance_id])
reservations = data.get('Reservations', [])
@ -87,26 +76,16 @@ class InstanceInVPCTest(base.EC2TestCase):
self.assertEqual(self.vpc_id, ni['VpcId'])
self.assertEqual(self.subnet_id, ni['SubnetId'])
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
# NOTE(andrey-mp): There is difference between Openstack and Amazon.
# Amazon returns instance in 'terminated' state some time after
# instance deletion. But Openstack doesn't return such instance.
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_describe_instances_filter(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=self.subnet_id)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(SubnetId=self.subnet_id)
data = self.client.describe_instances(InstanceIds=[instance_id])
self.assert_instance(data, instance_id)
@ -150,8 +129,7 @@ class InstanceInVPCTest(base.EC2TestCase):
Filters=[{'Name': 'vpc-id', 'Values': [self.vpc_id]}])
self.assert_instance(data, instance_id)
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
def assert_instance(self, data, instance_id):
@ -167,6 +145,7 @@ class InstanceInVPCTest(base.EC2TestCase):
"one subnet. Openstack can't do it without additional configuration."
"Worked only from Juno with parameter in config - "
"nova.conf/neutron/allow_duplicate_networks = True")
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_create_instance_with_two_interfaces(self):
kwargs = {
'SubnetId': self.subnet_id,
@ -186,69 +165,46 @@ class InstanceInVPCTest(base.EC2TestCase):
self.client.delete_network_interface, NetworkInterfaceId=ni_id2)
self.get_network_interface_waiter().wait_available(ni_id2)
kwargs = {
'ImageId': CONF.aws.image_id,
'InstanceType': CONF.aws.instance_type,
'MinCount': 1,
'MaxCount': 1,
'NetworkInterfaces': [{'NetworkInterfaceId': ni_id1,
'DeviceIndex': 0},
{'NetworkInterfaceId': ni_id2,
'DeviceIndex': 2}]
}
data = self.client.run_instances(*[], **kwargs)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(
NetworkInterfaces=[{'NetworkInterfaceId': ni_id1,
'DeviceIndex': 0},
{'NetworkInterfaceId': ni_id2,
'DeviceIndex': 2}])
instance = self.get_instance(instance_id)
nis = instance.get('NetworkInterfaces', [])
self.assertEqual(2, len(nis))
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
self.get_network_interface_waiter().wait_available(ni_id1)
self.get_network_interface_waiter().wait_available(ni_id2)
data = self.client.delete_network_interface(
self.client.delete_network_interface(
NetworkInterfaceId=ni_id2)
self.cancelResourceCleanUp(clean_ni2)
self.get_network_interface_waiter().wait_delete(ni_id2)
data = self.client.delete_network_interface(
self.client.delete_network_interface(
NetworkInterfaceId=ni_id1)
self.cancelResourceCleanUp(clean_ni1)
self.get_network_interface_waiter().wait_delete(ni_id1)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_create_instance_with_private_ip(self):
ip = '10.16.0.12'
kwargs = {
'ImageId': CONF.aws.image_id,
'InstanceType': CONF.aws.instance_type,
'MinCount': 1,
'MaxCount': 1,
'SubnetId': self.subnet_id,
'PrivateIpAddress': ip
}
data = self.client.run_instances(*[], **kwargs)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(SubnetId=self.subnet_id,
PrivateIpAddress=ip)
instance = self.get_instance(instance_id)
self.assertEqual(ip, instance['PrivateIpAddress'])
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_create_instance_with_invalid_params(self):
def _rollback(fn_data):
self.client.terminate_instances(

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

@ -18,6 +18,7 @@ import time
import botocore.exceptions
from oslo_log import log
from tempest_lib.common.utils import data_utils
import testtools
from ec2api.tests.functional import base
from ec2api.tests.functional import config
@ -365,12 +366,8 @@ class NetworkInterfaceTest(base.EC2TestCase):
self.cancelResourceCleanUp(res_clean)
self.get_network_interface_waiter().wait_delete(ni_id)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_attach_network_interface(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
if not image_id:
raise self.skipException('aws image_id does not provided')
kwargs = {
'SubnetId': self.subnet_id,
}
@ -383,14 +380,7 @@ class NetworkInterfaceTest(base.EC2TestCase):
self.assertIsNotNone(address)
self.get_network_interface_waiter().wait_available(ni_id)
data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=self.subnet_id)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(SubnetId=self.subnet_id)
# NOTE(andrey-mp): Amazon can't attach to device index = 0
kwargs = {
@ -427,23 +417,11 @@ class NetworkInterfaceTest(base.EC2TestCase):
data = self.client.detach_network_interface(*[], **kwargs)
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_network_interfaces_are_not_deleted_on_termination(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
if not image_id:
raise self.skipException('aws image_id does not provided')
data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=self.subnet_id)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(SubnetId=self.subnet_id)
instance = self.get_instance(instance_id)
nis = instance.get('NetworkInterfaces', [])
@ -459,7 +437,7 @@ class NetworkInterfaceTest(base.EC2TestCase):
'DeleteOnTermination': False,
}
}
data = self.client.modify_network_interface_attribute(*[], **kwargs)
self.client.modify_network_interface_attribute(*[], **kwargs)
clean_ni = self.addResourceCleanUp(
self.client.delete_network_interface, NetworkInterfaceId=ni_id)
@ -489,7 +467,6 @@ class NetworkInterfaceTest(base.EC2TestCase):
self.assertFalse(ni['Attachment']['DeleteOnTermination'])
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)
@ -505,20 +482,9 @@ class NetworkInterfaceTest(base.EC2TestCase):
self.cancelResourceCleanUp(clean_ni2)
self.get_network_interface_waiter().wait_delete(ni_id2)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_network_interfaces_are_deleted_on_termination(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
if not image_id:
raise self.skipException('aws image_id does not provided')
data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type, MinCount=1,
MaxCount=1, SubnetId=self.subnet_id)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(SubnetId=self.subnet_id)
instance = self.get_instance(instance_id)
nis = instance.get('NetworkInterfaces', [])
@ -552,7 +518,6 @@ class NetworkInterfaceTest(base.EC2TestCase):
data = self.client.modify_network_interface_attribute(*[], **kwargs)
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_delete(ni_id)

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

@ -16,6 +16,7 @@
import time
from tempest_lib.common.utils import data_utils
import testtools
from ec2api.tests.functional import base
from ec2api.tests.functional import config
@ -40,7 +41,7 @@ class TagTest(base.EC2TestCase):
def test_create_get_delete_tag(self):
tag_key = data_utils.rand_name('tag-key')
data = self.client.create_tags(Resources=[self.volume_id],
self.client.create_tags(Resources=[self.volume_id],
Tags=[{'Key': tag_key, 'Value': 'fake_value'}])
self.addResourceCleanUp(self.client.delete_tags,
Resources=[self.volume_id],
@ -50,8 +51,8 @@ class TagTest(base.EC2TestCase):
Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}])
self.assertEqual(1, len(data['Tags']))
data = self.client.delete_tags(Resources=[self.volume_id],
Tags=[{'Key': tag_key}])
self.client.delete_tags(Resources=[self.volume_id],
Tags=[{'Key': tag_key}])
data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}])
@ -59,7 +60,7 @@ class TagTest(base.EC2TestCase):
def test_describe_tags(self):
tag_key = data_utils.rand_name('tag-key')
data = self.client.create_tags(Resources=[self.volume_id],
self.client.create_tags(Resources=[self.volume_id],
Tags=[{'Key': tag_key, 'Value': 'fake_value'}])
self.addResourceCleanUp(self.client.delete_tags,
Resources=[self.volume_id],
@ -97,8 +98,8 @@ class TagTest(base.EC2TestCase):
Filters=[{'Name': 'resource-type', 'Values': ['volume']}])
self.assertIn(tag_key, [k.get('Key') for k in data['Tags']])
data = self.client.delete_tags(Resources=[self.volume_id],
Tags=[{'Key': tag_key}])
self.client.delete_tags(Resources=[self.volume_id],
Tags=[{'Key': tag_key}])
data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [self.volume_id]}])
@ -126,8 +127,8 @@ class TagTest(base.EC2TestCase):
describe_func(Filters=[{'Name': 'tag-key', 'Values': [tag_key]}])
data = self.client.delete_tags(Resources=[resource_id],
Tags=[{'Key': tag_key}])
self.client.delete_tags(Resources=[resource_id],
Tags=[{'Key': tag_key}])
data = self.client.describe_tags(
Filters=[{'Name': 'resource-id', 'Values': [resource_id]}])
@ -192,7 +193,7 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource(res_id, 'dhcp-options', describe_func)
data = self.client.delete_dhcp_options(DhcpOptionsId=res_id)
self.client.delete_dhcp_options(DhcpOptionsId=res_id)
self.cancelResourceCleanUp(res_clean)
def test_tag_volume(self):
@ -216,20 +217,12 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource_negative(res_id)
data = self.client.release_address(AllocationId=res_id)
self.client.release_address(AllocationId=res_id)
self.cancelResourceCleanUp(res_clean)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_tag_instance(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance()
def describe_func(*args, **kwargs):
data = self.client.describe_instances(*args, **kwargs)
@ -240,8 +233,7 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource(instance_id, 'instance', describe_func)
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
@base.skip_without_vpc()
@ -259,7 +251,7 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource(gw_id, 'internet-gateway', describe_func)
data = self.client.delete_internet_gateway(InternetGatewayId=gw_id)
self.client.delete_internet_gateway(InternetGatewayId=gw_id)
self.cancelResourceCleanUp(res_clean)
@base.skip_without_vpc()
@ -292,16 +284,15 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource(ni_id, 'network-interface', describe_func)
data = self.client.delete_network_interface(
NetworkInterfaceId=ni_id)
self.client.delete_network_interface(NetworkInterfaceId=ni_id)
self.cancelResourceCleanUp(res_clean)
self.get_network_interface_waiter().wait_delete(ni_id)
data = self.client.delete_subnet(SubnetId=subnet_id)
self.client.delete_subnet(SubnetId=subnet_id)
self.cancelResourceCleanUp(subnet_clean)
self.get_subnet_waiter().wait_delete(subnet_id)
data = self.client.delete_vpc(VpcId=vpc_id)
self.client.delete_vpc(VpcId=vpc_id)
self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id)
@ -325,10 +316,10 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource(rt_id, 'route-table', describe_func)
data = self.client.delete_route_table(RouteTableId=rt_id)
self.client.delete_route_table(RouteTableId=rt_id)
self.cancelResourceCleanUp(res_clean)
data = self.client.delete_vpc(VpcId=vpc_id)
self.client.delete_vpc(VpcId=vpc_id)
self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id)
@ -358,10 +349,10 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource(group_id, 'security-group', describe_func)
data = self.client.delete_security_group(GroupId=group_id)
self.client.delete_security_group(GroupId=group_id)
self.cancelResourceCleanUp(res_clean)
data = self.client.delete_vpc(VpcId=vpc_id)
self.client.delete_vpc(VpcId=vpc_id)
self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id)
@ -380,7 +371,7 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource(snapshot_id, 'snapshot', describe_func)
data = self.client.delete_snapshot(SnapshotId=snapshot_id)
self.client.delete_snapshot(SnapshotId=snapshot_id)
self.cancelResourceCleanUp(res_clean)
self.get_snapshot_waiter().wait_delete(snapshot_id)
@ -406,11 +397,11 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource(subnet_id, 'subnet', describe_func)
data = self.client.delete_subnet(SubnetId=subnet_id)
self.client.delete_subnet(SubnetId=subnet_id)
self.cancelResourceCleanUp(res_clean)
self.get_subnet_waiter().wait_delete(subnet_id)
data = self.client.delete_vpc(VpcId=vpc_id)
self.client.delete_vpc(VpcId=vpc_id)
self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id)
@ -429,6 +420,6 @@ class TagTest(base.EC2TestCase):
self._test_tag_resource(vpc_id, 'vpc', describe_func)
data = self.client.delete_vpc(VpcId=vpc_id)
self.client.delete_vpc(VpcId=vpc_id)
self.cancelResourceCleanUp(dv_clean)
self.get_vpc_waiter().wait_delete(vpc_id)

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

@ -45,7 +45,7 @@ class VolumeTest(base.EC2TestCase):
self.assertIsNotNone(data['CreateTime'])
self.assertEqual(CONF.aws.aws_zone, data['AvailabilityZone'])
data = self.client.delete_volume(VolumeId=volume_id)
self.client.delete_volume(VolumeId=volume_id)
self.cancelResourceCleanUp(res_clean)
self.get_volume_waiter().wait_delete(volume_id)
@ -74,7 +74,7 @@ class VolumeTest(base.EC2TestCase):
self.assertTrue(data['Encrypted'])
data = self.client.delete_volume(VolumeId=volume_id)
self.client.delete_volume(VolumeId=volume_id)
self.cancelResourceCleanUp(res_clean)
self.get_volume_waiter().wait_delete(volume_id)
@ -108,11 +108,11 @@ class VolumeTest(base.EC2TestCase):
if 'SnapshotId' in volume:
self.assertIsNone(volume['SnapshotId'])
data = self.client.delete_volume(VolumeId=volume_id_ext)
self.client.delete_volume(VolumeId=volume_id_ext)
self.cancelResourceCleanUp(res_clean_ext)
self.get_volume_waiter().wait_delete(volume_id_ext)
data = self.client.delete_volume(VolumeId=volume_id)
self.client.delete_volume(VolumeId=volume_id)
self.cancelResourceCleanUp(res_clean)
self.get_volume_waiter().wait_delete(volume_id)
@ -138,29 +138,13 @@ class VolumeTest(base.EC2TestCase):
self.assertIn('Events', volume_status)
self.assertIn('VolumeStatus', volume_status)
data = self.client.delete_volume(VolumeId=volume_id)
self.client.delete_volume(VolumeId=volume_id)
self.cancelResourceCleanUp(res_clean)
self.get_volume_waiter().wait_delete(volume_id)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_attach_detach_volume(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
if not image_id:
raise self.skipException('aws image_id does not provided')
kwargs = {
'ImageId': image_id,
'InstanceType': instance_type,
'MinCount': 1,
'MaxCount': 1,
'Placement': {'AvailabilityZone': CONF.aws.aws_zone}
}
data = self.client.run_instances(*[], **kwargs)
instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance()
kwargs = {
'Size': 1,
@ -177,7 +161,7 @@ class VolumeTest(base.EC2TestCase):
'InstanceId': instance_id,
'VolumeId': volume_id,
}
data = self.client.attach_volume(*[], **kwargs)
self.client.attach_volume(*[], **kwargs)
clean_vi = self.addResourceCleanUp(self.client.detach_volume,
VolumeId=volume_id)
self.get_volume_attachment_waiter().wait_available(
@ -203,7 +187,7 @@ class VolumeTest(base.EC2TestCase):
self.assertIn('DeviceName', bdms[0])
self.assertIn('Ebs', bdms[0])
data = self.client.detach_volume(VolumeId=volume_id)
self.client.detach_volume(VolumeId=volume_id)
self.cancelResourceCleanUp(clean_vi)
self.get_volume_attachment_waiter().wait_delete(volume_id)
@ -213,33 +197,16 @@ class VolumeTest(base.EC2TestCase):
self.assertEqual('available', volume['State'])
self.assertEqual(0, len(volume['Attachments']))
data = self.client.delete_volume(VolumeId=volume_id)
self.client.delete_volume(VolumeId=volume_id)
self.cancelResourceCleanUp(clean_v)
self.get_volume_waiter().wait_delete(volume_id)
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(clean_i)
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_attaching_stage(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
if not image_id:
raise self.skipException('aws image_id does not provided')
kwargs = {
'ImageId': image_id,
'InstanceType': instance_type,
'MinCount': 1,
'MaxCount': 1,
'Placement': {'AvailabilityZone': CONF.aws.aws_zone}
}
data = self.client.run_instances(*[], **kwargs)
instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance()
data = self.client.create_volume(
AvailabilityZone=CONF.aws.aws_zone, Size=1)
@ -267,39 +234,22 @@ class VolumeTest(base.EC2TestCase):
self.get_volume_attachment_waiter().wait_available(
volume_id, final_set=('attached'))
data = self.client.detach_volume(VolumeId=volume_id)
self.client.detach_volume(VolumeId=volume_id)
self.cancelResourceCleanUp(clean_vi)
self.get_volume_attachment_waiter().wait_delete(volume_id)
data = self.client.delete_volume(VolumeId=volume_id)
self.client.delete_volume(VolumeId=volume_id)
self.cancelResourceCleanUp(clean_v)
self.get_volume_waiter().wait_delete(volume_id)
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(clean_i)
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
@testtools.skipUnless(CONF.aws.run_incompatible_tests,
"Volume statuses are not implemented")
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_delete_detach_attached_volume(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
if not image_id:
raise self.skipException('aws image_id does not provided')
kwargs = {
'ImageId': image_id,
'InstanceType': instance_type,
'MinCount': 1,
'MaxCount': 1,
'Placement': {'AvailabilityZone': CONF.aws.aws_zone}
}
data = self.client.run_instances(*[], **kwargs)
instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance()
kwargs = {
'Size': 1,
@ -316,7 +266,7 @@ class VolumeTest(base.EC2TestCase):
'InstanceId': instance_id,
'VolumeId': volume_id,
}
data = self.client.attach_volume(*[], **kwargs)
self.client.attach_volume(*[], **kwargs)
clean_vi = self.addResourceCleanUp(self.client.detach_volume,
VolumeId=volume_id)
self.get_volume_attachment_waiter().wait_available(
@ -335,7 +285,7 @@ class VolumeTest(base.EC2TestCase):
self.client.delete_volume,
VolumeId=volume_id)
data = self.client.detach_volume(VolumeId=volume_id)
self.client.detach_volume(VolumeId=volume_id)
self.cancelResourceCleanUp(clean_vi)
self.get_volume_attachment_waiter().wait_delete(volume_id)
@ -343,7 +293,7 @@ class VolumeTest(base.EC2TestCase):
self.client.detach_volume,
VolumeId=volume_id)
data = self.client.delete_volume(VolumeId=volume_id)
self.client.delete_volume(VolumeId=volume_id)
self.cancelResourceCleanUp(clean_v)
self.get_volume_waiter().wait_delete(volume_id)
@ -351,29 +301,12 @@ class VolumeTest(base.EC2TestCase):
self.client.detach_volume,
VolumeId=volume_id)
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(clean_i)
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_volume_auto_termination_swithed_off(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
if not image_id:
raise self.skipException('aws image_id does not provided')
kwargs = {
'ImageId': image_id,
'InstanceType': instance_type,
'MinCount': 1,
'MaxCount': 1,
'Placement': {'AvailabilityZone': CONF.aws.aws_zone}
}
data = self.client.run_instances(*[], **kwargs)
instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance()
kwargs = {
'Size': 1,
@ -390,13 +323,12 @@ class VolumeTest(base.EC2TestCase):
'InstanceId': instance_id,
'VolumeId': volume_id,
}
data = self.client.attach_volume(*[], **kwargs)
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'))
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(clean_i)
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
data = self.client.describe_volumes(VolumeIds=[volume_id])
@ -406,31 +338,15 @@ class VolumeTest(base.EC2TestCase):
if 'Attachments' in volume:
self.assertEqual(0, len(volume['Attachments']))
data = self.client.delete_volume(VolumeId=volume_id)
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,
"modify_instance_attribute is not implemented")
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_volume_auto_termination_swithed_on(self):
instance_type = CONF.aws.instance_type
image_id = CONF.aws.image_id
if not image_id:
raise self.skipException('aws image_id does not provided')
kwargs = {
'ImageId': image_id,
'InstanceType': instance_type,
'MinCount': 1,
'MaxCount': 1,
'Placement': {'AvailabilityZone': CONF.aws.aws_zone}
}
data = self.client.run_instances(*[], **kwargs)
instance_id = data['Instances'][0]['InstanceId']
clean_i = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance()
kwargs = {
'Size': 1,
@ -446,7 +362,7 @@ class VolumeTest(base.EC2TestCase):
'InstanceId': instance_id,
'VolumeId': volume_id,
}
data = self.client.attach_volume(*[], **kwargs)
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'))
@ -457,10 +373,9 @@ class VolumeTest(base.EC2TestCase):
'Ebs': {'VolumeId': volume_id,
'DeleteOnTermination': True}}],
}
data = self.client.modify_instance_attribute(*[], **kwargs)
self.client.modify_instance_attribute(*[], **kwargs)
data = self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(clean_i)
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
self.assertRaises('InvalidVolume.NotFound',

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

@ -531,7 +531,51 @@ class EC2TestCase(base.BaseTestCase):
"""
instance = self.get_instance(instance_id)
if not device_name:
device_name = instance['RootDeviceName']
bdms = instance['BlockDeviceMappings']
device_name = instance.get('RootDeviceName')
if not device_name:
return None
bdms = instance.get('BlockDeviceMappings')
if bdms is None:
return None
bdt = [bdt for bdt in bdms if bdt['DeviceName'] == device_name]
return None if len(bdt) == 0 else bdt[0]
def run_instance(self, clean_dict=None, **kwargs):
kwargs.setdefault('ImageId', CONF.aws.image_id)
kwargs.setdefault('InstanceType', CONF.aws.instance_type)
kwargs.setdefault('Placement', {'AvailabilityZone': CONF.aws.aws_zone})
kwargs['MinCount'] = 1
kwargs['MaxCount'] = 1
data = self.client.run_instances(*[], **kwargs)
instance_id = data['Instances'][0]['InstanceId']
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): openstack has a bug - it doesn't delete volume
# that is created from EBS image
volume_ids = list()
instance = self.get_instance(instance_id)
bdms = instance.get('BlockDeviceMappings')
if bdms is None:
return instance_id
for bdm in bdms:
if 'Ebs' not in bdm:
continue
if not bdm['Ebs'].get('DeleteOnTermination', False):
volume_id = bdm['Ebs'].get('VolumeId')
volume_ids.append(volume_id)
if volume_ids:
# NOTE(andrey-mp): instance must be deleted first.
self.cancelResourceCleanUp(res_clean)
for volume_id in volume_ids:
self.addResourceCleanUp(self.client.delete_volume,
VolumeId=volume_id)
res_clean = self.addResourceCleanUp(
self.client.terminate_instances, InstanceIds=[instance_id])
if clean_dict is not None:
clean_dict['instance'] = res_clean
return instance_id

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

@ -27,20 +27,6 @@ LOG = log.getLogger(__name__)
class BaseScenarioTest(base.EC2TestCase):
def run_instance(self, **kwargs):
kwargs.setdefault('ImageId', CONF.aws.image_id)
kwargs.setdefault('InstanceType', CONF.aws.instance_type)
kwargs.setdefault('Placement', {'AvailabilityZone': CONF.aws.aws_zone})
kwargs['MinCount'] = 1
kwargs['MaxCount'] = 1
data = self.client.run_instances(*[], **kwargs)
instance_id = data['Instances'][0]['InstanceId']
self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
return instance_id
def get_instance_ip(self, instance_id):
instance = self.get_instance(instance_id)
public_ip = instance.get('PublicIpAddress')

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

@ -67,17 +67,9 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
Launch EBS-backed instance with left root device after termination
"""
instance_type = CONF.aws.instance_type
data = self.client.run_instances(
ImageId=self.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1,
instance_id = self.run_instance(ImageId=self.image_id,
BlockDeviceMappings=[{'DeviceName': self.root_device_name,
'Ebs': {'DeleteOnTermination': False}}])
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
bdt = self.get_instance_bdm(instance_id, self.root_device_name)
self.assertIsNotNone(bdt)
@ -92,7 +84,6 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
self.assertEqual(1, len(data['Volumes']))
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)
@ -109,17 +100,9 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
"""Launch EBS-backed instance with resizing root device."""
new_size = int(math.ceil(self.root_device_size * 1.1))
instance_type = CONF.aws.instance_type
data = self.client.run_instances(
ImageId=self.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1,
instance_id = self.run_instance(ImageId=self.image_id,
BlockDeviceMappings=[{'DeviceName': self.root_device_name,
'Ebs': {'VolumeSize': new_size}}])
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
bdt = self.get_instance_bdm(instance_id, self.root_device_name)
self.assertIsNotNone(bdt)
@ -133,7 +116,6 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
self.assertEqual(new_size, volume['Size'])
self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
@testtools.skipUnless(
@ -145,17 +127,9 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
device_name_prefix = _get_device_name_prefix(self.root_device_name)
device_name = device_name_prefix + 'd'
instance_type = CONF.aws.instance_type
data = self.client.run_instances(
ImageId=self.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1,
instance_id = self.run_instance(ImageId=self.image_id,
BlockDeviceMappings=[{'DeviceName': device_name,
'Ebs': {'VolumeSize': 1}}])
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
bdt = self.get_instance_bdm(instance_id, device_name)
self.assertIsNotNone(bdt)
@ -169,7 +143,6 @@ class EC2_EBSInstanceTuneBDM(base.EC2TestCase):
self.assertEqual(1, volume['Size'])
self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
@ -347,17 +320,9 @@ class EC2_EBSInstanceSnapshot(base.EC2TestCase):
def test_create_ebs_instance_snapshot(self):
"""Create snapshot of EBS-backed instance and check it."""
instance_type = CONF.aws.instance_type
data = self.client.run_instances(
ImageId=self.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance = self.get_instance(instance_id)
instance_id = self.run_instance(ImageId=self.image_id)
instance = self.get_instance(instance_id)
bdt = self.get_instance_bdm(instance_id, None)
self.assertIsNotNone(bdt)
volume_id = bdt['Ebs'].get('VolumeId')
@ -368,7 +333,6 @@ class EC2_EBSInstanceSnapshot(base.EC2TestCase):
final_set=('stopped'))
self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
data = self.client.create_snapshot(VolumeId=volume_id)
@ -397,19 +361,11 @@ class EC2_EBSInstanceSnapshot(base.EC2TestCase):
ImageId=image_id)
self.get_image_waiter().wait_available(image_id)
data = self.client.run_instances(
ImageId=image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
instance_id = self.run_instance(ImageId=image_id)
# NOTE(andrey-mp): if instance will run then test will pass
self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
self.client.deregister_image(ImageId=image_id)
@ -442,16 +398,11 @@ class EC2_EBSInstanceResizeRootDevice(base.EC2TestCase):
"Unexpected Forbidden raised: Can't detach root device volume")
def test_resize_root_ebs_device(self):
"""Resize root device of launched instance."""
instance_type = CONF.aws.instance_type
data = self.client.run_instances(
ImageId=self.image_id, InstanceType=instance_type,
Placement={'AvailabilityZone': self.zone}, MinCount=1, MaxCount=1)
instance = data['Instances'][0]
instance_id = data['Instances'][0]['InstanceId']
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])
self.get_instance_waiter().wait_available(instance_id,
final_set=('running'))
clean_dict = dict()
instance_id = self.run_instance(clean_dict=clean_dict,
ImageId=self.image_id)
res_clean = clean_dict['instance']
instance = self.get_instance(instance_id)
bdt = self.get_instance_bdm(instance_id, None)
self.assertIsNotNone(bdt)
@ -497,6 +448,7 @@ class EC2_EBSInstanceResizeRootDevice(base.EC2TestCase):
volume_id2, final_set=('attached'))
# NOTE(andrey-mp): move this cleanup operation to the end of trash
# (it will remove first)
self.cancelResourceCleanUp(res_clean)
res_clean = self.addResourceCleanUp(self.client.terminate_instances,
InstanceIds=[instance_id])

13
ec2api/tests/functional/scenario/test_instance_restart.py
View File

@ -16,6 +16,7 @@
from oslo_log import log
from tempest_lib.common import ssh
from tempest_lib.common.utils import data_utils
import testtools
from ec2api.tests.functional import base
from ec2api.tests.functional import config
@ -27,14 +28,8 @@ LOG = log.getLogger(__name__)
class InstanceRestartTest(scenario_base.BaseScenarioTest):
@classmethod
@base.safe_setup
def setUpClass(cls):
super(InstanceRestartTest, cls).setUpClass()
if not CONF.aws.image_id_ubuntu:
raise cls.skipException('ubuntu image_id does not provided')
cls.zone = CONF.aws.aws_zone
@testtools.skipUnless(CONF.aws.image_id_ubuntu,
"ubuntu image id is not defined")
def test_stop_start_instance(self):
key_name = data_utils.rand_name('testkey')
pkey = self.create_key_pair(key_name)
@ -59,6 +54,8 @@ class InstanceRestartTest(scenario_base.BaseScenarioTest):
data = ssh_client.exec_command('last -x')
self.assertIn("shutdown", data)
@testtools.skipUnless(CONF.aws.image_id_ubuntu,
"ubuntu image id is not defined")
def test_reboot_instance(self):
key_name = data_utils.rand_name('testkey')
pkey = self.create_key_pair(key_name)

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

@ -16,6 +16,7 @@
import time
from oslo_log import log
import testtools
from ec2api.tests.functional import base
from ec2api.tests.functional import config
@ -28,11 +29,8 @@ LOG = log.getLogger(__name__)
class VpcAddressTest(scenario_base.BaseScenarioTest):
@base.skip_without_vpc()
@testtools.skipUnless(CONF.aws.image_id, "image id is not defined")
def test_auto_diassociate_address(self):
image_id = CONF.aws.image_id
if not image_id:
raise self.skipException('aws image_id does not provided')
vpc_id, subnet_id = self.create_vpc_and_subnet('10.3.0.0/20')
ni_id1 = self.create_network_interface(subnet_id)
self.create_and_attach_internet_gateway(vpc_id)