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,
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'))
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))
self.assertEqual(1, len(instances[0]['SecurityGroups']))
groups = reservations[0].get('Groups', [])
if base.TesterStateHolder().get_ec2_enabled():
self.assertEqual(1, len(groups))
self.assertEqual(groups[0]['GroupName'],
instances[0]['SecurityGroups'][0]['GroupName'])
else:
self.assertEqual(0, len(groups))
self.client.terminate_instances(InstanceIds=[instance_id])
self.cancelResourceCleanUp(res_clean)
self.get_instance_waiter().wait_delete(instance_id)
def setUpClass(cls):
super(VpnGatewayTest, cls).setUpClass()
if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled')
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.delete_vpc, VpcId=cls.vpc_id)
def setUpClass(cls):
super(SecurityGroupTest, cls).setUpClass()
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)
cls.vpc_id = data['Vpc']['VpcId']
cls.addResourceCleanUpStatic(cls.client.DeleteVpc, VpcId=cls.vpc_id)
cls.get_vpc_waiter().wait_available(cls.vpc_id)
def setUpClass(cls):
super(NetworkInterfaceTest, cls).setUpClass()
if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled')
data = cls.client.create_vpc(CidrBlock=cls.VPC_CIDR)
cls.vpc_id = data['Vpc']['VpcId']
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
data = cls.client.create_subnet(VpcId=cls.vpc_id,
CidrBlock=cls.SUBNET_CIDR,
AvailabilityZone=aws_zone)
cls.subnet_id = data['Subnet']['SubnetId']
cls.addResourceCleanUpStatic(cls.client.delete_subnet,
SubnetId=cls.subnet_id)
cls.get_subnet_waiter().wait_available(cls.subnet_id)
def setUpClass(cls):
super(VpnConnectionTest, cls).setUpClass()
if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled')
data = cls.client.create_customer_gateway(
Type='ipsec.1', PublicIp=cls.CUSTOMER_GATEWAY_IP, BgpAsn=65000)
cls.cgw_id = data['CustomerGateway']['CustomerGatewayId']
cls.addResourceCleanUpStatic(cls.client.delete_customer_gateway,
CustomerGatewayId=cls.cgw_id)
cls.get_customer_gateway_waiter().wait_available(cls.cgw_id)
data = cls.client.create_vpn_gateway(
Type='ipsec.1', AvailabilityZone=CONF.aws.aws_zone)
cls.vgw_id = data['VpnGateway']['VpnGatewayId']
cls.addResourceCleanUpStatic(cls.client.delete_vpn_gateway,
VpnGatewayId=cls.vgw_id)
cls.get_vpn_gateway_waiter().wait_available(cls.vgw_id)
def setUpClass(cls):
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')
resp, data = cls.client.CreateVpc(CidrBlock=cls.VPC_CIDR)
cls.assertResultStatic(resp, data)
cls.vpc_id = data['Vpc']['VpcId']
cls.addResourceCleanUpStatic(cls.client.DeleteVpc, 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,
CidrBlock=cls.SUBNET_CIDR,
AvailabilityZone=aws_zone)
cls.assertResultStatic(resp, data)
cls.subnet_id = data['Subnet']['SubnetId']
cls.addResourceCleanUpStatic(cls.client.DeleteSubnet,
SubnetId=cls.subnet_id)
cls.get_subnet_waiter().wait_available(cls.subnet_id)
def setUpClass(cls):
super(InstancesInVPCTest, 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')
def test_instance_attributes_negative(self):
instance_id = self.run_instance()
self.assertRaises('InvalidParameterValue',
self.client.describe_instance_attribute,
InstanceId=instance_id, Attribute='fake_attribute')
self.assertRaises('InvalidInstanceID.NotFound',
self.client.describe_instance_attribute,
InstanceId='i-0', Attribute='disableApiTermination')
if base.TesterStateHolder().get_ec2_enabled():
self.assertRaises('InvalidParameterCombination',
self.client.describe_instance_attribute,
InstanceId=instance_id, Attribute='sourceDestCheck')
self.assertRaises('InvalidParameterValue',
self.client.modify_instance_attribute,
InstanceId=instance_id, Attribute='fake_attribute')
self.assertRaises('MissingParameter',
self.client.modify_instance_attribute,
InstanceId=instance_id, Attribute='disableApiTermination')
self.assertRaises('InvalidParameterCombination',
self.client.modify_instance_attribute,
InstanceId=instance_id)
self.assertRaises('InvalidParameterCombination',
self.client.modify_instance_attribute,
InstanceId=instance_id, Attribute='disableApiTermination',
Value='True', DisableApiTermination={'Value': False})
ex_str = ('InvalidParameterCombination'
if base.TesterStateHolder().get_ec2_enabled() else
'InvalidGroup.NotFound')
self.assertRaises(ex_str,
self.client.modify_instance_attribute,
InstanceId=instance_id, Groups=['sg-0'])
if base.TesterStateHolder().get_ec2_enabled():
self.assertRaises('InvalidParameterCombination',
self.client.modify_instance_attribute,
InstanceId=instance_id, Attribute='sourceDestCheck',
Value='False')
self.assertRaises('InvalidParameterValue',
self.client.reset_instance_attribute,
InstanceId=instance_id, Attribute='fake_attribute')
self.assertRaises('InvalidParameterValue',
self.client.reset_instance_attribute,
InstanceId=instance_id, Attribute='disableApiTermination')
self.assertRaises('InvalidParameterValue',
self.client.reset_instance_attribute,
InstanceId='i-0', Attribute='disableApiTermination')
self.assertRaises('InvalidParameterValue',
self.client.reset_instance_attribute,
InstanceId=instance_id, Attribute='groupSet')
self.assertRaises('InvalidParameterValue',
self.client.reset_instance_attribute,
InstanceId=instance_id, Attribute='instanceType')
if base.TesterStateHolder().get_ec2_enabled():
self.assertRaises('InvalidParameterCombination',
self.client.reset_instance_attribute,
InstanceId=instance_id, Attribute='sourceDestCheck')
self.assertRaises('IncorrectInstanceState',
self.client.modify_instance_attribute,
InstanceId=instance_id, Attribute='instanceType',
Value=CONF.aws.instance_type)
self.assertRaises('IncorrectInstanceState',
self.client.modify_instance_attribute,
InstanceId=instance_id,
InstanceType={'Value': CONF.aws.instance_type})
self.client.terminate_instances(InstanceIds=[instance_id])
self.get_instance_waiter().wait_delete(instance_id)
def setUpClass(cls):
super(VPCTest, cls).setUpClass()
if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled')
def setUpClass(cls):
super(CustomerGatewayTest, cls).setUpClass()
if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled')
base.check_network_feature_enabled('vpnaas')
def setUpClass(cls):
super(SecurityGroupEC2ClassicTest, cls).setUpClass()
if not base.TesterStateHolder().get_ec2_enabled():
raise cls.skipException('EC2-classic is disabled')
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,
'MinCount': 1,
'MaxCount': 1,
'PrivateIpAddress': '10.16.1.2'
}
ex_str = ('InvalidParameterCombination'
if base.TesterStateHolder().get_ec2_enabled() else
'InvalidParameterValue')
self.assertRaises(ex_str,
self.client.run_instances,
rollback_fn=_rollback,
**kwargs)
kwargs = {
'ImageId': CONF.aws.image_id,
'InstanceType': CONF.aws.instance_type,
'MinCount': 1,
'MaxCount': 1,
'SubnetId': self.subnet_id,
'PrivateIpAddress': '10.16.1.12'
}
self.assertRaises('InvalidParameterValue',
self.client.run_instances,
rollback_fn=_rollback,
**kwargs)
kwargs = {
'SubnetId': self.subnet_id,
}
data = self.client.create_network_interface(*[], **kwargs)
ni_id1 = data['NetworkInterface']['NetworkInterfaceId']
self.addResourceCleanUp(self.client.delete_network_interface,
NetworkInterfaceId=ni_id1)
self.get_network_interface_waiter().wait_available(ni_id1)
kwargs = {
'SubnetId': self.subnet_id,
}
data = self.client.create_network_interface(*[], **kwargs)
ni_id2 = data['NetworkInterface']['NetworkInterfaceId']
self.addResourceCleanUp(self.client.delete_network_interface,
NetworkInterfaceId=ni_id2)
self.get_network_interface_waiter().wait_available(ni_id2)
# NOTE(andrey-mp): A network interface may not specify a network
# interface ID and delete on termination as true
kwargs = {
'ImageId':
CONF.aws.image_id,
'InstanceType':
CONF.aws.instance_type,
'MinCount':
1,
'MaxCount':
1,
'NetworkInterfaces': [{
'NetworkInterfaceId': ni_id1,
'DeviceIndex': 0,
'DeleteOnTermination': True
}]
}
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.
kwargs = {
'ImageId':
CONF.aws.image_id,
'InstanceType':
CONF.aws.instance_type,
'MinCount':
1,
'MaxCount':
1,
'NetworkInterfaces': [{
'NetworkInterfaceId': ni_id1
}, {
'NetworkInterfaceId': ni_id2
}]
}
self.assertRaises('InvalidParameterValue',
self.client.run_instances,
rollback_fn=_rollback,
**kwargs)
