added new properties

src/cloudformation_cli_python_lib/interface.py

@@ -130,5 +130,10 @@ class BaseResourceHandlerRequest:
     clientRequestToken: str
     desiredResourceState: Optional[BaseModel]
     previousResourceState: Optional[BaseModel]
+    desiredResourceTags: Optional[Mapping[str, Any]]
+    systemTags: Optional[Mapping[str, Any]]
+    awsAccountId: Optional[str]
     logicalResourceIdentifier: Optional[str]
     nextToken: Optional[str]
+    region: Optional[str]
+    awsPartition: Optional[str]

src/cloudformation_cli_python_lib/resource.py

@@ -163,7 +163,11 @@ def _cast_resource_request(
                 clientRequestToken=request.bearerToken,
                 desiredResourceState=request.requestData.resourceProperties,
                 previousResourceState=request.requestData.previousResourceProperties,
+                desiredResourceTags=request.requestData.stackTags,
+                systemTags=request.requestData.systemTags,
+                awsAccountId=request.awsAccountId,
                 logicalResourceIdentifier=request.requestData.logicalResourceId,
+                region=request.region,
             ).to_modelled(self._model_cls)
         except Exception as e:  # pylint: disable=broad-except
             LOG.exception("Invalid request")

src/cloudformation_cli_python_lib/utils.py

@@ -113,19 +113,40 @@ class UnmodelledRequest:
     clientRequestToken: str
     desiredResourceState: Optional[Mapping[str, Any]] = None
     previousResourceState: Optional[Mapping[str, Any]] = None
+    desiredResourceTags: Optional[Mapping[str, Any]] = None
+    systemTags: Optional[Mapping[str, Any]] = None
+    awsAccountId: Optional[str] = None
     logicalResourceIdentifier: Optional[str] = None
     nextToken: Optional[str] = None
+    region: Optional[str] = None
 
     def to_modelled(self, model_cls: Type[BaseModel]) -> BaseResourceHandlerRequest:
         # pylint: disable=protected-access
         return BaseResourceHandlerRequest(
             clientRequestToken=self.clientRequestToken,
             desiredResourceState=model_cls._deserialize(self.desiredResourceState),
             previousResourceState=model_cls._deserialize(self.previousResourceState),
+            desiredResourceTags=self.desiredResourceTags,
+            systemTags=self.systemTags,
+            awsAccountId=self.awsAccountId,
             logicalResourceIdentifier=self.logicalResourceIdentifier,
             nextToken=self.nextToken,
+            region=self.region,
+            awsPartition=self.get_partition(self.region),
         )
 
+    @staticmethod
+    def get_partition(region: Optional[str]) -> Optional[str]:
+        if region is None:
+            return None
+
+        if region.startswith("cn"):
+            return "aws-cn"
+
+        if region.startswith("us-gov"):
+            return "aws-gov"
+        return "aws"
+
 
 class LambdaContext:
     get_remaining_time_in_millis: Callable[["LambdaContext"], int]

tests/lib/utils_test.py

@@ -66,10 +66,6 @@ def test_handler_request_serde_roundtrip():
         "requestContext": {
             "invocation": 2,
             "callbackContext": {"contextPropertyA": "Value"},
-            "cloudWatchEventsRuleName": "reinvoke-handler-4754ac8a-623b-45fe-84bc-f5394"
-            "118a8be",
-            "cloudWatchEventsTargetId": "reinvoke-target-4754ac8a-623b-45fe-84bc-f53941"
-            "18a8be",
         },
         "requestData": {
             "callerCredentials": None,
@@ -102,7 +98,8 @@ def test_handler_request_serde_roundtrip():
     assert ser == expected
 
 
-def test_unmodelled_request_to_modelled():
+@pytest.mark.parametrize("region", ("us-east-1", "cn-region1", "us-gov-region1"))
+def test_unmodelled_request_to_modelled(region):
     model_cls = Mock(spec_set=BaseModel)
     model_cls._deserialize.side_effect = [sentinel.new, sentinel.old]
 
@@ -112,6 +109,7 @@ def test_unmodelled_request_to_modelled():
         previousResourceState={"state": "old"},
         logicalResourceIdentifier="bar",
         nextToken="baz",
+        region=region,
     )
     modelled = unmodelled.to_modelled(model_cls)