Yasuke/moto
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
Co-authored-by: Karri Balk <kbalk@users.noreply.github.com>
This commit is contained in:
kbalk 2023-08-16 06:10:41 -04:00 committed by GitHub
parent b1195f8eb3
commit 45dfb54469
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 427 additions and 394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
tests/test_opsworks/test_apps.py
View File

@ -1,75 +1,80 @@
import boto3
from freezegun import freeze_time
import sure # noqa # pylint: disable=unused-import
import re
from moto import mock_opsworks
@freeze_time("2015-01-01")
@mock_opsworks
def test_create_app_response():
client = boto3.client("opsworks", region_name="us-east-1")
stack_id = client.create_stack(
Name="test_stack_1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
response = client.create_app(StackId=stack_id, Type="other", Name="TestApp")
response.should.contain("AppId")
second_stack_id = client.create_stack(
Name="test_stack_2",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
response = client.create_app(StackId=second_stack_id, Type="other", Name="TestApp")
response.should.contain("AppId")
# ClientError
client.create_app.when.called_with(
StackId=stack_id, Type="other", Name="TestApp"
).should.throw(Exception, re.compile(r'already an app named "TestApp"'))
# ClientError
client.create_app.when.called_with(
StackId="nothere", Type="other", Name="TestApp"
).should.throw(Exception, "nothere")
@freeze_time("2015-01-01")
@mock_opsworks
def test_describe_apps():
client = boto3.client("opsworks", region_name="us-east-1")
stack_id = client.create_stack(
Name="test_stack_1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
app_id = client.create_app(StackId=stack_id, Type="other", Name="TestApp")["AppId"]
rv1 = client.describe_apps(StackId=stack_id)
rv2 = client.describe_apps(AppIds=[app_id])
rv1["Apps"].should.equal(rv2["Apps"])
rv1["Apps"][0]["Name"].should.equal("TestApp")
# ClientError
client.describe_apps.when.called_with(
StackId=stack_id, AppIds=[app_id]
).should.throw(Exception, "Please provide one or more app IDs or a stack ID")
# ClientError
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(
Exception, "nothere"
)
import boto3
from freezegun import freeze_time
import pytest
from moto import mock_opsworks
@freeze_time("2015-01-01")
@mock_opsworks
def test_create_app_response():
client = boto3.client("opsworks", region_name="us-east-1")
stack_id = client.create_stack(
Name="test_stack_1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
response = client.create_app(StackId=stack_id, Type="other", Name="TestApp")
assert "AppId" in response
second_stack_id = client.create_stack(
Name="test_stack_2",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
response = client.create_app(StackId=second_stack_id, Type="other", Name="TestApp")
assert "AppId" in response
# ClientError
with pytest.raises(Exception) as exc:
client.create_app(StackId=stack_id, Type="other", Name="TestApp")
assert r'already an app named "TestApp"' in exc.value.response["Error"]["Message"]
# ClientError
with pytest.raises(Exception) as exc:
client.create_app(StackId="nothere", Type="other", Name="TestApp")
assert exc.value.response["Error"]["Message"] == "nothere"
@freeze_time("2015-01-01")
@mock_opsworks
def test_describe_apps():
client = boto3.client("opsworks", region_name="us-east-1")
stack_id = client.create_stack(
Name="test_stack_1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
app_id = client.create_app(StackId=stack_id, Type="other", Name="TestApp")["AppId"]
rv1 = client.describe_apps(StackId=stack_id)
rv2 = client.describe_apps(AppIds=[app_id])
assert rv1["Apps"] == rv2["Apps"]
assert rv1["Apps"][0]["Name"] == "TestApp"
# ClientError
with pytest.raises(Exception) as exc:
client.describe_apps(StackId=stack_id, AppIds=[app_id])
assert exc.value.response["Error"]["Message"] == (
"Please provide one or more app IDs or a stack ID"
)
# ClientError
with pytest.raises(Exception) as exc:
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"

440
tests/test_opsworks/test_instances.py
View File

@ -1,213 +1,227 @@
import boto3
import sure # noqa # pylint: disable=unused-import
from moto import mock_opsworks
from moto import mock_ec2
from tests import EXAMPLE_AMI_ID
@mock_opsworks
def test_create_instance():
client = boto3.client("opsworks", region_name="us-east-1")
stack_id = client.create_stack(
Name="test_stack_1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
layer_id = client.create_layer(
StackId=stack_id,
Type="custom",
Name="TestLayer",
Shortname="TestLayerShortName",
)["LayerId"]
second_stack_id = client.create_stack(
Name="test_stack_2",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
second_layer_id = client.create_layer(
StackId=second_stack_id,
Type="custom",
Name="SecondTestLayer",
Shortname="SecondTestLayerShortName",
)["LayerId"]
response = client.create_instance(
StackId=stack_id, LayerIds=[layer_id], InstanceType="t2.micro"
)
response.should.contain("InstanceId")
client.create_instance.when.called_with(
StackId="nothere", LayerIds=[layer_id], InstanceType="t2.micro"
).should.throw(Exception, "Unable to find stack with ID 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(
StackId=stack_id, LayerIds=[second_layer_id], InstanceType="t2.micro"
).should.throw(Exception, "Please only provide layer IDs from the same stack")
# ClientError
client.start_instance.when.called_with(InstanceId="nothere").should.throw(
Exception, "Unable to find instance with ID nothere"
)
@mock_opsworks
def test_describe_instances():
"""
create two stacks, with 1 layer and 2 layers (S1L1, S2L1, S2L2)
populate S1L1 with 2 instances (S1L1_i1, S1L1_i2)
populate S2L1 with 1 instance (S2L1_i1)
populate S2L2 with 3 instances (S2L2_i1..2)
"""
client = boto3.client("opsworks", region_name="us-east-1")
S1 = client.create_stack(
Name="S1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
S1L1 = client.create_layer(
StackId=S1, Type="custom", Name="S1L1", Shortname="S1L1"
)["LayerId"]
S2 = client.create_stack(
Name="S2",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
S2L1 = client.create_layer(
StackId=S2, Type="custom", Name="S2L1", Shortname="S2L1"
)["LayerId"]
S2L2 = client.create_layer(
StackId=S2, Type="custom", Name="S2L2", Shortname="S2L2"
)["LayerId"]
S1L1_i1 = client.create_instance(
StackId=S1, LayerIds=[S1L1], InstanceType="t2.micro"
)["InstanceId"]
S1L1_i2 = client.create_instance(
StackId=S1, LayerIds=[S1L1], InstanceType="t2.micro"
)["InstanceId"]
S2L1_i1 = client.create_instance(
StackId=S2, LayerIds=[S2L1], InstanceType="t2.micro"
)["InstanceId"]
S2L2_i1 = client.create_instance(
StackId=S2, LayerIds=[S2L2], InstanceType="t2.micro"
)["InstanceId"]
S2L2_i2 = client.create_instance(
StackId=S2, LayerIds=[S2L2], InstanceType="t2.micro"
)["InstanceId"]
# instances in Stack 1
response = client.describe_instances(StackId=S1)["Instances"]
response.should.have.length_of(2)
S1L1_i1.should.be.within([i["InstanceId"] for i in response])
S1L1_i2.should.be.within([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(
sorted(response, key=lambda d: d["InstanceId"])
)
response3 = client.describe_instances(LayerId=S1L1)["Instances"]
sorted(response3, key=lambda d: d["InstanceId"]).should.equal(
sorted(response, key=lambda d: d["InstanceId"])
)
response = client.describe_instances(StackId=S1)["Instances"]
response.should.have.length_of(2)
S1L1_i1.should.be.within([i["InstanceId"] for i in response])
S1L1_i2.should.be.within([i["InstanceId"] for i in response])
# instances in Stack 2
response = client.describe_instances(StackId=S2)["Instances"]
response.should.have.length_of(3)
S2L1_i1.should.be.within([i["InstanceId"] for i in response])
S2L2_i1.should.be.within([i["InstanceId"] for i in response])
S2L2_i2.should.be.within([i["InstanceId"] for i in response])
response = client.describe_instances(LayerId=S2L1)["Instances"]
response.should.have.length_of(1)
S2L1_i1.should.be.within([i["InstanceId"] for i in response])
response = client.describe_instances(LayerId=S2L2)["Instances"]
response.should.have.length_of(2)
S2L1_i1.should_not.be.within([i["InstanceId"] for i in response])
# ClientError
client.describe_instances.when.called_with(StackId=S1, LayerId=S1L1).should.throw(
Exception, "Please provide either one or more"
)
# ClientError
client.describe_instances.when.called_with(StackId="nothere").should.throw(
Exception, "nothere"
)
# ClientError
client.describe_instances.when.called_with(LayerId="nothere").should.throw(
Exception, "nothere"
)
# ClientError
client.describe_instances.when.called_with(InstanceIds=["nothere"]).should.throw(
Exception, "nothere"
)
@mock_opsworks
@mock_ec2
def test_ec2_integration():
"""
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",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
layer_id = opsworks.create_layer(
StackId=stack_id, Type="custom", Name="S1L1", Shortname="S1L1"
)["LayerId"]
instance_id = opsworks.create_instance(
AmiId=EXAMPLE_AMI_ID,
StackId=stack_id,
LayerIds=[layer_id],
InstanceType="t2.micro",
SshKeyName="testSSH",
)["InstanceId"]
ec2 = boto3.client("ec2", region_name="us-east-1")
# Before starting the instance, it shouldn't be discoverable via ec2
reservations = ec2.describe_instances()["Reservations"]
assert reservations.should.be.empty
# 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")
# 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)
instance = reservations[0]["Instances"][0]
opsworks_instance = opsworks.describe_instances(StackId=stack_id)["Instances"][0]
instance["InstanceId"].should.equal(opsworks_instance["Ec2InstanceId"])
instance["PrivateIpAddress"].should.equal(opsworks_instance["PrivateIp"])
# After starting the instance, its status should be "online"
opsworks_instance["Status"].should.equal("online")
import boto3
import pytest
from moto import mock_opsworks
from moto import mock_ec2
from tests import EXAMPLE_AMI_ID
@mock_opsworks
def test_create_instance():
client = boto3.client("opsworks", region_name="us-east-1")
stack_id = client.create_stack(
Name="test_stack_1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
layer_id = client.create_layer(
StackId=stack_id,
Type="custom",
Name="TestLayer",
Shortname="TestLayerShortName",
)["LayerId"]
second_stack_id = client.create_stack(
Name="test_stack_2",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
second_layer_id = client.create_layer(
StackId=second_stack_id,
Type="custom",
Name="SecondTestLayer",
Shortname="SecondTestLayerShortName",
)["LayerId"]
response = client.create_instance(
StackId=stack_id, LayerIds=[layer_id], InstanceType="t2.micro"
)
assert "InstanceId" in response
with pytest.raises(Exception) as exc:
client.create_instance(
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"
# ClientError
with pytest.raises(Exception) as exc:
client.create_instance(
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
with pytest.raises(Exception) as exc:
client.start_instance(InstanceId="nothere")
assert exc.value.response["Error"]["Message"] == (
"Unable to find instance with ID nothere"
)
@mock_opsworks
def test_describe_instances():
"""
create two stacks, with 1 layer and 2 layers (S1L1, S2L1, S2L2)
populate S1L1 with 2 instances (S1L1_i1, S1L1_i2)
populate S2L1 with 1 instance (S2L1_i1)
populate S2L2 with 3 instances (S2L2_i1..2)
"""
client = boto3.client("opsworks", region_name="us-east-1")
S1 = client.create_stack(
Name="S1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
S1L1 = client.create_layer(
StackId=S1, Type="custom", Name="S1L1", Shortname="S1L1"
)["LayerId"]
S2 = client.create_stack(
Name="S2",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
S2L1 = client.create_layer(
StackId=S2, Type="custom", Name="S2L1", Shortname="S2L1"
)["LayerId"]
S2L2 = client.create_layer(
StackId=S2, Type="custom", Name="S2L2", Shortname="S2L2"
)["LayerId"]
S1L1_i1 = client.create_instance(
StackId=S1, LayerIds=[S1L1], InstanceType="t2.micro"
)["InstanceId"]
S1L1_i2 = client.create_instance(
StackId=S1, LayerIds=[S1L1], InstanceType="t2.micro"
)["InstanceId"]
S2L1_i1 = client.create_instance(
StackId=S2, LayerIds=[S2L1], InstanceType="t2.micro"
)["InstanceId"]
S2L2_i1 = client.create_instance(
StackId=S2, LayerIds=[S2L2], InstanceType="t2.micro"
)["InstanceId"]
S2L2_i2 = client.create_instance(
StackId=S2, LayerIds=[S2L2], InstanceType="t2.micro"
)["InstanceId"]
# instances in Stack 1
response = client.describe_instances(StackId=S1)["Instances"]
assert len(response) == 2
assert S1L1_i1 in [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"]
assert sorted(response2, key=lambda d: d["InstanceId"]) == (
sorted(response, key=lambda d: d["InstanceId"])
)
response3 = client.describe_instances(LayerId=S1L1)["Instances"]
assert sorted(response3, key=lambda d: d["InstanceId"]) == (
sorted(response, key=lambda d: d["InstanceId"])
)
response = client.describe_instances(StackId=S1)["Instances"]
assert len(response) == 2
assert S1L1_i1 in [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"]
assert len(response) == 3
assert S2L1_i1 in [i["InstanceId"] for i in response]
assert S2L2_i1 in [i["InstanceId"] for i in response]
assert S2L2_i2 in [i["InstanceId"] for i in response]
response = client.describe_instances(LayerId=S2L1)["Instances"]
assert len(response) == 1
assert S2L1_i1 in [i["InstanceId"] for i in response]
response = client.describe_instances(LayerId=S2L2)["Instances"]
assert len(response) == 2
assert S2L1_i1 not in [i["InstanceId"] for i in response]
# ClientError
with pytest.raises(Exception) as exc:
client.describe_instances(StackId=S1, LayerId=S1L1)
assert "Please provide either one or more" in exc.value.response["Error"]["Message"]
# ClientError
with pytest.raises(Exception) as exc:
client.describe_instances(StackId="nothere")
assert "nothere" in exc.value.response["Error"]["Message"]
# ClientError
with pytest.raises(Exception) as exc:
client.describe_instances(LayerId="nothere")
assert "nothere" in exc.value.response["Error"]["Message"]
# ClientError
with pytest.raises(Exception) as exc:
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."""
opsworks = boto3.client("opsworks", region_name="us-east-1")
stack_id = opsworks.create_stack(
Name="S1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
layer_id = opsworks.create_layer(
StackId=stack_id, Type="custom", Name="S1L1", Shortname="S1L1"
)["LayerId"]
instance_id = opsworks.create_instance(
AmiId=EXAMPLE_AMI_ID,
StackId=stack_id,
LayerIds=[layer_id],
InstanceType="t2.micro",
SshKeyName="testSSH",
)["InstanceId"]
ec2 = boto3.client("ec2", region_name="us-east-1")
# Before starting the instance, it shouldn't be discoverable via ec2
reservations = ec2.describe_instances()["Reservations"]
assert not reservations
# Before starting the instance, its status should be "stopped"
opsworks_instance = opsworks.describe_instances(StackId=stack_id)["Instances"][0]
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"]
assert len(reservations[0]["Instances"]) == 1
instance = reservations[0]["Instances"][0]
opsworks_instance = opsworks.describe_instances(StackId=stack_id)["Instances"][0]
assert instance["InstanceId"] == opsworks_instance["Ec2InstanceId"]
assert instance["PrivateIpAddress"] == opsworks_instance["PrivateIp"]
# After starting the instance, its status should be "online"
assert opsworks_instance["Status"] == "online"

205
tests/test_opsworks/test_layers.py
View File

@ -1,95 +1,110 @@
import boto3
from freezegun import freeze_time
import sure # noqa # pylint: disable=unused-import
import re
from moto import mock_opsworks
@freeze_time("2015-01-01")
@mock_opsworks
def test_create_layer_response():
client = boto3.client("opsworks", region_name="us-east-1")
stack_id = client.create_stack(
Name="test_stack_1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
response = client.create_layer(
StackId=stack_id,
Type="custom",
Name="TestLayer",
Shortname="TestLayerShortName",
)
response.should.contain("LayerId")
second_stack_id = client.create_stack(
Name="test_stack_2",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
response = client.create_layer(
StackId=second_stack_id,
Type="custom",
Name="TestLayer",
Shortname="TestLayerShortName",
)
response.should.contain("LayerId")
# ClientError
client.create_layer.when.called_with(
StackId=stack_id, Type="custom", Name="TestLayer", Shortname="_"
).should.throw(Exception, re.compile(r'already a layer named "TestLayer"'))
# ClientError
client.create_layer.when.called_with(
StackId=stack_id, Type="custom", Name="_", Shortname="TestLayerShortName"
).should.throw(
Exception, re.compile(r'already a layer with shortname "TestLayerShortName"')
)
# ClientError
client.create_layer.when.called_with(
StackId="nothere", Type="custom", Name="TestLayer", Shortname="_"
).should.throw(Exception, "nothere")
@freeze_time("2015-01-01")
@mock_opsworks
def test_describe_layers():
client = boto3.client("opsworks", region_name="us-east-1")
stack_id = client.create_stack(
Name="test_stack_1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
layer_id = client.create_layer(
StackId=stack_id,
Type="custom",
Name="TestLayer",
Shortname="TestLayerShortName",
)["LayerId"]
rv1 = client.describe_layers(StackId=stack_id)
rv2 = client.describe_layers(LayerIds=[layer_id])
rv1["Layers"].should.equal(rv2["Layers"])
rv1["Layers"][0]["Name"].should.equal("TestLayer")
# ClientError
client.describe_layers.when.called_with(
StackId=stack_id, LayerIds=[layer_id]
).should.throw(Exception, "Please provide one or more layer IDs or a stack ID")
# ClientError
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(
Exception, "nothere"
)
import boto3
from freezegun import freeze_time
import pytest
from moto import mock_opsworks
@freeze_time("2015-01-01")
@mock_opsworks
def test_create_layer_response():
client = boto3.client("opsworks", region_name="us-east-1")
stack_id = client.create_stack(
Name="test_stack_1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
response = client.create_layer(
StackId=stack_id,
Type="custom",
Name="TestLayer",
Shortname="TestLayerShortName",
)
assert "LayerId" in response
second_stack_id = client.create_stack(
Name="test_stack_2",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
response = client.create_layer(
StackId=second_stack_id,
Type="custom",
Name="TestLayer",
Shortname="TestLayerShortName",
)
assert "LayerId" in response
# ClientError
with pytest.raises(Exception) as exc:
client.create_layer(
StackId=stack_id, Type="custom", Name="TestLayer", Shortname="_"
)
assert (
r'already a layer named "TestLayer"' in exc.value.response["Error"]["Message"]
)
# ClientError
with pytest.raises(Exception) as exc:
client.create_layer(
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")
@mock_opsworks
def test_describe_layers():
client = boto3.client("opsworks", region_name="us-east-1")
stack_id = client.create_stack(
Name="test_stack_1",
Region="us-east-1",
ServiceRoleArn="service_arn",
DefaultInstanceProfileArn="profile_arn",
)["StackId"]
layer_id = client.create_layer(
StackId=stack_id,
Type="custom",
Name="TestLayer",
Shortname="TestLayerShortName",
)["LayerId"]
rv1 = client.describe_layers(StackId=stack_id)
rv2 = client.describe_layers(LayerIds=[layer_id])
assert rv1["Layers"] == rv2["Layers"]
assert rv1["Layers"][0]["Name"] == "TestLayer"
# ClientError
with pytest.raises(Exception) as exc:
client.describe_layers(StackId=stack_id, LayerIds=[layer_id])
assert exc.value.response["Error"]["Message"] == (
"Please provide one or more layer IDs or a stack ID"
)
# ClientError
with pytest.raises(Exception) as exc:
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"

21
tests/test_opsworks/test_stack.py
View File

@ -1,6 +1,5 @@
import boto3
import sure # noqa # pylint: disable=unused-import
import re
import pytest
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")
stack["DefaultInstanceProfileArn"].should.equal("profile_arn")
assert stack["ServiceRoleArn"] == "service_arn"
assert stack["DefaultInstanceProfileArn"] == "profile_arn"
_id = response["Stacks"][0]["StackId"]
response = client.describe_stacks(StackIds=[_id])
response["Stacks"].should.have.length_of(1)
response["Stacks"][0]["Arn"].should.contain(_id)
assert len(response["Stacks"]) == 1
assert _id in response["Stacks"][0]["Arn"]
# ClientError/ResourceNotFoundException
client.describe_stacks.when.called_with(StackIds=["foo"]).should.throw(
Exception, re.compile(r"foo")
)
with pytest.raises(Exception) as exc:
client.describe_stacks(StackIds=["foo"])
assert r"foo" in exc.value.response["Error"]["Message"]