diff --git a/moto/greengrass/models.py b/moto/greengrass/models.py index 08fbd324b34..dd68c878c94 100644 --- a/moto/greengrass/models.py +++ b/moto/greengrass/models.py @@ -459,6 +459,32 @@ def create_resource_definition_version(self, resource_definition_id, resources): return resource_def_ver + def list_resource_definition_versions(self, resource_definition_id): + + if resource_definition_id not in self.resource_definition_versions: + raise IdNotFoundException("That resources definition does not exist.") + + return self.resource_definition_versions[resource_definition_id].values() + + def get_resource_definition_version( + self, resource_definition_id, resource_definition_version_id + ): + + if resource_definition_id not in self.resource_definition_versions: + raise IdNotFoundException("That resources definition does not exist.") + + if ( + resource_definition_version_id + not in self.resource_definition_versions[resource_definition_id] + ): + raise VersionNotFoundException( + f"Version {resource_definition_version_id} of Resource List Definition {resource_definition_id} does not exist." + ) + + return self.resource_definition_versions[resource_definition_id][ + resource_definition_version_id + ] + @staticmethod def _validate_resources(resources): for resource in resources: diff --git a/moto/greengrass/responses.py b/moto/greengrass/responses.py index eb9efdbef30..ba9a58dacc4 100644 --- a/moto/greengrass/responses.py +++ b/moto/greengrass/responses.py @@ -299,6 +299,9 @@ def resource_definition_versions(self, request, full_url, headers): if self.method == "POST": return self.create_resource_definition_version() + if self.method == "GET": + return self.list_resource_definition_versions() + def create_resource_definition_version(self): resource_definition_id = self.path.split("/")[-2] @@ -309,6 +312,36 @@ def create_resource_definition_version(self): ) return 201, {"status": 201}, json.dumps(res.to_dict()) + def list_resource_definition_versions(self): + + resource_device_definition_id = self.path.split("/")[-2] + res = self.greengrass_backend.list_resource_definition_versions( + resource_device_definition_id + ) + + return ( + 200, + {"status": 200}, + json.dumps( + {"Versions": [resource_def_ver.to_dict() for resource_def_ver in res]} + ), + ) + + def resource_definition_version(self, request, full_url, headers): + self.setup_class(request, full_url, headers) + + if self.method == "GET": + return self.get_resource_definition_version() + + def get_resource_definition_version(self): + resource_definition_id = self.path.split("/")[-3] + resource_definition_version_id = self.path.split("/")[-1] + res = self.greengrass_backend.get_resource_definition_version( + resource_definition_id=resource_definition_id, + resource_definition_version_id=resource_definition_version_id, + ) + return 200, {"status": 200}, json.dumps(res.to_dict()) + def function_definitions(self, request, full_url, headers): self.setup_class(request, full_url, headers) diff --git a/moto/greengrass/urls.py b/moto/greengrass/urls.py index 5bc8bd69312..dfde7cf6c39 100644 --- a/moto/greengrass/urls.py +++ b/moto/greengrass/urls.py @@ -24,4 +24,5 @@ "{0}/greengrass/definition/resources$": response.resource_definitions, "{0}/greengrass/definition/resources/(?P[^/]+)/?$": response.resource_definition, "{0}/greengrass/definition/resources/(?P[^/]+)/versions$": response.resource_definition_versions, + "{0}/greengrass/definition/resources/(?P[^/]+)/versions/(?P[^/]+)/?$": response.resource_definition_version, } diff --git a/tests/test_greengrass/test_greengrass_resource.py b/tests/test_greengrass/test_greengrass_resource.py index 193dce4040d..df493206363 100644 --- a/tests/test_greengrass/test_greengrass_resource.py +++ b/tests/test_greengrass/test_greengrass_resource.py @@ -498,3 +498,147 @@ def test_update_resource_definition_with_invalid_id(): "That resources definition does not exist." ) ex.value.response["Error"]["Code"].should.equal("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 = [ + { + "Id": "123", + "Name": "test_directory", + "ResourceDataContainer": { + "LocalDeviceResourceData": { + "SourcePath": "/dev/null", + } + }, + } + ] + + initial_version = {"Resources": resources} + create_res = client.create_resource_definition( + InitialVersion=initial_version, Name="TestResource" + ) + resource_def_id = create_res["Id"] + + resource_def_vers_res = client.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) + 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") + + if not TEST_SERVER_MODE: + device_def_ver["CreationTimestamp"].should.equal("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") + + +@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 = [ + { + "Id": "123", + "Name": "test_directory", + "ResourceDataContainer": { + "LocalDeviceResourceData": { + "SourcePath": "/dev/null", + } + }, + } + ] + + initial_version = {"Resources": resources} + create_res = client.create_resource_definition( + InitialVersion=initial_version, Name="TestResource" + ) + resource_def_id = create_res["Id"] + resource_def_ver_id = create_res["LatestVersion"] + + resource_def_ver_res = client.get_resource_definition_version( + ResourceDefinitionId=resource_def_id, + 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) + + if not TEST_SERVER_MODE: + resource_def_ver_res["CreationTimestamp"].should.equal( + "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") + + +@mock_greengrass +def test_get_resource_definition_version_with_invalid_version_id(): + + client = boto3.client("greengrass", region_name="ap-northeast-1") + resources = [ + { + "Id": "123", + "Name": "test_directory", + "ResourceDataContainer": { + "LocalDeviceResourceData": { + "SourcePath": "/dev/null", + } + }, + } + ] + + initial_version = {"Resources": resources} + create_res = client.create_resource_definition( + InitialVersion=initial_version, Name="TestResource" + ) + + resource_def_id = create_res["Id"] + invalid_resource_version_id = "6fbffc21-989e-4d29-a793-a42f450a78c6" + with pytest.raises(ClientError) as ex: + client.get_resource_definition_version( + 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." + ) + ex.value.response["Error"]["Code"].should.equal("VersionNotFoundException")