def setUpClass(cls):
super(SecurityGroupInVPCTest, 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)
def setUpClass(cls):
super(VpnGatewayTest, cls).setUpClass()
if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled')
base.check_network_feature_enabled('vpnaas')
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(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')
base.check_vpnaas_enabled()
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(DhcpOptionsTest, cls).setUpClass()
if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC 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)
def setUpClass(cls):
super(VpnTest, cls).setUpClass()
if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled')
base.check_vpnaas_enabled()
def setUpClass(cls):
super(SecurityGroupEC2ClassicTest, cls).setUpClass()
if not base.TesterStateHolder().get_ec2_enabled():
raise cls.skipException('EC2-classic is disabled')
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(CustomerGatewayTest, cls).setUpClass()
if not base.TesterStateHolder().get_vpc_enabled():
raise cls.skipException('VPC is disabled')
base.check_network_feature_enabled('vpnaas')
