Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
import datetime
import os
import urllib.error
import urllib.parse
import urllib.request
import uuid
import boto3
import pytest
from botocore.config import Config
from botocore.exceptions import ClientError
def _uid(prefix="test"):
return f"{prefix}-{uuid.uuid4().hex[:8]}"
def _client(region):
return boto3.client(
"autoscaling",
endpoint_url=os.environ.get("MINISTACK_ENDPOINT", "http://localhost:4566"),
region_name=region,
aws_access_key_id="test",
aws_secret_access_key="test",
config=Config(retries={"mode": "standard"}),
)
# ---------------------------------------------------------------------------
# AutoScalingGroup: Create, Describe, Update, Delete
# ---------------------------------------------------------------------------
def test_create_and_describe_asg(autoscaling):
name = _uid("asg")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=1,
MaxSize=5,
DesiredCapacity=2,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
resp = autoscaling.describe_auto_scaling_groups(AutoScalingGroupNames=[name])
groups = resp["AutoScalingGroups"]
assert len(groups) == 1
g = groups[0]
assert g["AutoScalingGroupName"] == name
assert g["MinSize"] == 1
assert g["MaxSize"] == 5
assert g["DesiredCapacity"] == 2
assert g["AutoScalingGroupARN"].startswith("arn:aws:autoscaling:")
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=name)
def test_create_asg_duplicate_fails(autoscaling):
name = _uid("asg-dup")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
with pytest.raises(ClientError) as exc:
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
assert "AlreadyExists" in str(exc.value)
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=name)
def test_autoscaling_groups_and_tags_are_region_scoped():
east = _client("us-east-1")
west = _client("us-west-2")
name = _uid("asg-region")
east.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=1,
MaxSize=3,
AvailabilityZones=["us-east-1a"],
Tags=[{"Key": "region", "Value": "east", "PropagateAtLaunch": True}],
)
west.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=2,
MaxSize=4,
AvailabilityZones=["us-west-2a"],
Tags=[{"Key": "region", "Value": "west", "PropagateAtLaunch": True}],
)
try:
east_group = east.describe_auto_scaling_groups(
AutoScalingGroupNames=[name]
)["AutoScalingGroups"][0]
west_group = west.describe_auto_scaling_groups(
AutoScalingGroupNames=[name]
)["AutoScalingGroups"][0]
assert east_group["MinSize"] == 1
assert west_group["MinSize"] == 2
assert ":us-east-1:" in east_group["AutoScalingGroupARN"]
assert ":us-west-2:" in west_group["AutoScalingGroupARN"]
assert east_group["Tags"][0]["Value"] == "east"
assert west_group["Tags"][0]["Value"] == "west"
finally:
east.delete_auto_scaling_group(AutoScalingGroupName=name)
west.delete_auto_scaling_group(AutoScalingGroupName=name)
def test_restore_legacy_child_state_uses_parent_asg_region():
from ministack.core.responses import (
AccountScopedDict,
get_account_id,
get_region,
set_request_account_id,
set_request_region,
)
from ministack.services import autoscaling as service
account_id = "111111111111"
boot_region = "us-east-1"
resource_region = "us-west-2"
asg_name = "legacy-asg"
child_key = f"{asg_name}/legacy-child"
original_account = get_account_id()
original_region = get_region()
asgs = AccountScopedDict()
policies = AccountScopedDict()
hooks = AccountScopedDict()
scheduled_actions = AccountScopedDict()
tags = AccountScopedDict()
set_request_account_id(account_id)
set_request_region(boot_region)
asgs[asg_name] = {
"AutoScalingGroupName": asg_name,
"AutoScalingGroupARN": (
f"arn:aws:autoscaling:{resource_region}:{account_id}:"
f"autoScalingGroup:legacy:autoScalingGroupName/{asg_name}"
),
}
policies[child_key] = {"AutoScalingGroupName": asg_name}
hooks[child_key] = {"AutoScalingGroupName": asg_name}
scheduled_actions[child_key] = {"AutoScalingGroupName": asg_name}
tags[asg_name] = [{"Key": "legacy", "Value": "true"}]
service.reset()
try:
service.load_persisted_state(
{
"asgs": asgs,
"policies": policies,
"hooks": hooks,
"scheduled_actions": scheduled_actions,
"tags": tags,
}
)
assert service._asgs.get_scoped(
account_id, resource_region, asg_name
)["AutoScalingGroupName"] == asg_name
for store in (
service._policies,
service._hooks,
service._scheduled_actions,
):
assert (
store.get_scoped(account_id, resource_region, child_key) is not None
)
assert store.get_scoped(account_id, boot_region, child_key) is None
assert service._tags.get_scoped(account_id, resource_region, asg_name) == [
{"Key": "legacy", "Value": "true"}
]
assert service._tags.get_scoped(account_id, boot_region, asg_name) is None
finally:
service.reset()
set_request_account_id(original_account)
set_request_region(original_region)
def test_reset_clears_autoscaling_state_across_regions():
from ministack.core.responses import get_region, set_request_region
from ministack.services import autoscaling as service
original_region = get_region()
stores = (
service._asgs,
service._launch_configs,
service._policies,
service._hooks,
service._scheduled_actions,
service._tags,
)
service.reset()
try:
for region in ("us-east-1", "us-west-2"):
set_request_region(region)
for store in stores:
store[f"resource-{region}"] = {"region": region}
service.reset()
assert all(not store.has_any() for store in stores)
finally:
service.reset()
set_request_region(original_region)
def test_describe_asgs_empty(autoscaling):
bogus = _uid("no-exist")
resp = autoscaling.describe_auto_scaling_groups(AutoScalingGroupNames=[bogus])
assert resp["AutoScalingGroups"] == []
def test_describe_asgs_all(autoscaling):
names = [_uid("asg-all") for _ in range(3)]
for n in names:
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=n,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
resp = autoscaling.describe_auto_scaling_groups()
returned_names = [g["AutoScalingGroupName"] for g in resp["AutoScalingGroups"]]
for n in names:
assert n in returned_names
finally:
for n in names:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=n)
def test_update_asg(autoscaling):
name = _uid("asg-upd")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=0,
MaxSize=1,
DesiredCapacity=0,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.update_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=2,
MaxSize=10,
DesiredCapacity=5,
)
resp = autoscaling.describe_auto_scaling_groups(AutoScalingGroupNames=[name])
g = resp["AutoScalingGroups"][0]
assert g["MinSize"] == 2
assert g["MaxSize"] == 10
assert g["DesiredCapacity"] == 5
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=name)
def test_update_nonexistent_asg_fails(autoscaling):
with pytest.raises(ClientError) as exc:
autoscaling.update_auto_scaling_group(
AutoScalingGroupName="nonexistent-asg",
MinSize=1,
)
assert "ValidationError" in str(exc.value) or "not found" in str(exc.value).lower()
def test_delete_asg(autoscaling):
name = _uid("asg-del")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=name)
resp = autoscaling.describe_auto_scaling_groups(AutoScalingGroupNames=[name])
assert resp["AutoScalingGroups"] == []
def test_delete_asg_idempotent(autoscaling):
"""Deleting a non-existent ASG should not error."""
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=_uid("ghost"))
# ---------------------------------------------------------------------------
# DescribeAutoScalingInstances
# ---------------------------------------------------------------------------
def test_describe_auto_scaling_instances_empty(autoscaling):
resp = autoscaling.describe_auto_scaling_instances()
assert resp["AutoScalingInstances"] == []
# ---------------------------------------------------------------------------
# DescribeScalingActivities
# ---------------------------------------------------------------------------
def test_describe_scaling_activities_empty(autoscaling):
resp = autoscaling.describe_scaling_activities()
assert resp["Activities"] == []
def test_describe_scaling_activities_for_asg(autoscaling):
name = _uid("asg-act")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=0,
MaxSize=1,
DesiredCapacity=0,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
resp = autoscaling.describe_scaling_activities(AutoScalingGroupName=name)
assert resp["Activities"] == []
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=name)
# ---------------------------------------------------------------------------
# LaunchConfiguration: Create, Describe, Delete
# ---------------------------------------------------------------------------
def test_create_and_describe_launch_configuration(autoscaling):
name = _uid("lc")
autoscaling.create_launch_configuration(
LaunchConfigurationName=name,
ImageId="ami-12345678",
InstanceType="t3.micro",
)
try:
resp = autoscaling.describe_launch_configurations(
LaunchConfigurationNames=[name]
)
configs = resp["LaunchConfigurations"]
assert len(configs) == 1
lc = configs[0]
assert lc["LaunchConfigurationName"] == name
assert lc["ImageId"] == "ami-12345678"
assert lc["InstanceType"] == "t3.micro"
assert lc["LaunchConfigurationARN"].startswith("arn:aws:autoscaling:")
finally:
autoscaling.delete_launch_configuration(LaunchConfigurationName=name)
def test_create_launch_configuration_duplicate_fails(autoscaling):
name = _uid("lc-dup")
autoscaling.create_launch_configuration(
LaunchConfigurationName=name,
ImageId="ami-00000000",
InstanceType="t2.micro",
)
try:
with pytest.raises(ClientError) as exc:
autoscaling.create_launch_configuration(
LaunchConfigurationName=name,
ImageId="ami-00000000",
InstanceType="t2.micro",
)
assert "AlreadyExists" in str(exc.value)
finally:
autoscaling.delete_launch_configuration(LaunchConfigurationName=name)
def test_describe_launch_configurations_empty(autoscaling):
resp = autoscaling.describe_launch_configurations(
LaunchConfigurationNames=[_uid("no-lc")]
)
assert resp["LaunchConfigurations"] == []
def test_delete_launch_configuration(autoscaling):
name = _uid("lc-del")
autoscaling.create_launch_configuration(
LaunchConfigurationName=name,
ImageId="ami-00000000",
InstanceType="t2.micro",
)
autoscaling.delete_launch_configuration(LaunchConfigurationName=name)
resp = autoscaling.describe_launch_configurations(
LaunchConfigurationNames=[name]
)
assert resp["LaunchConfigurations"] == []
def test_delete_launch_configuration_idempotent(autoscaling):
autoscaling.delete_launch_configuration(LaunchConfigurationName=_uid("ghost-lc"))
# ---------------------------------------------------------------------------
# Scaling Policies: Put, Describe, Delete
# ---------------------------------------------------------------------------
def test_put_and_describe_scaling_policy(autoscaling):
asg = _uid("asg-pol")
pol = _uid("pol")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=10,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
resp = autoscaling.put_scaling_policy(
AutoScalingGroupName=asg,
PolicyName=pol,
PolicyType="SimpleScaling",
AdjustmentType="ChangeInCapacity",
ScalingAdjustment=2,
Cooldown=60,
)
assert "PolicyARN" in resp
assert resp["PolicyARN"].startswith("arn:aws:autoscaling:")
desc = autoscaling.describe_policies(AutoScalingGroupName=asg)
policies = desc["ScalingPolicies"]
assert len(policies) >= 1
found = [p for p in policies if p["PolicyName"] == pol]
assert len(found) == 1
assert found[0]["AdjustmentType"] == "ChangeInCapacity"
assert found[0]["ScalingAdjustment"] == 2
finally:
autoscaling.delete_policy(AutoScalingGroupName=asg, PolicyName=pol)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_put_scaling_policy_target_tracking_and_step_read_back(autoscaling):
"""Target-tracking and step policies read back with only their type's members."""
asg = _uid("asg-ttpol")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg, MinSize=0, MaxSize=2,
AvailabilityZones=["us-east-1a"], LaunchConfigurationName="dummy-lc",
)
tracking = {
"CustomizedMetricSpecification": {
"MetricName": "CPUUtilization", "Namespace": "AWS/EC2",
"Dimensions": [{"Name": "AutoScalingGroupName", "Value": asg}],
"Statistic": "Average", "Unit": "Percent",
},
"TargetValue": 50.5,
"DisableScaleIn": True,
}
steps = [
{"MetricIntervalLowerBound": 0.0, "MetricIntervalUpperBound": 10.0, "ScalingAdjustment": 10},
{"MetricIntervalLowerBound": 10.0, "ScalingAdjustment": 20},
]
try:
autoscaling.put_scaling_policy(
AutoScalingGroupName=asg, PolicyName="tt", PolicyType="TargetTrackingScaling",
TargetTrackingConfiguration=tracking, EstimatedInstanceWarmup=120,
)
autoscaling.put_scaling_policy(
AutoScalingGroupName=asg, PolicyName="step", PolicyType="StepScaling",
AdjustmentType="PercentChangeInCapacity", MinAdjustmentMagnitude=1,
MetricAggregationType="Average", StepAdjustments=steps,
)
policies = {p["PolicyName"]: p for p in autoscaling.describe_policies(
AutoScalingGroupName=asg)["ScalingPolicies"]}
tt, step = policies["tt"], policies["step"]
assert tt["TargetTrackingConfiguration"] == tracking
assert tt["EstimatedInstanceWarmup"] == 120
assert tt["Enabled"] is True and tt["StepAdjustments"] == []
assert not {"AdjustmentType", "ScalingAdjustment", "Cooldown"} & set(tt)
assert step["StepAdjustments"] == steps
assert step["AdjustmentType"] == "PercentChangeInCapacity"
assert step["MinAdjustmentMagnitude"] == 1
assert step["MetricAggregationType"] == "Average"
assert not {"ScalingAdjustment", "Cooldown"} & set(step)
finally:
for name in ("tt", "step"):
autoscaling.delete_policy(AutoScalingGroupName=asg, PolicyName=name)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_put_scaling_policy_predictive_read_back(autoscaling):
"""PredictiveScalingConfiguration reads back with MaxCapacityBreachBehavior defaulted."""
asg = _uid("asg-pred")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg, MinSize=0, MaxSize=2,
AvailabilityZones=["us-east-1a"], LaunchConfigurationName="dummy-lc",
)
config = {"Mode": "ForecastOnly", "MetricSpecifications": [{
"TargetValue": 40.0,
"PredefinedMetricPairSpecification": {"PredefinedMetricType": "ASGCPUUtilization"}}]}
try:
autoscaling.put_scaling_policy(
AutoScalingGroupName=asg, PolicyName="pred", PolicyType="PredictiveScaling",
PredictiveScalingConfiguration=config)
policy = autoscaling.describe_policies(AutoScalingGroupName=asg)["ScalingPolicies"][0]
assert policy["PredictiveScalingConfiguration"] == {
**config, "MaxCapacityBreachBehavior": "HonorMaxCapacity"}
assert not {"AdjustmentType", "ScalingAdjustment", "Cooldown"} & set(policy)
finally:
autoscaling.delete_policy(AutoScalingGroupName=asg, PolicyName="pred")
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
_CPU_TRACKING = {"PredefinedMetricSpecification": {"PredefinedMetricType": "ASGAverageCPUUtilization"},
"TargetValue": 50.0}
def _tracking_group(autoscaling):
asg = _uid("asg-ttalarm")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg, MinSize=0, MaxSize=2,
AvailabilityZones=["us-east-1a"], LaunchConfigurationName="dummy-lc",
)
return asg
def _put_tracking(autoscaling, asg, name, tracking):
return autoscaling.put_scaling_policy(
AutoScalingGroupName=asg, PolicyName=name, PolicyType="TargetTrackingScaling",
TargetTrackingConfiguration=tracking)
def test_target_tracking_policy_creates_alarms(autoscaling, cw):
"""A target tracking policy creates an AlarmHigh and an AlarmLow alarm and lists them."""
asg = _tracking_group(autoscaling)
try:
put = _put_tracking(autoscaling, asg, "cpu", _CPU_TRACKING)
arn = put["PolicyARN"]
names = [a["AlarmName"] for a in put["Alarms"]]
assert [n.rsplit("-", 5)[0] for n in names] == [
f"TargetTracking-{asg}-AlarmHigh", f"TargetTracking-{asg}-AlarmLow"]
assert autoscaling.describe_policies(
AutoScalingGroupName=asg)["ScalingPolicies"][0]["Alarms"] == put["Alarms"]
alarms = {a["AlarmName"]: a for a in cw.describe_alarms(AlarmNames=names)["MetricAlarms"]}
dims = [{"Name": "AutoScalingGroupName", "Value": asg}]
assert [(a["AlarmArn"], a["Namespace"], a["MetricName"], a["Statistic"], a["Dimensions"],
a["Period"], a["EvaluationPeriods"], a["Threshold"], a["ComparisonOperator"],
a["AlarmActions"]) for a in (alarms[n] for n in names)] == [
(put["Alarms"][0]["AlarmARN"], "AWS/EC2", "CPUUtilization", "Average", dims,
60, 3, 50.0, "GreaterThanThreshold", [arn]),
(put["Alarms"][1]["AlarmARN"], "AWS/EC2", "CPUUtilization", "Average", dims,
60, 15, 45.0, "LessThanThreshold", [arn]),
]
for alarm in alarms.values():
assert alarm["AlarmDescription"] == (
f"DO NOT EDIT OR DELETE. For TargetTrackingScaling policy {arn}.")
assert not {"Unit", "DatapointsToAlarm", "TreatMissingData"} & set(alarm)
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
@pytest.mark.parametrize("tracking,metric,thresholds", [
({"PredefinedMetricSpecification": {"PredefinedMetricType": "ASGAverageNetworkIn"},
"TargetValue": 1000000.0},
("AWS/EC2", "NetworkIn", "Average", "Bytes"), [1000000.0, 900000.0]),
({"PredefinedMetricSpecification": {"PredefinedMetricType": "ASGAverageNetworkOut"},
"TargetValue": 1000000.0},
("AWS/EC2", "NetworkOut", "Average", "Bytes"), [1000000.0, 900000.0]),
({"CustomizedMetricSpecification": {"MetricName": "Depth", "Namespace": "Test/App",
"Dimensions": [{"Name": "Q", "Value": "q1"}],
"Statistic": "Sum", "Unit": "Count"},
"TargetValue": 0.1},
("Test/App", "Depth", "Sum", "Count"), [0.1, 0.09]),
({**_CPU_TRACKING, "DisableScaleIn": True},
("AWS/EC2", "CPUUtilization", "Average", None), [50.0]),
], ids=["network-in", "network-out", "customized", "disable-scale-in"])
def test_target_tracking_alarm_metric_and_thresholds(autoscaling, cw, tracking, metric, thresholds):
"""The alarms follow the tracked metric and target; DisableScaleIn leaves only AlarmHigh."""
asg = _tracking_group(autoscaling)
try:
names = [a["AlarmName"] for a in _put_tracking(autoscaling, asg, "p", tracking)["Alarms"]]
alarms = {a["AlarmName"]: a for a in cw.describe_alarms(AlarmNames=names)["MetricAlarms"]}
assert [(a["Namespace"], a["MetricName"], a["Statistic"], a.get("Unit"))
for a in (alarms[n] for n in names)] == [metric] * len(thresholds)
assert [alarms[n]["Threshold"] for n in names] == thresholds
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_target_tracking_alarms_follow_policy_lifecycle(autoscaling, cw):
"""Updating a policy replaces its alarms; deleting the policy or the group deletes them."""
asg = _tracking_group(autoscaling)
def existing(put):
names = [a["AlarmName"] for a in put["Alarms"]]
return [a["AlarmName"] for a in cw.describe_alarms(AlarmNames=names)["MetricAlarms"]]
try:
first = _put_tracking(autoscaling, asg, "cpu", _CPU_TRACKING)
second = _put_tracking(autoscaling, asg, "cpu", {**_CPU_TRACKING, "TargetValue": 60.0})
assert existing(first) == []
assert len(existing(second)) == 2
autoscaling.delete_policy(AutoScalingGroupName=asg, PolicyName="cpu")
assert existing(second) == []
kept = [_put_tracking(autoscaling, asg, name, _CPU_TRACKING) for name in ("a", "b")]
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
assert [existing(put) for put in kept] == [[], []]
assert cw.describe_alarms(AlarmNamePrefix=f"TargetTracking-{asg}-")["MetricAlarms"] == []
def test_group_delete_keeps_the_alarms_of_a_group_with_a_longer_name(autoscaling, cw):
"""Deleting a group leaves the policies and alarms of a group whose name starts with it."""
asg = _tracking_group(autoscaling)
other = f"{asg}/blue"
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=other, MinSize=0, MaxSize=2,
AvailabilityZones=["us-east-1a"], LaunchConfigurationName="dummy-lc",
)
try:
_put_tracking(autoscaling, asg, "cpu", _CPU_TRACKING)
kept = _put_tracking(autoscaling, other, "cpu", _CPU_TRACKING)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
names = [a["AlarmName"] for a in kept["Alarms"]]
assert len(cw.describe_alarms(AlarmNames=names)["MetricAlarms"]) == 2
assert [p["PolicyName"] for p in autoscaling.describe_policies(
AutoScalingGroupName=other)["ScalingPolicies"]] == ["cpu"]
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=other)
assert cw.describe_alarms(AlarmNamePrefix=f"TargetTracking-{other}-")["MetricAlarms"] == []
@pytest.mark.parametrize("members", [
{"PolicyType": "TargetTrackingScaling",
"TargetTrackingConfiguration.PredefinedMetricSpecification.PredefinedMetricType":
"ASGAverageCPUUtilization",
"TargetTrackingConfiguration.TargetValue": "fifty"},
{"PolicyType": "StepScaling", "AdjustmentType": "ChangeInCapacity",
"StepAdjustments.member.1.MetricIntervalLowerBound": "zero",
"StepAdjustments.member.1.ScalingAdjustment": "1"},
{"PolicyType": "SimpleScaling", "ScalingAdjustment": "one"},
], ids=["target-value", "step-bound", "scaling-adjustment"])
def test_put_scaling_policy_non_numeric_member_is_a_validation_error(autoscaling, members):
"""A non-numeric number member is a ValidationError, not a 500."""
asg = _uid("asg-badnum")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg, MinSize=0, MaxSize=2,
AvailabilityZones=["us-east-1a"], LaunchConfigurationName="dummy-lc",
)
body = urllib.parse.urlencode({
"Action": "PutScalingPolicy", "Version": "2011-01-01",
"AutoScalingGroupName": asg, "PolicyName": "bad", **members,
}).encode()
req = urllib.request.Request(
os.environ.get("MINISTACK_ENDPOINT", "http://localhost:4566") + "/",
data=body, method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded",
"Authorization": ("AWS4-HMAC-SHA256 Credential=test/20260921/"
"us-east-1/autoscaling/aws4_request, "
"SignedHeaders=, Signature=x")},
)
try:
with pytest.raises(urllib.error.HTTPError) as exc:
urllib.request.urlopen(req, timeout=10)
assert exc.value.code == 400
assert b"<Code>ValidationError</Code>" in exc.value.read()
assert autoscaling.describe_policies(AutoScalingGroupName=asg)["ScalingPolicies"] == []
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_describe_policies_empty(autoscaling):
resp = autoscaling.describe_policies(AutoScalingGroupName=_uid("no-asg"))
assert resp["ScalingPolicies"] == []
def test_delete_policy(autoscaling):
asg = _uid("asg-dpol")
pol = _uid("dpol")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.put_scaling_policy(
AutoScalingGroupName=asg,
PolicyName=pol,
AdjustmentType="ChangeInCapacity",
ScalingAdjustment=1,
)
autoscaling.delete_policy(AutoScalingGroupName=asg, PolicyName=pol)
desc = autoscaling.describe_policies(AutoScalingGroupName=asg)
names = [p["PolicyName"] for p in desc["ScalingPolicies"]]
assert pol not in names
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_delete_policy_idempotent(autoscaling):
autoscaling.delete_policy(
AutoScalingGroupName="ghost-asg",
PolicyName="ghost-pol",
)
# ---------------------------------------------------------------------------
# Lifecycle Hooks: Put, Describe, Delete, Complete, Heartbeat
# ---------------------------------------------------------------------------
def test_put_and_describe_lifecycle_hook(autoscaling):
asg = _uid("asg-hook")
hook = _uid("hook")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.put_lifecycle_hook(
AutoScalingGroupName=asg,
LifecycleHookName=hook,
LifecycleTransition="autoscaling:EC2_INSTANCE_LAUNCHING",
HeartbeatTimeout=300,
DefaultResult="CONTINUE",
)
resp = autoscaling.describe_lifecycle_hooks(AutoScalingGroupName=asg)
hooks = resp["LifecycleHooks"]
assert len(hooks) >= 1
found = [h for h in hooks if h["LifecycleHookName"] == hook]
assert len(found) == 1
assert found[0]["LifecycleTransition"] == "autoscaling:EC2_INSTANCE_LAUNCHING"
assert found[0]["DefaultResult"] == "CONTINUE"
assert found[0]["HeartbeatTimeout"] == 300
finally:
autoscaling.delete_lifecycle_hook(
AutoScalingGroupName=asg, LifecycleHookName=hook
)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_put_lifecycle_hook_notification_metadata_reads_back(autoscaling):
asg = _uid("asg-hmeta")
hook = _uid("hmeta")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.put_lifecycle_hook(
AutoScalingGroupName=asg,
LifecycleHookName=hook,
LifecycleTransition="autoscaling:EC2_INSTANCE_TERMINATING",
NotificationMetadata='{"drain": "<all> & wait"}',
)
[found] = autoscaling.describe_lifecycle_hooks(AutoScalingGroupName=asg)["LifecycleHooks"]
assert found["NotificationMetadata"] == '{"drain": "<all> & wait"}'
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_describe_lifecycle_hooks_empty(autoscaling):
asg = _uid("asg-nohook")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
resp = autoscaling.describe_lifecycle_hooks(AutoScalingGroupName=asg)
assert resp["LifecycleHooks"] == []
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_delete_lifecycle_hook(autoscaling):
asg = _uid("asg-dhook")
hook = _uid("dhook")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.put_lifecycle_hook(
AutoScalingGroupName=asg,
LifecycleHookName=hook,
LifecycleTransition="autoscaling:EC2_INSTANCE_TERMINATING",
)
autoscaling.delete_lifecycle_hook(
AutoScalingGroupName=asg, LifecycleHookName=hook
)
resp = autoscaling.describe_lifecycle_hooks(AutoScalingGroupName=asg)
names = [h["LifecycleHookName"] for h in resp["LifecycleHooks"]]
assert hook not in names
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_delete_lifecycle_hook_idempotent(autoscaling):
autoscaling.delete_lifecycle_hook(
AutoScalingGroupName="ghost-asg",
LifecycleHookName="ghost-hook",
)
def test_complete_lifecycle_action(autoscaling):
asg = _uid("asg-cla")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
resp = autoscaling.complete_lifecycle_action(
AutoScalingGroupName=asg,
LifecycleHookName="any-hook",
LifecycleActionResult="CONTINUE",
)
assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_record_lifecycle_action_heartbeat(autoscaling):
asg = _uid("asg-hb")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
resp = autoscaling.record_lifecycle_action_heartbeat(
AutoScalingGroupName=asg,
LifecycleHookName="any-hook",
)
assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_delete_asg_cleans_up_hooks(autoscaling):
"""Deleting an ASG should also remove its lifecycle hooks."""
asg = _uid("asg-hclean")
hook = _uid("hclean")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
autoscaling.put_lifecycle_hook(
AutoScalingGroupName=asg,
LifecycleHookName=hook,
LifecycleTransition="autoscaling:EC2_INSTANCE_LAUNCHING",
)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
# Re-create the ASG to query hooks — should be empty
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
resp = autoscaling.describe_lifecycle_hooks(AutoScalingGroupName=asg)
names = [h["LifecycleHookName"] for h in resp["LifecycleHooks"]]
assert hook not in names
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
# ---------------------------------------------------------------------------
# Scheduled Actions: Put, Describe, Delete
# ---------------------------------------------------------------------------
def test_put_and_describe_scheduled_action(autoscaling):
asg = _uid("asg-sched")
action = _uid("sched")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=10,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.put_scheduled_update_group_action(
AutoScalingGroupName=asg,
ScheduledActionName=action,
Recurrence="0 8 * * *",
MinSize=2,
MaxSize=8,
DesiredCapacity=4,
)
resp = autoscaling.describe_scheduled_actions(AutoScalingGroupName=asg)
actions = resp["ScheduledUpdateGroupActions"]
assert len(actions) >= 1
found = [a for a in actions if a["ScheduledActionName"] == action]
assert len(found) == 1
assert found[0]["ScheduledActionARN"].startswith("arn:aws:autoscaling:")
finally:
autoscaling.delete_scheduled_action(
AutoScalingGroupName=asg, ScheduledActionName=action
)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_scheduled_action_times_read_back(autoscaling):
"""StartTime (also as Time), EndTime and TimeZone read back."""
asg = _uid("asg-stimes")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg, MinSize=0, MaxSize=2,
AvailabilityZones=["us-east-1a"], LaunchConfigurationName="dummy-lc",
)
start = datetime.datetime(2027, 1, 4, 9, tzinfo=datetime.timezone.utc)
end = datetime.datetime(2027, 6, 1, tzinfo=datetime.timezone.utc)
try:
autoscaling.put_scheduled_update_group_action(
AutoScalingGroupName=asg, ScheduledActionName="times",
Recurrence="0 9 * * *", StartTime=start, EndTime=end,
TimeZone="Europe/Berlin", MinSize=0, MaxSize=1)
action = autoscaling.describe_scheduled_actions(
AutoScalingGroupName=asg)["ScheduledUpdateGroupActions"][0]
assert (action["StartTime"], action["Time"], action["EndTime"], action["TimeZone"]) == (
start, start, end, "Europe/Berlin")
finally:
autoscaling.delete_scheduled_action(AutoScalingGroupName=asg, ScheduledActionName="times")
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_describe_scheduled_actions_empty(autoscaling):
resp = autoscaling.describe_scheduled_actions(
AutoScalingGroupName=_uid("no-sched")
)
assert resp["ScheduledUpdateGroupActions"] == []
def test_delete_scheduled_action(autoscaling):
asg = _uid("asg-dsched")
action = _uid("dsched")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.put_scheduled_update_group_action(
AutoScalingGroupName=asg,
ScheduledActionName=action,
MinSize=1,
MaxSize=5,
)
autoscaling.delete_scheduled_action(
AutoScalingGroupName=asg, ScheduledActionName=action
)
resp = autoscaling.describe_scheduled_actions(AutoScalingGroupName=asg)
names = [a["ScheduledActionName"] for a in resp["ScheduledUpdateGroupActions"]]
assert action not in names
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_delete_scheduled_action_idempotent(autoscaling):
autoscaling.delete_scheduled_action(
AutoScalingGroupName="ghost-asg",
ScheduledActionName="ghost-action",
)
# ---------------------------------------------------------------------------
# Tags: CreateOrUpdate, Describe, Delete
# ---------------------------------------------------------------------------
def test_create_or_update_tags_and_describe(autoscaling):
asg = _uid("asg-tag")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.create_or_update_tags(
Tags=[
{
"ResourceId": asg,
"ResourceType": "auto-scaling-group",
"Key": "Environment",
"Value": "test",
"PropagateAtLaunch": True,
},
{
"ResourceId": asg,
"ResourceType": "auto-scaling-group",
"Key": "Team",
"Value": "platform",
"PropagateAtLaunch": False,
},
]
)
resp = autoscaling.describe_tags()
all_tags = resp["Tags"]
my_tags = [t for t in all_tags if t["ResourceId"] == asg]
assert len(my_tags) == 2
keys = {t["Key"] for t in my_tags}
assert keys == {"Environment", "Team"}
finally:
autoscaling.delete_tags(
Tags=[
{"ResourceId": asg, "ResourceType": "auto-scaling-group", "Key": "Environment"},
{"ResourceId": asg, "ResourceType": "auto-scaling-group", "Key": "Team"},
]
)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_update_existing_tag(autoscaling):
asg = _uid("asg-tagup")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.create_or_update_tags(
Tags=[
{
"ResourceId": asg,
"ResourceType": "auto-scaling-group",
"Key": "Version",
"Value": "v1",
"PropagateAtLaunch": False,
},
]
)
# Update same key with new value
autoscaling.create_or_update_tags(
Tags=[
{
"ResourceId": asg,
"ResourceType": "auto-scaling-group",
"Key": "Version",
"Value": "v2",
"PropagateAtLaunch": True,
},
]
)
resp = autoscaling.describe_tags()
my_tags = [t for t in resp["Tags"] if t["ResourceId"] == asg and t["Key"] == "Version"]
assert len(my_tags) == 1
assert my_tags[0]["Value"] == "v2"
finally:
autoscaling.delete_tags(
Tags=[{"ResourceId": asg, "ResourceType": "auto-scaling-group", "Key": "Version"}]
)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_delete_tags(autoscaling):
asg = _uid("asg-dtag")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.create_or_update_tags(
Tags=[
{
"ResourceId": asg,
"ResourceType": "auto-scaling-group",
"Key": "Ephemeral",
"Value": "yes",
"PropagateAtLaunch": False,
},
]
)
autoscaling.delete_tags(
Tags=[
{
"ResourceId": asg,
"ResourceType": "auto-scaling-group",
"Key": "Ephemeral",
},
]
)
resp = autoscaling.describe_tags()
my_tags = [t for t in resp["Tags"] if t["ResourceId"] == asg and t["Key"] == "Ephemeral"]
assert my_tags == []
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_tags_reflect_in_asg_describe(autoscaling):
"""Tags added via CreateOrUpdateTags should appear in DescribeAutoScalingGroups."""
asg = _uid("asg-tagsync")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.create_or_update_tags(
Tags=[
{
"ResourceId": asg,
"ResourceType": "auto-scaling-group",
"Key": "Sync",
"Value": "check",
"PropagateAtLaunch": False,
},
]
)
resp = autoscaling.describe_auto_scaling_groups(AutoScalingGroupNames=[asg])
asg_tags = resp["AutoScalingGroups"][0]["Tags"]
keys = [t["Key"] for t in asg_tags]
assert "Sync" in keys
finally:
autoscaling.delete_tags(
Tags=[{"ResourceId": asg, "ResourceType": "auto-scaling-group", "Key": "Sync"}]
)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_create_asg_with_inline_tags(autoscaling):
"""Tags passed at ASG creation time should be visible."""
asg = _uid("asg-itag")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
Tags=[
{
"ResourceId": asg,
"ResourceType": "auto-scaling-group",
"Key": "Inline",
"Value": "yes",
"PropagateAtLaunch": True,
}
],
)
try:
resp = autoscaling.describe_auto_scaling_groups(AutoScalingGroupNames=[asg])
tags = resp["AutoScalingGroups"][0]["Tags"]
assert any(t["Key"] == "Inline" and t["Value"] == "yes" for t in tags)
# Also visible in DescribeTags
tresp = autoscaling.describe_tags()
my = [t for t in tresp["Tags"] if t["ResourceId"] == asg and t["Key"] == "Inline"]
assert len(my) == 1
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
# ---------------------------------------------------------------------------
# Multiple policies on same ASG
# ---------------------------------------------------------------------------
def test_multiple_policies_on_same_asg(autoscaling):
asg = _uid("asg-mpol")
p1 = _uid("scale-up")
p2 = _uid("scale-down")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=10,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.put_scaling_policy(
AutoScalingGroupName=asg,
PolicyName=p1,
AdjustmentType="ChangeInCapacity",
ScalingAdjustment=2,
)
autoscaling.put_scaling_policy(
AutoScalingGroupName=asg,
PolicyName=p2,
AdjustmentType="ChangeInCapacity",
ScalingAdjustment=-1,
)
desc = autoscaling.describe_policies(AutoScalingGroupName=asg)
names = [p["PolicyName"] for p in desc["ScalingPolicies"]]
assert p1 in names
assert p2 in names
finally:
autoscaling.delete_policy(AutoScalingGroupName=asg, PolicyName=p1)
autoscaling.delete_policy(AutoScalingGroupName=asg, PolicyName=p2)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
# ---------------------------------------------------------------------------
# Multiple hooks on same ASG
# ---------------------------------------------------------------------------
def test_multiple_hooks_on_same_asg(autoscaling):
asg = _uid("asg-mhook")
h1 = _uid("launch-hook")
h2 = _uid("term-hook")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.put_lifecycle_hook(
AutoScalingGroupName=asg,
LifecycleHookName=h1,
LifecycleTransition="autoscaling:EC2_INSTANCE_LAUNCHING",
)
autoscaling.put_lifecycle_hook(
AutoScalingGroupName=asg,
LifecycleHookName=h2,
LifecycleTransition="autoscaling:EC2_INSTANCE_TERMINATING",
)
resp = autoscaling.describe_lifecycle_hooks(AutoScalingGroupName=asg)
names = [h["LifecycleHookName"] for h in resp["LifecycleHooks"]]
assert h1 in names
assert h2 in names
finally:
autoscaling.delete_lifecycle_hook(AutoScalingGroupName=asg, LifecycleHookName=h1)
autoscaling.delete_lifecycle_hook(AutoScalingGroupName=asg, LifecycleHookName=h2)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
# ---------------------------------------------------------------------------
# Multiple scheduled actions on same ASG
# ---------------------------------------------------------------------------
def test_multiple_scheduled_actions(autoscaling):
asg = _uid("asg-msched")
a1 = _uid("morning")
a2 = _uid("evening")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=10,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.put_scheduled_update_group_action(
AutoScalingGroupName=asg,
ScheduledActionName=a1,
Recurrence="0 8 * * *",
MinSize=5,
MaxSize=10,
)
autoscaling.put_scheduled_update_group_action(
AutoScalingGroupName=asg,
ScheduledActionName=a2,
Recurrence="0 20 * * *",
MinSize=1,
MaxSize=3,
)
resp = autoscaling.describe_scheduled_actions(AutoScalingGroupName=asg)
names = [a["ScheduledActionName"] for a in resp["ScheduledUpdateGroupActions"]]
assert a1 in names
assert a2 in names
finally:
autoscaling.delete_scheduled_action(AutoScalingGroupName=asg, ScheduledActionName=a1)
autoscaling.delete_scheduled_action(AutoScalingGroupName=asg, ScheduledActionName=a2)
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
# ---------------------------------------------------------------------------
# ASG with launch template reference
# ---------------------------------------------------------------------------
def test_create_asg_with_launch_template(autoscaling):
asg = _uid("asg-lt")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchTemplate={
"LaunchTemplateName": "my-template",
"Version": "$Latest",
},
)
try:
resp = autoscaling.describe_auto_scaling_groups(AutoScalingGroupNames=[asg])
g = resp["AutoScalingGroups"][0]
lt = g.get("LaunchTemplate", {})
assert lt.get("LaunchTemplateName") == "my-template"
assert lt.get("Version") == "$Latest"
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
# ---------------------------------------------------------------------------
# Instance Refresh
# ---------------------------------------------------------------------------
def test_start_and_describe_instance_refresh(autoscaling):
asg = _uid("asg-refresh")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchTemplate={"LaunchTemplateName": "my-template", "Version": "$Latest"},
)
try:
start = autoscaling.start_instance_refresh(
AutoScalingGroupName=asg,
Preferences={"MinHealthyPercentage": 90, "InstanceWarmup": 0},
)
refresh_id = start["InstanceRefreshId"]
assert refresh_id
resp = autoscaling.describe_instance_refreshes(AutoScalingGroupName=asg)
refreshes = resp["InstanceRefreshes"]
assert len(refreshes) == 1
r = refreshes[0]
assert r["InstanceRefreshId"] == refresh_id
assert r["AutoScalingGroupName"] == asg
assert r["Status"] == "Successful"
assert r["PercentageComplete"] == 100
# Filter by id round-trips.
filtered = autoscaling.describe_instance_refreshes(
AutoScalingGroupName=asg, InstanceRefreshIds=[refresh_id]
)
assert filtered["InstanceRefreshes"][0]["InstanceRefreshId"] == refresh_id
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
def test_start_instance_refresh_unknown_asg_fails(autoscaling):
with pytest.raises(ClientError) as exc:
autoscaling.start_instance_refresh(AutoScalingGroupName=_uid("missing"))
assert "ValidationError" in str(exc.value)
def test_cancel_instance_refresh_when_none_active(autoscaling):
asg = _uid("asg-cancel")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=asg,
MinSize=0,
MaxSize=1,
AvailabilityZones=["us-east-1a"],
LaunchTemplate={"LaunchTemplateName": "my-template", "Version": "$Latest"},
)
try:
# Refresh completes immediately, so there is nothing active to cancel.
autoscaling.start_instance_refresh(AutoScalingGroupName=asg)
with pytest.raises(ClientError) as exc:
autoscaling.cancel_instance_refresh(AutoScalingGroupName=asg)
assert "ActiveInstanceRefreshNotFound" in str(exc.value)
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=asg)
# ---------------------------------------------------------------------------
# Mock in-service instances (capacity waiters)
# ---------------------------------------------------------------------------
def test_asg_reports_desired_capacity_instances(autoscaling):
name = _uid("asg-cap")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=1,
MaxSize=5,
DesiredCapacity=3,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
g = autoscaling.describe_auto_scaling_groups(
AutoScalingGroupNames=[name]
)["AutoScalingGroups"][0]
instances = g["Instances"]
assert len(instances) == 3
for inst in instances:
assert inst["InstanceId"].startswith("i-")
assert inst["LifecycleState"] == "InService"
assert inst["HealthStatus"] == "Healthy"
assert inst["AvailabilityZone"] == "us-east-1a"
described = autoscaling.describe_auto_scaling_instances()["AutoScalingInstances"]
for_group = [i for i in described if i["AutoScalingGroupName"] == name]
assert len(for_group) == 3
assert {i["InstanceId"] for i in for_group} == {i["InstanceId"] for i in instances}
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=name)
def test_set_desired_capacity_reconciles_instances(autoscaling):
name = _uid("asg-set")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=0,
MaxSize=5,
DesiredCapacity=1,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
autoscaling.set_desired_capacity(AutoScalingGroupName=name, DesiredCapacity=4)
g = autoscaling.describe_auto_scaling_groups(
AutoScalingGroupNames=[name]
)["AutoScalingGroups"][0]
assert len(g["Instances"]) == 4
assert all(i["LifecycleState"] == "InService" for i in g["Instances"])
autoscaling.set_desired_capacity(AutoScalingGroupName=name, DesiredCapacity=2)
g = autoscaling.describe_auto_scaling_groups(
AutoScalingGroupNames=[name]
)["AutoScalingGroups"][0]
assert len(g["Instances"]) == 2
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=name)
def test_update_asg_reconciles_instances(autoscaling):
name = _uid("asg-upd-cap")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=0,
MaxSize=5,
DesiredCapacity=0,
AvailabilityZones=["us-east-1a"],
LaunchConfigurationName="dummy-lc",
)
try:
assert autoscaling.describe_auto_scaling_groups(
AutoScalingGroupNames=[name]
)["AutoScalingGroups"][0]["Instances"] == []
autoscaling.update_auto_scaling_group(AutoScalingGroupName=name, DesiredCapacity=2)
g = autoscaling.describe_auto_scaling_groups(
AutoScalingGroupNames=[name]
)["AutoScalingGroups"][0]
assert len(g["Instances"]) == 2
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=name)
def test_asg_instances_round_robin_azs(autoscaling):
name = _uid("asg-az")
autoscaling.create_auto_scaling_group(
AutoScalingGroupName=name,
MinSize=0,
MaxSize=5,
DesiredCapacity=4,
AvailabilityZones=["us-east-1a", "us-east-1b"],
LaunchConfigurationName="dummy-lc",
)
try:
instances = autoscaling.describe_auto_scaling_groups(
AutoScalingGroupNames=[name]
)["AutoScalingGroups"][0]["Instances"]
azs = [i["AvailabilityZone"] for i in instances]
assert azs == ["us-east-1a", "us-east-1b", "us-east-1a", "us-east-1b"]
finally:
autoscaling.delete_auto_scaling_group(AutoScalingGroupName=name)