286 lines
10 KiB
Python
286 lines
10 KiB
Python
from __future__ import unicode_literals
|
|
import boto.ec2
|
|
import boto.ec2.autoscale
|
|
import boto.ec2.elb
|
|
import boto3
|
|
import sure
|
|
from boto3 import Session
|
|
|
|
from moto import mock_ec2_deprecated, mock_autoscaling_deprecated, mock_elb_deprecated
|
|
from moto import mock_autoscaling, mock_ec2, mock_elb
|
|
|
|
from moto.ec2 import ec2_backends
|
|
from tests import EXAMPLE_AMI_ID, EXAMPLE_AMI_ID2
|
|
from uuid import uuid4
|
|
from .test_instances import retrieve_all_instances
|
|
|
|
|
|
def test_use_boto_regions():
|
|
boto_regions = set()
|
|
for region in Session().get_available_regions("ec2"):
|
|
boto_regions.add(region)
|
|
for region in Session().get_available_regions("ec2", partition_name="aws-us-gov"):
|
|
boto_regions.add(region)
|
|
for region in Session().get_available_regions("ec2", partition_name="aws-cn"):
|
|
boto_regions.add(region)
|
|
moto_regions = set(ec2_backends)
|
|
|
|
moto_regions.should.equal(boto_regions)
|
|
|
|
|
|
def add_servers_to_region(ami_id, count, region):
|
|
conn = boto.ec2.connect_to_region(region)
|
|
for index in range(count):
|
|
conn.run_instances(ami_id)
|
|
|
|
|
|
def add_servers_to_region_boto3(ami_id, count, region):
|
|
ec2 = boto3.resource("ec2", region_name=region)
|
|
return ec2.create_instances(ImageId=ami_id, MinCount=count, MaxCount=count)
|
|
|
|
|
|
# Has boto3 equivalent
|
|
@mock_ec2_deprecated
|
|
def test_add_servers_to_a_single_region():
|
|
region = "ap-northeast-1"
|
|
add_servers_to_region(EXAMPLE_AMI_ID, 1, region)
|
|
add_servers_to_region(EXAMPLE_AMI_ID2, 1, region)
|
|
|
|
conn = boto.ec2.connect_to_region(region)
|
|
reservations = conn.get_all_reservations()
|
|
len(reservations).should.equal(2)
|
|
|
|
image_ids = [r.instances[0].image_id for r in reservations]
|
|
image_ids.should.equal([EXAMPLE_AMI_ID, EXAMPLE_AMI_ID2])
|
|
|
|
|
|
@mock_ec2
|
|
def test_add_servers_to_a_single_region_boto3():
|
|
region = "ap-northeast-1"
|
|
id_1 = add_servers_to_region_boto3(EXAMPLE_AMI_ID, 1, region)[0].id
|
|
id_2 = add_servers_to_region_boto3(EXAMPLE_AMI_ID2, 1, region)[0].id
|
|
|
|
client = boto3.client("ec2", region_name=region)
|
|
instances = retrieve_all_instances(client)
|
|
|
|
instance1 = [i for i in instances if i["InstanceId"] == id_1][0]
|
|
instance1["ImageId"].should.equal(EXAMPLE_AMI_ID)
|
|
instance2 = [i for i in instances if i["InstanceId"] == id_2][0]
|
|
instance2["ImageId"].should.equal(EXAMPLE_AMI_ID2)
|
|
|
|
|
|
# Has boto3 equivalent
|
|
@mock_ec2_deprecated
|
|
def test_add_servers_to_multiple_regions():
|
|
region1 = "us-east-1"
|
|
region2 = "ap-northeast-1"
|
|
add_servers_to_region(EXAMPLE_AMI_ID, 1, region1)
|
|
add_servers_to_region(EXAMPLE_AMI_ID2, 1, region2)
|
|
|
|
us_conn = boto.ec2.connect_to_region(region1)
|
|
ap_conn = boto.ec2.connect_to_region(region2)
|
|
us_reservations = us_conn.get_all_reservations()
|
|
ap_reservations = ap_conn.get_all_reservations()
|
|
|
|
len(us_reservations).should.equal(1)
|
|
len(ap_reservations).should.equal(1)
|
|
|
|
us_reservations[0].instances[0].image_id.should.equal(EXAMPLE_AMI_ID)
|
|
ap_reservations[0].instances[0].image_id.should.equal(EXAMPLE_AMI_ID2)
|
|
|
|
|
|
@mock_ec2
|
|
def test_add_servers_to_multiple_regions_boto3():
|
|
region1 = "us-east-1"
|
|
region2 = "ap-northeast-1"
|
|
us_id = add_servers_to_region_boto3(EXAMPLE_AMI_ID, 1, region1)[0].id
|
|
ap_id = add_servers_to_region_boto3(EXAMPLE_AMI_ID2, 1, region2)[0].id
|
|
|
|
us_client = boto3.client("ec2", region_name=region1)
|
|
ap_client = boto3.client("ec2", region_name=region2)
|
|
us_instances = retrieve_all_instances(us_client)
|
|
ap_instances = retrieve_all_instances(ap_client)
|
|
|
|
[r["InstanceId"] for r in us_instances].should.contain(us_id)
|
|
[r["InstanceId"] for r in us_instances].shouldnt.contain(ap_id)
|
|
[r["InstanceId"] for r in ap_instances].should.contain(ap_id)
|
|
[r["InstanceId"] for r in ap_instances].shouldnt.contain(us_id)
|
|
|
|
us_instance = us_client.describe_instances(InstanceIds=[us_id])["Reservations"][0][
|
|
"Instances"
|
|
][0]
|
|
us_instance["ImageId"].should.equal(EXAMPLE_AMI_ID)
|
|
ap_instance = ap_client.describe_instances(InstanceIds=[ap_id])["Reservations"][0][
|
|
"Instances"
|
|
][0]
|
|
ap_instance["ImageId"].should.equal(EXAMPLE_AMI_ID2)
|
|
|
|
|
|
# Has boto3 equivalent
|
|
@mock_autoscaling_deprecated
|
|
@mock_elb_deprecated
|
|
def test_create_autoscaling_group():
|
|
elb_conn = boto.ec2.elb.connect_to_region("us-east-1")
|
|
elb_conn.create_load_balancer(
|
|
"us_test_lb", zones=[], listeners=[(80, 8080, "http")]
|
|
)
|
|
elb_conn = boto.ec2.elb.connect_to_region("ap-northeast-1")
|
|
elb_conn.create_load_balancer(
|
|
"ap_test_lb", zones=[], listeners=[(80, 8080, "http")]
|
|
)
|
|
|
|
us_conn = boto.ec2.autoscale.connect_to_region("us-east-1")
|
|
config = boto.ec2.autoscale.LaunchConfiguration(
|
|
name="us_tester", image_id=EXAMPLE_AMI_ID, instance_type="m1.small"
|
|
)
|
|
x = us_conn.create_launch_configuration(config)
|
|
|
|
us_subnet_id = list(ec2_backends["us-east-1"].subnets["us-east-1c"].keys())[0]
|
|
ap_subnet_id = list(
|
|
ec2_backends["ap-northeast-1"].subnets["ap-northeast-1a"].keys()
|
|
)[0]
|
|
group = boto.ec2.autoscale.AutoScalingGroup(
|
|
name="us_tester_group",
|
|
availability_zones=["us-east-1c"],
|
|
default_cooldown=60,
|
|
desired_capacity=2,
|
|
health_check_period=100,
|
|
health_check_type="EC2",
|
|
max_size=2,
|
|
min_size=2,
|
|
launch_config=config,
|
|
load_balancers=["us_test_lb"],
|
|
placement_group="us_test_placement",
|
|
vpc_zone_identifier=us_subnet_id,
|
|
termination_policies=["OldestInstance", "NewestInstance"],
|
|
)
|
|
us_conn.create_auto_scaling_group(group)
|
|
|
|
ap_conn = boto.ec2.autoscale.connect_to_region("ap-northeast-1")
|
|
config = boto.ec2.autoscale.LaunchConfiguration(
|
|
name="ap_tester", image_id=EXAMPLE_AMI_ID, instance_type="m1.small"
|
|
)
|
|
ap_conn.create_launch_configuration(config)
|
|
|
|
group = boto.ec2.autoscale.AutoScalingGroup(
|
|
name="ap_tester_group",
|
|
availability_zones=["ap-northeast-1a"],
|
|
default_cooldown=60,
|
|
desired_capacity=2,
|
|
health_check_period=100,
|
|
health_check_type="EC2",
|
|
max_size=2,
|
|
min_size=2,
|
|
launch_config=config,
|
|
load_balancers=["ap_test_lb"],
|
|
placement_group="ap_test_placement",
|
|
vpc_zone_identifier=ap_subnet_id,
|
|
termination_policies=["OldestInstance", "NewestInstance"],
|
|
)
|
|
ap_conn.create_auto_scaling_group(group)
|
|
|
|
len(us_conn.get_all_groups()).should.equal(1)
|
|
len(ap_conn.get_all_groups()).should.equal(1)
|
|
|
|
us_group = us_conn.get_all_groups()[0]
|
|
us_group.name.should.equal("us_tester_group")
|
|
list(us_group.availability_zones).should.equal(["us-east-1c"])
|
|
us_group.desired_capacity.should.equal(2)
|
|
us_group.max_size.should.equal(2)
|
|
us_group.min_size.should.equal(2)
|
|
us_group.vpc_zone_identifier.should.equal(us_subnet_id)
|
|
us_group.launch_config_name.should.equal("us_tester")
|
|
us_group.default_cooldown.should.equal(60)
|
|
us_group.health_check_period.should.equal(100)
|
|
us_group.health_check_type.should.equal("EC2")
|
|
list(us_group.load_balancers).should.equal(["us_test_lb"])
|
|
us_group.placement_group.should.equal("us_test_placement")
|
|
list(us_group.termination_policies).should.equal(
|
|
["OldestInstance", "NewestInstance"]
|
|
)
|
|
|
|
ap_group = ap_conn.get_all_groups()[0]
|
|
ap_group.name.should.equal("ap_tester_group")
|
|
list(ap_group.availability_zones).should.equal(["ap-northeast-1a"])
|
|
ap_group.desired_capacity.should.equal(2)
|
|
ap_group.max_size.should.equal(2)
|
|
ap_group.min_size.should.equal(2)
|
|
ap_group.vpc_zone_identifier.should.equal(ap_subnet_id)
|
|
ap_group.launch_config_name.should.equal("ap_tester")
|
|
ap_group.default_cooldown.should.equal(60)
|
|
ap_group.health_check_period.should.equal(100)
|
|
ap_group.health_check_type.should.equal("EC2")
|
|
list(ap_group.load_balancers).should.equal(["ap_test_lb"])
|
|
ap_group.placement_group.should.equal("ap_test_placement")
|
|
list(ap_group.termination_policies).should.equal(
|
|
["OldestInstance", "NewestInstance"]
|
|
)
|
|
|
|
|
|
@mock_autoscaling
|
|
@mock_elb
|
|
@mock_ec2
|
|
def test_create_autoscaling_group_boto3():
|
|
regions = [("us-east-1", "c"), ("ap-northeast-1", "a")]
|
|
for region, zone in regions:
|
|
a_zone = "{}{}".format(region, zone)
|
|
asg_name = "{}_tester_group_{}".format(region, str(uuid4())[0:6])
|
|
lb_name = "{}_lb_{}".format(region, str(uuid4())[0:6])
|
|
config_name = "{}_tester_{}".format(region, str(uuid4())[0:6])
|
|
|
|
elb_client = boto3.client("elb", region_name=region)
|
|
elb_client.create_load_balancer(
|
|
LoadBalancerName=lb_name,
|
|
Listeners=[
|
|
{"Protocol": "http", "LoadBalancerPort": 80, "InstancePort": 8080}
|
|
],
|
|
AvailabilityZones=[],
|
|
)
|
|
|
|
as_client = boto3.client("autoscaling", region_name=region)
|
|
as_client.create_launch_configuration(
|
|
LaunchConfigurationName=config_name,
|
|
ImageId=EXAMPLE_AMI_ID,
|
|
InstanceType="m1.small",
|
|
)
|
|
|
|
ec2_client = boto3.client("ec2", region_name=region)
|
|
subnet_id = ec2_client.describe_subnets(
|
|
Filters=[{"Name": "availability-zone", "Values": [a_zone]}]
|
|
)["Subnets"][0]["SubnetId"]
|
|
|
|
as_client.create_auto_scaling_group(
|
|
AutoScalingGroupName=asg_name,
|
|
AvailabilityZones=[a_zone],
|
|
DefaultCooldown=60,
|
|
DesiredCapacity=2,
|
|
HealthCheckGracePeriod=100,
|
|
HealthCheckType="EC2",
|
|
LaunchConfigurationName=config_name,
|
|
LoadBalancerNames=[lb_name],
|
|
MinSize=2,
|
|
MaxSize=2,
|
|
PlacementGroup="us_test_placement",
|
|
VPCZoneIdentifier=subnet_id,
|
|
TerminationPolicies=["OldestInstance", "NewestInstance"],
|
|
)
|
|
|
|
groups = as_client.describe_auto_scaling_groups(
|
|
AutoScalingGroupNames=[asg_name]
|
|
)["AutoScalingGroups"]
|
|
groups.should.have.length_of(1)
|
|
group = groups[0]
|
|
|
|
group["AutoScalingGroupName"].should.equal(asg_name)
|
|
group["DesiredCapacity"].should.equal(2)
|
|
group["MaxSize"].should.equal(2)
|
|
group["MinSize"].should.equal(2)
|
|
group["VPCZoneIdentifier"].should.equal(subnet_id)
|
|
group["LaunchConfigurationName"].should.equal(config_name)
|
|
group["DefaultCooldown"].should.equal(60)
|
|
group["HealthCheckGracePeriod"].should.equal(100)
|
|
group["HealthCheckType"].should.equal("EC2")
|
|
group["LoadBalancerNames"].should.equal([lb_name])
|
|
group["PlacementGroup"].should.equal("us_test_placement")
|
|
group["TerminationPolicies"].should.equal(["OldestInstance", "NewestInstance"])
|