Techdebt: Replace sure with regular assertions in OpsWorks (#6673)

Co-authored-by: Karri Balk <kbalk@users.noreply.github.com>

tests/test_opsworks/test_apps.py

@@ -1,7 +1,6 @@
 import boto3
 from freezegun import freeze_time
-import sure  # noqa # pylint: disable=unused-import
+import pytest
-import re
 
 from moto import mock_opsworks
 
@@ -19,7 +18,7 @@ def test_create_app_response():
 
     response = client.create_app(StackId=stack_id, Type="other", Name="TestApp")
 
-    response.should.contain("AppId")
+    assert "AppId" in response
 
     second_stack_id = client.create_stack(
         Name="test_stack_2",
@@ -30,17 +29,17 @@ def test_create_app_response():
 
     response = client.create_app(StackId=second_stack_id, Type="other", Name="TestApp")
 
-    response.should.contain("AppId")
+    assert "AppId" in response
 
     # ClientError
-    client.create_app.when.called_with(
+    with pytest.raises(Exception) as exc:
-        StackId=stack_id, Type="other", Name="TestApp"
+        client.create_app(StackId=stack_id, Type="other", Name="TestApp")
-    ).should.throw(Exception, re.compile(r'already an app named "TestApp"'))
+    assert r'already an app named "TestApp"' in exc.value.response["Error"]["Message"]
 
     # ClientError
-    client.create_app.when.called_with(
+    with pytest.raises(Exception) as exc:
-        StackId="nothere", Type="other", Name="TestApp"
+        client.create_app(StackId="nothere", Type="other", Name="TestApp")
-    ).should.throw(Exception, "nothere")
+    assert exc.value.response["Error"]["Message"] == "nothere"
 
 
 @freeze_time("2015-01-01")
@@ -57,19 +56,25 @@ def test_describe_apps():
 
     rv1 = client.describe_apps(StackId=stack_id)
     rv2 = client.describe_apps(AppIds=[app_id])
-    rv1["Apps"].should.equal(rv2["Apps"])
+    assert rv1["Apps"] == rv2["Apps"]
 
-    rv1["Apps"][0]["Name"].should.equal("TestApp")
+    assert rv1["Apps"][0]["Name"] == "TestApp"
 
     # ClientError
-    client.describe_apps.when.called_with(
+    with pytest.raises(Exception) as exc:
-        StackId=stack_id, AppIds=[app_id]
+        client.describe_apps(StackId=stack_id, AppIds=[app_id])
-    ).should.throw(Exception, "Please provide one or more app IDs or a stack ID")
+    assert exc.value.response["Error"]["Message"] == (
-    # ClientError
+        "Please provide one or more app IDs or a stack ID"
-    client.describe_apps.when.called_with(StackId="nothere").should.throw(
-        Exception, "Unable to find stack with ID nothere"
     )
+
     # ClientError
-    client.describe_apps.when.called_with(AppIds=["nothere"]).should.throw(
+    with pytest.raises(Exception) as exc:
-        Exception, "nothere"
+        client.describe_apps(StackId="nothere")
+    assert exc.value.response["Error"]["Message"] == (
+        "Unable to find stack with ID nothere"
     )
+
+    # ClientError
+    with pytest.raises(Exception) as exc:
+        client.describe_apps(AppIds=["nothere"])
+    assert exc.value.response["Error"]["Message"] == "nothere"

tests/test_opsworks/test_instances.py

@@ -1,5 +1,5 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
+import pytest
 
 from moto import mock_opsworks
 from moto import mock_ec2
@@ -41,22 +41,36 @@ def test_create_instance():
         StackId=stack_id, LayerIds=[layer_id], InstanceType="t2.micro"
     )
 
-    response.should.contain("InstanceId")
+    assert "InstanceId" in response
 
-    client.create_instance.when.called_with(
+    with pytest.raises(Exception) as exc:
-        StackId="nothere", LayerIds=[layer_id], InstanceType="t2.micro"
+        client.create_instance(
-    ).should.throw(Exception, "Unable to find stack with ID nothere")
+            StackId="nothere", LayerIds=[layer_id], InstanceType="t2.micro"
+        )
+    assert exc.value.response["Error"]["Message"] == (
+        "Unable to find stack with ID nothere"
+    )
+
+    with pytest.raises(Exception) as exc:
+        client.create_instance(
+            StackId=stack_id, LayerIds=["nothere"], InstanceType="t2.micro"
+        )
+    assert exc.value.response["Error"]["Message"] == "nothere"
 
-    client.create_instance.when.called_with(
-        StackId=stack_id, LayerIds=["nothere"], InstanceType="t2.micro"
-    ).should.throw(Exception, "nothere")
     # ClientError
-    client.create_instance.when.called_with(
+    with pytest.raises(Exception) as exc:
-        StackId=stack_id, LayerIds=[second_layer_id], InstanceType="t2.micro"
+        client.create_instance(
-    ).should.throw(Exception, "Please only provide layer IDs from the same stack")
+            StackId=stack_id, LayerIds=[second_layer_id], InstanceType="t2.micro"
+        )
+    assert exc.value.response["Error"]["Message"] == (
+        "Please only provide layer IDs from the same stack"
+    )
+
     # ClientError
-    client.start_instance.when.called_with(InstanceId="nothere").should.throw(
+    with pytest.raises(Exception) as exc:
-        Exception, "Unable to find instance with ID nothere"
+        client.start_instance(InstanceId="nothere")
+    assert exc.value.response["Error"]["Message"] == (
+        "Unable to find instance with ID nothere"
     )
 
 
@@ -111,65 +125,65 @@ def test_describe_instances():
 
     # instances in Stack 1
     response = client.describe_instances(StackId=S1)["Instances"]
-    response.should.have.length_of(2)
+    assert len(response) == 2
-    S1L1_i1.should.be.within([i["InstanceId"] for i in response])
+    assert S1L1_i1 in [i["InstanceId"] for i in response]
-    S1L1_i2.should.be.within([i["InstanceId"] for i in response])
+    assert S1L1_i2 in [i["InstanceId"] for i in response]
 
     response2 = client.describe_instances(InstanceIds=[S1L1_i1, S1L1_i2])["Instances"]
-    sorted(response2, key=lambda d: d["InstanceId"]).should.equal(
+    assert sorted(response2, key=lambda d: d["InstanceId"]) == (
         sorted(response, key=lambda d: d["InstanceId"])
     )
 
     response3 = client.describe_instances(LayerId=S1L1)["Instances"]
-    sorted(response3, key=lambda d: d["InstanceId"]).should.equal(
+    assert sorted(response3, key=lambda d: d["InstanceId"]) == (
         sorted(response, key=lambda d: d["InstanceId"])
     )
 
     response = client.describe_instances(StackId=S1)["Instances"]
-    response.should.have.length_of(2)
+    assert len(response) == 2
-    S1L1_i1.should.be.within([i["InstanceId"] for i in response])
+    assert S1L1_i1 in [i["InstanceId"] for i in response]
-    S1L1_i2.should.be.within([i["InstanceId"] for i in response])
+    assert S1L1_i2 in [i["InstanceId"] for i in response]
 
     # instances in Stack 2
     response = client.describe_instances(StackId=S2)["Instances"]
-    response.should.have.length_of(3)
+    assert len(response) == 3
-    S2L1_i1.should.be.within([i["InstanceId"] for i in response])
+    assert S2L1_i1 in [i["InstanceId"] for i in response]
-    S2L2_i1.should.be.within([i["InstanceId"] for i in response])
+    assert S2L2_i1 in [i["InstanceId"] for i in response]
-    S2L2_i2.should.be.within([i["InstanceId"] for i in response])
+    assert S2L2_i2 in [i["InstanceId"] for i in response]
 
     response = client.describe_instances(LayerId=S2L1)["Instances"]
-    response.should.have.length_of(1)
+    assert len(response) == 1
-    S2L1_i1.should.be.within([i["InstanceId"] for i in response])
+    assert S2L1_i1 in [i["InstanceId"] for i in response]
 
     response = client.describe_instances(LayerId=S2L2)["Instances"]
-    response.should.have.length_of(2)
+    assert len(response) == 2
-    S2L1_i1.should_not.be.within([i["InstanceId"] for i in response])
+    assert S2L1_i1 not in [i["InstanceId"] for i in response]
 
     # ClientError
-    client.describe_instances.when.called_with(StackId=S1, LayerId=S1L1).should.throw(
+    with pytest.raises(Exception) as exc:
-        Exception, "Please provide either one or more"
+        client.describe_instances(StackId=S1, LayerId=S1L1)
-    )
+    assert "Please provide either one or more" in exc.value.response["Error"]["Message"]
+
     # ClientError
-    client.describe_instances.when.called_with(StackId="nothere").should.throw(
+    with pytest.raises(Exception) as exc:
-        Exception, "nothere"
+        client.describe_instances(StackId="nothere")
-    )
+    assert "nothere" in exc.value.response["Error"]["Message"]
+
     # ClientError
-    client.describe_instances.when.called_with(LayerId="nothere").should.throw(
+    with pytest.raises(Exception) as exc:
-        Exception, "nothere"
+        client.describe_instances(LayerId="nothere")
-    )
+    assert "nothere" in exc.value.response["Error"]["Message"]
+
     # ClientError
-    client.describe_instances.when.called_with(InstanceIds=["nothere"]).should.throw(
+    with pytest.raises(Exception) as exc:
-        Exception, "nothere"
+        client.describe_instances(InstanceIds=["nothere"])
-    )
+    assert exc.value.response["Error"]["Message"] == "nothere"
 
 
 @mock_opsworks
 @mock_ec2
 def test_ec2_integration():
-    """
+    """Verify instances created via OpsWorks are discoverable via ec2."""
-    instances created via OpsWorks should be discoverable via ec2
-    """
-
     opsworks = boto3.client("opsworks", region_name="us-east-1")
     stack_id = opsworks.create_stack(
         Name="S1",
@@ -194,20 +208,20 @@ def test_ec2_integration():
 
     # Before starting the instance, it shouldn't be discoverable via ec2
     reservations = ec2.describe_instances()["Reservations"]
-    assert reservations.should.be.empty
+    assert not reservations
 
     # Before starting the instance, its status should be "stopped"
     opsworks_instance = opsworks.describe_instances(StackId=stack_id)["Instances"][0]
-    opsworks_instance["Status"].should.equal("stopped")
+    assert opsworks_instance["Status"] == "stopped"
 
     # After starting the instance, it should be discoverable via ec2
     opsworks.start_instance(InstanceId=instance_id)
     reservations = ec2.describe_instances()["Reservations"]
-    reservations[0]["Instances"].should.have.length_of(1)
+    assert len(reservations[0]["Instances"]) == 1
     instance = reservations[0]["Instances"][0]
     opsworks_instance = opsworks.describe_instances(StackId=stack_id)["Instances"][0]
 
-    instance["InstanceId"].should.equal(opsworks_instance["Ec2InstanceId"])
+    assert instance["InstanceId"] == opsworks_instance["Ec2InstanceId"]
-    instance["PrivateIpAddress"].should.equal(opsworks_instance["PrivateIp"])
+    assert instance["PrivateIpAddress"] == opsworks_instance["PrivateIp"]
     # After starting the instance, its status should be "online"
-    opsworks_instance["Status"].should.equal("online")
+    assert opsworks_instance["Status"] == "online"

tests/test_opsworks/test_layers.py

@@ -1,7 +1,6 @@
 import boto3
 from freezegun import freeze_time
-import sure  # noqa # pylint: disable=unused-import
+import pytest
-import re
 
 from moto import mock_opsworks
 
@@ -24,7 +23,7 @@ def test_create_layer_response():
         Shortname="TestLayerShortName",
     )
 
-    response.should.contain("LayerId")
+    assert "LayerId" in response
 
     second_stack_id = client.create_stack(
         Name="test_stack_2",
@@ -40,22 +39,32 @@ def test_create_layer_response():
         Shortname="TestLayerShortName",
     )
 
-    response.should.contain("LayerId")
+    assert "LayerId" in response
 
     # ClientError
-    client.create_layer.when.called_with(
+    with pytest.raises(Exception) as exc:
-        StackId=stack_id, Type="custom", Name="TestLayer", Shortname="_"
+        client.create_layer(
-    ).should.throw(Exception, re.compile(r'already a layer named "TestLayer"'))
+            StackId=stack_id, Type="custom", Name="TestLayer", Shortname="_"
-    # ClientError
+        )
-    client.create_layer.when.called_with(
+    assert (
-        StackId=stack_id, Type="custom", Name="_", Shortname="TestLayerShortName"
+        r'already a layer named "TestLayer"' in exc.value.response["Error"]["Message"]
-    ).should.throw(
-        Exception, re.compile(r'already a layer with shortname "TestLayerShortName"')
     )
+
     # ClientError
-    client.create_layer.when.called_with(
+    with pytest.raises(Exception) as exc:
-        StackId="nothere", Type="custom", Name="TestLayer", Shortname="_"
+        client.create_layer(
-    ).should.throw(Exception, "nothere")
+            StackId=stack_id, Type="custom", Name="_", Shortname="TestLayerShortName"
+        )
+    assert (
+        r'already a layer with shortname "TestLayerShortName"'
+    ) in exc.value.response["Error"]["Message"]
+
+    # ClientError
+    with pytest.raises(Exception) as exc:
+        client.create_layer(
+            StackId="nothere", Type="custom", Name="TestLayer", Shortname="_"
+        )
+    assert exc.value.response["Error"]["Message"] == "nothere"
 
 
 @freeze_time("2015-01-01")
@@ -77,19 +86,25 @@ def test_describe_layers():
 
     rv1 = client.describe_layers(StackId=stack_id)
     rv2 = client.describe_layers(LayerIds=[layer_id])
-    rv1["Layers"].should.equal(rv2["Layers"])
+    assert rv1["Layers"] == rv2["Layers"]
 
-    rv1["Layers"][0]["Name"].should.equal("TestLayer")
+    assert rv1["Layers"][0]["Name"] == "TestLayer"
 
     # ClientError
-    client.describe_layers.when.called_with(
+    with pytest.raises(Exception) as exc:
-        StackId=stack_id, LayerIds=[layer_id]
+        client.describe_layers(StackId=stack_id, LayerIds=[layer_id])
-    ).should.throw(Exception, "Please provide one or more layer IDs or a stack ID")
+    assert exc.value.response["Error"]["Message"] == (
-    # ClientError
+        "Please provide one or more layer IDs or a stack ID"
-    client.describe_layers.when.called_with(StackId="nothere").should.throw(
-        Exception, "Unable to find stack with ID nothere"
     )
+
     # ClientError
-    client.describe_layers.when.called_with(LayerIds=["nothere"]).should.throw(
+    with pytest.raises(Exception) as exc:
-        Exception, "nothere"
+        client.describe_layers(StackId="nothere")
+    assert exc.value.response["Error"]["Message"] == (
+        "Unable to find stack with ID nothere"
     )
+
+    # ClientError
+    with pytest.raises(Exception) as exc:
+        client.describe_layers(LayerIds=["nothere"])
+    assert exc.value.response["Error"]["Message"] == "nothere"

tests/test_opsworks/test_stack.py

@@ -1,6 +1,5 @@
 import boto3
-import sure  # noqa # pylint: disable=unused-import
+import pytest
-import re
 
 from moto import mock_opsworks
 
@@ -14,7 +13,7 @@ def test_create_stack_response():
         ServiceRoleArn="service_arn",
         DefaultInstanceProfileArn="profile_arn",
     )
-    response.should.contain("StackId")
+    assert "StackId" in response
 
 
 @mock_opsworks
@@ -29,17 +28,17 @@ def test_describe_stacks():
         )
 
     response = client.describe_stacks()
-    response["Stacks"].should.have.length_of(3)
+    assert len(response["Stacks"]) == 3
     for stack in response["Stacks"]:
-        stack["ServiceRoleArn"].should.equal("service_arn")
+        assert stack["ServiceRoleArn"] == "service_arn"
-        stack["DefaultInstanceProfileArn"].should.equal("profile_arn")
+        assert stack["DefaultInstanceProfileArn"] == "profile_arn"
 
     _id = response["Stacks"][0]["StackId"]
     response = client.describe_stacks(StackIds=[_id])
-    response["Stacks"].should.have.length_of(1)
+    assert len(response["Stacks"]) == 1
-    response["Stacks"][0]["Arn"].should.contain(_id)
+    assert _id in response["Stacks"][0]["Arn"]
 
     # ClientError/ResourceNotFoundException
-    client.describe_stacks.when.called_with(StackIds=["foo"]).should.throw(
+    with pytest.raises(Exception) as exc:
-        Exception, re.compile(r"foo")
+        client.describe_stacks(StackIds=["foo"])
-    )
+    assert r"foo" in exc.value.response["Error"]["Message"]