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

Techdebt: Replace sure with regular assertions in GreenGrass (#6490)

Browse Source
This commit is contained in:
Bert Blommers 2023-07-06 14:48:14 +00:00 committed by GitHub
parent 435519ff7a
commit 13e4a08dc6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 544 additions and 715 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
tests/test_greengrass/test_greengrass_core.py
View File

@ -11,7 +11,6 @@ from moto.settings import TEST_SERVER_MODE
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_core_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -25,20 +24,19 @@ def test_create_core_definition():
core_name = "TestCore"
res = client.create_core_definition(InitialVersion=initial_version, Name=core_name)
res.should.have.key("Arn")
res.should.have.key("Id")
assert "Arn" in res
assert "Id" in res
if not TEST_SERVER_MODE:
res.should.have.key("CreationTimestamp").equals("2022-06-01T12:00:00.000Z")
res.should.have.key("LastUpdatedTimestamp").equals("2022-06-01T12:00:00.000Z")
res.should.have.key("LatestVersionArn")
res.should.have.key("Name").equals(core_name)
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(201)
assert res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
assert "LatestVersionArn" in res
assert res["Name"] == core_name
assert res["ResponseMetadata"]["HTTPStatusCode"] == 201
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_core_definitions():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -52,27 +50,22 @@ def test_list_core_definitions():
core_name = "TestCore"
client.create_core_definition(InitialVersion=initial_version, Name=core_name)
res = client.list_core_definitions()
res.should.have.key("Definitions")
assert "Definitions" in res
core_definition = res["Definitions"][0]
core_definition.should.have.key("Name").equals(core_name)
core_definition.should.have.key("Arn")
core_definition.should.have.key("Id")
core_definition.should.have.key("LatestVersion")
core_definition.should.have.key("LatestVersionArn")
assert core_definition["Name"] == core_name
assert "Arn" in core_definition
assert "Id" in core_definition
assert "LatestVersion" in core_definition
assert "LatestVersionArn" in core_definition
if not TEST_SERVER_MODE:
core_definition.should.have.key("CreationTimestamp").equal(
"2022-06-01T12:00:00.000Z"
)
core_definition.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert core_definition["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert core_definition["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_core_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -95,22 +88,19 @@ def test_get_core_definition():
get_res = client.get_core_definition(CoreDefinitionId=core_def_id)
get_res.should.have.key("Name").equals(core_name)
get_res.should.have.key("Arn").equals(arn)
get_res.should.have.key("Id").equals(core_def_id)
get_res.should.have.key("LatestVersion").equals(latest_version)
get_res.should.have.key("LatestVersionArn").equals(latest_version_arn)
assert get_res["Name"] == core_name
assert get_res["Arn"] == arn
assert get_res["Id"] == core_def_id
assert get_res["LatestVersion"] == latest_version
assert get_res["LatestVersionArn"] == latest_version_arn
if not TEST_SERVER_MODE:
get_res.should.have.key("CreationTimestamp").equal("2022-06-01T12:00:00.000Z")
get_res.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert get_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert get_res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_delete_core_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -131,15 +121,13 @@ def test_delete_core_definition():
client.delete_core_definition(CoreDefinitionId=core_def_id)
with pytest.raises(ClientError) as ex:
client.delete_core_definition(CoreDefinitionId=core_def_id)
ex.value.response["Error"]["Message"].should.equal(
"That cores definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That cores definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_update_core_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -157,12 +145,11 @@ def test_update_core_definition():
updated_core_name = "UpdatedCore"
client.update_core_definition(CoreDefinitionId=core_def_id, Name="UpdatedCore")
get_res = client.get_core_definition(CoreDefinitionId=core_def_id)
get_res.should.have.key("Name").equals(updated_core_name)
assert get_res["Name"] == updated_core_name
@mock_greengrass
def test_update_core_definition_with_empty_name():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -180,32 +167,26 @@ def test_update_core_definition_with_empty_name():
with pytest.raises(ClientError) as ex:
client.update_core_definition(CoreDefinitionId=core_def_id, Name="")
ex.value.response["Error"]["Message"].should.equal(
"Input does not contain any attributes to be updated"
)
ex.value.response["Error"]["Code"].should.equal(
"InvalidContainerDefinitionException"
)
err = ex.value.response["Error"]
assert err["Message"] == "Input does not contain any attributes to be updated"
assert err["Code"] == "InvalidContainerDefinitionException"
@mock_greengrass
def test_update_core_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.update_core_definition(
CoreDefinitionId="6fbffc21-989e-4d29-a793-a42f450a78c6", Name="abc"
)
ex.value.response["Error"]["Message"].should.equal(
"That cores definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That cores definition does not exist."
assert err["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_core_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
v1_cores = [
{
@ -233,18 +214,17 @@ def test_create_core_definition_version():
core_def_ver_res = client.create_core_definition_version(
CoreDefinitionId=core_def_id, Cores=v2_cores
)
core_def_ver_res.should.have.key("Arn")
core_def_ver_res.should.have.key("CreationTimestamp")
assert "Arn" in core_def_ver_res
assert "CreationTimestamp" in core_def_ver_res
if not TEST_SERVER_MODE:
core_def_ver_res["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
core_def_ver_res.should.have.key("Id").equals(core_def_id)
core_def_ver_res.should.have.key("Version")
assert core_def_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert core_def_ver_res["Id"] == core_def_id
assert "Version" in core_def_ver_res
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_core_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
initial_version = {
"Cores": [
@ -266,18 +246,17 @@ def test_get_core_definition_version():
CoreDefinitionId=core_def_id, CoreDefinitionVersionId=core_def_ver_id
)
core_def_ver_res.should.have.key("Arn")
core_def_ver_res.should.have.key("CreationTimestamp")
core_def_ver_res.should.have.key("Definition").should.equal(initial_version)
assert "Arn" in core_def_ver_res
assert "CreationTimestamp" in core_def_ver_res
assert core_def_ver_res["Definition"] == initial_version
if not TEST_SERVER_MODE:
core_def_ver_res["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
core_def_ver_res.should.have.key("Id").equals(core_def_id)
core_def_ver_res.should.have.key("Version")
assert core_def_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert core_def_ver_res["Id"] == core_def_id
assert "Version" in core_def_ver_res
@mock_greengrass
def test_get_core_definition_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
@ -285,15 +264,13 @@ def test_get_core_definition_version_with_invalid_id():
CoreDefinitionId="fe2392e9-e67f-4308-af1b-ff94a128b231",
CoreDefinitionVersionId="cd2ea6dc-6634-4e89-8441-8003500435f9",
)
ex.value.response["Error"]["Message"].should.equal(
"That cores definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That cores definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_get_core_definition_version_with_invalid_version_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
core_def_res = client.create_core_definition(
Name="TestCore",
@ -313,16 +290,17 @@ def test_get_core_definition_version_with_invalid_version_id():
client.get_core_definition_version(
CoreDefinitionId=core_def_id, CoreDefinitionVersionId=invalid_version_id
)
ex.value.response["Error"]["Message"].should.equal(
f"Version {invalid_version_id} of Core List Definition {core_def_id} does not exist."
err = ex.value.response["Error"]
assert (
err["Message"]
== f"Version {invalid_version_id} of Core List Definition {core_def_id} does not exist."
)
ex.value.response["Error"]["Code"].should.equal("VersionNotFoundException")
assert err["Code"] == "VersionNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_core_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
initial_version = {
"Cores": [
@ -342,27 +320,25 @@ def test_list_core_definition_version():
CoreDefinitionId=core_def_id
)
core_def_vers_res.should.have.key("Versions")
assert "Versions" in core_def_vers_res
core_def_ver = core_def_vers_res["Versions"][0]
core_def_ver.should.have.key("Arn")
core_def_ver.should.have.key("CreationTimestamp")
assert "Arn" in core_def_ver
assert "CreationTimestamp" in core_def_ver
if not TEST_SERVER_MODE:
core_def_ver["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
core_def_ver.should.have.key("Id").equals(core_def_id)
core_def_ver.should.have.key("Version")
assert core_def_ver["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert core_def_ver["Id"] == core_def_id
assert "Version" in core_def_ver
@mock_greengrass
def test_list_core_definition_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.list_core_definition_versions(
CoreDefinitionId="cd2ea6dc-6634-4e89-8441-8003500435f9"
)
ex.value.response["Error"]["Message"].should.equal(
"That cores definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That cores definition does not exist."
assert err["Code"] == "IdNotFoundException"

153
tests/test_greengrass/test_greengrass_deployment.py
View File

@ -12,7 +12,6 @@ from moto.settings import TEST_SERVER_MODE
@mock_greengrass
def test_create_deployment():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -36,14 +35,13 @@ def test_create_deployment():
res = client.create_deployment(
GroupId=group_id, GroupVersionId=latest_grp_ver, DeploymentType="NewDeployment"
)
res.should.have.key("DeploymentArn")
res.should.have.key("DeploymentId")
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert "DeploymentArn" in res
assert "DeploymentId" in res
assert res["ResponseMetadata"]["HTTPStatusCode"] == 200
@mock_greengrass
def test_re_deployment_with_no_deployment_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -70,15 +68,16 @@ def test_re_deployment_with_no_deployment_id():
GroupVersionId=latest_grp_ver,
DeploymentType="Redeployment",
)
ex.value.response["Error"]["Message"].should.equal(
"Your request is missing the following required parameter(s): {DeploymentId}."
err = ex.value.response["Error"]
assert (
err["Message"]
== "Your request is missing the following required parameter(s): {DeploymentId}."
)
ex.value.response["Error"]["Code"].should.equal("InvalidInputException")
assert err["Code"] == "InvalidInputException"
@mock_greengrass
def test_re_deployment_with_invalid_deployment_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -107,15 +106,13 @@ def test_re_deployment_with_invalid_deployment_id():
DeploymentType="Redeployment",
DeploymentId=deployment_id,
)
ex.value.response["Error"]["Message"].should.equal(
f"Deployment ID '{deployment_id}' is invalid."
)
ex.value.response["Error"]["Code"].should.equal("InvalidInputException")
err = ex.value.response["Error"]
assert err["Message"] == f"Deployment ID '{deployment_id}' is invalid."
assert err["Code"] == "InvalidInputException"
@mock_greengrass
def test_create_deployment_with_no_core_group():
client = boto3.client("greengrass", region_name="ap-northeast-1")
create_group_res = client.create_group(Name="TestGroup")
group_id = create_group_res["Id"]
@ -128,20 +125,20 @@ def test_create_deployment_with_no_core_group():
DeploymentType="NewDeployment",
)
ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
ex.value.response["Error"]["Code"].should.equal("MissingCoreException")
assert ex.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
assert ex.value.response["Error"]["Code"] == "MissingCoreException"
err = json.loads(ex.value.response["Error"]["Message"])
err_details = err["ErrorDetails"]
err_details[0].should.have.key("DetailedErrorCode").equals("GG-303")
err_details[0].should.have.key("DetailedErrorMessage").equals(
"You need a Greengrass Core in this Group before you can deploy."
assert err_details[0]["DetailedErrorCode"] == "GG-303"
assert (
err_details[0]["DetailedErrorMessage"]
== "You need a Greengrass Core in this Group before you can deploy."
)
@mock_greengrass
def test_create_deployment_with_invalid_group_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.create_deployment(
@ -150,16 +147,15 @@ def test_create_deployment_with_invalid_group_id():
DeploymentType="NewDeployment",
)
ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(404)
ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
ex.value.response["Error"]["Message"].should.equal(
"That group definition does not exist."
assert ex.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
assert ex.value.response["Error"]["Code"] == "ResourceNotFoundException"
assert (
ex.value.response["Error"]["Message"] == "That group definition does not exist."
)
@mock_greengrass
def test_create_deployment_with_invalid_group_version_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -187,16 +183,16 @@ def test_create_deployment_with_invalid_group_version_id():
DeploymentType="NewDeployment",
)
ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(404)
ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
ex.value.response["Error"]["Message"].should.equal(
f"Version {group_version_id} of Group Definition {group_id} does not exist."
assert ex.value.response["ResponseMetadata"]["HTTPStatusCode"] == 404
assert ex.value.response["Error"]["Code"] == "ResourceNotFoundException"
assert (
ex.value.response["Error"]["Message"]
== f"Version {group_version_id} of Group Definition {group_id} does not exist."
)
@mock_greengrass
def test_create_deployment_with_invalid_deployment_type():
client = boto3.client("greengrass", region_name="ap-northeast-1")
create_group_res = client.create_group(Name="TestGroup")
group_id = create_group_res["Id"]
@ -209,17 +205,18 @@ def test_create_deployment_with_invalid_deployment_type():
DeploymentType="InvalidDeploymentType",
)
ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
ex.value.response["Error"]["Code"].should.equal("InvalidInputException")
ex.value.response["Error"]["Message"].should.equal(
"That deployment type is not valid. Please specify one of the following types: {NewDeployment,Redeployment,ResetDeployment,ForceResetDeployment}."
assert ex.value.response["ResponseMetadata"]["HTTPStatusCode"] == 400
err = ex.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "That deployment type is not valid. Please specify one of the following types: {NewDeployment,Redeployment,ResetDeployment,ForceResetDeployment}."
)
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_deployments():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -246,23 +243,22 @@ def test_list_deployments():
)
res = client.list_deployments(GroupId=group_id)
res.should.have.key("Deployments")
assert "Deployments" in res
deployments = res["Deployments"][0]
deployments.should.have.key("CreatedAt")
deployments.should.have.key("DeploymentArn")
deployments.should.have.key("DeploymentId")
deployments.should.have.key("DeploymentType").equals(deployment_type)
deployments.should.have.key("GroupArn").equals(latest_grp_ver_arn)
assert "CreatedAt" in deployments
assert "DeploymentArn" in deployments
assert "DeploymentId" in deployments
assert deployments["DeploymentType"] == deployment_type
assert deployments["GroupArn"] == latest_grp_ver_arn
if not TEST_SERVER_MODE:
deployments.should.have.key("CreatedAt").equal("2022-06-01T12:00:00.000Z")
assert deployments["CreatedAt"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_deployment_status():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -290,18 +286,17 @@ def test_get_deployment_status():
deployment_id = create_deployment_res["DeploymentId"]
res = client.get_deployment_status(GroupId=group_id, DeploymentId=deployment_id)
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
res.should.have.key("DeploymentStatus").equal("InProgress")
res.should.have.key("DeploymentType").equal(deployment_type)
res.should.have.key("UpdatedAt")
assert res["ResponseMetadata"]["HTTPStatusCode"] == 200
assert res["DeploymentStatus"] == "InProgress"
assert res["DeploymentType"] == deployment_type
assert "UpdatedAt" in res
if not TEST_SERVER_MODE:
res.should.have.key("UpdatedAt").equal("2022-06-01T12:00:00.000Z")
assert res["UpdatedAt"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_deployment_status_with_invalid_deployment_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
create_group_res = client.create_group(Name="TestGroup")
group_id = create_group_res["Id"]
@ -310,15 +305,13 @@ def test_get_deployment_status_with_invalid_deployment_id():
with pytest.raises(ClientError) as ex:
client.get_deployment_status(GroupId=group_id, DeploymentId=deployment_id)
ex.value.response["Error"]["Message"].should.equal(
f"Deployment '{deployment_id}' does not exist."
)
ex.value.response["Error"]["Code"].should.equal("InvalidInputException")
err = ex.value.response["Error"]
assert err["Message"] == f"Deployment '{deployment_id}' does not exist."
assert err["Code"] == "InvalidInputException"
@mock_greengrass
def test_get_deployment_status_with_invalid_group_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -349,10 +342,9 @@ def test_get_deployment_status_with_invalid_group_id():
client.get_deployment_status(
GroupId="7b0bdeae-54c7-47cf-9f93-561e672efd9c", DeploymentId=deployment_id
)
ex.value.response["Error"]["Message"].should.equal(
f"Deployment '{deployment_id}' does not exist."
)
ex.value.response["Error"]["Code"].should.equal("InvalidInputException")
err = ex.value.response["Error"]
assert err["Message"] == f"Deployment '{deployment_id}' does not exist."
assert err["Code"] == "InvalidInputException"
@pytest.mark.skipif(
@ -362,7 +354,6 @@ def test_get_deployment_status_with_invalid_group_id():
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_reset_deployments():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -389,20 +380,20 @@ def test_reset_deployments():
reset_res = client.reset_deployments(GroupId=group_id)
reset_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
reset_res.should.have.key("DeploymentId")
reset_res.should.have.key("DeploymentArn")
assert reset_res["ResponseMetadata"]["HTTPStatusCode"] == 200
assert "DeploymentId" in reset_res
assert "DeploymentArn" in reset_res
list_res = client.list_deployments(GroupId=group_id)
reset_deployment = list_res["Deployments"][1]
reset_deployment.should.have.key("CreatedAt")
reset_deployment.should.have.key("DeploymentArn")
reset_deployment.should.have.key("DeploymentId")
reset_deployment.should.have.key("DeploymentType").should.equal("ResetDeployment")
reset_deployment.should.have.key("GroupArn").should.equal(group_arn)
assert "CreatedAt" in reset_deployment
assert "DeploymentArn" in reset_deployment
assert "DeploymentId" in reset_deployment
assert reset_deployment["DeploymentType"] == "ResetDeployment"
assert reset_deployment["GroupArn"] == group_arn
if not TEST_SERVER_MODE:
reset_deployment["CreatedAt"].should.equal("2022-06-01T12:00:00.000Z")
assert reset_deployment["CreatedAt"] == "2022-06-01T12:00:00.000Z"
@pytest.mark.skipif(
@ -411,15 +402,13 @@ def test_reset_deployments():
)
@mock_greengrass
def test_reset_deployments_with_invalid_group_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.reset_deployments(GroupId="7b0bdeae-54c7-47cf-9f93-561e672efd9c")
ex.value.response["Error"]["Message"].should.equal(
"That Group Definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That Group Definition does not exist."
assert err["Code"] == "ResourceNotFoundException"
@pytest.mark.skipif(
@ -428,7 +417,6 @@ def test_reset_deployments_with_invalid_group_id():
)
@mock_greengrass
def test_reset_deployments_with_never_deployed_group():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -449,10 +437,12 @@ def test_reset_deployments_with_never_deployed_group():
with pytest.raises(ClientError) as ex:
client.reset_deployments(GroupId=group_id)
ex.value.response["Error"]["Message"].should.equal(
f"Group id: {group_id} has not been deployed or has already been reset."
err = ex.value.response["Error"]
assert (
err["Message"]
== f"Group id: {group_id} has not been deployed or has already been reset."
)
ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
assert err["Code"] == "ResourceNotFoundException"
@pytest.mark.skipif(
@ -461,7 +451,6 @@ def test_reset_deployments_with_never_deployed_group():
)
@mock_greengrass
def test_reset_deployments_with_already_reset_group():
client = boto3.client("greengrass", region_name="ap-northeast-1")
cores = [
{
@ -488,7 +477,9 @@ def test_reset_deployments_with_already_reset_group():
with pytest.raises(ClientError) as ex:
client.reset_deployments(GroupId=group_id)
ex.value.response["Error"]["Message"].should.equal(
f"Group id: {group_id} has not been deployed or has already been reset."
err = ex.value.response["Error"]
assert (
err["Message"]
== f"Group id: {group_id} has not been deployed or has already been reset."
)
ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
assert err["Code"] == "ResourceNotFoundException"

159
tests/test_greengrass/test_greengrass_device.py
View File

@ -11,7 +11,6 @@ from moto.settings import TEST_SERVER_MODE
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_device_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Devices": [
@ -26,22 +25,21 @@ def test_create_device_definition():
device_name = "TestDevice"
res = client.create_device_definition(InitialVersion=init_ver, Name=device_name)
res.should.have.key("Arn")
res.should.have.key("Id")
res.should.have.key("LatestVersion")
res.should.have.key("LatestVersionArn")
res.should.have.key("Name").equals(device_name)
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(201)
assert "Arn" in res
assert "Id" in res
assert "LatestVersion" in res
assert "LatestVersionArn" in res
assert res["Name"] == device_name
assert res["ResponseMetadata"]["HTTPStatusCode"] == 201
if not TEST_SERVER_MODE:
res.should.have.key("CreationTimestamp").equals("2022-06-01T12:00:00.000Z")
res.should.have.key("LastUpdatedTimestamp").equals("2022-06-01T12:00:00.000Z")
assert res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_device_definitions():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Devices": [
@ -58,27 +56,22 @@ def test_list_device_definitions():
client.create_device_definition(InitialVersion=init_ver, Name=device_name)
res = client.list_device_definitions()
res.should.have.key("Definitions")
assert "Definitions" in res
device_definition = res["Definitions"][0]
device_definition.should.have.key("Name").equals(device_name)
device_definition.should.have.key("Arn")
device_definition.should.have.key("Id")
device_definition.should.have.key("LatestVersion")
device_definition.should.have.key("LatestVersionArn")
assert device_definition["Name"] == device_name
assert "Arn" in device_definition
assert "Id" in device_definition
assert "LatestVersion" in device_definition
assert "LatestVersionArn" in device_definition
if not TEST_SERVER_MODE:
device_definition.should.have.key("CreationTimestamp").equal(
"2022-06-01T12:00:00.000Z"
)
device_definition.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert device_definition["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert device_definition["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_device_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Devices": [
@ -102,37 +95,32 @@ def test_get_device_definition():
get_res = client.get_device_definition(DeviceDefinitionId=device_def_id)
get_res.should.have.key("Name").equals(device_name)
get_res.should.have.key("Arn").equals(arn)
get_res.should.have.key("Id").equals(device_def_id)
get_res.should.have.key("LatestVersion").equals(latest_version)
get_res.should.have.key("LatestVersionArn").equals(latest_version_arn)
assert get_res["Name"] == device_name
assert get_res["Arn"] == arn
assert get_res["Id"] == device_def_id
assert get_res["LatestVersion"] == latest_version
assert get_res["LatestVersionArn"] == latest_version_arn
if not TEST_SERVER_MODE:
get_res.should.have.key("CreationTimestamp").equal("2022-06-01T12:00:00.000Z")
get_res.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert get_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert get_res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_device_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.get_device_definition(
DeviceDefinitionId="b552443b-1888-469b-81f8-0ebc5ca92949"
)
ex.value.response["Error"]["Message"].should.equal(
"That Device List Definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That Device List Definition does not exist."
assert err["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_device_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
v1_devices = [
{
@ -161,19 +149,18 @@ def test_create_device_definition_version():
device_def_ver_res = client.create_device_definition_version(
DeviceDefinitionId=device_def_id, Devices=v2_devices
)
device_def_ver_res.should.have.key("Arn")
device_def_ver_res.should.have.key("CreationTimestamp")
device_def_ver_res.should.have.key("Id").equals(device_def_id)
device_def_ver_res.should.have.key("Version")
assert "Arn" in device_def_ver_res
assert "CreationTimestamp" in device_def_ver_res
assert device_def_ver_res["Id"] == device_def_id
assert "Version" in device_def_ver_res
if not TEST_SERVER_MODE:
device_def_ver_res["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
assert device_def_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_device_definition_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
devices = [
{
@ -192,15 +179,13 @@ def test_create_device_definition_version_with_invalid_id():
client.create_device_definition_version(
DeviceDefinitionId="123", Devices=devices
)
ex.value.response["Error"]["Message"].should.equal(
"That devices definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That devices definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_delete_device_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
devices = [
{
@ -217,27 +202,24 @@ def test_delete_device_definition():
device_def_id = create_res["Id"]
del_res = client.delete_device_definition(DeviceDefinitionId=device_def_id)
del_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert del_res["ResponseMetadata"]["HTTPStatusCode"] == 200
@mock_greengrass
def test_delete_device_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.delete_device_definition(
DeviceDefinitionId="6fbffc21-989e-4d29-a793-a42f450a78c6"
)
ex.value.response["Error"]["Message"].should.equal(
"That devices definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That devices definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_update_device_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
devices = [
{
@ -257,15 +239,14 @@ def test_update_device_definition():
update_res = client.update_device_definition(
DeviceDefinitionId=device_def_id, Name=updated_device_name
)
update_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert update_res["ResponseMetadata"]["HTTPStatusCode"] == 200
get_res = client.get_device_definition(DeviceDefinitionId=device_def_id)
get_res.should.have.key("Name").equals(updated_device_name)
assert get_res["Name"] == updated_device_name
@mock_greengrass
def test_update_device_definition_with_empty_name():
client = boto3.client("greengrass", region_name="ap-northeast-1")
devices = [
{
@ -284,33 +265,27 @@ def test_update_device_definition_with_empty_name():
with pytest.raises(ClientError) as ex:
client.update_device_definition(DeviceDefinitionId=device_def_id, Name="")
ex.value.response["Error"]["Message"].should.equal(
"Input does not contain any attributes to be updated"
)
ex.value.response["Error"]["Code"].should.equal(
"InvalidContainerDefinitionException"
)
err = ex.value.response["Error"]
assert err["Message"] == "Input does not contain any attributes to be updated"
assert err["Code"] == "InvalidContainerDefinitionException"
@mock_greengrass
def test_update_device_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.update_device_definition(
DeviceDefinitionId="6fbffc21-989e-4d29-a793-a42f450a78c6", Name="123"
)
ex.value.response["Error"]["Message"].should.equal(
"That devices definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That devices definition does not exist."
assert err["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_device_definition_versions():
client = boto3.client("greengrass", region_name="ap-northeast-1")
devices = [
{
@ -331,21 +306,20 @@ def test_list_device_definition_versions():
DeviceDefinitionId=device_def_id
)
device_def_vers_res.should.have.key("Versions")
assert "Versions" in device_def_vers_res
device_def_ver = device_def_vers_res["Versions"][0]
device_def_ver.should.have.key("Arn")
device_def_ver.should.have.key("CreationTimestamp")
assert "Arn" in device_def_ver
assert "CreationTimestamp" in device_def_ver
if not TEST_SERVER_MODE:
device_def_ver["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
device_def_ver.should.have.key("Id").equals(device_def_id)
device_def_ver.should.have.key("Version")
assert device_def_ver["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert device_def_ver["Id"] == device_def_id
assert "Version" in device_def_ver
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_device_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
devices = [
{
@ -368,33 +342,30 @@ def test_get_device_definition_version():
DeviceDefinitionId=device_def_id, DeviceDefinitionVersionId=device_def_ver_id
)
core_def_ver_res.should.have.key("Arn")
core_def_ver_res.should.have.key("CreationTimestamp")
core_def_ver_res.should.have.key("Definition").should.equal(initial_version)
assert "Arn" in core_def_ver_res
assert "CreationTimestamp" in core_def_ver_res
assert core_def_ver_res["Definition"] == initial_version
if not TEST_SERVER_MODE:
core_def_ver_res["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
core_def_ver_res.should.have.key("Id").equals(device_def_id)
core_def_ver_res.should.have.key("Version")
assert core_def_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert core_def_ver_res["Id"] == device_def_id
assert "Version" in core_def_ver_res
@mock_greengrass
def test_get_device_definition_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.get_device_definition_version(
DeviceDefinitionId="fe2392e9-e67f-4308-af1b-ff94a128b231",
DeviceDefinitionVersionId="cd2ea6dc-6634-4e89-8441-8003500435f9",
)
ex.value.response["Error"]["Message"].should.equal(
"That devices definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That devices definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_get_device_definition_version_with_invalid_version_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
devices = [
{
@ -417,7 +388,9 @@ def test_get_device_definition_version_with_invalid_version_id():
DeviceDefinitionId=device_def_id,
DeviceDefinitionVersionId=invalid_device_version_id,
)
ex.value.response["Error"]["Message"].should.equal(
f"Version {invalid_device_version_id} of Device List Definition {device_def_id} does not exist."
err = ex.value.response["Error"]
assert (
err["Message"]
== f"Version {invalid_device_version_id} of Device List Definition {device_def_id} does not exist."
)
ex.value.response["Error"]["Code"].should.equal("VersionNotFoundException")
assert err["Code"] == "VersionNotFoundException"

163
tests/test_greengrass/test_greengrass_functions.py
View File

@ -11,7 +11,6 @@ from moto.settings import TEST_SERVER_MODE
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_function_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Functions": [
@ -29,22 +28,21 @@ def test_create_function_definition():
}
func_name = "TestFunc"
res = client.create_function_definition(InitialVersion=init_ver, Name=func_name)
res.should.have.key("Arn")
res.should.have.key("Id")
res.should.have.key("LatestVersion")
res.should.have.key("LatestVersionArn")
res.should.have.key("Name").equals(func_name)
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(201)
assert "Arn" in res
assert "Id" in res
assert "LatestVersion" in res
assert "LatestVersionArn" in res
assert res["Name"] == func_name
assert res["ResponseMetadata"]["HTTPStatusCode"] == 201
if not TEST_SERVER_MODE:
res.should.have.key("CreationTimestamp").equals("2022-06-01T12:00:00.000Z")
res.should.have.key("LastUpdatedTimestamp").equals("2022-06-01T12:00:00.000Z")
assert res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_function_definitions():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Functions": [
@ -66,22 +64,19 @@ def test_list_function_definitions():
res = client.list_function_definitions()
func_def = res["Definitions"][0]
func_def.should.have.key("Name").equals(func_name)
func_def.should.have.key("Arn")
func_def.should.have.key("Id")
func_def.should.have.key("LatestVersion")
func_def.should.have.key("LatestVersionArn")
assert func_def["Name"] == func_name
assert "Arn" in func_def
assert "Id" in func_def
assert "LatestVersion" in func_def
assert "LatestVersionArn" in func_def
if not TEST_SERVER_MODE:
func_def.should.have.key("CreationTimestamp").equal("2022-06-01T12:00:00.000Z")
func_def.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert func_def["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert func_def["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_function_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Functions": [
@ -109,37 +104,32 @@ def test_get_function_definition():
get_res = client.get_function_definition(FunctionDefinitionId=func_def_id)
get_res.should.have.key("Name").equals(func_name)
get_res.should.have.key("Arn").equals(arn)
get_res.should.have.key("Id").equals(func_def_id)
get_res.should.have.key("LatestVersion").equals(latest_version)
get_res.should.have.key("LatestVersionArn").equals(latest_version_arn)
get_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert get_res["Name"] == func_name
assert get_res["Arn"] == arn
assert get_res["Id"] == func_def_id
assert get_res["LatestVersion"] == latest_version
assert get_res["LatestVersionArn"] == latest_version_arn
assert get_res["ResponseMetadata"]["HTTPStatusCode"] == 200
if not TEST_SERVER_MODE:
get_res.should.have.key("CreationTimestamp").equal("2022-06-01T12:00:00.000Z")
get_res.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert get_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert get_res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_function_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.get_function_definition(
FunctionDefinitionId="b552443b-1888-469b-81f8-0ebc5ca92949"
)
ex.value.response["Error"]["Message"].should.equal(
"That Lambda List Definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That Lambda List Definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_delete_function_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Functions": [
@ -161,27 +151,24 @@ def test_delete_function_definition():
func_def_id = create_res["Id"]
del_res = client.delete_function_definition(FunctionDefinitionId=func_def_id)
del_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert del_res["ResponseMetadata"]["HTTPStatusCode"] == 200
@mock_greengrass
def test_delete_function_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.delete_function_definition(
FunctionDefinitionId="6fbffc21-989e-4d29-a793-a42f450a78c6"
)
ex.value.response["Error"]["Message"].should.equal(
"That lambdas definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That lambdas definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_update_function_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Functions": [
@ -206,15 +193,14 @@ def test_update_function_definition():
update_res = client.update_function_definition(
FunctionDefinitionId=func_def_id, Name=updated_func_name
)
update_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert update_res["ResponseMetadata"]["HTTPStatusCode"] == 200
get_res = client.get_function_definition(FunctionDefinitionId=func_def_id)
get_res.should.have.key("Name").equals(updated_func_name)
assert get_res["Name"] == updated_func_name
@mock_greengrass
def test_update_function_definition_with_empty_name():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Functions": [
@ -238,33 +224,27 @@ def test_update_function_definition_with_empty_name():
with pytest.raises(ClientError) as ex:
client.update_function_definition(FunctionDefinitionId=func_def_id, Name="")
ex.value.response["Error"]["Message"].should.equal(
"Input does not contain any attributes to be updated"
)
ex.value.response["Error"]["Code"].should.equal(
"InvalidContainerDefinitionException"
)
err = ex.value.response["Error"]
assert err["Message"] == "Input does not contain any attributes to be updated"
assert err["Code"] == "InvalidContainerDefinitionException"
@mock_greengrass
def test_update_function_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.update_function_definition(
FunctionDefinitionId="6fbffc21-989e-4d29-a793-a42f450a78c6", Name="123"
)
ex.value.response["Error"]["Message"].should.equal(
"That lambdas definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
rr = ex.value.response["Error"]
assert rr["Message"] == "That lambdas definition does not exist."
assert rr["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_function_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
v1_functions = [
{
@ -301,18 +281,17 @@ def test_create_function_definition_version():
func_def_ver_res = client.create_function_definition_version(
FunctionDefinitionId=func_def_id, Functions=v2_functions
)
func_def_ver_res.should.have.key("Arn")
func_def_ver_res.should.have.key("CreationTimestamp")
func_def_ver_res.should.have.key("Id").equals(func_def_id)
func_def_ver_res.should.have.key("Version")
assert "Arn" in func_def_ver_res
assert "CreationTimestamp" in func_def_ver_res
assert func_def_ver_res["Id"] == func_def_id
assert "Version" in func_def_ver_res
if not TEST_SERVER_MODE:
func_def_ver_res["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
assert func_def_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_create_function_definition_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
functions = [
{
@ -331,14 +310,14 @@ def test_create_function_definition_version_with_invalid_id():
FunctionDefinitionId="7b0bdeae-54c7-47cf-9f93-561e672efd9c",
Functions=functions,
)
ex.value.response["Error"]["Message"].should.equal("That lambdas does not exist.")
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That lambdas does not exist."
assert err["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_function_definition_versions():
client = boto3.client("greengrass", region_name="ap-northeast-1")
functions = [
{
@ -363,36 +342,33 @@ def test_list_function_definition_versions():
FunctionDefinitionId=func_def_id
)
func_def_vers_res.should.have.key("Versions")
assert "Versions" in func_def_vers_res
device_def_ver = func_def_vers_res["Versions"][0]
device_def_ver.should.have.key("Arn")
device_def_ver.should.have.key("CreationTimestamp")
assert "Arn" in device_def_ver
assert "CreationTimestamp" in device_def_ver
if not TEST_SERVER_MODE:
device_def_ver["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
device_def_ver.should.have.key("Id").equals(func_def_id)
device_def_ver.should.have.key("Version")
assert device_def_ver["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert device_def_ver["Id"] == func_def_id
assert "Version" in device_def_ver
@mock_greengrass
def test_list_function_definition_versions_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.list_function_definition_versions(
FunctionDefinitionId="7b0bdeae-54c7-47cf-9f93-561e672efd9c"
)
ex.value.response["Error"]["Message"].should.equal(
"That lambdas definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That lambdas definition does not exist."
assert err["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_function_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
functions = [
{
@ -419,19 +395,18 @@ def test_get_function_definition_version():
FunctionDefinitionId=func_def_id, FunctionDefinitionVersionId=func_def_ver_id
)
func_def_ver_res.should.have.key("Arn")
func_def_ver_res.should.have.key("CreationTimestamp")
func_def_ver_res.should.have.key("Definition").should.equal(initial_version)
func_def_ver_res.should.have.key("Id").equals(func_def_id)
func_def_ver_res.should.have.key("Version")
assert "Arn" in func_def_ver_res
assert "CreationTimestamp" in func_def_ver_res
assert func_def_ver_res["Definition"] == initial_version
assert func_def_ver_res["Id"] == func_def_id
assert "Version" in func_def_ver_res
if not TEST_SERVER_MODE:
func_def_ver_res["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
assert func_def_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_function_definition_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
@ -439,15 +414,13 @@ def test_get_function_definition_version_with_invalid_id():
FunctionDefinitionId="7b0bdeae-54c7-47cf-9f93-561e672efd9c",
FunctionDefinitionVersionId="7b0bdeae-54c7-47cf-9f93-561e672efd9c",
)
ex.value.response["Error"]["Message"].should.equal(
"That lambdas definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That lambdas definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_get_function_definition_version_with_invalid_version_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
functions = [
{
@ -475,7 +448,9 @@ def test_get_function_definition_version_with_invalid_version_id():
FunctionDefinitionId=func_def_id,
FunctionDefinitionVersionId=invalid_func_def_ver_id,
)
ex.value.response["Error"]["Message"].should.equal(
f"Version {invalid_func_def_ver_id} of Lambda List Definition {func_def_id} does not exist."
err = ex.value.response["Error"]
assert (
err["Message"]
== f"Version {invalid_func_def_ver_id} of Lambda List Definition {func_def_id} does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
assert err["Code"] == "IdNotFoundException"

219
tests/test_greengrass/test_greengrass_groups.py
View File

@ -11,7 +11,6 @@ from moto.settings import TEST_SERVER_MODE
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_group():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_core_ver = {
"Cores": [
@ -32,27 +31,22 @@ def test_create_group():
grp_name = "TestGroup"
create_grp_res = client.create_group(Name=grp_name, InitialVersion=init_grp)
create_grp_res.should.have.key("Arn")
create_grp_res.should.have.key("Id")
create_grp_res.should.have.key("LastUpdatedTimestamp")
create_grp_res.should.have.key("LatestVersion")
create_grp_res.should.have.key("LatestVersionArn")
create_grp_res.should.have.key("Name").equals(grp_name)
create_grp_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(201)
assert "Arn" in create_grp_res
assert "Id" in create_grp_res
assert "LastUpdatedTimestamp" in create_grp_res
assert "LatestVersion" in create_grp_res
assert "LatestVersionArn" in create_grp_res
assert create_grp_res["Name"] == grp_name
assert create_grp_res["ResponseMetadata"]["HTTPStatusCode"] == 201
if not TEST_SERVER_MODE:
create_grp_res.should.have.key("CreationTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
create_grp_res.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert create_grp_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert create_grp_res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_groups():
client = boto3.client("greengrass", region_name="ap-northeast-1")
grp_name = "TestGroup"
create_grp_res = client.create_group(Name=grp_name)
@ -61,20 +55,19 @@ def test_list_groups():
list_res = client.list_groups()
group = list_res["Groups"][0]
group.should.have.key("Name").equals(grp_name)
group.should.have.key("Arn")
group.should.have.key("Id").equals(group_id)
group.should.have.key("LatestVersion")
group.should.have.key("LatestVersionArn")
assert group["Name"] == grp_name
assert "Arn" in group
assert group["Id"] == group_id
assert "LatestVersion" in group
assert "LatestVersionArn" in group
if not TEST_SERVER_MODE:
group.should.have.key("CreationTimestamp").equal("2022-06-01T12:00:00.000Z")
group.should.have.key("LastUpdatedTimestamp").equals("2022-06-01T12:00:00.000Z")
assert group["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert group["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_group():
client = boto3.client("greengrass", region_name="ap-northeast-1")
grp_name = "TestGroup"
create_res = client.create_group(Name=grp_name)
@ -85,74 +78,65 @@ def test_get_group():
get_res = client.get_group(GroupId=group_id)
get_res.should.have.key("Name").equals(grp_name)
get_res.should.have.key("Arn").equals(group_arn)
get_res.should.have.key("Id").equals(group_id)
get_res.should.have.key("LatestVersion").equals(latest_version)
get_res.should.have.key("LatestVersionArn").equals(latest_version_arn)
get_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert get_res["Name"] == grp_name
assert get_res["Arn"] == group_arn
assert get_res["Id"] == group_id
assert get_res["LatestVersion"] == latest_version
assert get_res["LatestVersionArn"] == latest_version_arn
assert get_res["ResponseMetadata"]["HTTPStatusCode"] == 200
if not TEST_SERVER_MODE:
get_res.should.have.key("CreationTimestamp").equal("2022-06-01T12:00:00.000Z")
get_res.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert get_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert get_res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_group_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.get_group(GroupId="b552443b-1888-469b-81f8-0ebc5ca92949")
ex.value.response["Error"]["Message"].should.equal(
"That Group Definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That Group Definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_delete_group():
client = boto3.client("greengrass", region_name="ap-northeast-1")
create_res = client.create_group(Name="TestGroup")
group_id = create_res["Id"]
del_res = client.delete_group(GroupId=group_id)
del_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert del_res["ResponseMetadata"]["HTTPStatusCode"] == 200
@mock_greengrass
def test_delete_group_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.delete_group(GroupId="6fbffc21-989e-4d29-a793-a42f450a78c6")
ex.value.response["Error"]["Message"].should.equal(
"That group definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That group definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_update_group():
client = boto3.client("greengrass", region_name="ap-northeast-1")
create_res = client.create_group(Name="TestGroup")
group_id = create_res["Id"]
updated_group_name = "UpdatedGroup"
update_res = client.update_group(GroupId=group_id, Name=updated_group_name)
update_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert update_res["ResponseMetadata"]["HTTPStatusCode"] == 200
get_res = client.get_group(GroupId=group_id)
get_res.should.have.key("Name").equals(updated_group_name)
assert get_res["Name"] == updated_group_name
@mock_greengrass
def test_update_group_with_empty_name():
client = boto3.client("greengrass", region_name="ap-northeast-1")
create_res = client.create_group(Name="TestGroup")
@ -160,54 +144,48 @@ def test_update_group_with_empty_name():
with pytest.raises(ClientError) as ex:
client.update_group(GroupId=group_id, Name="")
ex.value.response["Error"]["Message"].should.equal(
"Input does not contain any attributes to be updated"
)
ex.value.response["Error"]["Code"].should.equal(
"InvalidContainerDefinitionException"
)
err = ex.value.response["Error"]
assert err["Message"] == "Input does not contain any attributes to be updated"
assert err["Code"] == "InvalidContainerDefinitionException"
@mock_greengrass
def test_update_group_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.update_group(GroupId="6fbffc21-989e-4d29-a793-a42f450a78c6", Name="123")
ex.value.response["Error"]["Message"].should.equal(
"That group definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That group definition does not exist."
assert err["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_group_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
create_grp_res = client.create_group(Name="TestGroup")
group_id = create_grp_res["Id"]
group_ver_res = client.create_group_version(GroupId=group_id)
group_ver_res.should.have.key("Arn")
group_ver_res.should.have.key("CreationTimestamp")
group_ver_res.should.have.key("Id").equals(group_id)
group_ver_res.should.have.key("Version")
assert "Arn" in group_ver_res
assert "CreationTimestamp" in group_ver_res
assert group_ver_res["Id"] == group_id
assert "Version" in group_ver_res
if not TEST_SERVER_MODE:
group_ver_res["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
assert group_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_create_group_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.create_group_version(GroupId="cd2ea6dc-6634-4e89-8441-8003500435f9")
ex.value.response["Error"]["Message"].should.equal("That group does not exist.")
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That group does not exist."
assert err["Code"] == "IdNotFoundException"
@pytest.mark.parametrize(
@ -269,7 +247,6 @@ def test_create_group_version_with_invalid_id():
def test_create_group_version_with_invalid_version_arn(
def_ver_key_name, arn, error_message
):
client = boto3.client("greengrass", region_name="ap-northeast-1")
create_grp_res = client.create_group(Name="TestGroup")
group_id = create_grp_res["Id"]
@ -279,50 +256,48 @@ def test_create_group_version_with_invalid_version_arn(
with pytest.raises(ClientError) as ex:
client.create_group_version(GroupId=group_id, **definition_versions)
ex.value.response["Error"]["Message"].should.equal(
f"The group is invalid or corrupted. (ErrorDetails: [{error_message}])"
err = ex.value.response["Error"]
assert (
err["Message"]
== f"The group is invalid or corrupted. (ErrorDetails: [{error_message}])"
)
ex.value.response["Error"]["Code"].should.equal("400")
assert err["Code"] == "400"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_group_versions():
client = boto3.client("greengrass", region_name="ap-northeast-1")
create_res = client.create_group(Name="TestGroup")
group_id = create_res["Id"]
group_vers_res = client.list_group_versions(GroupId=group_id)
group_vers_res.should.have.key("Versions")
assert "Versions" in group_vers_res
group_ver = group_vers_res["Versions"][0]
group_ver.should.have.key("Arn")
group_ver.should.have.key("CreationTimestamp")
group_ver.should.have.key("Id").equals(group_id)
group_ver.should.have.key("Version")
assert "Arn" in group_ver
assert "CreationTimestamp" in group_ver
assert group_ver["Id"] == group_id
assert "Version" in group_ver
if not TEST_SERVER_MODE:
group_ver["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
assert group_ver["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_list_group_versions_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.list_group_versions(GroupId="7b0bdeae-54c7-47cf-9f93-561e672efd9c")
ex.value.response["Error"]["Message"].should.equal(
"That group definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That group definition does not exist."
assert err["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_group_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_core_ver = {
"Cores": [
@ -427,19 +402,18 @@ def test_get_group_version():
GroupId=group_id, GroupVersionId=group_ver_id
)
group_ver_res.should.have.key("Arn")
group_ver_res.should.have.key("CreationTimestamp")
group_ver_res.should.have.key("Definition").should.equal(definition)
group_ver_res.should.have.key("Id").equals(group_id)
group_ver_res.should.have.key("Version").should.equal(group_ver_id)
assert "Arn" in group_ver_res
assert "CreationTimestamp" in group_ver_res
assert group_ver_res["Definition"] == definition
assert group_ver_res["Id"] == group_id
assert group_ver_res["Version"] == group_ver_id
if not TEST_SERVER_MODE:
group_ver_res["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
assert group_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_group_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
@ -447,15 +421,13 @@ def test_get_group_version_with_invalid_id():
GroupId="7b0bdeae-54c7-47cf-9f93-561e672efd9c",
GroupVersionId="7b0bdeae-54c7-47cf-9f93-561e672efd9c",
)
ex.value.response["Error"]["Message"].should.equal(
"That group definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That group definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_get_group_version_with_invalid_version_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
create_res = client.create_group(Name="TestGroup")
@ -467,61 +439,58 @@ def test_get_group_version_with_invalid_version_id():
GroupId=group_id,
GroupVersionId=invalid_group_ver_id,
)
ex.value.response["Error"]["Message"].should.equal(
f"Version {invalid_group_ver_id} of Group Definition {group_id} does not exist."
err = ex.value.response["Error"]
assert (
err["Message"]
== f"Version {invalid_group_ver_id} of Group Definition {group_id} does not exist."
)
ex.value.response["Error"]["Code"].should.equal("VersionNotFoundException")
assert err["Code"] == "VersionNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_associate_role_to_group():
client = boto3.client("greengrass", region_name="ap-northeast-1")
res = client.associate_role_to_group(
GroupId="abc002c8-1093-485e-9324-3baadf38e582",
RoleArn=f"arn:aws:iam::{ACCOUNT_ID}:role/greengrass-role",
)
res.should.have.key("AssociatedAt")
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert "AssociatedAt" in res
assert res["ResponseMetadata"]["HTTPStatusCode"] == 200
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_associated_role():
client = boto3.client("greengrass", region_name="ap-northeast-1")
group_id = "abc002c8-1093-485e-9324-3baadf38e582"
role_arn = f"arn:aws:iam::{ACCOUNT_ID}:role/greengrass-role"
client.associate_role_to_group(GroupId=group_id, RoleArn=role_arn)
res = client.get_associated_role(GroupId=group_id)
res.should.have.key("AssociatedAt")
res.should.have.key("RoleArn").should.equal(role_arn)
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert "AssociatedAt" in res
assert res["RoleArn"] == role_arn
assert res["ResponseMetadata"]["HTTPStatusCode"] == 200
if not TEST_SERVER_MODE:
res["AssociatedAt"].should.equal("2022-06-01T12:00:00.000Z")
assert res["AssociatedAt"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_associated_role_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.get_associated_role(GroupId="abc002c8-1093-485e-9324-3baadf38e582")
ex.value.response["Error"]["Message"].should.equal(
"You need to attach an IAM role to this deployment group."
)
ex.value.response["Error"]["Code"].should.equal("404")
err = ex.value.response["Error"]
assert err["Message"] == "You need to attach an IAM role to this deployment group."
assert err["Code"] == "404"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_disassociate_role_from_group():
client = boto3.client("greengrass", region_name="ap-northeast-1")
group_id = "abc002c8-1093-485e-9324-3baadf38e582"
role_arn = f"arn:aws:iam::{ACCOUNT_ID}:role/greengrass-role"
@ -529,30 +498,28 @@ def test_disassociate_role_from_group():
client.get_associated_role(GroupId=group_id)
res = client.disassociate_role_from_group(GroupId=group_id)
res.should.have.key("DisassociatedAt")
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert "DisassociatedAt" in res
assert res["ResponseMetadata"]["HTTPStatusCode"] == 200
if not TEST_SERVER_MODE:
res["DisassociatedAt"].should.equal("2022-06-01T12:00:00.000Z")
assert res["DisassociatedAt"] == "2022-06-01T12:00:00.000Z"
with pytest.raises(ClientError) as ex:
client.get_associated_role(GroupId=group_id)
ex.value.response["Error"]["Message"].should.equal(
"You need to attach an IAM role to this deployment group."
)
ex.value.response["Error"]["Code"].should.equal("404")
err = ex.value.response["Error"]
assert err["Message"] == "You need to attach an IAM role to this deployment group."
assert err["Code"] == "404"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_disassociate_role_from_group_with_none_exists_group_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
group_id = "abc002c8-1093-485e-9324-3baadf38e582"
res = client.disassociate_role_from_group(GroupId=group_id)
res.should.have.key("DisassociatedAt")
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert "DisassociatedAt" in res
assert res["ResponseMetadata"]["HTTPStatusCode"] == 200
if not TEST_SERVER_MODE:
res["DisassociatedAt"].should.equal("2022-06-01T12:00:00.000Z")
assert res["DisassociatedAt"] == "2022-06-01T12:00:00.000Z"

210
tests/test_greengrass/test_greengrass_resource.py
View File

@ -10,7 +10,6 @@ from moto.settings import TEST_SERVER_MODE
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_resource_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Resources": [
@ -30,21 +29,20 @@ def test_create_resource_definition():
resource_name = "TestResource"
res = client.create_resource_definition(InitialVersion=init_ver, Name=resource_name)
res.should.have.key("Arn")
res.should.have.key("Id")
res.should.have.key("LatestVersion")
res.should.have.key("LatestVersionArn")
res.should.have.key("Name").equals(resource_name)
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(201)
assert "Arn" in res
assert "Id" in res
assert "LatestVersion" in res
assert "LatestVersionArn" in res
assert res["Name"] == resource_name
assert res["ResponseMetadata"]["HTTPStatusCode"] == 201
if not TEST_SERVER_MODE:
res.should.have.key("CreationTimestamp").equals("2022-06-01T12:00:00.000Z")
res.should.have.key("LastUpdatedTimestamp").equals("2022-06-01T12:00:00.000Z")
assert res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_create_resource_definition_with_invalid_volume_resource():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Resources": [
@ -64,15 +62,16 @@ def test_create_resource_definition_with_invalid_volume_resource():
with pytest.raises(ClientError) as ex:
client.create_resource_definition(InitialVersion=init_ver)
ex.value.response["Error"]["Message"].should.equal(
"The resources definition is invalid. (ErrorDetails: [Accessing /sys is prohibited])"
err = ex.value.response["Error"]
assert (
err["Message"]
== "The resources definition is invalid. (ErrorDetails: [Accessing /sys is prohibited])"
)
ex.value.response["Error"]["Code"].should.equal("400")
assert err["Code"] == "400"
@mock_greengrass
def test_create_resource_definition_with_invalid_local_device_resource():
client = boto3.client("greengrass", region_name="ap-northeast-1")
source_path = "/foo/bar"
init_ver = {
@ -91,18 +90,17 @@ def test_create_resource_definition_with_invalid_local_device_resource():
with pytest.raises(ClientError) as ex:
client.create_resource_definition(InitialVersion=init_ver)
ex.value.response["Error"]["Message"].should.equal(
f"The resources definition is invalid. (ErrorDetails: [Device resource path should begin with "
"/dev"
f", but got: {source_path}])"
err = ex.value.response["Error"]
assert (
err["Message"]
== f"The resources definition is invalid. (ErrorDetails: [Device resource path should begin with /dev, but got: {source_path}])"
)
ex.value.response["Error"]["Code"].should.equal("400")
assert err["Code"] == "400"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_resource_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
v1_resources = [
{
@ -141,18 +139,17 @@ def test_create_resource_definition_version():
device_def_ver_res = client.create_resource_definition_version(
ResourceDefinitionId=resource_def_id, Resources=v2_resources
)
device_def_ver_res.should.have.key("Arn")
device_def_ver_res.should.have.key("CreationTimestamp")
device_def_ver_res.should.have.key("Id").equals(resource_def_id)
device_def_ver_res.should.have.key("Version")
assert "Arn" in device_def_ver_res
assert "CreationTimestamp" in device_def_ver_res
assert device_def_ver_res["Id"] == resource_def_id
assert "Version" in device_def_ver_res
if not TEST_SERVER_MODE:
device_def_ver_res["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
assert device_def_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_create_resources_definition_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
resources = [
{
@ -172,15 +169,13 @@ def test_create_resources_definition_version_with_invalid_id():
ResourceDefinitionId="7b0bdeae-54c7-47cf-9f93-561e672efd9c",
Resources=resources,
)
ex.value.response["Error"]["Message"].should.equal(
"That resource definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That resource definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_create_resources_definition_version_with_volume_resource():
client = boto3.client("greengrass", region_name="ap-northeast-1")
v1_resources = [
{
@ -219,15 +214,16 @@ def test_create_resources_definition_version_with_volume_resource():
client.create_resource_definition_version(
ResourceDefinitionId=resource_def_id, Resources=v2_resources
)
ex.value.response["Error"]["Message"].should.equal(
"The resources definition is invalid. (ErrorDetails: [Accessing /sys is prohibited])"
err = ex.value.response["Error"]
assert (
err["Message"]
== "The resources definition is invalid. (ErrorDetails: [Accessing /sys is prohibited])"
)
ex.value.response["Error"]["Code"].should.equal("400")
assert err["Code"] == "400"
@mock_greengrass
def test_create_resources_definition_version_with_invalid_local_device_resource():
client = boto3.client("greengrass", region_name="ap-northeast-1")
v1_resources = [
{
@ -261,12 +257,12 @@ def test_create_resources_definition_version_with_invalid_local_device_resource(
client.create_resource_definition_version(
ResourceDefinitionId=resource_def_id, Resources=v2_resources
)
ex.value.response["Error"]["Message"].should.equal(
f"The resources definition is invalid. (ErrorDetails: [Device resource path should begin with "
"/dev"
f", but got: {source_path}])"
err = ex.value.response["Error"]
assert (
err["Message"]
== f"The resources definition is invalid. (ErrorDetails: [Device resource path should begin with /dev, but got: {source_path}])"
)
ex.value.response["Error"]["Code"].should.equal("400")
assert err["Code"] == "400"
@freezegun.freeze_time("2022-06-01 12:00:00")
@ -299,28 +295,23 @@ def test_list_resources():
res_ver_arn = create_res["LatestVersionArn"]
res = client.list_resource_definitions()
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
res.should.have.key("Definitions")
res["Definitions"].should.have.length_of(1)
assert res["ResponseMetadata"]["HTTPStatusCode"] == 200
assert "Definitions" in res
assert len(res["Definitions"]) == 1
definition = res["Definitions"][0]
definition.should.have.key("Id").equals(res_def_id)
definition.should.have.key("Arn").equals(res_def_arn)
definition.should.have.key("LatestVersion").equals(res_ver)
definition.should.have.key("LatestVersionArn").equals(res_ver_arn)
assert definition["Id"] == res_def_id
assert definition["Arn"] == res_def_arn
assert definition["LatestVersion"] == res_ver
assert definition["LatestVersionArn"] == res_ver_arn
if not TEST_SERVER_MODE:
definition.should.have.key("CreationTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
definition.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert definition["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert definition["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_resource_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Resources": [
@ -349,36 +340,31 @@ def test_get_resource_definition():
get_res = client.get_resource_definition(ResourceDefinitionId=resource_def_id)
get_res.should.have.key("Name").equals(resource_name)
get_res.should.have.key("Arn").equals(arn)
get_res.should.have.key("Id").equals(resource_def_id)
get_res.should.have.key("LatestVersion").equals(latest_version)
get_res.should.have.key("LatestVersionArn").equals(latest_version_arn)
assert get_res["Name"] == resource_name
assert get_res["Arn"] == arn
assert get_res["Id"] == resource_def_id
assert get_res["LatestVersion"] == latest_version
assert get_res["LatestVersionArn"] == latest_version_arn
if not TEST_SERVER_MODE:
get_res.should.have.key("CreationTimestamp").equal("2022-06-01T12:00:00.000Z")
get_res.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert get_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert get_res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_resource_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.get_resource_definition(
ResourceDefinitionId="76f22a66-176a-4474-b450-04099dc4b069"
)
ex.value.response["Error"]["Message"].should.equal(
"That Resource List Definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That Resource List Definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_delete_resource_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Resources": [
@ -401,27 +387,24 @@ def test_delete_resource_definition():
resource_def_id = create_res["Id"]
del_res = client.delete_resource_definition(ResourceDefinitionId=resource_def_id)
del_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert del_res["ResponseMetadata"]["HTTPStatusCode"] == 200
@mock_greengrass
def test_delete_resource_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.delete_resource_definition(
ResourceDefinitionId="6fbffc21-989e-4d29-a793-a42f450a78c6"
)
ex.value.response["Error"]["Message"].should.equal(
"That resources definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That resources definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_update_resource_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Resources": [
@ -446,15 +429,14 @@ def test_update_resource_definition():
update_res = client.update_resource_definition(
ResourceDefinitionId=resource_def_id, Name=updated_resource_name
)
update_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert update_res["ResponseMetadata"]["HTTPStatusCode"] == 200
get_res = client.get_resource_definition(ResourceDefinitionId=resource_def_id)
get_res.should.have.key("Name").equals(updated_resource_name)
assert get_res["Name"] == updated_resource_name
@mock_greengrass
def test_update_device_definition_with_empty_name():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Resources": [
@ -478,29 +460,27 @@ def test_update_device_definition_with_empty_name():
with pytest.raises(ClientError) as ex:
client.update_resource_definition(ResourceDefinitionId=resource_def_id, Name="")
ex.value.response["Error"]["Message"].should.equal("Invalid resource name.")
ex.value.response["Error"]["Code"].should.equal("InvalidInputException")
err = ex.value.response["Error"]
assert err["Message"] == "Invalid resource name."
assert err["Code"] == "InvalidInputException"
@mock_greengrass
def test_update_resource_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.update_resource_definition(
ResourceDefinitionId="6fbffc21-989e-4d29-a793-a42f450a78c6", Name="123"
)
ex.value.response["Error"]["Message"].should.equal(
"That resources definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
rr = ex.value.response["Error"]
assert rr["Message"] == "That resources definition does not exist."
assert rr["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_resource_definition_versions():
client = boto3.client("greengrass", region_name="ap-northeast-1")
resources = [
{
@ -524,36 +504,33 @@ def test_list_resource_definition_versions():
ResourceDefinitionId=resource_def_id
)
resource_def_vers_res.should.have.key("Versions")
resource_def_vers_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert "Versions" in resource_def_vers_res
assert resource_def_vers_res["ResponseMetadata"]["HTTPStatusCode"] == 200
device_def_ver = resource_def_vers_res["Versions"][0]
device_def_ver.should.have.key("Arn")
device_def_ver.should.have.key("CreationTimestamp")
device_def_ver.should.have.key("Id").equals(resource_def_id)
device_def_ver.should.have.key("Version")
assert "Arn" in device_def_ver
assert "CreationTimestamp" in device_def_ver
assert device_def_ver["Id"] == resource_def_id
assert "Version" in device_def_ver
if not TEST_SERVER_MODE:
device_def_ver["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
assert device_def_ver["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_list_resource_definition_versions_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.list_resource_definition_versions(
ResourceDefinitionId="fe2392e9-e67f-4308-af1b-ff94a128b231"
)
ex.value.response["Error"]["Message"].should.equal(
"That resources definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That resources definition does not exist."
assert err["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_resource_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
resources = [
{
@ -579,37 +556,32 @@ def test_get_resource_definition_version():
ResourceDefinitionVersionId=resource_def_ver_id,
)
resource_def_ver_res.should.have.key("Arn")
resource_def_ver_res.should.have.key("CreationTimestamp")
resource_def_ver_res.should.have.key("Definition").should.equal(initial_version)
resource_def_ver_res.should.have.key("Id").equals(resource_def_id)
resource_def_ver_res.should.have.key("Version")
resource_def_ver_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert "Arn" in resource_def_ver_res
assert "CreationTimestamp" in resource_def_ver_res
assert resource_def_ver_res["Definition"] == initial_version
assert resource_def_ver_res["Id"] == resource_def_id
assert "Version" in resource_def_ver_res
assert resource_def_ver_res["ResponseMetadata"]["HTTPStatusCode"] == 200
if not TEST_SERVER_MODE:
resource_def_ver_res["CreationTimestamp"].should.equal(
"2022-06-01T12:00:00.000Z"
)
assert resource_def_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_resource_definition_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.get_resource_definition_version(
ResourceDefinitionId="fe2392e9-e67f-4308-af1b-ff94a128b231",
ResourceDefinitionVersionId="cd2ea6dc-6634-4e89-8441-8003500435f9",
)
ex.value.response["Error"]["Message"].should.equal(
"That resources definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That resources definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_get_resource_definition_version_with_invalid_version_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
resources = [
{
@ -635,7 +607,9 @@ def test_get_resource_definition_version_with_invalid_version_id():
ResourceDefinitionId=resource_def_id,
ResourceDefinitionVersionId=invalid_resource_version_id,
)
ex.value.response["Error"]["Message"].should.equal(
f"Version {invalid_resource_version_id} of Resource List Definition {resource_def_id} does not exist."
err = ex.value.response["Error"]
assert (
err["Message"]
== f"Version {invalid_resource_version_id} of Resource List Definition {resource_def_id} does not exist."
)
ex.value.response["Error"]["Code"].should.equal("VersionNotFoundException")
assert err["Code"] == "VersionNotFoundException"

211
tests/test_greengrass/test_greengrass_subscriptions.py
View File

@ -19,7 +19,6 @@ from moto.settings import TEST_SERVER_MODE
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_subscription_definition(target):
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -35,21 +34,20 @@ def test_create_subscription_definition(target):
res = client.create_subscription_definition(
InitialVersion=init_ver, Name=subscription_name
)
res.should.have.key("Arn")
res.should.have.key("Id")
res.should.have.key("LatestVersion")
res.should.have.key("LatestVersionArn")
res.should.have.key("Name").equals(subscription_name)
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(201)
assert "Arn" in res
assert "Id" in res
assert "LatestVersion" in res
assert "LatestVersionArn" in res
assert res["Name"] == subscription_name
assert res["ResponseMetadata"]["HTTPStatusCode"] == 201
if not TEST_SERVER_MODE:
res.should.have.key("CreationTimestamp").equals("2022-06-01T12:00:00.000Z")
res.should.have.key("LastUpdatedTimestamp").equals("2022-06-01T12:00:00.000Z")
assert res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_create_subscription_definition_with_invalid_target():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -66,15 +64,16 @@ def test_create_subscription_definition_with_invalid_target():
InitialVersion=init_ver, Name="TestSubscription"
)
ex.value.response["Error"]["Message"].should.equal(
"The subscriptions definition is invalid or corrupted. (ErrorDetails: [Subscription target is invalid. ID is '123456' and Target is 'foo'])"
err = ex.value.response["Error"]
assert (
err["Message"]
== "The subscriptions definition is invalid or corrupted. (ErrorDetails: [Subscription target is invalid. ID is '123456' and Target is 'foo'])"
)
ex.value.response["Error"]["Code"].should.equal("400")
assert err["Code"] == "400"
@mock_greengrass
def test_create_subscription_definition_with_invalid_source():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -91,16 +90,17 @@ def test_create_subscription_definition_with_invalid_source():
InitialVersion=init_ver, Name="TestSubscription"
)
ex.value.response["Error"]["Message"].should.equal(
"The subscriptions definition is invalid or corrupted. (ErrorDetails: [Subscription source is invalid. ID is '123456' and Source is 'foo'])"
err = ex.value.response["Error"]
assert (
err["Message"]
== "The subscriptions definition is invalid or corrupted. (ErrorDetails: [Subscription source is invalid. ID is '123456' and Source is 'foo'])"
)
ex.value.response["Error"]["Code"].should.equal("400")
assert err["Code"] == "400"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_subscription_definitions():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -118,27 +118,22 @@ def test_list_subscription_definitions():
)
res = client.list_subscription_definitions()
res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert res["ResponseMetadata"]["HTTPStatusCode"] == 200
subscription_def = res["Definitions"][0]
subscription_def.should.have.key("Name").equals(subscription_name)
subscription_def.should.have.key("Arn")
subscription_def.should.have.key("Id")
subscription_def.should.have.key("LatestVersion")
subscription_def.should.have.key("LatestVersionArn")
assert subscription_def["Name"] == subscription_name
assert "Arn" in subscription_def
assert "Id" in subscription_def
assert "LatestVersion" in subscription_def
assert "LatestVersionArn" in subscription_def
if not TEST_SERVER_MODE:
subscription_def.should.have.key("CreationTimestamp").equal(
"2022-06-01T12:00:00.000Z"
)
subscription_def.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert subscription_def["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert subscription_def["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_subscription_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -164,38 +159,33 @@ def test_get_subscription_definition():
SubscriptionDefinitionId=subscription_def_id
)
get_res.should.have.key("Name").equals(subscription_name)
get_res.should.have.key("Arn").equals(arn)
get_res.should.have.key("Id").equals(subscription_def_id)
get_res.should.have.key("LatestVersion").equals(latest_version)
get_res.should.have.key("LatestVersionArn").equals(latest_version_arn)
get_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert get_res["Name"] == subscription_name
assert get_res["Arn"] == arn
assert get_res["Id"] == subscription_def_id
assert get_res["LatestVersion"] == latest_version
assert get_res["LatestVersionArn"] == latest_version_arn
assert get_res["ResponseMetadata"]["HTTPStatusCode"] == 200
if not TEST_SERVER_MODE:
get_res.should.have.key("CreationTimestamp").equal("2022-06-01T12:00:00.000Z")
get_res.should.have.key("LastUpdatedTimestamp").equals(
"2022-06-01T12:00:00.000Z"
)
assert get_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
assert get_res["LastUpdatedTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_subscription_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.get_subscription_definition(
SubscriptionDefinitionId="b552443b-1888-469b-81f8-0ebc5ca92949"
)
ex.value.response["Error"]["Message"].should.equal(
"That Subscription List Definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That Subscription List Definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_delete_subscription_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -215,12 +205,11 @@ def test_delete_subscription_definition():
del_res = client.delete_subscription_definition(
SubscriptionDefinitionId=subscription_def_id
)
del_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert del_res["ResponseMetadata"]["HTTPStatusCode"] == 200
@mock_greengrass
def test_update_subscription_definition():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -241,17 +230,16 @@ def test_update_subscription_definition():
update_res = client.update_subscription_definition(
SubscriptionDefinitionId=subscription_def_id, Name=updated_subscription_name
)
update_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
assert update_res["ResponseMetadata"]["HTTPStatusCode"] == 200
get_res = client.get_subscription_definition(
SubscriptionDefinitionId=subscription_def_id
)
get_res.should.have.key("Name").equals(updated_subscription_name)
assert get_res["Name"] == updated_subscription_name
@mock_greengrass
def test_update_subscription_definition_with_empty_name():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -272,48 +260,40 @@ def test_update_subscription_definition_with_empty_name():
client.update_subscription_definition(
SubscriptionDefinitionId=subscription_def_id, Name=""
)
ex.value.response["Error"]["Message"].should.equal(
"Input does not contain any attributes to be updated"
)
ex.value.response["Error"]["Code"].should.equal(
"InvalidContainerDefinitionException"
)
err = ex.value.response["Error"]
assert err["Message"] == "Input does not contain any attributes to be updated"
assert err["Code"] == "InvalidContainerDefinitionException"
@mock_greengrass
def test_update_subscription_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.update_subscription_definition(
SubscriptionDefinitionId="6fbffc21-989e-4d29-a793-a42f450a78c6", Name="123"
)
ex.value.response["Error"]["Message"].should.equal(
"That subscriptions definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That subscriptions definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_delete_subscription_definition_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.delete_subscription_definition(
SubscriptionDefinitionId="6fbffc21-989e-4d29-a793-a42f450a78c6"
)
ex.value.response["Error"]["Message"].should.equal(
"That subscriptions definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That subscriptions definition does not exist."
assert err["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_create_subscription_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
v1_subscriptions = [
{
@ -342,20 +322,19 @@ def test_create_subscription_definition_version():
subscription_def_ver_res = client.create_subscription_definition_version(
SubscriptionDefinitionId=subscription_def_id, Subscriptions=v2_subscriptions
)
subscription_def_ver_res.should.have.key("Arn")
subscription_def_ver_res.should.have.key("CreationTimestamp")
subscription_def_ver_res.should.have.key("Id").equals(subscription_def_id)
subscription_def_ver_res.should.have.key("Version")
assert "Arn" in subscription_def_ver_res
assert "CreationTimestamp" in subscription_def_ver_res
assert subscription_def_ver_res["Id"] == subscription_def_id
assert "Version" in subscription_def_ver_res
if not TEST_SERVER_MODE:
subscription_def_ver_res["CreationTimestamp"].should.equal(
"2022-06-01T12:00:00.000Z"
assert (
subscription_def_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
)
@mock_greengrass
def test_create_subscription_definition_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
subscriptions = [
{
@ -371,15 +350,13 @@ def test_create_subscription_definition_version_with_invalid_id():
SubscriptionDefinitionId="7b0bdeae-54c7-47cf-9f93-561e672efd9c",
Subscriptions=subscriptions,
)
ex.value.response["Error"]["Message"].should.equal(
"That subscriptions does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That subscriptions does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_create_subscription_definition_version_with_invalid_target():
client = boto3.client("greengrass", region_name="ap-northeast-1")
v1_subscriptions = [
{
@ -410,15 +387,16 @@ def test_create_subscription_definition_version_with_invalid_target():
SubscriptionDefinitionId=subscription_def_id, Subscriptions=v2_subscriptions
)
ex.value.response["Error"]["Message"].should.equal(
"The subscriptions definition is invalid or corrupted. (ErrorDetails: [Subscription target is invalid. ID is '999999' and Target is 'foo'])"
err = ex.value.response["Error"]
assert (
err["Message"]
== "The subscriptions definition is invalid or corrupted. (ErrorDetails: [Subscription target is invalid. ID is '999999' and Target is 'foo'])"
)
ex.value.response["Error"]["Code"].should.equal("400")
assert err["Code"] == "400"
@mock_greengrass
def test_create_subscription_definition_version_with_invalid_source():
client = boto3.client("greengrass", region_name="ap-northeast-1")
v1_subscriptions = [
{
@ -449,16 +427,17 @@ def test_create_subscription_definition_version_with_invalid_source():
SubscriptionDefinitionId=subscription_def_id, Subscriptions=v2_subscriptions
)
ex.value.response["Error"]["Message"].should.equal(
"The subscriptions definition is invalid or corrupted. (ErrorDetails: [Subscription source is invalid. ID is '999999' and Source is 'foo'])"
err = ex.value.response["Error"]
assert (
err["Message"]
== "The subscriptions definition is invalid or corrupted. (ErrorDetails: [Subscription source is invalid. ID is '999999' and Source is 'foo'])"
)
ex.value.response["Error"]["Code"].should.equal("400")
assert err["Code"] == "400"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_list_subscription_definition_versions():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -479,39 +458,34 @@ def test_list_subscription_definition_versions():
SubscriptionDefinitionId=subscription_def_id
)
subscription_def_ver_res["ResponseMetadata"]["HTTPStatusCode"].should.equal(200)
subscription_def_ver_res.should.have.key("Versions")
assert subscription_def_ver_res["ResponseMetadata"]["HTTPStatusCode"] == 200
assert "Versions" in subscription_def_ver_res
subscription_def_ver = subscription_def_ver_res["Versions"][0]
subscription_def_ver.should.have.key("Arn")
subscription_def_ver.should.have.key("CreationTimestamp")
subscription_def_ver.should.have.key("Id").equals(subscription_def_id)
subscription_def_ver.should.have.key("Version")
assert "Arn" in subscription_def_ver
assert "CreationTimestamp" in subscription_def_ver
assert subscription_def_ver["Id"] == subscription_def_id
assert "Version" in subscription_def_ver
if not TEST_SERVER_MODE:
subscription_def_ver["CreationTimestamp"].should.equal(
"2022-06-01T12:00:00.000Z"
)
assert subscription_def_ver["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_list_subscription_definition_versions_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
client.list_subscription_definition_versions(
SubscriptionDefinitionId="7b0bdeae-54c7-47cf-9f93-561e672efd9c"
)
ex.value.response["Error"]["Message"].should.equal(
"That subscriptions definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That subscriptions definition does not exist."
assert err["Code"] == "IdNotFoundException"
@freezegun.freeze_time("2022-06-01 12:00:00")
@mock_greengrass
def test_get_subscription_definition_version():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -535,19 +509,18 @@ def test_get_subscription_definition_version():
SubscriptionDefinitionVersionId=subscription_def_ver_id,
)
func_def_ver_res.should.have.key("Arn")
func_def_ver_res.should.have.key("CreationTimestamp")
func_def_ver_res.should.have.key("Definition").should.equal(init_ver)
func_def_ver_res.should.have.key("Id").equals(subscription_def_id)
func_def_ver_res.should.have.key("Version")
assert "Arn" in func_def_ver_res
assert "CreationTimestamp" in func_def_ver_res
assert func_def_ver_res["Definition"] == init_ver
assert func_def_ver_res["Id"] == subscription_def_id
assert "Version" in func_def_ver_res
if not TEST_SERVER_MODE:
func_def_ver_res["CreationTimestamp"].should.equal("2022-06-01T12:00:00.000Z")
assert func_def_ver_res["CreationTimestamp"] == "2022-06-01T12:00:00.000Z"
@mock_greengrass
def test_get_subscription_definition_version_with_invalid_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
with pytest.raises(ClientError) as ex:
@ -555,15 +528,13 @@ def test_get_subscription_definition_version_with_invalid_id():
SubscriptionDefinitionId="7b0bdeae-54c7-47cf-9f93-561e672efd9c",
SubscriptionDefinitionVersionId="7b0bdeae-54c7-47cf-9f93-561e672efd9c",
)
ex.value.response["Error"]["Message"].should.equal(
"That subscriptions definition does not exist."
)
ex.value.response["Error"]["Code"].should.equal("IdNotFoundException")
err = ex.value.response["Error"]
assert err["Message"] == "That subscriptions definition does not exist."
assert err["Code"] == "IdNotFoundException"
@mock_greengrass
def test_get_subscription_definition_version_with_invalid_version_id():
client = boto3.client("greengrass", region_name="ap-northeast-1")
init_ver = {
"Subscriptions": [
@ -587,7 +558,9 @@ def test_get_subscription_definition_version_with_invalid_version_id():
SubscriptionDefinitionId=subscription_def_id,
SubscriptionDefinitionVersionId=invalid_subscription_def_ver_id,
)
ex.value.response["Error"]["Message"].should.equal(
f"Version {invalid_subscription_def_ver_id} of Subscription List Definition {subscription_def_id} does not exist."
err = ex.value.response["Error"]
assert (
err["Message"]
== f"Version {invalid_subscription_def_ver_id} of Subscription List Definition {subscription_def_id} does not exist."
)
ex.value.response["Error"]["Code"].should.equal("VersionNotFoundException")
assert err["Code"] == "VersionNotFoundException"