From 0b2e86ce6812abaa755f57c27bcf8fba6c393251 Mon Sep 17 00:00:00 2001 From: Bert Blommers Date: Fri, 9 Jun 2023 11:16:59 +0000 Subject: [PATCH] Techdebt: Replace sure with regular asserts in Autoscaling (#6383) --- tests/test_autoscaling/test_autoscaling.py | 449 +++++++++-------- .../test_autoscaling_cloudformation.py | 114 +++-- .../test_autoscaling_groups.py | 80 ++-- .../test_autoscaling_metrics.py | 10 +- .../test_autoscaling_scheduledactions.py | 11 +- .../test_autoscaling/test_autoscaling_tags.py | 182 ++++--- tests/test_autoscaling/test_elb.py | 450 ++++++++---------- tests/test_autoscaling/test_elbv2.py | 19 +- .../test_launch_configurations.py | 134 +++--- tests/test_autoscaling/test_policies.py | 33 +- tests/test_autoscaling/test_server.py | 6 +- 11 files changed, 679 insertions(+), 809 deletions(-) diff --git a/tests/test_autoscaling/test_autoscaling.py b/tests/test_autoscaling/test_autoscaling.py index 8e4fade10..d77091c89 100644 --- a/tests/test_autoscaling/test_autoscaling.py +++ b/tests/test_autoscaling/test_autoscaling.py @@ -1,5 +1,4 @@ import boto3 -import sure # noqa # pylint: disable=unused-import import pytest from botocore.exceptions import ClientError @@ -42,8 +41,8 @@ def test_propogate_tags(): instances = ec2.describe_instances() tags = instances["Reservations"][0]["Instances"][0]["Tags"] - tags.should.contain({"Value": "TestTagValue1", "Key": "TestTagKey1"}) - tags.should.contain({"Value": "TestGroup1", "Key": "aws:autoscaling:groupName"}) + assert {"Value": "TestTagValue1", "Key": "TestTagKey1"} in tags + assert {"Value": "TestGroup1", "Key": "aws:autoscaling:groupName"} in tags @mock_autoscaling @@ -65,20 +64,14 @@ def test_create_autoscaling_group_from_instance(): VPCZoneIdentifier=mocked_instance_with_networking["subnet1"], NewInstancesProtectedFromScaleIn=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 describe_launch_configurations_response = client.describe_launch_configurations() - describe_launch_configurations_response[ - "LaunchConfigurations" - ].should.have.length_of(1) - launch_configuration_from_instance = describe_launch_configurations_response[ - "LaunchConfigurations" - ][0] - launch_configuration_from_instance["LaunchConfigurationName"].should.equal( - "test_asg" - ) - launch_configuration_from_instance["ImageId"].should.equal(image_id) - launch_configuration_from_instance["InstanceType"].should.equal(instance_type) + assert len(describe_launch_configurations_response["LaunchConfigurations"]) == 1 + config = describe_launch_configurations_response["LaunchConfigurations"][0] + assert config["LaunchConfigurationName"] == "test_asg" + assert config["ImageId"] == image_id + assert config["InstanceType"] == instance_type @mock_autoscaling @@ -109,7 +102,7 @@ def test_create_autoscaling_group_from_instance_with_security_groups(): NewInstancesProtectedFromScaleIn=False, ) # Just verifying this works - used to throw an error when supplying a instance that belonged to an SG - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 @mock_autoscaling @@ -128,11 +121,10 @@ def test_create_autoscaling_group_from_invalid_instance_id(): VPCZoneIdentifier=mocked_networking["subnet1"], NewInstancesProtectedFromScaleIn=False, ) - ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400) - ex.value.response["Error"]["Code"].should.equal("ValidationError") - ex.value.response["Error"]["Message"].should.equal( - f"Instance [{invalid_instance_id}] is invalid." - ) + err = ex.value.response["Error"] + assert ex.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400 + assert err["Code"] == "ValidationError" + assert err["Message"] == f"Instance [{invalid_instance_id}] is invalid." @mock_autoscaling @@ -158,7 +150,7 @@ def test_create_autoscaling_group_from_template(): VPCZoneIdentifier=mocked_networking["subnet1"], NewInstancesProtectedFromScaleIn=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 @mock_ec2 @@ -186,11 +178,9 @@ def test_create_auto_scaling_from_template_version__latest(): response = asg_client.describe_auto_scaling_groups(AutoScalingGroupNames=["name"])[ "AutoScalingGroups" ][0] - response.should.have.key("LaunchTemplate") - response["LaunchTemplate"].should.have.key("LaunchTemplateName").equals( - launch_template_name - ) - response["LaunchTemplate"].should.have.key("Version").equals("$Latest") + assert "LaunchTemplate" in response + assert response["LaunchTemplate"]["LaunchTemplateName"] == launch_template_name + assert response["LaunchTemplate"]["Version"] == "$Latest" @mock_ec2 @@ -223,11 +213,9 @@ def test_create_auto_scaling_from_template_version__default(): response = asg_client.describe_auto_scaling_groups(AutoScalingGroupNames=["name"])[ "AutoScalingGroups" ][0] - response.should.have.key("LaunchTemplate") - response["LaunchTemplate"].should.have.key("LaunchTemplateName").equals( - launch_template_name - ) - response["LaunchTemplate"].should.have.key("Version").equals("$Default") + assert "LaunchTemplate" in response + assert response["LaunchTemplate"]["LaunchTemplateName"] == launch_template_name + assert response["LaunchTemplate"]["Version"] == "$Default" @mock_ec2 @@ -252,9 +240,9 @@ def test_create_auto_scaling_from_template_version__no_version(): response = asg_client.describe_auto_scaling_groups(AutoScalingGroupNames=["name"])[ "AutoScalingGroups" ][0] - response.should.have.key("LaunchTemplate") + assert "LaunchTemplate" in response # We never specified the version - and AWS will not return anything if we don't - response["LaunchTemplate"].shouldnt.have.key("Version") + assert "Version" not in response["LaunchTemplate"] @mock_autoscaling @@ -279,10 +267,12 @@ def test_create_autoscaling_group_no_template_ref(): VPCZoneIdentifier=mocked_networking["subnet1"], NewInstancesProtectedFromScaleIn=False, ) - ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400) - ex.value.response["Error"]["Code"].should.equal("ValidationError") - ex.value.response["Error"]["Message"].should.equal( - "Valid requests must contain either launchTemplateId or LaunchTemplateName" + err = ex.value.response["Error"] + assert ex.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400 + assert err["Code"] == "ValidationError" + assert ( + err["Message"] + == "Valid requests must contain either launchTemplateId or LaunchTemplateName" ) @@ -312,10 +302,12 @@ def test_create_autoscaling_group_multiple_template_ref(): VPCZoneIdentifier=mocked_networking["subnet1"], NewInstancesProtectedFromScaleIn=False, ) - ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400) - ex.value.response["Error"]["Code"].should.equal("ValidationError") - ex.value.response["Error"]["Message"].should.equal( - "Valid requests must contain either launchTemplateId or LaunchTemplateName" + err = ex.value.response["Error"] + assert ex.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400 + assert err["Code"] == "ValidationError" + assert ( + err["Message"] + == "Valid requests must contain either launchTemplateId or LaunchTemplateName" ) @@ -332,11 +324,12 @@ def test_create_autoscaling_group_no_launch_configuration(): VPCZoneIdentifier=mocked_networking["subnet1"], NewInstancesProtectedFromScaleIn=False, ) - ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400) - ex.value.response["Error"]["Code"].should.equal("ValidationError") - ex.value.response["Error"]["Message"].should.equal( - "Valid requests must contain either LaunchTemplate, LaunchConfigurationName, " - "InstanceId or MixedInstancesPolicy parameter." + err = ex.value.response["Error"] + assert ex.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400 + assert err["Code"] == "ValidationError" + assert ( + err["Message"] + == "Valid requests must contain either LaunchTemplate, LaunchConfigurationName, InstanceId or MixedInstancesPolicy parameter." ) @@ -371,11 +364,12 @@ def test_create_autoscaling_group_multiple_launch_configurations(): VPCZoneIdentifier=mocked_networking["subnet1"], NewInstancesProtectedFromScaleIn=False, ) - ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400) - ex.value.response["Error"]["Code"].should.equal("ValidationError") - ex.value.response["Error"]["Message"].should.equal( - "Valid requests must contain either LaunchTemplate, LaunchConfigurationName, " - "InstanceId or MixedInstancesPolicy parameter." + err = ex.value.response["Error"] + assert ex.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400 + assert err["Code"] == "ValidationError" + assert ( + err["Message"] + == "Valid requests must contain either LaunchTemplate, LaunchConfigurationName, InstanceId or MixedInstancesPolicy parameter." ) @@ -405,20 +399,20 @@ def test_describe_autoscaling_groups_launch_template(): } response = client.describe_auto_scaling_groups(AutoScalingGroupNames=["test_asg"]) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 group = response["AutoScalingGroups"][0] - group["AutoScalingGroupName"].should.equal("test_asg") - group["LaunchTemplate"].should.equal(expected_launch_template) - group.should_not.have.key("LaunchConfigurationName") - group["AvailabilityZones"].should.equal(["us-east-1a"]) - group["VPCZoneIdentifier"].should.equal(mocked_networking["subnet1"]) - group["NewInstancesProtectedFromScaleIn"].should.equal(True) + assert group["AutoScalingGroupName"] == "test_asg" + assert group["LaunchTemplate"] == expected_launch_template + assert "LaunchConfigurationName" not in group + assert group["AvailabilityZones"] == ["us-east-1a"] + assert group["VPCZoneIdentifier"] == mocked_networking["subnet1"] + assert group["NewInstancesProtectedFromScaleIn"] is True for instance in group["Instances"]: - instance["LaunchTemplate"].should.equal(expected_launch_template) - instance.should_not.have.key("LaunchConfigurationName") - instance["AvailabilityZone"].should.equal("us-east-1a") - instance["ProtectedFromScaleIn"].should.equal(True) - instance["InstanceType"].should.equal("t2.micro") + assert instance["LaunchTemplate"] == expected_launch_template + assert "LaunchConfigurationName" not in instance + assert instance["AvailabilityZone"] == "us-east-1a" + assert instance["ProtectedFromScaleIn"] is True + assert instance["InstanceType"] == "t2.micro" @mock_autoscaling @@ -441,14 +435,14 @@ def test_describe_autoscaling_instances_launch_config(): ) response = client.describe_auto_scaling_instances() - len(response["AutoScalingInstances"]).should.equal(5) + assert len(response["AutoScalingInstances"]) == 5 for instance in response["AutoScalingInstances"]: - instance["LaunchConfigurationName"].should.equal("test_launch_configuration") - instance.should_not.have.key("LaunchTemplate") - instance["AutoScalingGroupName"].should.equal("test_asg") - instance["AvailabilityZone"].should.equal("us-east-1a") - instance["ProtectedFromScaleIn"].should.equal(True) - instance["InstanceType"].should.equal("t2.micro") + assert instance["LaunchConfigurationName"] == "test_launch_configuration" + assert "LaunchTemplate" not in instance + assert instance["AutoScalingGroupName"] == "test_asg" + assert instance["AvailabilityZone"] == "us-east-1a" + assert instance["ProtectedFromScaleIn"] is True + assert instance["InstanceType"] == "t2.micro" @mock_autoscaling @@ -477,14 +471,14 @@ def test_describe_autoscaling_instances_launch_template(): } response = client.describe_auto_scaling_instances() - len(response["AutoScalingInstances"]).should.equal(5) + assert len(response["AutoScalingInstances"]) == 5 for instance in response["AutoScalingInstances"]: - instance["LaunchTemplate"].should.equal(expected_launch_template) - instance.should_not.have.key("LaunchConfigurationName") - instance["AutoScalingGroupName"].should.equal("test_asg") - instance["AvailabilityZone"].should.equal("us-east-1a") - instance["ProtectedFromScaleIn"].should.equal(True) - instance["InstanceType"].should.equal("t2.micro") + assert instance["LaunchTemplate"] == expected_launch_template + assert "LaunchConfigurationName" not in instance + assert instance["AutoScalingGroupName"] == "test_asg" + assert instance["AvailabilityZone"] == "us-east-1a" + assert instance["ProtectedFromScaleIn"] is True + assert instance["InstanceType"] == "t2.micro" @mock_autoscaling @@ -515,11 +509,11 @@ def test_describe_autoscaling_instances_instanceid_filter(): response = client.describe_auto_scaling_instances( InstanceIds=instance_ids[0:2] ) # Filter by first 2 of 5 - len(response["AutoScalingInstances"]).should.equal(2) + assert len(response["AutoScalingInstances"]) == 2 for instance in response["AutoScalingInstances"]: - instance["AutoScalingGroupName"].should.equal("test_asg") - instance["AvailabilityZone"].should.equal("us-east-1a") - instance["ProtectedFromScaleIn"].should.equal(True) + assert instance["AutoScalingGroupName"] == "test_asg" + assert instance["AvailabilityZone"] == "us-east-1a" + assert instance["ProtectedFromScaleIn"] is True @mock_autoscaling @@ -556,10 +550,10 @@ def test_update_autoscaling_group_launch_config(): response = client.describe_auto_scaling_groups(AutoScalingGroupNames=["test_asg"]) group = response["AutoScalingGroups"][0] - group["LaunchConfigurationName"].should.equal("test_launch_configuration_new") - group["MinSize"].should.equal(1) - set(group["AvailabilityZones"]).should.equal({"us-east-1a", "us-east-1b"}) - group["NewInstancesProtectedFromScaleIn"].should.equal(False) + assert group["LaunchConfigurationName"] == "test_launch_configuration_new" + assert group["MinSize"] == 1 + assert set(group["AvailabilityZones"]) == {"us-east-1a", "us-east-1b"} + assert group["NewInstancesProtectedFromScaleIn"] is False @mock_autoscaling @@ -608,10 +602,10 @@ def test_update_autoscaling_group_launch_template(): response = client.describe_auto_scaling_groups(AutoScalingGroupNames=["test_asg"]) group = response["AutoScalingGroups"][0] - group["LaunchTemplate"].should.equal(expected_launch_template) - group["MinSize"].should.equal(1) - set(group["AvailabilityZones"]).should.equal({"us-east-1a", "us-east-1b"}) - group["NewInstancesProtectedFromScaleIn"].should.equal(False) + assert group["LaunchTemplate"] == expected_launch_template + assert group["MinSize"] == 1 + assert set(group["AvailabilityZones"]) == {"us-east-1a", "us-east-1b"} + assert group["NewInstancesProtectedFromScaleIn"] is False @mock_autoscaling @@ -635,9 +629,9 @@ def test_update_autoscaling_group_min_size_desired_capacity_change(): client.update_auto_scaling_group(AutoScalingGroupName="test_asg", MinSize=5) response = client.describe_auto_scaling_groups(AutoScalingGroupNames=["test_asg"]) group = response["AutoScalingGroups"][0] - group["DesiredCapacity"].should.equal(5) - group["MinSize"].should.equal(5) - group["Instances"].should.have.length_of(5) + assert group["DesiredCapacity"] == 5 + assert group["MinSize"] == 5 + assert len(group["Instances"]) == 5 @mock_autoscaling @@ -661,9 +655,9 @@ def test_update_autoscaling_group_max_size_desired_capacity_change(): client.update_auto_scaling_group(AutoScalingGroupName="test_asg", MaxSize=5) response = client.describe_auto_scaling_groups(AutoScalingGroupNames=["test_asg"]) group = response["AutoScalingGroups"][0] - group["DesiredCapacity"].should.equal(5) - group["MaxSize"].should.equal(5) - group["Instances"].should.have.length_of(5) + assert group["DesiredCapacity"] == 5 + assert group["MaxSize"] == 5 + assert len(group["Instances"]) == 5 @mock_autoscaling @@ -713,31 +707,32 @@ def test_autoscaling_describe_policies(): ) response = client.describe_policies() - response["ScalingPolicies"].should.have.length_of(2) + assert len(response["ScalingPolicies"]) == 2 response = client.describe_policies(AutoScalingGroupName="test_asg") - response["ScalingPolicies"].should.have.length_of(2) + assert len(response["ScalingPolicies"]) == 2 response = client.describe_policies(PolicyTypes=["StepScaling"]) - response["ScalingPolicies"].should.have.length_of(0) + assert len(response["ScalingPolicies"]) == 0 response = client.describe_policies( AutoScalingGroupName="test_asg", PolicyNames=["test_policy_down"], PolicyTypes=["SimpleScaling"], ) - response["ScalingPolicies"].should.have.length_of(1) + assert len(response["ScalingPolicies"]) == 1 policy = response["ScalingPolicies"][0] - policy["PolicyType"].should.equal("SimpleScaling") - policy["MetricAggregationType"].should.equal("Minimum") - policy["AdjustmentType"].should.equal("PercentChangeInCapacity") - policy["ScalingAdjustment"].should.equal(-10) - policy["Cooldown"].should.equal(60) - policy["PolicyARN"].should.equal( - f"arn:aws:autoscaling:us-east-1:{ACCOUNT_ID}:scalingPolicy:c322761b-3172-4d56-9a21-0ed9d6161d67:autoScalingGroupName/test_asg:policyName/test_policy_down" + assert policy["PolicyType"] == "SimpleScaling" + assert policy["MetricAggregationType"] == "Minimum" + assert policy["AdjustmentType"] == "PercentChangeInCapacity" + assert policy["ScalingAdjustment"] == -10 + assert policy["Cooldown"] == 60 + assert ( + policy["PolicyARN"] + == f"arn:aws:autoscaling:us-east-1:{ACCOUNT_ID}:scalingPolicy:c322761b-3172-4d56-9a21-0ed9d6161d67:autoScalingGroupName/test_asg:policyName/test_policy_down" ) - policy["PolicyName"].should.equal("test_policy_down") - policy.shouldnt.have.key("TargetTrackingConfiguration") + assert policy["PolicyName"] == "test_policy_down" + assert "TargetTrackingConfiguration" not in policy @mock_autoscaling @@ -800,51 +795,50 @@ def test_create_autoscaling_policy_with_policytype__targettrackingscaling(): resp = client.describe_policies(AutoScalingGroupName=asg_name) policy = resp["ScalingPolicies"][0] - policy.should.have.key("PolicyName").equals(configuration_name) - policy.should.have.key("PolicyARN").equals( - f"arn:aws:autoscaling:us-west-1:{ACCOUNT_ID}:scalingPolicy:c322761b-3172-4d56-9a21-0ed9d6161d67:autoScalingGroupName/{asg_name}:policyName/{configuration_name}" + assert policy["PolicyName"] == configuration_name + assert ( + policy["PolicyARN"] + == f"arn:aws:autoscaling:us-west-1:{ACCOUNT_ID}:scalingPolicy:c322761b-3172-4d56-9a21-0ed9d6161d67:autoScalingGroupName/{asg_name}:policyName/{configuration_name}" ) - policy.should.have.key("PolicyType").equals("TargetTrackingScaling") - policy.should.have.key("TargetTrackingConfiguration").should.equal( - { - "PredefinedMetricSpecification": { - "PredefinedMetricType": "ASGAverageNetworkIn", - }, - "CustomizedMetricSpecification": { - "MetricName": "None", - "Namespace": "None", - "Dimensions": [], - "Statistic": "None", - "Metrics": [ - { - "Label": "Get ASGAverageCPUUtilization", - "Id": "cpu", - "MetricStat": { - "Metric": { - "MetricName": "CPUUtilization", - "Namespace": "AWS/EC2", - "Dimensions": [ - {"Name": "AutoScalingGroupName", "Value": asg_name} - ], - }, - "Stat": "Average", - "Unit": "None", + assert policy["PolicyType"] == "TargetTrackingScaling" + assert policy["TargetTrackingConfiguration"] == { + "PredefinedMetricSpecification": { + "PredefinedMetricType": "ASGAverageNetworkIn", + }, + "CustomizedMetricSpecification": { + "MetricName": "None", + "Namespace": "None", + "Dimensions": [], + "Statistic": "None", + "Metrics": [ + { + "Label": "Get ASGAverageCPUUtilization", + "Id": "cpu", + "MetricStat": { + "Metric": { + "MetricName": "CPUUtilization", + "Namespace": "AWS/EC2", + "Dimensions": [ + {"Name": "AutoScalingGroupName", "Value": asg_name} + ], }, - "ReturnData": False, + "Stat": "Average", + "Unit": "None", }, - { - "Label": "Calculate square cpu", - "Id": "load", - "Expression": "cpu^2", - "ReturnData": True, - }, - ], - }, - "TargetValue": 1000000.0, - } - ) - policy.shouldnt.have.key("ScalingAdjustment") - policy.shouldnt.have.key("Cooldown") + "ReturnData": False, + }, + { + "Label": "Calculate square cpu", + "Id": "load", + "Expression": "cpu^2", + "ReturnData": True, + }, + ], + }, + "TargetValue": 1000000.0, + } + assert "ScalingAdjustment" not in policy + assert "Cooldown" not in policy @mock_autoscaling @@ -883,23 +877,22 @@ def test_create_autoscaling_policy_with_policytype__stepscaling(): resp = client.describe_policies(AutoScalingGroupName=asg_name) policy = resp["ScalingPolicies"][0] - policy.should.have.key("PolicyName").equals(launch_config_name) - policy.should.have.key("PolicyARN").equals( - f"arn:aws:autoscaling:eu-west-1:{ACCOUNT_ID}:scalingPolicy:c322761b-3172-4d56-9a21-0ed9d6161d67:autoScalingGroupName/{asg_name}:policyName/{launch_config_name}" + assert policy["PolicyName"] == launch_config_name + assert ( + policy["PolicyARN"] + == f"arn:aws:autoscaling:eu-west-1:{ACCOUNT_ID}:scalingPolicy:c322761b-3172-4d56-9a21-0ed9d6161d67:autoScalingGroupName/{asg_name}:policyName/{launch_config_name}" ) - policy.should.have.key("PolicyType").equals("StepScaling") - policy.should.have.key("StepAdjustments").equal( - [ - { - "MetricIntervalLowerBound": 2, - "MetricIntervalUpperBound": 8, - "ScalingAdjustment": 1, - } - ] - ) - policy.shouldnt.have.key("TargetTrackingConfiguration") - policy.shouldnt.have.key("ScalingAdjustment") - policy.shouldnt.have.key("Cooldown") + assert policy["PolicyType"] == "StepScaling" + assert policy["StepAdjustments"] == [ + { + "MetricIntervalLowerBound": 2, + "MetricIntervalUpperBound": 8, + "ScalingAdjustment": 1, + } + ] + assert "TargetTrackingConfiguration" not in policy + assert "ScalingAdjustment" not in policy + assert "Cooldown" not in policy @mock_autoscaling @@ -935,9 +928,10 @@ def test_create_autoscaling_policy_with_predictive_scaling_config(): resp = client.describe_policies(AutoScalingGroupName=asg_name) policy = resp["ScalingPolicies"][0] - policy.should.have.key("PredictiveScalingConfiguration").equals( - {"MetricSpecifications": [{"TargetValue": 5.0}], "SchedulingBufferTime": 7} - ) + assert policy["PredictiveScalingConfiguration"] == { + "MetricSpecifications": [{"TargetValue": 5.0}], + "SchedulingBufferTime": 7, + } @mock_autoscaling @@ -970,29 +964,25 @@ def test_create_auto_scaling_group_with_mixed_instances_policy(): # Assert we can describe MixedInstancesPolicy response = client.describe_auto_scaling_groups(AutoScalingGroupNames=[asg_name]) group = response["AutoScalingGroups"][0] - group.should.have.key("MixedInstancesPolicy").equals( - { - "LaunchTemplate": { - "LaunchTemplateSpecification": { - "LaunchTemplateId": lt["LaunchTemplateId"], - "LaunchTemplateName": "launchie", - "Version": "$DEFAULT", - } - } - } - ) - - # Assert the LaunchTemplate is known for the resulting instances - response = client.describe_auto_scaling_instances() - len(response["AutoScalingInstances"]).should.equal(2) - for instance in response["AutoScalingInstances"]: - instance["LaunchTemplate"].should.equal( - { + assert group["MixedInstancesPolicy"] == { + "LaunchTemplate": { + "LaunchTemplateSpecification": { "LaunchTemplateId": lt["LaunchTemplateId"], "LaunchTemplateName": "launchie", "Version": "$DEFAULT", } - ) + } + } + + # Assert the LaunchTemplate is known for the resulting instances + response = client.describe_auto_scaling_instances() + assert len(response["AutoScalingInstances"]) == 2 + for instance in response["AutoScalingInstances"]: + assert instance["LaunchTemplate"] == { + "LaunchTemplateId": lt["LaunchTemplateId"], + "LaunchTemplateName": "launchie", + "Version": "$DEFAULT", + } @mock_autoscaling @@ -1031,23 +1021,21 @@ def test_create_auto_scaling_group_with_mixed_instances_policy_overrides(): # Assert we can describe MixedInstancesPolicy response = client.describe_auto_scaling_groups(AutoScalingGroupNames=[asg_name]) group = response["AutoScalingGroups"][0] - group.should.have.key("MixedInstancesPolicy").equals( - { - "LaunchTemplate": { - "LaunchTemplateSpecification": { - "LaunchTemplateId": lt["LaunchTemplateId"], - "LaunchTemplateName": "launchie", - "Version": "$DEFAULT", - }, - "Overrides": [ - { - "InstanceType": "t2.medium", - "WeightedCapacity": "50", - } - ], - } + assert group["MixedInstancesPolicy"] == { + "LaunchTemplate": { + "LaunchTemplateSpecification": { + "LaunchTemplateId": lt["LaunchTemplateId"], + "LaunchTemplateName": "launchie", + "Version": "$DEFAULT", + }, + "Overrides": [ + { + "InstanceType": "t2.medium", + "WeightedCapacity": "50", + } + ], } - ) + } @mock_autoscaling @@ -1084,9 +1072,7 @@ def test_set_instance_protection(): response = client.describe_auto_scaling_groups(AutoScalingGroupNames=["test_asg"]) for instance in response["AutoScalingGroups"][0]["Instances"]: - instance["ProtectedFromScaleIn"].should.equal( - instance["InstanceId"] in protected - ) + assert instance["ProtectedFromScaleIn"] is (instance["InstanceId"] in protected) @mock_autoscaling @@ -1112,9 +1098,9 @@ def test_set_desired_capacity_up(): response = client.describe_auto_scaling_groups(AutoScalingGroupNames=["test_asg"]) instances = response["AutoScalingGroups"][0]["Instances"] - instances.should.have.length_of(10) + assert len(instances) == 10 for instance in instances: - instance["ProtectedFromScaleIn"].should.equal(True) + assert instance["ProtectedFromScaleIn"] is True @mock_autoscaling @@ -1153,10 +1139,11 @@ def test_set_desired_capacity_down(): response = client.describe_auto_scaling_groups(AutoScalingGroupNames=["test_asg"]) group = response["AutoScalingGroups"][0] - group["DesiredCapacity"].should.equal(1) + assert group["DesiredCapacity"] == 1 instance_ids = {instance["InstanceId"] for instance in group["Instances"]} - set(protected).should.equal(instance_ids) - set(unprotected).should_not.be.within(instance_ids) # only unprotected killed + assert set(protected) == instance_ids + for x in unprotected: + assert x not in instance_ids # only unprotected killed @mock_autoscaling @@ -1191,7 +1178,7 @@ def test_terminate_instance_via_ec2_in_autoscaling_group(): instance["InstanceId"] for instance in response["AutoScalingGroups"][0]["Instances"] ) - replaced_instance_id.should_not.equal(original_instance_id) + assert replaced_instance_id != original_instance_id @mock_ec2 @@ -1228,11 +1215,11 @@ def test_attach_instances(): InstanceIds=[fake_instance["InstanceId"]], AutoScalingGroupName="test_asg" ) response = asg_client.describe_auto_scaling_instances() - len(response["AutoScalingInstances"]).should.equal(1) + assert len(response["AutoScalingInstances"]) == 1 for instance in response["AutoScalingInstances"]: - instance["LaunchConfigurationName"].should.equal("test_launch_configuration") - instance["AutoScalingGroupName"].should.equal("test_asg") - instance["InstanceType"].should.equal("c4.2xlarge") + assert instance["LaunchConfigurationName"] == "test_launch_configuration" + assert instance["AutoScalingGroupName"] == "test_asg" + assert instance["InstanceType"] == "c4.2xlarge" @mock_autoscaling @@ -1261,11 +1248,11 @@ def test_autoscaling_lifecyclehook(): response = client.describe_lifecycle_hooks( AutoScalingGroupName="test_asg", LifecycleHookNames=["test-lifecyclehook"] ) - len(response["LifecycleHooks"]).should.equal(1) + assert len(response["LifecycleHooks"]) == 1 for hook in response["LifecycleHooks"]: - hook["LifecycleHookName"].should.equal("test-lifecyclehook") - hook["AutoScalingGroupName"].should.equal("test_asg") - hook["LifecycleTransition"].should.equal("autoscaling:EC2_INSTANCE_TERMINATING") + assert hook["LifecycleHookName"] == "test-lifecyclehook" + assert hook["AutoScalingGroupName"] == "test_asg" + assert hook["LifecycleTransition"] == "autoscaling:EC2_INSTANCE_TERMINATING" client.delete_lifecycle_hook( LifecycleHookName="test-lifecyclehook", AutoScalingGroupName="test_asg" @@ -1275,7 +1262,7 @@ def test_autoscaling_lifecyclehook(): AutoScalingGroupName="test_asg", LifecycleHookNames=["test-lifecyclehook"] ) - len(response["LifecycleHooks"]).should.equal(0) + assert len(response["LifecycleHooks"]) == 0 @pytest.mark.parametrize("original,new", [(2, 1), (2, 3), (1, 5), (1, 1)]) @@ -1300,18 +1287,18 @@ def test_set_desired_capacity_without_protection(original, new): ) group = client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - group["DesiredCapacity"].should.equal(original) + assert group["DesiredCapacity"] == original instances = client.describe_auto_scaling_instances()["AutoScalingInstances"] - instances.should.have.length_of(original) + assert len(instances) == original client.update_auto_scaling_group( AutoScalingGroupName="tester_group", DesiredCapacity=new ) group = client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - group["DesiredCapacity"].should.equal(new) + assert group["DesiredCapacity"] == new instances = client.describe_auto_scaling_instances()["AutoScalingInstances"] - instances.should.have.length_of(new) + assert len(instances) == new @mock_autoscaling @@ -1342,8 +1329,8 @@ def test_create_template_with_block_device(): ec2_client = boto3.client("ec2", region_name="ap-southeast-2") volumes = ec2_client.describe_volumes()["Volumes"] # The standard root volume - volumes[0]["VolumeType"].should.equal("gp2") - volumes[0]["Size"].should.equal(8) + assert volumes[0]["VolumeType"] == "gp2" + assert volumes[0]["Size"] == 8 # Our Ebs-volume - volumes[1]["VolumeType"].should.equal("gp3") - volumes[1]["Size"].should.equal(20) + assert volumes[1]["VolumeType"] == "gp3" + assert volumes[1]["Size"] == 20 diff --git a/tests/test_autoscaling/test_autoscaling_cloudformation.py b/tests/test_autoscaling/test_autoscaling_cloudformation.py index d95cee074..5eb71bdfe 100644 --- a/tests/test_autoscaling/test_autoscaling_cloudformation.py +++ b/tests/test_autoscaling/test_autoscaling_cloudformation.py @@ -1,5 +1,4 @@ import boto3 -import sure # noqa # pylint: disable=unused-import import json from moto import mock_autoscaling, mock_cloudformation, mock_ec2, mock_elb @@ -33,12 +32,12 @@ Outputs: cf_client.create_stack(StackName=stack_name, TemplateBody=cf_template) stack = cf_client.describe_stacks(StackName=stack_name)["Stacks"][0] - stack["Outputs"][0]["OutputValue"].should.be.equal("test_launch_configuration") + assert stack["Outputs"][0]["OutputValue"] == "test_launch_configuration" lc = client.describe_launch_configurations()["LaunchConfigurations"][0] - lc["LaunchConfigurationName"].should.be.equal("test_launch_configuration") - lc["ImageId"].should.be.equal(EXAMPLE_AMI_ID) - lc["InstanceType"].should.be.equal("t2.micro") + assert lc["LaunchConfigurationName"] == "test_launch_configuration" + assert lc["ImageId"] == EXAMPLE_AMI_ID + assert lc["InstanceType"] == "t2.micro" cf_template = """ Resources: @@ -57,12 +56,12 @@ Outputs: cf_client.update_stack(StackName=stack_name, TemplateBody=cf_template) stack = cf_client.describe_stacks(StackName=stack_name)["Stacks"][0] - stack["Outputs"][0]["OutputValue"].should.be.equal("test_launch_configuration") + assert stack["Outputs"][0]["OutputValue"] == "test_launch_configuration" lc = client.describe_launch_configurations()["LaunchConfigurations"][0] - lc["LaunchConfigurationName"].should.be.equal("test_launch_configuration") - lc["ImageId"].should.be.equal(EXAMPLE_AMI_ID) - lc["InstanceType"].should.be.equal("m5.large") + assert lc["LaunchConfigurationName"] == "test_launch_configuration" + assert lc["ImageId"] == EXAMPLE_AMI_ID + assert lc["InstanceType"] == "m5.large" @mock_autoscaling @@ -107,13 +106,13 @@ Outputs: Parameters=[{"ParameterKey": "SubnetId", "ParameterValue": subnet_id}], ) stack = cf_client.describe_stacks(StackName=stack_name)["Stacks"][0] - stack["Outputs"][0]["OutputValue"].should.be.equal("test_auto_scaling_group") + assert stack["Outputs"][0]["OutputValue"] == "test_auto_scaling_group" asg = client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - asg["AutoScalingGroupName"].should.be.equal("test_auto_scaling_group") - asg["MinSize"].should.be.equal(1) - asg["MaxSize"].should.be.equal(5) - asg["LaunchConfigurationName"].should.be.equal("test_launch_configuration") + assert asg["AutoScalingGroupName"] == "test_auto_scaling_group" + assert asg["MinSize"] == 1 + assert asg["MaxSize"] == 5 + assert asg["LaunchConfigurationName"] == "test_launch_configuration" client.create_launch_configuration( LaunchConfigurationName="test_launch_configuration_new", @@ -148,13 +147,13 @@ Outputs: Parameters=[{"ParameterKey": "SubnetId", "ParameterValue": subnet_id}], ) stack = cf_client.describe_stacks(StackName=stack_name)["Stacks"][0] - stack["Outputs"][0]["OutputValue"].should.be.equal("test_auto_scaling_group") + assert stack["Outputs"][0]["OutputValue"] == "test_auto_scaling_group" asg = client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - asg["AutoScalingGroupName"].should.be.equal("test_auto_scaling_group") - asg["MinSize"].should.be.equal(2) - asg["MaxSize"].should.be.equal(6) - asg["LaunchConfigurationName"].should.be.equal("test_launch_configuration_new") + assert asg["AutoScalingGroupName"] == "test_auto_scaling_group" + assert asg["MinSize"] == 2 + assert asg["MaxSize"] == 6 + assert asg["LaunchConfigurationName"] == "test_launch_configuration_new" @mock_autoscaling @@ -208,16 +207,16 @@ Outputs: ], ) stack = cf_client.describe_stacks(StackName=stack_name)["Stacks"][0] - stack["Outputs"][0]["OutputValue"].should.be.equal("test_auto_scaling_group") + assert stack["Outputs"][0]["OutputValue"] == "test_auto_scaling_group" asg = client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - asg["AutoScalingGroupName"].should.be.equal("test_auto_scaling_group") - asg["MinSize"].should.be.equal(1) - asg["MaxSize"].should.be.equal(5) + assert asg["AutoScalingGroupName"] == "test_auto_scaling_group" + assert asg["MinSize"] == 1 + assert asg["MaxSize"] == 5 lt = asg["LaunchTemplate"] - lt["LaunchTemplateId"].should.be.equal(launch_template_id) - lt["LaunchTemplateName"].should.be.equal("test_launch_template") - lt["Version"].should.be.equal("1") + assert lt["LaunchTemplateId"] == launch_template_id + assert lt["LaunchTemplateName"] == "test_launch_template" + assert lt["Version"] == "1" template_response = ec2_client.create_launch_template( LaunchTemplateName="test_launch_template_new", @@ -259,16 +258,16 @@ Outputs: ], ) stack = cf_client.describe_stacks(StackName=stack_name)["Stacks"][0] - stack["Outputs"][0]["OutputValue"].should.be.equal("test_auto_scaling_group") + assert stack["Outputs"][0]["OutputValue"] == "test_auto_scaling_group" asg = client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - asg["AutoScalingGroupName"].should.be.equal("test_auto_scaling_group") - asg["MinSize"].should.be.equal(2) - asg["MaxSize"].should.be.equal(6) + assert asg["AutoScalingGroupName"] == "test_auto_scaling_group" + assert asg["MinSize"] == 2 + assert asg["MaxSize"] == 6 lt = asg["LaunchTemplate"] - lt["LaunchTemplateId"].should.be.equal(launch_template_id) - lt["LaunchTemplateName"].should.be.equal("test_launch_template_new") - lt["Version"].should.be.equal("1") + assert lt["LaunchTemplateId"] == launch_template_id + assert lt["LaunchTemplateName"] == "test_launch_template_new" + assert lt["Version"] == "1" @mock_autoscaling @@ -356,16 +355,14 @@ def test_autoscaling_group_with_elb(): cf.create_stack(StackName="web_stack", TemplateBody=web_setup_template_json) autoscale_group = client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - autoscale_group["LaunchConfigurationName"].should.contain("my-launch-config") - autoscale_group["LoadBalancerNames"].should.equal(["my-elb"]) + assert "my-launch-config" in autoscale_group["LaunchConfigurationName"] + assert autoscale_group["LoadBalancerNames"] == ["my-elb"] # Confirm the Launch config was actually created - client.describe_launch_configurations()[ - "LaunchConfigurations" - ].should.have.length_of(1) + assert len(client.describe_launch_configurations()["LaunchConfigurations"]) == 1 # Confirm the ELB was actually created - elb.describe_load_balancers()["LoadBalancerDescriptions"].should.have.length_of(1) + assert len(elb.describe_load_balancers()["LoadBalancerDescriptions"]) == 1 resources = cf.list_stack_resources(StackName="web_stack")["StackResourceSummaries"] as_group_resource = [ @@ -373,37 +370,37 @@ def test_autoscaling_group_with_elb(): for resource in resources if resource["ResourceType"] == "AWS::AutoScaling::AutoScalingGroup" ][0] - as_group_resource["PhysicalResourceId"].should.contain("my-as-group") + assert "my-as-group" in as_group_resource["PhysicalResourceId"] launch_config_resource = [ resource for resource in resources if resource["ResourceType"] == "AWS::AutoScaling::LaunchConfiguration" ][0] - launch_config_resource["PhysicalResourceId"].should.contain("my-launch-config") + assert "my-launch-config" in launch_config_resource["PhysicalResourceId"] elb_resource = [ resource for resource in resources if resource["ResourceType"] == "AWS::ElasticLoadBalancing::LoadBalancer" ][0] - elb_resource["PhysicalResourceId"].should.contain("my-elb") + assert "my-elb" in elb_resource["PhysicalResourceId"] # confirm the instances were created with the right tags reservations = ec2.describe_instances()["Reservations"] - reservations.should.have.length_of(1) - reservations[0]["Instances"].should.have.length_of(2) + assert len(reservations) == 1 + assert len(reservations[0]["Instances"]) == 2 for instance in reservations[0]["Instances"]: tag_keys = [t["Key"] for t in instance["Tags"]] - tag_keys.should.contain("propagated-test-tag") - tag_keys.should_not.contain("not-propagated-test-tag") + assert "propagated-test-tag" in tag_keys + assert "not-propagated-test-tag" not in tag_keys # confirm scheduled scaling action was created response = client.describe_scheduled_actions( AutoScalingGroupName="test-scaling-group" )["ScheduledUpdateGroupActions"] - response.should.have.length_of(1) + assert len(response) == 1 @mock_autoscaling @@ -441,9 +438,9 @@ def test_autoscaling_group_update(): cf.create_stack(StackName="asg_stack", TemplateBody=asg_template_json) asg = client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - asg["MinSize"].should.equal(2) - asg["MaxSize"].should.equal(2) - asg["DesiredCapacity"].should.equal(2) + assert asg["MinSize"] == 2 + assert asg["MaxSize"] == 2 + assert asg["DesiredCapacity"] == 2 asg_template["Resources"]["my-as-group"]["Properties"]["MaxSize"] = 3 asg_template["Resources"]["my-as-group"]["Properties"]["Tags"] = [ @@ -461,9 +458,9 @@ def test_autoscaling_group_update(): asg_template_json = json.dumps(asg_template) cf.update_stack(StackName="asg_stack", TemplateBody=asg_template_json) asg = client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - asg["MinSize"].should.equal(2) - asg["MaxSize"].should.equal(3) - asg["DesiredCapacity"].should.equal(2) + assert asg["MinSize"] == 2 + assert asg["MaxSize"] == 3 + assert asg["DesiredCapacity"] == 2 # confirm the instances were created with the right tags reservations = ec2.describe_instances()["Reservations"] @@ -472,9 +469,10 @@ def test_autoscaling_group_update(): for instance in res["Instances"]: if instance["State"]["Name"] == "running": running_instance_count += 1 - instance["Tags"].should.contain( - {"Key": "propagated-test-tag", "Value": "propagated-test-tag-value"} - ) + assert { + "Key": "propagated-test-tag", + "Value": "propagated-test-tag-value", + } in instance["Tags"] tag_keys = [t["Key"] for t in instance["Tags"]] - tag_keys.should_not.contain("not-propagated-test-tag") - running_instance_count.should.equal(2) + assert "not-propagated-test-tag" not in tag_keys + assert running_instance_count == 2 diff --git a/tests/test_autoscaling/test_autoscaling_groups.py b/tests/test_autoscaling/test_autoscaling_groups.py index db0e535b2..7c6b78e3e 100644 --- a/tests/test_autoscaling/test_autoscaling_groups.py +++ b/tests/test_autoscaling/test_autoscaling_groups.py @@ -1,5 +1,4 @@ import boto3 -import sure # noqa # pylint: disable=unused-import from moto import mock_autoscaling from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID @@ -27,22 +26,22 @@ class TestAutoScalingGroup(TestCase): self._create_group(name="tester_group") group = self.as_client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - group["AutoScalingGroupName"].should.equal("tester_group") - group["MaxSize"].should.equal(2) - group["MinSize"].should.equal(1) - group["LaunchConfigurationName"].should.equal(self.lc_name) + assert group["AutoScalingGroupName"] == "tester_group" + assert group["MaxSize"] == 2 + assert group["MinSize"] == 1 + assert group["LaunchConfigurationName"] == self.lc_name # Defaults - group["AvailabilityZones"].should.equal(["us-east-1a"]) # subnet1 - group["DesiredCapacity"].should.equal(1) - group["VPCZoneIdentifier"].should.equal(self.mocked_networking["subnet1"]) - group["DefaultCooldown"].should.equal(300) - group["HealthCheckGracePeriod"].should.equal(300) - group["HealthCheckType"].should.equal("EC2") - group["LoadBalancerNames"].should.equal([]) - group.shouldnt.have.key("PlacementGroup") - group["TerminationPolicies"].should.equal(["Default"]) - group["Tags"].should.equal([]) + assert group["AvailabilityZones"] == ["us-east-1a"] # subnet1 + assert group["DesiredCapacity"] == 1 + assert group["VPCZoneIdentifier"] == self.mocked_networking["subnet1"] + assert group["DefaultCooldown"] == 300 + assert group["HealthCheckGracePeriod"] == 300 + assert group["HealthCheckType"] == "EC2" + assert group["LoadBalancerNames"] == [] + assert "PlacementGroup" not in group + assert group["TerminationPolicies"] == ["Default"] + assert group["Tags"] == [] def test_create_autoscaling_group__additional_params(self): self.as_client.create_auto_scaling_group( @@ -55,36 +54,35 @@ class TestAutoScalingGroup(TestCase): ) group = self.as_client.describe_auto_scaling_groups()["AutoScalingGroups"][0] - group["AutoScalingGroupName"].should.equal("tester_group") - group["CapacityRebalance"].should.equal(True) + assert group["AutoScalingGroupName"] == "tester_group" + assert group["CapacityRebalance"] is True def test_list_many_autoscaling_groups(self): - for i in range(51): self._create_group(f"TestGroup{i}") response = self.as_client.describe_auto_scaling_groups() groups = response["AutoScalingGroups"] marker = response["NextToken"] - groups.should.have.length_of(50) - marker.should.equal(groups[-1]["AutoScalingGroupName"]) + assert len(groups) == 50 + assert marker == groups[-1]["AutoScalingGroupName"] response2 = self.as_client.describe_auto_scaling_groups(NextToken=marker) groups.extend(response2["AutoScalingGroups"]) - groups.should.have.length_of(51) + assert len(groups) == 51 assert "NextToken" not in response2.keys() def test_autoscaling_group_delete(self): self._create_group(name="tester_group") groups = self.as_client.describe_auto_scaling_groups()["AutoScalingGroups"] - groups.should.have.length_of(1) + assert len(groups) == 1 self.as_client.delete_auto_scaling_group(AutoScalingGroupName="tester_group") groups = self.as_client.describe_auto_scaling_groups()["AutoScalingGroups"] - groups.should.have.length_of(0) + assert len(groups) == 0 def test_describe_autoscaling_groups__instances(self): self._create_group(name="test_asg") @@ -92,21 +90,22 @@ class TestAutoScalingGroup(TestCase): response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=["test_asg"] ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 group = response["AutoScalingGroups"][0] - group["AutoScalingGroupARN"].should.match( + assert ( f"arn:aws:autoscaling:us-east-1:{ACCOUNT_ID}:autoScalingGroup:" + in group["AutoScalingGroupARN"] ) - group["AutoScalingGroupName"].should.equal("test_asg") - group["LaunchConfigurationName"].should.equal(self.lc_name) - group.should_not.have.key("LaunchTemplate") - group["AvailabilityZones"].should.equal(["us-east-1a"]) - group["VPCZoneIdentifier"].should.equal(self.mocked_networking["subnet1"]) + assert group["AutoScalingGroupName"] == "test_asg" + assert group["LaunchConfigurationName"] == self.lc_name + assert "LaunchTemplate" not in group + assert group["AvailabilityZones"] == ["us-east-1a"] + assert group["VPCZoneIdentifier"] == self.mocked_networking["subnet1"] for instance in group["Instances"]: - instance["LaunchConfigurationName"].should.equal(self.lc_name) - instance.should_not.have.key("LaunchTemplate") - instance["AvailabilityZone"].should.equal("us-east-1a") - instance["InstanceType"].should.equal("t2.medium") + assert instance["LaunchConfigurationName"] == self.lc_name + assert "LaunchTemplate" not in instance + assert instance["AvailabilityZone"] == "us-east-1a" + assert instance["InstanceType"] == "t2.medium" def test_set_instance_health(self): self._create_group(name="test_asg") @@ -116,7 +115,7 @@ class TestAutoScalingGroup(TestCase): ) instance1 = response["AutoScalingGroups"][0]["Instances"][0] - instance1["HealthStatus"].should.equal("Healthy") + assert instance1["HealthStatus"] == "Healthy" self.as_client.set_instance_health( InstanceId=instance1["InstanceId"], HealthStatus="Unhealthy" @@ -127,7 +126,7 @@ class TestAutoScalingGroup(TestCase): ) instance1 = response["AutoScalingGroups"][0]["Instances"][0] - instance1["HealthStatus"].should.equal("Unhealthy") + assert instance1["HealthStatus"] == "Unhealthy" def test_suspend_processes(self): self._create_group(name="test-asg") @@ -175,7 +174,7 @@ class TestAutoScalingGroup(TestCase): proc["ProcessName"] for proc in res["AutoScalingGroups"][0]["SuspendedProcesses"] ] - set(suspended_proc_names).should.equal(set(all_proc_names)) + assert set(suspended_proc_names) == set(all_proc_names) def test_suspend_additional_processes(self): self._create_group(name="test-asg") @@ -224,8 +223,9 @@ class TestAutoScalingGroup(TestCase): expected_suspended_processes = [ {"ProcessName": "Terminate", "SuspensionReason": ""} ] - res["AutoScalingGroups"][0]["SuspendedProcesses"].should.equal( - expected_suspended_processes + assert ( + res["AutoScalingGroups"][0]["SuspendedProcesses"] + == expected_suspended_processes ) def test_resume_processes_all_by_default(self): @@ -243,7 +243,7 @@ class TestAutoScalingGroup(TestCase): ) # No processes should be suspended - res["AutoScalingGroups"][0]["SuspendedProcesses"].should.equal([]) + assert res["AutoScalingGroups"][0]["SuspendedProcesses"] == [] def _create_group(self, name): self.as_client.create_auto_scaling_group( diff --git a/tests/test_autoscaling/test_autoscaling_metrics.py b/tests/test_autoscaling/test_autoscaling_metrics.py index 83f1809cf..58dcfc5e3 100644 --- a/tests/test_autoscaling/test_autoscaling_metrics.py +++ b/tests/test_autoscaling/test_autoscaling_metrics.py @@ -1,5 +1,4 @@ import boto3 -import sure # noqa # pylint: disable=unused-import from moto import mock_autoscaling, mock_elb, mock_ec2 @@ -43,7 +42,8 @@ def test_enable_metrics_collection(): resp = as_client.describe_auto_scaling_groups( AutoScalingGroupNames=["tester_group"] )["AutoScalingGroups"][0] - resp.should.have.key("EnabledMetrics").length_of(1) - resp["EnabledMetrics"][0].should.equal( - {"Metric": "GroupMinSize", "Granularity": "1Minute"} - ) + assert len(resp["EnabledMetrics"]) == 1 + assert resp["EnabledMetrics"][0] == { + "Metric": "GroupMinSize", + "Granularity": "1Minute", + } diff --git a/tests/test_autoscaling/test_autoscaling_scheduledactions.py b/tests/test_autoscaling/test_autoscaling_scheduledactions.py index 372faf47c..787b81b1e 100644 --- a/tests/test_autoscaling/test_autoscaling_scheduledactions.py +++ b/tests/test_autoscaling/test_autoscaling_scheduledactions.py @@ -1,5 +1,4 @@ import boto3 -import sure # noqa # pylint: disable=unused-import from moto import mock_autoscaling from unittest import TestCase @@ -19,7 +18,7 @@ class TestAutoScalingScheduledActions(TestCase): AutoScalingGroupName=self.asg_name ) actions = response["ScheduledUpdateGroupActions"] - actions.should.have.length_of(30) + assert len(actions) == 30 def test_non_existing_group_name(self): self._create_scheduled_action(name="my-scheduled-action", idx=1) @@ -29,7 +28,7 @@ class TestAutoScalingScheduledActions(TestCase): ) actions = response["ScheduledUpdateGroupActions"] # since there is no such group name, no actions have been returned - actions.should.have.length_of(0) + assert len(actions) == 0 def test_describe_scheduled_actions_returns_all_actions_when_no_argument_is_passed( self, @@ -46,7 +45,7 @@ class TestAutoScalingScheduledActions(TestCase): actions = response["ScheduledUpdateGroupActions"] # Since no argument is passed describe_scheduled_actions, all scheduled actions are returned - actions.should.have.length_of(40) + assert len(actions) == 40 def test_scheduled_action_delete(self): for i in range(3): @@ -56,7 +55,7 @@ class TestAutoScalingScheduledActions(TestCase): AutoScalingGroupName=self.asg_name ) actions = response["ScheduledUpdateGroupActions"] - actions.should.have.length_of(3) + assert len(actions) == 3 self.client.delete_scheduled_action( AutoScalingGroupName=self.asg_name, @@ -70,7 +69,7 @@ class TestAutoScalingScheduledActions(TestCase): AutoScalingGroupName=self.asg_name ) actions = response["ScheduledUpdateGroupActions"] - actions.should.have.length_of(1) + assert len(actions) == 1 def _create_scheduled_action(self, name, idx, asg_name=None): self.client.put_scheduled_update_group_action( diff --git a/tests/test_autoscaling/test_autoscaling_tags.py b/tests/test_autoscaling/test_autoscaling_tags.py index f61bee361..69cb07cb0 100644 --- a/tests/test_autoscaling/test_autoscaling_tags.py +++ b/tests/test_autoscaling/test_autoscaling_tags.py @@ -50,7 +50,7 @@ def test_autoscaling_tags_update(): ) response = client.describe_auto_scaling_groups(AutoScalingGroupNames=["test_asg"]) - response["AutoScalingGroups"][0]["Tags"].should.have.length_of(2) + assert len(response["AutoScalingGroups"][0]["Tags"]) == 2 @mock_autoscaling @@ -101,16 +101,16 @@ def test_delete_tags_by_key(): ) group = response["AutoScalingGroups"][0] tags = group["Tags"] - tags.should.contain(tag_to_keep) - tags.should_not.contain(tag_to_delete) + assert tag_to_keep in tags + assert tag_to_delete not in tags @mock_autoscaling def test_describe_tags_without_resources(): client = boto3.client("autoscaling", region_name="us-east-2") resp = client.describe_tags() - resp.should.have.key("Tags").equals([]) - resp.shouldnt.have.key("NextToken") + assert resp["Tags"] == [] + assert "NextToken" not in resp @mock_autoscaling @@ -120,43 +120,35 @@ def test_describe_tags_no_filter(): create_asgs(client, subnet) response = client.describe_tags() - response.should.have.key("Tags").length_of(4) - response["Tags"].should.contain( - { - "ResourceId": "test_asg", - "ResourceType": "auto-scaling-group", - "Key": "test_key", - "Value": "updated_test_value", - "PropagateAtLaunch": True, - } - ) - response["Tags"].should.contain( - { - "ResourceId": "test_asg", - "ResourceType": "auto-scaling-group", - "Key": "test_key2", - "Value": "test_value2", - "PropagateAtLaunch": False, - } - ) - response["Tags"].should.contain( - { - "ResourceId": "test_asg2", - "ResourceType": "auto-scaling-group", - "Key": "asg2tag1", - "Value": "val", - "PropagateAtLaunch": False, - } - ) - response["Tags"].should.contain( - { - "ResourceId": "test_asg2", - "ResourceType": "auto-scaling-group", - "Key": "asg2tag2", - "Value": "diff", - "PropagateAtLaunch": False, - } - ) + len(response["Tags"]) == 4 + assert { + "ResourceId": "test_asg", + "ResourceType": "auto-scaling-group", + "Key": "test_key", + "Value": "updated_test_value", + "PropagateAtLaunch": True, + } in response["Tags"] + assert { + "ResourceId": "test_asg", + "ResourceType": "auto-scaling-group", + "Key": "test_key2", + "Value": "test_value2", + "PropagateAtLaunch": False, + } in response["Tags"] + assert { + "ResourceId": "test_asg2", + "ResourceType": "auto-scaling-group", + "Key": "asg2tag1", + "Value": "val", + "PropagateAtLaunch": False, + } in response["Tags"] + assert { + "ResourceId": "test_asg2", + "ResourceType": "auto-scaling-group", + "Key": "asg2tag2", + "Value": "diff", + "PropagateAtLaunch": False, + } in response["Tags"] @mock_autoscaling @@ -168,66 +160,54 @@ def test_describe_tags_filter_by_name(): response = client.describe_tags( Filters=[{"Name": "auto-scaling-group", "Values": ["test_asg"]}] ) - response.should.have.key("Tags").length_of(2) - response["Tags"].should.contain( - { - "ResourceId": "test_asg", - "ResourceType": "auto-scaling-group", - "Key": "test_key", - "Value": "updated_test_value", - "PropagateAtLaunch": True, - } - ) - response["Tags"].should.contain( - { - "ResourceId": "test_asg", - "ResourceType": "auto-scaling-group", - "Key": "test_key2", - "Value": "test_value2", - "PropagateAtLaunch": False, - } - ) + assert len(response["Tags"]) == 2 + assert { + "ResourceId": "test_asg", + "ResourceType": "auto-scaling-group", + "Key": "test_key", + "Value": "updated_test_value", + "PropagateAtLaunch": True, + } in response["Tags"] + assert { + "ResourceId": "test_asg", + "ResourceType": "auto-scaling-group", + "Key": "test_key2", + "Value": "test_value2", + "PropagateAtLaunch": False, + } in response["Tags"] response = client.describe_tags( Filters=[{"Name": "auto-scaling-group", "Values": ["test_asg", "test_asg2"]}] ) - response.should.have.key("Tags").length_of(4) - response["Tags"].should.contain( - { - "ResourceId": "test_asg", - "ResourceType": "auto-scaling-group", - "Key": "test_key", - "Value": "updated_test_value", - "PropagateAtLaunch": True, - } - ) - response["Tags"].should.contain( - { - "ResourceId": "test_asg", - "ResourceType": "auto-scaling-group", - "Key": "test_key2", - "Value": "test_value2", - "PropagateAtLaunch": False, - } - ) - response["Tags"].should.contain( - { - "ResourceId": "test_asg2", - "ResourceType": "auto-scaling-group", - "Key": "asg2tag1", - "Value": "val", - "PropagateAtLaunch": False, - } - ) - response["Tags"].should.contain( - { - "ResourceId": "test_asg2", - "ResourceType": "auto-scaling-group", - "Key": "asg2tag2", - "Value": "diff", - "PropagateAtLaunch": False, - } - ) + assert len(response["Tags"]) == 4 + assert { + "ResourceId": "test_asg", + "ResourceType": "auto-scaling-group", + "Key": "test_key", + "Value": "updated_test_value", + "PropagateAtLaunch": True, + } in response["Tags"] + assert { + "ResourceId": "test_asg", + "ResourceType": "auto-scaling-group", + "Key": "test_key2", + "Value": "test_value2", + "PropagateAtLaunch": False, + } in response["Tags"] + assert { + "ResourceId": "test_asg2", + "ResourceType": "auto-scaling-group", + "Key": "asg2tag1", + "Value": "val", + "PropagateAtLaunch": False, + } in response["Tags"] + assert { + "ResourceId": "test_asg2", + "ResourceType": "auto-scaling-group", + "Key": "asg2tag2", + "Value": "diff", + "PropagateAtLaunch": False, + } in response["Tags"] @mock_autoscaling @@ -239,8 +219,8 @@ def test_describe_tags_filter_by_propgateatlaunch(): response = client.describe_tags( Filters=[{"Name": "propagate-at-launch", "Values": ["True"]}] ) - response.should.have.key("Tags").length_of(1) - response["Tags"].should.contain( + len(response["Tags"]) == 1 + assert response["Tags"] == [ { "ResourceId": "test_asg", "ResourceType": "auto-scaling-group", @@ -248,7 +228,7 @@ def test_describe_tags_filter_by_propgateatlaunch(): "Value": "updated_test_value", "PropagateAtLaunch": True, } - ) + ] def create_asgs(client, subnet): diff --git a/tests/test_autoscaling/test_elb.py b/tests/test_autoscaling/test_elb.py index 268ac21a1..ca0d16a1f 100644 --- a/tests/test_autoscaling/test_elb.py +++ b/tests/test_autoscaling/test_elb.py @@ -1,5 +1,4 @@ import boto3 -import sure # noqa # pylint: disable=unused-import from moto import mock_autoscaling, mock_elb, mock_ec2 from .utils import setup_networking @@ -57,8 +56,8 @@ class TestAutoScalingELB(TestCase): AutoScalingGroupName=self.asg_name ) assert response["ResponseMetadata"]["RequestId"] - list(response["LoadBalancers"]).should.have.length_of(1) - response["LoadBalancers"][0]["LoadBalancerName"].should.equal(self.lb_name) + assert len(list(response["LoadBalancers"])) == 1 + assert response["LoadBalancers"][0]["LoadBalancerName"] == self.lb_name def test_create_elb_and_autoscaling_group_no_relationship(self): self.as_client.create_auto_scaling_group( @@ -74,13 +73,11 @@ class TestAutoScalingELB(TestCase): response = self.as_client.describe_load_balancers( AutoScalingGroupName=self.asg_name ) - list(response["LoadBalancers"]).should.have.length_of(0) + assert len(list(response["LoadBalancers"])) == 0 response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(0) + assert len(list(response["LoadBalancerDescriptions"][0]["Instances"])) == 0 def test_attach_load_balancer(self): self.as_client.create_auto_scaling_group( @@ -103,21 +100,20 @@ class TestAutoScalingELB(TestCase): response = self.as_client.attach_load_balancers( AutoScalingGroupName=self.asg_name, LoadBalancerNames=[self.lb_name] ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(self.instance_count) + assert ( + len(list(response["LoadBalancerDescriptions"][0]["Instances"])) + == self.instance_count + ) response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - list( - response["AutoScalingGroups"][0]["LoadBalancerNames"] - ).should.have.length_of(1) + assert len(list(response["AutoScalingGroups"][0]["LoadBalancerNames"])) == 1 def test_detach_load_balancer(self): self.as_client.create_auto_scaling_group( @@ -141,19 +137,17 @@ class TestAutoScalingELB(TestCase): response = self.as_client.detach_load_balancers( AutoScalingGroupName=self.asg_name, LoadBalancerNames=[self.lb_name] ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(0) + assert len(list(response["LoadBalancerDescriptions"][0]["Instances"])) == 0 response = self.as_client.describe_load_balancers( AutoScalingGroupName=self.asg_name ) - list(response["LoadBalancers"]).should.have.length_of(0) + assert len(list(response["LoadBalancers"])) == 0 def test_create_autoscaling_group_within_elb(self): # we attach a couple of machines to the load balancer @@ -221,53 +215,53 @@ class TestAutoScalingELB(TestCase): AutoScalingGroupNames=[self.asg_name] ) group = resp["AutoScalingGroups"][0] - group["AutoScalingGroupName"].should.equal(self.asg_name) - set(group["AvailabilityZones"]).should.equal(set(["us-east-1a", "us-east-1b"])) - group["DesiredCapacity"].should.equal(2) - group["MaxSize"].should.equal(INSTANCE_COUNT_GROUP) - group["MinSize"].should.equal(INSTANCE_COUNT_GROUP) - group["Instances"].should.have.length_of(INSTANCE_COUNT_GROUP) - group["VPCZoneIdentifier"].should.equal( - f"{self.mocked_networking['subnet1']},{self.mocked_networking['subnet2']}" + assert group["AutoScalingGroupName"] == self.asg_name + assert set(group["AvailabilityZones"]) == set(["us-east-1a", "us-east-1b"]) + assert group["DesiredCapacity"] == 2 + assert group["MaxSize"] == INSTANCE_COUNT_GROUP + assert group["MinSize"] == INSTANCE_COUNT_GROUP + assert len(group["Instances"]) == INSTANCE_COUNT_GROUP + assert ( + group["VPCZoneIdentifier"] + == f"{self.mocked_networking['subnet1']},{self.mocked_networking['subnet2']}" ) - group["LaunchConfigurationName"].should.equal(self.lc_name) - group["DefaultCooldown"].should.equal(60) - group["HealthCheckGracePeriod"].should.equal(100) - group["HealthCheckType"].should.equal("EC2") - group["LoadBalancerNames"].should.equal([self.lb_name]) - group["PlacementGroup"].should.equal("test_placement") - list(group["TerminationPolicies"]).should.equal( - ["OldestInstance", "NewestInstance"] - ) - list(group["Tags"]).should.have.length_of(1) + assert group["LaunchConfigurationName"] == self.lc_name + assert group["DefaultCooldown"] == 60 + assert group["HealthCheckGracePeriod"] == 100 + assert group["HealthCheckType"] == "EC2" + assert group["LoadBalancerNames"] == [self.lb_name] + assert group["PlacementGroup"] == "test_placement" + assert list(group["TerminationPolicies"]) == [ + "OldestInstance", + "NewestInstance", + ] + assert len(list(group["Tags"])) == 1 tag = group["Tags"][0] - tag["ResourceId"].should.equal(self.asg_name) - tag["Key"].should.equal("test_key") - tag["Value"].should.equal("test_value") - tag["PropagateAtLaunch"].should.equal(True) + assert tag["ResourceId"] == self.asg_name + assert tag["Key"] == "test_key" + assert tag["Value"] == "test_value" + assert tag["PropagateAtLaunch"] is True instances_attached = self.elb_client.describe_instance_health( LoadBalancerName=self.lb_name )["InstanceStates"] - instances_attached.should.have.length_of( - INSTANCE_COUNT_START + INSTANCE_COUNT_GROUP - ) + assert len(instances_attached) == INSTANCE_COUNT_START + INSTANCE_COUNT_GROUP attached_ids = [i["InstanceId"] for i in instances_attached] for ec2_instance_id in instances_ids: - attached_ids.should.contain(ec2_instance_id) + assert ec2_instance_id in attached_ids scheduled_actions = self.as_client.describe_scheduled_actions( AutoScalingGroupName=self.asg_name ) scheduled_action_1 = scheduled_actions["ScheduledUpdateGroupActions"][0] - scheduled_action_1["AutoScalingGroupName"].should.equal(self.asg_name) - scheduled_action_1["DesiredCapacity"].should.equal(9) - scheduled_action_1["MaxSize"].should.equal(12) - scheduled_action_1["MinSize"].should.equal(5) - scheduled_action_1.should.contain("StartTime") - scheduled_action_1.should.contain("EndTime") - scheduled_action_1["Recurrence"].should.equal("* * * * *") - scheduled_action_1["ScheduledActionName"].should.equal("my-scheduled-action") + assert scheduled_action_1["AutoScalingGroupName"] == self.asg_name + assert scheduled_action_1["DesiredCapacity"] == 9 + assert scheduled_action_1["MaxSize"] == 12 + assert scheduled_action_1["MinSize"] == 5 + assert "StartTime" in scheduled_action_1 + assert "EndTime" in scheduled_action_1 + assert scheduled_action_1["Recurrence"] == "* * * * *" + assert scheduled_action_1["ScheduledActionName"] == "my-scheduled-action" @mock_autoscaling @@ -316,7 +310,7 @@ class TestAutoScalingInstances(TestCase): response = self.as_client.attach_load_balancers( AutoScalingGroupName=self.asg_name, LoadBalancerNames=[self.lb_name] ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 def test_detach_one_instance_decrement(self): response = self.as_client.describe_auto_scaling_groups( @@ -336,38 +330,34 @@ class TestAutoScalingInstances(TestCase): InstanceIds=[instance_to_detach], ShouldDecrementDesiredCapacity=True, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(1) - instance_to_detach.shouldnt.be.within( - [x["InstanceId"] for x in response["AutoScalingGroups"][0]["Instances"]] - ) + assert len(response["AutoScalingGroups"][0]["Instances"]) == 1 + assert instance_to_detach not in [ + x["InstanceId"] for x in response["AutoScalingGroups"][0]["Instances"] + ] # test to ensure tag has been removed response = ec2_client.describe_instances(InstanceIds=[instance_to_detach]) tags = response["Reservations"][0]["Instances"][0]["Tags"] - tags.should.have.length_of(1) + assert len(tags) == 1 # test to ensure tag is present on other instance response = ec2_client.describe_instances(InstanceIds=[instance_to_keep]) tags = response["Reservations"][0]["Instances"][0]["Tags"] - tags.should.have.length_of(2) + assert len(tags) == 2 response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(1) - instance_to_detach.shouldnt.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(list(response["LoadBalancerDescriptions"][0]["Instances"])) == 1 + assert instance_to_detach not in [ + x["InstanceId"] + for x in response["LoadBalancerDescriptions"][0]["Instances"] + ] def test_detach_one_instance(self): response = self.as_client.describe_auto_scaling_groups( @@ -387,34 +377,30 @@ class TestAutoScalingInstances(TestCase): InstanceIds=[instance_to_detach], ShouldDecrementDesiredCapacity=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) # test to ensure instance was replaced - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(2) + assert len(response["AutoScalingGroups"][0]["Instances"]) == 2 response = ec2_client.describe_instances(InstanceIds=[instance_to_detach]) tags = response["Reservations"][0]["Instances"][0]["Tags"] - tags.should.have.length_of(1) + assert len(tags) == 1 response = ec2_client.describe_instances(InstanceIds=[instance_to_keep]) tags = response["Reservations"][0]["Instances"][0]["Tags"] - tags.should.have.length_of(2) + assert len(tags) == 2 response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(2) - instance_to_detach.shouldnt.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(list(response["LoadBalancerDescriptions"][0]["Instances"])) == 2 + assert instance_to_detach not in [ + x["InstanceId"] + for x in response["LoadBalancerDescriptions"][0]["Instances"] + ] def test_standby_one_instance_decrement(self): response = self.as_client.describe_auto_scaling_groups( @@ -431,38 +417,32 @@ class TestAutoScalingInstances(TestCase): InstanceIds=[instance_to_standby], ShouldDecrementDesiredCapacity=True, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(2) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(1) + assert len(response["AutoScalingGroups"][0]["Instances"]) == 2 + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 1 response = self.as_client.describe_auto_scaling_instances( InstanceIds=[instance_to_standby] ) - response["AutoScalingInstances"][0]["LifecycleState"].should.equal("Standby") + assert response["AutoScalingInstances"][0]["LifecycleState"] == "Standby" # test to ensure tag has been retained (standby instance is still part of the ASG) response = ec2_client.describe_instances(InstanceIds=[instance_to_standby]) for reservation in response["Reservations"]: for instance in reservation["Instances"]: tags = instance["Tags"] - tags.should.have.length_of(2) + assert len(tags) == 2 response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(1) - instance_to_standby.shouldnt.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(response["LoadBalancerDescriptions"][0]["Instances"]) == 1 + for x in response["LoadBalancerDescriptions"][0]["Instances"]: + assert x["InstanceId"] not in instance_to_standby def test_standby_one_instance(self): response = self.as_client.describe_auto_scaling_groups( @@ -479,38 +459,32 @@ class TestAutoScalingInstances(TestCase): InstanceIds=[instance_to_standby], ShouldDecrementDesiredCapacity=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(3) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(2) + assert len(response["AutoScalingGroups"][0]["Instances"]) == 3 + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 2 response = self.as_client.describe_auto_scaling_instances( InstanceIds=[instance_to_standby] ) - response["AutoScalingInstances"][0]["LifecycleState"].should.equal("Standby") + assert response["AutoScalingInstances"][0]["LifecycleState"] == "Standby" # test to ensure tag has been retained (standby instance is still part of the ASG) response = ec2_client.describe_instances(InstanceIds=[instance_to_standby]) for reservation in response["Reservations"]: for instance in reservation["Instances"]: tags = instance["Tags"] - tags.should.have.length_of(2) + assert len(tags) == 2 response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(2) - instance_to_standby.shouldnt.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(response["LoadBalancerDescriptions"][0]["Instances"]) == 2 + for x in response["LoadBalancerDescriptions"][0]["Instances"]: + assert x["InstanceId"] not in instance_to_standby def test_standby_elb_update(self): response = self.as_client.describe_auto_scaling_groups( @@ -525,31 +499,25 @@ class TestAutoScalingInstances(TestCase): InstanceIds=[instance_to_standby], ShouldDecrementDesiredCapacity=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(3) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(2) + assert len(response["AutoScalingGroups"][0]["Instances"]) == 3 + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 2 response = self.as_client.describe_auto_scaling_instances( InstanceIds=[instance_to_standby] ) - response["AutoScalingInstances"][0]["LifecycleState"].should.equal("Standby") + assert response["AutoScalingInstances"][0]["LifecycleState"] == "Standby" response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(2) - instance_to_standby.shouldnt.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(response["LoadBalancerDescriptions"][0]["Instances"]) == 2 + for x in response["LoadBalancerDescriptions"][0]["Instances"]: + assert x["InstanceId"] not in instance_to_standby def test_standby_terminate_instance_decrement(self): response = self.as_client.describe_auto_scaling_groups( @@ -566,54 +534,49 @@ class TestAutoScalingInstances(TestCase): InstanceIds=[instance_to_standby_terminate], ShouldDecrementDesiredCapacity=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(3) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(2) + assert len(response["AutoScalingGroups"][0]["Instances"]) == 3 + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 2 response = self.as_client.describe_auto_scaling_instances( InstanceIds=[instance_to_standby_terminate] ) - response["AutoScalingInstances"][0]["LifecycleState"].should.equal("Standby") + assert response["AutoScalingInstances"][0]["LifecycleState"] == "Standby" response = self.as_client.terminate_instance_in_auto_scaling_group( InstanceId=instance_to_standby_terminate, ShouldDecrementDesiredCapacity=True, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 # AWS still decrements desired capacity ASG if requested, even if the terminated instance is in standby response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(1) - response["AutoScalingGroups"][0]["Instances"][0]["InstanceId"].should_not.equal( - instance_to_standby_terminate + assert len(response["AutoScalingGroups"][0]["Instances"]) == 1 + assert ( + response["AutoScalingGroups"][0]["Instances"][0]["InstanceId"] + != instance_to_standby_terminate ) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(1) + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 1 response = ec2_client.describe_instances( InstanceIds=[instance_to_standby_terminate] ) - response["Reservations"][0]["Instances"][0]["State"]["Name"].should.equal( - "terminated" + assert ( + response["Reservations"][0]["Instances"][0]["State"]["Name"] == "terminated" ) response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(1) - instance_to_standby_terminate.shouldnt.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(list(response["LoadBalancerDescriptions"][0]["Instances"])) == 1 + for x in response["LoadBalancerDescriptions"][0]["Instances"]: + assert x["InstanceId"] not in instance_to_standby_terminate def test_standby_terminate_instance_no_decrement(self): response = self.as_client.describe_auto_scaling_groups( @@ -630,54 +593,48 @@ class TestAutoScalingInstances(TestCase): InstanceIds=[instance_to_standby_terminate], ShouldDecrementDesiredCapacity=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(3) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(2) + assert len(response["AutoScalingGroups"][0]["Instances"]) == 3 + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 2 response = self.as_client.describe_auto_scaling_instances( InstanceIds=[instance_to_standby_terminate] ) - response["AutoScalingInstances"][0]["LifecycleState"].should.equal("Standby") + assert response["AutoScalingInstances"][0]["LifecycleState"] == "Standby" response = self.as_client.terminate_instance_in_auto_scaling_group( InstanceId=instance_to_standby_terminate, ShouldDecrementDesiredCapacity=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) group = response["AutoScalingGroups"][0] - group["Instances"].should.have.length_of(2) - instance_to_standby_terminate.shouldnt.be.within( - [x["InstanceId"] for x in group["Instances"]] - ) - group["DesiredCapacity"].should.equal(2) + assert len(group["Instances"]) == 2 + assert instance_to_standby_terminate not in [ + x["InstanceId"] for x in group["Instances"] + ] + assert group["DesiredCapacity"] == 2 response = ec2_client.describe_instances( InstanceIds=[instance_to_standby_terminate] ) - response["Reservations"][0]["Instances"][0]["State"]["Name"].should.equal( - "terminated" + assert ( + response["Reservations"][0]["Instances"][0]["State"]["Name"] == "terminated" ) response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(2) - instance_to_standby_terminate.shouldnt.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(response["LoadBalancerDescriptions"][0]["Instances"]) == 2 + for x in response["LoadBalancerDescriptions"][0]["Instances"]: + assert x["InstanceId"] not in instance_to_standby_terminate def test_standby_detach_instance_decrement(self): response = self.as_client.describe_auto_scaling_groups( @@ -694,55 +651,45 @@ class TestAutoScalingInstances(TestCase): InstanceIds=[instance_to_standby_detach], ShouldDecrementDesiredCapacity=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(3) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(2) + assert len(response["AutoScalingGroups"][0]["Instances"]) == 3 + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 2 response = self.as_client.describe_auto_scaling_instances( InstanceIds=[instance_to_standby_detach] ) - response["AutoScalingInstances"][0]["LifecycleState"].should.equal("Standby") + assert response["AutoScalingInstances"][0]["LifecycleState"] == "Standby" response = self.as_client.detach_instances( AutoScalingGroupName=self.asg_name, InstanceIds=[instance_to_standby_detach], ShouldDecrementDesiredCapacity=True, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 # AWS still decrements desired capacity ASG if requested, even if the detached instance was in standby - response = self.as_client.describe_auto_scaling_groups( + group = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] - ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(1) - response["AutoScalingGroups"][0]["Instances"][0]["InstanceId"].should_not.equal( - instance_to_standby_detach - ) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(1) + )["AutoScalingGroups"][0] + assert len(group["Instances"]) == 1 + assert group["Instances"][0]["InstanceId"] != instance_to_standby_detach + assert group["DesiredCapacity"] == 1 - response = ec2_client.describe_instances( + instance = ec2_client.describe_instances( InstanceIds=[instance_to_standby_detach] - ) - response["Reservations"][0]["Instances"][0]["State"]["Name"].should.equal( - "running" - ) + )["Reservations"][0]["Instances"][0] + assert instance["State"]["Name"] == "running" response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(1) - instance_to_standby_detach.shouldnt.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(response["LoadBalancerDescriptions"][0]["Instances"]) == 1 + for x in response["LoadBalancerDescriptions"][0]["Instances"]: + assert x["InstanceId"] not in instance_to_standby_detach def test_standby_detach_instance_no_decrement(self): response = self.as_client.describe_auto_scaling_groups( @@ -759,55 +706,47 @@ class TestAutoScalingInstances(TestCase): InstanceIds=[instance_to_standby_detach], ShouldDecrementDesiredCapacity=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(3) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(2) + assert len(response["AutoScalingGroups"][0]["Instances"]) == 3 + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 2 response = self.as_client.describe_auto_scaling_instances( InstanceIds=[instance_to_standby_detach] ) - response["AutoScalingInstances"][0]["LifecycleState"].should.equal("Standby") + assert response["AutoScalingInstances"][0]["LifecycleState"] == "Standby" response = self.as_client.detach_instances( AutoScalingGroupName=self.asg_name, InstanceIds=[instance_to_standby_detach], ShouldDecrementDesiredCapacity=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) group = response["AutoScalingGroups"][0] - group["Instances"].should.have.length_of(2) - instance_to_standby_detach.shouldnt.be.within( - [x["InstanceId"] for x in group["Instances"]] - ) - group["DesiredCapacity"].should.equal(2) + assert len(group["Instances"]) == 2 + assert instance_to_standby_detach not in [ + x["InstanceId"] for x in group["Instances"] + ] + assert group["DesiredCapacity"] == 2 - response = ec2_client.describe_instances( + instance = ec2_client.describe_instances( InstanceIds=[instance_to_standby_detach] - ) - response["Reservations"][0]["Instances"][0]["State"]["Name"].should.equal( - "running" - ) + )["Reservations"][0]["Instances"][0] + assert instance["State"]["Name"] == "running" response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(2) - instance_to_standby_detach.shouldnt.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(list(response["LoadBalancerDescriptions"][0]["Instances"])) == 2 + for x in response["LoadBalancerDescriptions"][0]["Instances"]: + assert x["InstanceId"] not in instance_to_standby_detach def test_standby_exit_standby(self): response = self.as_client.describe_auto_scaling_groups( @@ -824,54 +763,48 @@ class TestAutoScalingInstances(TestCase): InstanceIds=[instance_to_standby_exit_standby], ShouldDecrementDesiredCapacity=False, ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.have.length_of(3) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(2) + assert len(response["AutoScalingGroups"][0]["Instances"]) == 3 + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 2 response = self.as_client.describe_auto_scaling_instances( InstanceIds=[instance_to_standby_exit_standby] ) - response["AutoScalingInstances"][0]["LifecycleState"].should.equal("Standby") + assert response["AutoScalingInstances"][0]["LifecycleState"] == "Standby" response = self.as_client.exit_standby( AutoScalingGroupName=self.asg_name, InstanceIds=[instance_to_standby_exit_standby], ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) group = response["AutoScalingGroups"][0] - group["Instances"].should.have.length_of(3) - instance_to_standby_exit_standby.should.be.within( - [x["InstanceId"] for x in group["Instances"]] - ) - group["DesiredCapacity"].should.equal(3) + assert len(group["Instances"]) == 3 + assert instance_to_standby_exit_standby in [ + x["InstanceId"] for x in group["Instances"] + ] + assert group["DesiredCapacity"] == 3 - response = ec2_client.describe_instances( + instance = ec2_client.describe_instances( InstanceIds=[instance_to_standby_exit_standby] - ) - response["Reservations"][0]["Instances"][0]["State"]["Name"].should.equal( - "running" - ) + )["Reservations"][0]["Instances"][0] + assert instance["State"]["Name"] == "running" response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(3) - instance_to_standby_exit_standby.should.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(list(response["LoadBalancerDescriptions"][0]["Instances"])) == 3 + assert instance_to_standby_exit_standby in [ + x["InstanceId"] + for x in response["LoadBalancerDescriptions"][0]["Instances"] + ] @mock_autoscaling @@ -921,7 +854,7 @@ class TestAutoScalingInstancesProtected(TestCase): response = self.as_client.attach_load_balancers( AutoScalingGroupName=self.asg_name, LoadBalancerNames=[self.lb_name] ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 def test_attach_one_instance(self): ec2 = boto3.resource("ec2", "us-east-1") @@ -935,22 +868,20 @@ class TestAutoScalingInstancesProtected(TestCase): response = self.as_client.attach_instances( AutoScalingGroupName=self.asg_name, InstanceIds=instances_to_add ) - response["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert response["ResponseMetadata"]["HTTPStatusCode"] == 200 response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) instances = response["AutoScalingGroups"][0]["Instances"] - instances.should.have.length_of(3) + assert len(instances) == 3 for instance in instances: - instance["ProtectedFromScaleIn"].should.equal(True) + assert instance["ProtectedFromScaleIn"] is True response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(3) + assert len(list(response["LoadBalancerDescriptions"][0]["Instances"])) == 3 @mock_autoscaling @@ -991,7 +922,6 @@ class TestAutoScalingTerminateInstances(TestCase): ) def test_terminate_instance_in_auto_scaling_group_decrement(self): - response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) @@ -1006,15 +936,13 @@ class TestAutoScalingTerminateInstances(TestCase): response = self.as_client.describe_auto_scaling_groups( AutoScalingGroupNames=[self.asg_name] ) - response["AutoScalingGroups"][0]["Instances"].should.equal([]) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(0) + assert response["AutoScalingGroups"][0]["Instances"] == [] + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 0 response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(0) + assert len(list(response["LoadBalancerDescriptions"][0]["Instances"])) == 0 def test_terminate_instance_in_auto_scaling_group_no_decrement(self): response = self.as_client.describe_auto_scaling_groups( @@ -1035,18 +963,14 @@ class TestAutoScalingTerminateInstances(TestCase): instance["InstanceId"] for instance in response["AutoScalingGroups"][0]["Instances"] ) - replaced_instance_id.should_not.equal(original_instance_id) - response["AutoScalingGroups"][0]["DesiredCapacity"].should.equal(1) + assert replaced_instance_id != original_instance_id + assert response["AutoScalingGroups"][0]["DesiredCapacity"] == 1 response = self.elb_client.describe_load_balancers( LoadBalancerNames=[self.lb_name] ) - list( - response["LoadBalancerDescriptions"][0]["Instances"] - ).should.have.length_of(1) - original_instance_id.shouldnt.be.within( - [ - x["InstanceId"] - for x in response["LoadBalancerDescriptions"][0]["Instances"] - ] - ) + assert len(list(response["LoadBalancerDescriptions"][0]["Instances"])) == 1 + assert original_instance_id not in [ + x["InstanceId"] + for x in response["LoadBalancerDescriptions"][0]["Instances"] + ] diff --git a/tests/test_autoscaling/test_elbv2.py b/tests/test_autoscaling/test_elbv2.py index 5edbcd7e3..0ab897c2c 100644 --- a/tests/test_autoscaling/test_elbv2.py +++ b/tests/test_autoscaling/test_elbv2.py @@ -1,5 +1,4 @@ import boto3 -import sure # noqa # pylint: disable=unused-import import unittest from moto import mock_autoscaling, mock_elbv2 from tests import EXAMPLE_AMI_ID @@ -53,14 +52,12 @@ class TestAutoscalignELBv2(unittest.TestCase): response = self.as_client.describe_load_balancer_target_groups( AutoScalingGroupName=self.asg_name ) - list(response["LoadBalancerTargetGroups"]).should.have.length_of(1) + assert len(list(response["LoadBalancerTargetGroups"])) == 1 response = self.elbv2_client.describe_target_health( TargetGroupArn=self.target_group_arn ) - list(response["TargetHealthDescriptions"]).should.have.length_of( - self.instance_count - ) + assert len(list(response["TargetHealthDescriptions"])) == self.instance_count def test_attach_detach_target_groups(self): # create asg without attaching to target group @@ -81,8 +78,8 @@ class TestAutoscalignELBv2(unittest.TestCase): response = self.elbv2_client.describe_target_health( TargetGroupArn=self.target_group_arn ) - list(response["TargetHealthDescriptions"]).should.have.length_of( - self.instance_count * 2 + assert ( + len(list(response["TargetHealthDescriptions"])) == self.instance_count * 2 ) response = self.as_client.detach_load_balancer_target_groups( @@ -91,9 +88,7 @@ class TestAutoscalignELBv2(unittest.TestCase): response = self.elbv2_client.describe_target_health( TargetGroupArn=self.target_group_arn ) - list(response["TargetHealthDescriptions"]).should.have.length_of( - self.instance_count - ) + assert len(list(response["TargetHealthDescriptions"])) == self.instance_count def test_detach_all_target_groups(self): response = self.as_client.detach_load_balancer_target_groups( @@ -103,8 +98,8 @@ class TestAutoscalignELBv2(unittest.TestCase): response = self.elbv2_client.describe_target_health( TargetGroupArn=self.target_group_arn ) - list(response["TargetHealthDescriptions"]).should.have.length_of(0) + assert len(list(response["TargetHealthDescriptions"])) == 0 response = self.as_client.describe_load_balancer_target_groups( AutoScalingGroupName=self.asg_name ) - list(response["LoadBalancerTargetGroups"]).should.have.length_of(0) + assert len(list(response["LoadBalancerTargetGroups"])) == 0 diff --git a/tests/test_autoscaling/test_launch_configurations.py b/tests/test_autoscaling/test_launch_configurations.py index 0ef4aae75..71384ad2e 100644 --- a/tests/test_autoscaling/test_launch_configurations.py +++ b/tests/test_autoscaling/test_launch_configurations.py @@ -3,7 +3,6 @@ import boto3 from botocore.exceptions import ClientError import pytest -import sure # noqa # pylint: disable=unused-import from moto import mock_autoscaling, mock_ec2 from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID @@ -26,21 +25,22 @@ def test_create_launch_configuration(): ) launch_config = client.describe_launch_configurations()["LaunchConfigurations"][0] - launch_config["LaunchConfigurationName"].should.equal("tester") - launch_config.should.have.key("LaunchConfigurationARN") - launch_config["ImageId"].should.equal(EXAMPLE_AMI_ID) - launch_config["InstanceType"].should.equal("t1.micro") - launch_config["KeyName"].should.equal("the_keys") - set(launch_config["SecurityGroups"]).should.equal(set(["default", "default2"])) + assert launch_config["LaunchConfigurationName"] == "tester" + assert "LaunchConfigurationARN" in launch_config + assert launch_config["ImageId"] == EXAMPLE_AMI_ID + assert launch_config["InstanceType"] == "t1.micro" + assert launch_config["KeyName"] == "the_keys" + assert set(launch_config["SecurityGroups"]) == set(["default", "default2"]) userdata = launch_config["UserData"] userdata = base64.b64decode(userdata) - userdata.should.equal(b"This is some user_data") - launch_config["InstanceMonitoring"].should.equal({"Enabled": True}) - launch_config["IamInstanceProfile"].should.equal( - f"arn:aws:iam::{ACCOUNT_ID}:instance-profile/testing" + assert userdata == b"This is some user_data" + assert launch_config["InstanceMonitoring"] == {"Enabled": True} + assert ( + launch_config["IamInstanceProfile"] + == f"arn:aws:iam::{ACCOUNT_ID}:instance-profile/testing" ) - launch_config["SpotPrice"].should.equal("0.1") - launch_config["BlockDeviceMappings"].should.equal([]) + assert launch_config["SpotPrice"] == "0.1" + assert launch_config["BlockDeviceMappings"] == [] @mock_autoscaling @@ -75,29 +75,29 @@ def test_create_launch_configuration_with_block_device_mappings(): ) launch_config = client.describe_launch_configurations()["LaunchConfigurations"][0] - launch_config["LaunchConfigurationName"].should.equal("tester") + assert launch_config["LaunchConfigurationName"] == "tester" mappings = launch_config["BlockDeviceMappings"] - mappings.should.have.length_of(3) + assert len(mappings) == 3 xvdh = [m for m in mappings if m["DeviceName"] == "/dev/xvdh"][0] xvdp = [m for m in mappings if m["DeviceName"] == "/dev/xvdp"][0] xvdb = [m for m in mappings if m["DeviceName"] == "/dev/xvdb"][0] - xvdh.shouldnt.have.key("VirtualName") - xvdh.should.have.key("Ebs") - xvdh["Ebs"]["VolumeSize"].should.equal(100) - xvdh["Ebs"]["VolumeType"].should.equal("io1") - xvdh["Ebs"]["DeleteOnTermination"].should.equal(False) - xvdh["Ebs"]["Iops"].should.equal(1000) + assert "VirtualName" not in xvdh + assert "Ebs" in xvdh + assert xvdh["Ebs"]["VolumeSize"] == 100 + assert xvdh["Ebs"]["VolumeType"] == "io1" + assert xvdh["Ebs"]["DeleteOnTermination"] is False + assert xvdh["Ebs"]["Iops"] == 1000 - xvdp.shouldnt.have.key("VirtualName") - xvdp.should.have.key("Ebs") - xvdp["Ebs"]["SnapshotId"].should.equal("snap-1234abcd") - xvdp["Ebs"]["VolumeType"].should.equal("standard") + assert "VirtualName" not in xvdp + assert "Ebs" in xvdp + assert xvdp["Ebs"]["SnapshotId"] == "snap-1234abcd" + assert xvdp["Ebs"]["VolumeType"] == "standard" - xvdb["VirtualName"].should.equal("ephemeral0") - xvdb.shouldnt.have.key("Ebs") + assert xvdb["VirtualName"] == "ephemeral0" + assert "Ebs" not in xvdb @mock_autoscaling @@ -119,17 +119,15 @@ def test_create_launch_configuration_additional_parameters(): ) launch_config = client.describe_launch_configurations()["LaunchConfigurations"][0] - launch_config["ClassicLinkVPCId"].should.equal("vpc_id") - launch_config["ClassicLinkVPCSecurityGroups"].should.equal(["classic_sg1"]) - launch_config["EbsOptimized"].should.equal(True) - launch_config["AssociatePublicIpAddress"].should.equal(True) - launch_config["MetadataOptions"].should.equal( - { - "HttpTokens": "optional", - "HttpPutResponseHopLimit": 123, - "HttpEndpoint": "disabled", - } - ) + assert launch_config["ClassicLinkVPCId"] == "vpc_id" + assert launch_config["ClassicLinkVPCSecurityGroups"] == ["classic_sg1"] + assert launch_config["EbsOptimized"] is True + assert launch_config["AssociatePublicIpAddress"] is True + assert launch_config["MetadataOptions"] == { + "HttpTokens": "optional", + "HttpPutResponseHopLimit": 123, + "HttpEndpoint": "disabled", + } @mock_autoscaling @@ -151,7 +149,7 @@ def test_create_launch_configuration_without_public_ip(): ) launch_config = client.describe_launch_configurations()["LaunchConfigurations"][0] - launch_config["AssociatePublicIpAddress"].should.equal(False) + assert launch_config["AssociatePublicIpAddress"] is False asg_name = f"asg-{random_image_id}" client.create_auto_scaling_group( @@ -169,7 +167,7 @@ def test_create_launch_configuration_without_public_ip(): instance = ec2_client.describe_instances(InstanceIds=[instance_id])["Reservations"][ 0 ]["Instances"][0] - instance.shouldnt.have.key("PublicIpAddress") + assert "PublicIpAddress" not in instance @mock_autoscaling @@ -182,8 +180,8 @@ def test_create_launch_configuration_additional_params_default_to_false(): ) launch_config = client.describe_launch_configurations()["LaunchConfigurations"][0] - launch_config["EbsOptimized"].should.equal(False) - launch_config["AssociatePublicIpAddress"].should.equal(False) + assert launch_config["EbsOptimized"] is False + assert launch_config["AssociatePublicIpAddress"] is False @mock_autoscaling @@ -200,12 +198,12 @@ def test_create_launch_configuration_defaults(): launch_config = client.describe_launch_configurations()["LaunchConfigurations"][0] # Defaults - launch_config["KeyName"].should.equal("") - launch_config["SecurityGroups"].should.equal([]) - launch_config["UserData"].should.equal("") - launch_config["InstanceMonitoring"].should.equal({"Enabled": False}) - launch_config.shouldnt.have.key("IamInstanceProfile") - launch_config.shouldnt.have.key("SpotPrice") + assert launch_config["KeyName"] == "" + assert launch_config["SecurityGroups"] == [] + assert launch_config["UserData"] == "" + assert launch_config["InstanceMonitoring"] == {"Enabled": False} + assert "IamInstanceProfile" not in launch_config + assert "SpotPrice" not in launch_config @mock_autoscaling @@ -221,10 +219,8 @@ def test_launch_configuration_describe_filter(): configs = client.describe_launch_configurations( LaunchConfigurationNames=["tester", "tester2"] ) - configs["LaunchConfigurations"].should.have.length_of(2) - client.describe_launch_configurations()[ - "LaunchConfigurations" - ].should.have.length_of(3) + assert len(configs["LaunchConfigurations"]) == 2 + assert len(client.describe_launch_configurations()["LaunchConfigurations"]) == 3 @mock_autoscaling @@ -240,13 +236,13 @@ def test_launch_configuration_describe_paginated(): response = conn.describe_launch_configurations() lcs = response["LaunchConfigurations"] marker = response["NextToken"] - lcs.should.have.length_of(50) - marker.should.equal(lcs[-1]["LaunchConfigurationName"]) + assert len(lcs) == 50 + assert marker == lcs[-1]["LaunchConfigurationName"] response2 = conn.describe_launch_configurations(NextToken=marker) lcs.extend(response2["LaunchConfigurations"]) - lcs.should.have.length_of(51) + assert len(lcs) == 51 assert "NextToken" not in response2.keys() @@ -259,15 +255,11 @@ def test_launch_configuration_delete(): InstanceType="m1.small", ) - client.describe_launch_configurations()[ - "LaunchConfigurations" - ].should.have.length_of(1) + assert len(client.describe_launch_configurations()["LaunchConfigurations"]) == 1 client.delete_launch_configuration(LaunchConfigurationName="tester") - client.describe_launch_configurations()[ - "LaunchConfigurations" - ].should.have.length_of(0) + assert len(client.describe_launch_configurations()["LaunchConfigurations"]) == 0 @pytest.mark.parametrize( @@ -292,10 +284,8 @@ def test_invalid_launch_configuration_request_raises_error(request_params): client = boto3.client("autoscaling", region_name="us-east-1") with pytest.raises(ClientError) as ex: client.create_launch_configuration(**request_params) - ex.value.response["Error"]["Code"].should.equal("ValidationError") - ex.value.response["Error"]["Message"].should.match( - r"^Valid requests must contain.*" - ) + assert ex.value.response["Error"]["Code"] == "ValidationError" + assert "Valid requests must contain" in ex.value.response["Error"]["Message"] @mock_autoscaling @@ -338,10 +328,10 @@ def test_launch_config_with_block_device_mappings__volumes_are_created(): volumes = ec2_client.describe_volumes( Filters=[{"Name": "attachment.instance-id", "Values": [instance_id]}] )["Volumes"] - volumes.should.have.length_of(2) - volumes[0].should.have.key("Size").equals(8) - volumes[0].should.have.key("Encrypted").equals(False) - volumes[0].should.have.key("VolumeType").equals("gp2") - volumes[1].should.have.key("Size").equals(10) - volumes[1].should.have.key("Encrypted").equals(False) - volumes[1].should.have.key("VolumeType").equals("standard") + assert len(volumes) == 2 + assert volumes[0]["Size"] == 8 + assert volumes[0]["Encrypted"] is False + assert volumes[0]["VolumeType"] == "gp2" + assert volumes[1]["Size"] == 10 + assert volumes[1]["Encrypted"] is False + assert volumes[1]["VolumeType"] == "standard" diff --git a/tests/test_autoscaling/test_policies.py b/tests/test_autoscaling/test_policies.py index 9f521f9a9..09efa2fdc 100644 --- a/tests/test_autoscaling/test_policies.py +++ b/tests/test_autoscaling/test_policies.py @@ -1,5 +1,4 @@ import boto3 -import sure # noqa # pylint: disable=unused-import import pytest from moto import mock_autoscaling @@ -39,11 +38,11 @@ def test_create_policy_boto3(): ) policy = client.describe_policies()["ScalingPolicies"][0] - policy["PolicyName"].should.equal("ScaleUp") - policy["AdjustmentType"].should.equal("ExactCapacity") - policy["AutoScalingGroupName"].should.equal("tester_group") - policy["ScalingAdjustment"].should.equal(3) - policy["Cooldown"].should.equal(60) + assert policy["PolicyName"] == "ScaleUp" + assert policy["AdjustmentType"] == "ExactCapacity" + assert policy["AutoScalingGroupName"] == "tester_group" + assert policy["ScalingAdjustment"] == 3 + assert policy["Cooldown"] == 60 @mock_autoscaling @@ -58,10 +57,10 @@ def test_create_policy_default_values_boto3(): ) policy = client.describe_policies()["ScalingPolicies"][0] - policy["PolicyName"].should.equal("ScaleUp") + assert policy["PolicyName"] == "ScaleUp" # Defaults - policy["Cooldown"].should.equal(300) + assert policy["Cooldown"] == 300 @mock_autoscaling @@ -75,9 +74,9 @@ def test_update_policy_boto3(): ScalingAdjustment=3, ) - client.describe_policies()["ScalingPolicies"].should.have.length_of(1) + assert len(client.describe_policies()["ScalingPolicies"]) == 1 policy = client.describe_policies()["ScalingPolicies"][0] - policy["ScalingAdjustment"].should.equal(3) + assert policy["ScalingAdjustment"] == 3 # Now update it by creating another with the same name client.put_scaling_policy( @@ -86,9 +85,9 @@ def test_update_policy_boto3(): AutoScalingGroupName="tester_group", ScalingAdjustment=2, ) - client.describe_policies()["ScalingPolicies"].should.have.length_of(1) + assert len(client.describe_policies()["ScalingPolicies"]) == 1 policy = client.describe_policies()["ScalingPolicies"][0] - policy["ScalingAdjustment"].should.equal(2) + assert policy["ScalingAdjustment"] == 2 @mock_autoscaling @@ -102,10 +101,10 @@ def test_delete_policy_boto3(): ScalingAdjustment=3, ) - client.describe_policies()["ScalingPolicies"].should.have.length_of(1) + assert len(client.describe_policies()["ScalingPolicies"]) == 1 client.delete_policy(PolicyName="ScaleUp") - client.describe_policies()["ScalingPolicies"].should.have.length_of(0) + assert len(client.describe_policies()["ScalingPolicies"]) == 0 @mock_autoscaling @@ -122,7 +121,7 @@ def test_execute_policy_exact_capacity_boto3(): client.execute_policy(PolicyName="ScaleUp") instances = client.describe_auto_scaling_instances() - instances["AutoScalingInstances"].should.have.length_of(3) + assert len(instances["AutoScalingInstances"]) == 3 @mock_autoscaling @@ -139,7 +138,7 @@ def test_execute_policy_positive_change_in_capacity_boto3(): client.execute_policy(PolicyName="ScaleUp") instances = client.describe_auto_scaling_instances() - instances["AutoScalingInstances"].should.have.length_of(5) + assert len(instances["AutoScalingInstances"]) == 5 @pytest.mark.parametrize( @@ -162,4 +161,4 @@ def test_execute_policy_percent_change_in_capacity_boto3(adjustment, nr_of_insta client.execute_policy(PolicyName="ScaleUp") instances = client.describe_auto_scaling_instances() - instances["AutoScalingInstances"].should.have.length_of(nr_of_instances) + assert len(instances["AutoScalingInstances"]) == nr_of_instances diff --git a/tests/test_autoscaling/test_server.py b/tests/test_autoscaling/test_server.py index b89396217..164101151 100644 --- a/tests/test_autoscaling/test_server.py +++ b/tests/test_autoscaling/test_server.py @@ -1,5 +1,3 @@ -import sure # noqa # pylint: disable=unused-import - import moto.server as server """ @@ -13,5 +11,5 @@ def test_describe_autoscaling_groups(): res = test_client.get("/?Action=DescribeLaunchConfigurations") - res.data.should.contain(b"") + assert b"" in res.data