moto 4.1.15.dev101__tar.gz → 4.2.0__tar.gz

{moto-4.1.15.dev101/moto.egg-info → moto-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 4.1.15.dev101
+Version: 4.2.0
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: "spulec@gmail.com"

{moto-4.1.15.dev101 → moto-4.2.0}/moto/__init__.py

@@ -210,7 +210,7 @@ mock_all = MockAll
 # logging.getLogger('boto').setLevel(logging.CRITICAL)
 
 __title__ = "moto"
-__version__ = "4.1.15.dev101"
+__version__ = "4.2.0"
 
 
 try:

{moto-4.1.15.dev101 → moto-4.2.0}/moto/acmpca/models.py

@@ -23,6 +23,7 @@ class CertificateAuthority(BaseModel):
         certificate_authority_configuration: Dict[str, Any],
         certificate_authority_type: str,
         revocation_configuration: Dict[str, Any],
+        security_standard: Optional[str],
     ):
         self.id = mock_random.uuid4()
         self.arn = (
@@ -40,6 +41,7 @@ class CertificateAuthority(BaseModel):
         self.updated_at: Optional[float] = None
         self.status = "PENDING_CERTIFICATE"
         self.usage_mode = "SHORT_LIVED_CERTIFICATE"
+        self.security_standard = security_standard or "FIPS_140_2_LEVEL_3_OR_HIGHER"
 
         common_name = self.certificate_authority_configuration.get("Subject", {}).get(
             "CommonName", "Moto.org"
@@ -170,6 +172,7 @@ class CertificateAuthority(BaseModel):
             "CreatedAt": self.created_at,
             "Status": self.status,
             "UsageMode": self.usage_mode,
+            "KeyStorageSecurityStandard": self.security_standard,
         }
         if self.updated_at:
             dct["LastStateChangeAt"] = self.updated_at
@@ -196,6 +199,7 @@ class ACMPCABackend(BaseBackend):
         certificate_authority_configuration: Dict[str, Any],
         revocation_configuration: Dict[str, Any],
         certificate_authority_type: str,
+        security_standard: Optional[str],
         tags: List[Dict[str, str]],
     ) -> str:
         """
@@ -207,6 +211,7 @@ class ACMPCABackend(BaseBackend):
             certificate_authority_configuration=certificate_authority_configuration,
             certificate_authority_type=certificate_authority_type,
             revocation_configuration=revocation_configuration,
+            security_standard=security_standard,
         )
         self.certificate_authorities[authority.arn] = authority
         if tags:

{moto-4.1.15.dev101 → moto-4.2.0}/moto/acmpca/responses.py

@@ -24,11 +24,13 @@ class ACMPCAResponse(BaseResponse):
         )
         revocation_configuration = params.get("RevocationConfiguration")
         certificate_authority_type = params.get("CertificateAuthorityType")
+        security_standard = params.get("KeyStorageSecurityStandard")
         tags = params.get("Tags")
         certificate_authority_arn = self.acmpca_backend.create_certificate_authority(
             certificate_authority_configuration=certificate_authority_configuration,
             revocation_configuration=revocation_configuration,
             certificate_authority_type=certificate_authority_type,
+            security_standard=security_standard,
             tags=tags,
         )
         return json.dumps(dict(CertificateAuthorityArn=certificate_authority_arn))

{moto-4.1.15.dev101 → moto-4.2.0}/moto/autoscaling/models.py

@@ -30,7 +30,7 @@ DEFAULT_COOLDOWN = 300
 ASG_NAME_TAG = "aws:autoscaling:groupName"
 
 
-class InstanceState(object):
+class InstanceState:
     def __init__(
         self,
         instance: "Instance",
@@ -382,6 +382,20 @@ def set_string_propagate_at_launch_booleans_on_tags(
     return tags
 
 
+class FakeWarmPool(CloudFormationModel):
+    def __init__(
+        self,
+        max_capacity: Optional[int],
+        min_size: Optional[int],
+        pool_state: Optional[str],
+        instance_reuse_policy: Optional[Dict[str, bool]],
+    ):
+        self.max_capacity = max_capacity
+        self.min_size = min_size or 0
+        self.pool_state = pool_state or "Stopped"
+        self.instance_reuse_policy = instance_reuse_policy
+
+
 class FakeAutoScalingGroup(CloudFormationModel):
     def __init__(
         self,
@@ -449,6 +463,7 @@ class FakeAutoScalingGroup(CloudFormationModel):
         self.set_desired_capacity(desired_capacity)
 
         self.metrics: List[str] = []
+        self.warm_pool: Optional[FakeWarmPool] = None
 
     @property
     def tags(self) -> List[Dict[str, str]]:
@@ -815,6 +830,23 @@ class FakeAutoScalingGroup(CloudFormationModel):
     def enable_metrics_collection(self, metrics: List[str]) -> None:
         self.metrics = metrics or []
 
+    def put_warm_pool(
+        self,
+        max_capacity: Optional[int],
+        min_size: Optional[int],
+        pool_state: Optional[str],
+        instance_reuse_policy: Optional[Dict[str, bool]],
+    ) -> None:
+        self.warm_pool = FakeWarmPool(
+            max_capacity=max_capacity,
+            min_size=min_size,
+            pool_state=pool_state,
+            instance_reuse_policy=instance_reuse_policy,
+        )
+
+    def get_warm_pool(self) -> Optional[FakeWarmPool]:
+        return self.warm_pool
+
 
 class AutoScalingBackend(BaseBackend):
     def __init__(self, region_name: str, account_id: str):
@@ -1546,5 +1578,32 @@ class AutoScalingBackend(BaseBackend):
         group = self.describe_auto_scaling_groups([group_name])[0]
         group.enable_metrics_collection(metrics)
 
+    def put_warm_pool(
+        self,
+        group_name: str,
+        max_capacity: Optional[int],
+        min_size: Optional[int],
+        pool_state: Optional[str],
+        instance_reuse_policy: Optional[Dict[str, bool]],
+    ) -> None:
+        group = self.describe_auto_scaling_groups([group_name])[0]
+        group.put_warm_pool(
+            max_capacity=max_capacity,
+            min_size=min_size,
+            pool_state=pool_state,
+            instance_reuse_policy=instance_reuse_policy,
+        )
+
+    def describe_warm_pool(self, group_name: str) -> Optional[FakeWarmPool]:
+        """
+        Pagination is not yet implemented. Does not create/return any Instances currently.
+        """
+        group = self.describe_auto_scaling_groups([group_name])[0]
+        return group.get_warm_pool()
+
+    def delete_warm_pool(self, group_name: str) -> None:
+        group = self.describe_auto_scaling_groups([group_name])[0]
+        group.warm_pool = None
+
 
 autoscaling_backends = BackendDict(AutoScalingBackend, "autoscaling")

{moto-4.1.15.dev101 → moto-4.2.0}/moto/autoscaling/responses.py

@@ -484,6 +484,35 @@ class AutoScalingResponse(BaseResponse):
         template = self.response_template(ENABLE_METRICS_COLLECTION_TEMPLATE)
         return template.render()
 
+    def put_warm_pool(self) -> str:
+        params = self._get_params()
+        group_name = params.get("AutoScalingGroupName")
+        max_capacity = params.get("MaxGroupPreparedCapacity")
+        min_size = params.get("MinSize")
+        pool_state = params.get("PoolState")
+        instance_reuse_policy = params.get("InstanceReusePolicy")
+        self.autoscaling_backend.put_warm_pool(
+            group_name=group_name,  # type: ignore[arg-type]
+            max_capacity=max_capacity,
+            min_size=min_size,
+            pool_state=pool_state,
+            instance_reuse_policy=instance_reuse_policy,
+        )
+        template = self.response_template(PUT_WARM_POOL_TEMPLATE)
+        return template.render()
+
+    def describe_warm_pool(self) -> str:
+        group_name = self._get_param("AutoScalingGroupName")
+        warm_pool = self.autoscaling_backend.describe_warm_pool(group_name=group_name)
+        template = self.response_template(DESCRIBE_WARM_POOL_TEMPLATE)
+        return template.render(pool=warm_pool)
+
+    def delete_warm_pool(self) -> str:
+        group_name = self._get_param("AutoScalingGroupName")
+        self.autoscaling_backend.delete_warm_pool(group_name=group_name)
+        template = self.response_template(DELETE_WARM_POOL_TEMPLATE)
+        return template.render()
+
 
 CREATE_LAUNCH_CONFIGURATION_TEMPLATE = """<CreateLaunchConfigurationResponse xmlns="http://autoscaling.amazonaws.com/doc/2011-01-01/">
 <ResponseMetadata>
@@ -774,6 +803,28 @@ DESCRIBE_AUTOSCALING_GROUPS_TEMPLATE = """<DescribeAutoScalingGroupsResponse xml
             </Overrides>
             {% endif %}
           </LaunchTemplate>
+          {% if group.mixed_instance_policy.get("InstancesDistribution") %}
+          <InstancesDistribution>
+            {% if group.mixed_instance_policy.get("InstancesDistribution").get("OnDemandAllocationStrategy") %}
+            <OnDemandAllocationStrategy>{{ group.mixed_instance_policy.get("InstancesDistribution").get("OnDemandAllocationStrategy") }}</OnDemandAllocationStrategy>
+            {% endif %}
+            {% if group.mixed_instance_policy.get("InstancesDistribution").get("OnDemandBaseCapacity") %}
+            <OnDemandBaseCapacity>{{ group.mixed_instance_policy.get("InstancesDistribution").get("OnDemandBaseCapacity") }}</OnDemandBaseCapacity>
+            {% endif %}
+            {% if group.mixed_instance_policy.get("InstancesDistribution").get("OnDemandPercentageAboveBaseCapacity") %}
+            <OnDemandPercentageAboveBaseCapacity>{{ group.mixed_instance_policy.get("InstancesDistribution").get("OnDemandPercentageAboveBaseCapacity") }}</OnDemandPercentageAboveBaseCapacity>
+            {% endif %}
+            {% if group.mixed_instance_policy.get("InstancesDistribution").get("SpotAllocationStrategy") %}
+            <SpotAllocationStrategy>{{ group.mixed_instance_policy.get("InstancesDistribution").get("SpotAllocationStrategy") }}</SpotAllocationStrategy>
+            {% endif %}
+            {% if group.mixed_instance_policy.get("InstancesDistribution").get("SpotInstancePools") %}
+            <SpotInstancePools>{{ group.mixed_instance_policy.get("InstancesDistribution").get("SpotInstancePools") }}</SpotInstancePools>
+            {% endif %}
+            {% if group.mixed_instance_policy.get("InstancesDistribution").get("SpotMaxPrice") %}
+            <SpotMaxPrice>{{ group.mixed_instance_policy.get("InstancesDistribution").get("SpotMaxPrice") }}</SpotMaxPrice>
+            {% endif %}
+          </InstancesDistribution>
+          {% endif %}
         </MixedInstancesPolicy>
         {% elif group.launch_template %}
         <LaunchTemplate>
@@ -864,6 +915,18 @@ DESCRIBE_AUTOSCALING_GROUPS_TEMPLATE = """<DescribeAutoScalingGroupsResponse xml
         </EnabledMetrics>
         {% endif %}
         <ServiceLinkedRoleARN>{{ group.service_linked_role }}</ServiceLinkedRoleARN>
+        {% if group.warm_pool %}
+        <WarmPoolConfiguration>
+          <MaxGroupPreparedCapacity>{{ group.warm_pool.max_capacity }}</MaxGroupPreparedCapacity>
+          <MinSize>{{ group.warm_pool.min_size or 0 }}</MinSize>
+          {% if group.warm_pool.pool_state %}
+          <PoolState>{{ group.warm_pool.pool_state }}</PoolState>
+          {% endif %}
+          <InstanceReusePolicy>
+            <ReuseOnScaleIn>{{ 'true' if group.warm_pool.instance_reuse_policy["ReuseOnScaleIn"] else 'false' }}</ReuseOnScaleIn>
+          </InstanceReusePolicy>
+        </WarmPoolConfiguration>
+        {% endif %}
       </member>
       {% endfor %}
     </AutoScalingGroups>
@@ -1386,3 +1449,46 @@ ENABLE_METRICS_COLLECTION_TEMPLATE = """<EnableMetricsCollectionResponse xmlns="
    <RequestId></RequestId>
 </ResponseMetadata>
 </EnableMetricsCollectionResponse>"""
+
+
+PUT_WARM_POOL_TEMPLATE = """<PutWarmPoolResponse xmlns="http://autoscaling.amazonaws.com/doc/2011-01-01/">
+<ResponseMetadata>
+   <RequestId></RequestId>
+</ResponseMetadata>
+<PutWarmPoolResult></PutWarmPoolResult>
+</PutWarmPoolResponse>"""
+
+
+DESCRIBE_WARM_POOL_TEMPLATE = """<DescribeWarmPoolResponse xmlns="http://autoscaling.amazonaws.com/doc/2011-01-01/">
+<ResponseMetadata>
+   <RequestId></RequestId>
+</ResponseMetadata>
+<DescribeWarmPoolResult>
+  {% if pool %}
+  <WarmPoolConfiguration>
+    {% if pool.max_capacity %}
+    <MaxGroupPreparedCapacity>{{ pool.max_capacity }}</MaxGroupPreparedCapacity>
+    {% endif %}
+    <MinSize>{{ pool.min_size }}</MinSize>
+    {% if pool.pool_state %}
+    <PoolState>{{ pool.pool_state }}</PoolState>
+    {% endif %}
+    {% if pool.instance_reuse_policy %}
+    <InstanceReusePolicy>
+      <ReuseOnScaleIn>{{ 'true' if pool.instance_reuse_policy["ReuseOnScaleIn"] else 'false' }}</ReuseOnScaleIn>
+    </InstanceReusePolicy>
+    {% endif %}
+  </WarmPoolConfiguration>
+  {% endif %}
+  <Instances>
+  </Instances>
+</DescribeWarmPoolResult>
+</DescribeWarmPoolResponse>"""
+
+
+DELETE_WARM_POOL_TEMPLATE = """<DeleteWarmPoolResponse xmlns="http://autoscaling.amazonaws.com/doc/2011-01-01/">
+<ResponseMetadata>
+   <RequestId></RequestId>
+</ResponseMetadata>
+<DeleteWarmPoolResult></DeleteWarmPoolResult>
+</DeleteWarmPoolResponse>"""

{moto-4.1.15.dev101 → moto-4.2.0}/moto/awslambda/models.py

@@ -1047,6 +1047,7 @@ class FunctionUrlConfig:
             "Cors": self.config.get("Cors"),
             "CreationTime": self.created,
             "LastModifiedTime": self.last_modified,
+            "InvokeMode": self.config.get("InvokeMode") or "Buffered",
         }
 
     def update(self, new_config: Dict[str, Any]) -> None:

{moto-4.1.15.dev101 → moto-4.2.0}/moto/batch/models.py

@@ -250,10 +250,33 @@ class JobDefinition(CloudFormationModel):
         self.propagate_tags = propagate_tags
 
         if self.container_properties is not None:
-            if "resourceRequirements" not in self.container_properties:
-                self.container_properties["resourceRequirements"] = []
-            if "secrets" not in self.container_properties:
-                self.container_properties["secrets"] = []
+            # Set some default values
+            default_values: Dict[str, List[Any]] = {
+                "command": [],
+                "resourceRequirements": [],
+                "secrets": [],
+                "environment": [],
+                "mountPoints": [],
+                "ulimits": [],
+                "volumes": [],
+            }
+            for key, val in default_values.items():
+                if key not in self.container_properties:
+                    self.container_properties[key] = val
+
+            # Set default FARGATE configuration
+            if "FARGATE" in (self.platform_capabilities or []):
+                if "fargatePlatformConfiguration" not in self.container_properties:
+                    self.container_properties["fargatePlatformConfiguration"] = {
+                        "platformVersion": "LATEST"
+                    }
+
+            # Remove any empty environment variables
+            self.container_properties["environment"] = [
+                env_var
+                for env_var in self.container_properties["environment"]
+                if env_var.get("value") != ""
+            ]
 
         self._validate()
         self.revision += 1

{moto-4.1.15.dev101 → moto-4.2.0}/moto/cloudformation/responses.py

@@ -1045,6 +1045,7 @@ DESCRIBE_STACK_SET_RESPONSE_TEMPLATE = """<DescribeStackSetResponse xmlns="http:
       {% if stackset.description %}
       <Description>{{ stackset.description }}</Description>
       {% endif %}
+      <ManagedExecution><Active>false</Active></ManagedExecution>
     </StackSet>
   </DescribeStackSetResult>
   <ResponseMetadata>

{moto-4.1.15.dev101 → moto-4.2.0}/moto/cloudfront/models.py

@@ -106,6 +106,8 @@ class CustomOriginConfig:
         self.read_timeout = config.get("OriginReadTimeout") or 30
         protocols = config.get("OriginSslProtocols", {}).get("Items") or {}
         self.ssl_protocols = protocols.get("SslProtocol") or []
+        if isinstance(self.ssl_protocols, str):
+            self.ssl_protocols = [self.ssl_protocols]
 
 
 class Origin:

{moto-4.1.15.dev101 → moto-4.2.0}/moto/cognitoidp/models.py

@@ -370,6 +370,12 @@ DEFAULT_USER_POOL_CONFIG: Dict[str, Any] = {
         "EmailSubject": "Your verification code",
         "DefaultEmailOption": "CONFIRM_WITH_CODE",
     },
+    "AccountRecoverySetting": {
+        "RecoveryMechanisms": [
+            {"Priority": 1, "Name": "verified_email"},
+            {"Priority": 2, "Name": "verified_phone_number"},
+        ]
+    },
 }
 
 
@@ -465,19 +471,6 @@ class CognitoIdpUserPool(BaseModel):
             None,
         )
 
-    def _account_recovery_setting(self) -> Any:
-        # AccountRecoverySetting is not present in DescribeUserPool response if the pool was created without
-        # specifying it, ForgotPassword works on default settings nonetheless
-        return self.extended_config.get(
-            "AccountRecoverySetting",
-            {
-                "RecoveryMechanisms": [
-                    {"Priority": 1, "Name": "verified_phone_number"},
-                    {"Priority": 2, "Name": "verified_email"},
-                ]
-            },
-        )
-
     def _base_json(self) -> Dict[str, Any]:
         return {
             "Id": self.id,
@@ -684,7 +677,15 @@ class CognitoIdpUserPoolClient(BaseModel):
         self.id = create_id()
         self.secret = str(random.uuid4())
         self.generate_secret = generate_secret or False
-        self.extended_config = extended_config or {}
+        # Some default values - may be overridden by the user
+        self.extended_config: Dict[str, Any] = {
+            "AllowedOAuthFlowsUserPoolClient": False,
+            "AuthSessionValidity": 3,
+            "EnablePropagateAdditionalUserContextData": False,
+            "EnableTokenRevocation": True,
+            "RefreshTokenValidity": 30,
+        }
+        self.extended_config.update(extended_config or {})
 
     def _base_json(self) -> Dict[str, Any]:
         return {
@@ -1590,7 +1591,7 @@ class CognitoIdpBackend(BaseBackend):
         """
         for user_pool in self.user_pools.values():
             if client_id in user_pool.clients:
-                recovery_settings = user_pool._account_recovery_setting()
+                recovery_settings = user_pool.extended_config["AccountRecoverySetting"]
                 user = user_pool._get_user(username)
                 break
         else:

{moto-4.1.15.dev101 → moto-4.2.0}/moto/dynamodb/models/__init__.py

@@ -301,11 +301,11 @@ class DynamoDBBackend(BaseBackend):
         self,
         table_name: str,
         keys: Dict[str, Any],
-        projection_expression: Optional[str] = None,
+        projection_expressions: Optional[List[List[str]]] = None,
     ) -> Optional[Item]:
         table = self.get_table(table_name)
         hash_key, range_key = self.get_keys_value(table, keys)
-        return table.get_item(hash_key, range_key, projection_expression)
+        return table.get_item(hash_key, range_key, projection_expressions)
 
     def query(
         self,
@@ -316,7 +316,7 @@ class DynamoDBBackend(BaseBackend):
         limit: int,
         exclusive_start_key: Dict[str, Any],
         scan_index_forward: bool,
-        projection_expression: Optional[str],
+        projection_expressions: Optional[List[List[str]]],
         index_name: Optional[str] = None,
         expr_names: Optional[Dict[str, str]] = None,
         expr_values: Optional[Dict[str, str]] = None,
@@ -339,7 +339,7 @@ class DynamoDBBackend(BaseBackend):
             limit,
             exclusive_start_key,
             scan_index_forward,
-            projection_expression,
+            projection_expressions,
             index_name,
             filter_expression_op,
             **filter_kwargs,
@@ -355,7 +355,7 @@ class DynamoDBBackend(BaseBackend):
         expr_names: Dict[str, Any],
         expr_values: Dict[str, Any],
         index_name: str,
-        projection_expression: Optional[str],
+        projection_expression: Optional[List[List[str]]],
     ) -> Tuple[List[Item], int, Optional[Dict[str, Any]]]:
         table = self.get_table(table_name)
 

{moto-4.1.15.dev101 → moto-4.2.0}/moto/dynamodb/models/dynamo_type.py

@@ -418,13 +418,12 @@ class Item(BaseModel):
                     f"{action} action not support for update_with_attribute_updates"
                 )
 
-    def project(self, projection_expression: str) -> "Item":
+    def project(self, projection_expressions: List[List[str]]) -> "Item":
         # Returns a new Item with only the dictionary-keys that match the provided projection_expression
         # Will return an empty Item if the expression does not match anything
         result: Dict[str, Any] = dict()
-        expressions = [x.strip() for x in projection_expression.split(",")]
-        for expr in expressions:
-            x = find_nested_key(expr.split("."), self.to_regular_json())
+        for expr in projection_expressions:
+            x = find_nested_key(expr, self.to_regular_json())
             merge_dicts(result, x)
 
         return Item(

{moto-4.1.15.dev101 → moto-4.2.0}/moto/dynamodb/models/table.py

@@ -50,12 +50,18 @@ class SecondaryIndex(BaseModel):
             ]
 
             if projection_type == "KEYS_ONLY":
-                item = item.project(",".join(key_attributes))
+                # 'project' expects lists of lists of strings
+                # project([["attr1"], ["nested", "attr2"]]
+                #
+                # In our case, we need to convert
+                # ["key1", "key2"]
+                # into
+                # [["key1"], ["key2"]]
+                item = item.project([[attr] for attr in key_attributes])
             elif projection_type == "INCLUDE":
-                allowed_attributes = key_attributes + self.projection.get(
-                    "NonKeyAttributes", []
-                )
-                item = item.project(",".join(allowed_attributes))
+                allowed_attributes = key_attributes
+                allowed_attributes.extend(self.projection.get("NonKeyAttributes", []))
+                item = item.project([[attr] for attr in allowed_attributes])
             # ALL is handled implicitly by not filtering
         return item
 
@@ -592,7 +598,7 @@ class Table(CloudFormationModel):
         self,
         hash_key: DynamoType,
         range_key: Optional[DynamoType] = None,
-        projection_expression: Optional[str] = None,
+        projection_expression: Optional[List[List[str]]] = None,
     ) -> Optional[Item]:
         if self.has_range_key and not range_key:
             raise MockValidationException(
@@ -637,7 +643,7 @@ class Table(CloudFormationModel):
         limit: int,
         exclusive_start_key: Dict[str, Any],
         scan_index_forward: bool,
-        projection_expression: Optional[str],
+        projection_expressions: Optional[List[List[str]]],
         index_name: Optional[str] = None,
         filter_expression: Any = None,
         **filter_kwargs: Any,
@@ -754,8 +760,8 @@ class Table(CloudFormationModel):
         if filter_expression is not None:
             results = [item for item in results if filter_expression.expr(item)]
 
-        if projection_expression:
-            results = [r.project(projection_expression) for r in results]
+        if projection_expressions:
+            results = [r.project(projection_expressions) for r in results]
 
         return results, scanned_count, last_evaluated_key
 
@@ -799,7 +805,7 @@ class Table(CloudFormationModel):
         exclusive_start_key: Dict[str, Any],
         filter_expression: Any = None,
         index_name: Optional[str] = None,
-        projection_expression: Optional[str] = None,
+        projection_expression: Optional[List[List[str]]] = None,
     ) -> Tuple[List[Item], int, Optional[Dict[str, Any]]]:
         results = []
         scanned_count = 0

{moto-4.1.15.dev101 → moto-4.2.0}/moto/dynamodb/responses.py

@@ -556,11 +556,11 @@ class DynamoHandler(BaseResponse):
                 )
 
         expression_attribute_names = expression_attribute_names or {}
-        projection_expression = self._adjust_projection_expression(
+        projection_expressions = self._adjust_projection_expression(
             projection_expression, expression_attribute_names
         )
 
-        item = self.dynamodb_backend.get_item(name, key, projection_expression)
+        item = self.dynamodb_backend.get_item(name, key, projection_expressions)
         if item:
             item_dict = item.describe_attrs(attributes=None)
             return dynamo_json_dump(item_dict)
@@ -608,14 +608,14 @@ class DynamoHandler(BaseResponse):
                 "ExpressionAttributeNames", {}
             )
 
-            projection_expression = self._adjust_projection_expression(
+            projection_expressions = self._adjust_projection_expression(
                 projection_expression, expression_attribute_names
             )
 
             results["Responses"][table_name] = []
             for key in keys:
                 item = self.dynamodb_backend.get_item(
-                    table_name, key, projection_expression
+                    table_name, key, projection_expressions
                 )
                 if item:
                     # A single operation can retrieve up to 16 MB of data [and] returns a partial result if the response size limit is exceeded
@@ -652,7 +652,7 @@ class DynamoHandler(BaseResponse):
         filter_expression = self._get_filter_expression()
         expression_attribute_values = self.body.get("ExpressionAttributeValues", {})
 
-        projection_expression = self._adjust_projection_expression(
+        projection_expressions = self._adjust_projection_expression(
             projection_expression, expression_attribute_names
         )
 
@@ -720,7 +720,7 @@ class DynamoHandler(BaseResponse):
             limit,
             exclusive_start_key,
             scan_index_forward,
-            projection_expression,
+            projection_expressions,
             index_name=index_name,
             expr_names=expression_attribute_names,
             expr_values=expression_attribute_values,
@@ -743,27 +743,24 @@ class DynamoHandler(BaseResponse):
 
     def _adjust_projection_expression(
         self, projection_expression: Optional[str], expr_attr_names: Dict[str, str]
-    ) -> Optional[str]:
+    ) -> List[List[str]]:
+        """
+        lvl1.lvl2.attr1,lvl1.attr2 --> [["lvl1", "lvl2", "attr1"], ["lvl1", "attr2]]
+        """
+
         def _adjust(expression: str) -> str:
-            return (
-                expr_attr_names[expression]
-                if expression in expr_attr_names
-                else expression
-            )
+            return (expr_attr_names or {}).get(expression, expression)
 
         if projection_expression:
             expressions = [x.strip() for x in projection_expression.split(",")]
             for expression in expressions:
                 check_projection_expression(expression)
-            if expr_attr_names:
-                return ",".join(
-                    [
-                        ".".join([_adjust(expr) for expr in nested_expr.split(".")])
-                        for nested_expr in expressions
-                    ]
-                )
+            return [
+                [_adjust(expr) for expr in nested_expr.split(".")]
+                for nested_expr in expressions
+            ]
 
-        return projection_expression
+        return []
 
     @include_consumed_capacity()
     def scan(self) -> str:
@@ -786,7 +783,7 @@ class DynamoHandler(BaseResponse):
         limit = self.body.get("Limit")
         index_name = self.body.get("IndexName")
 
-        projection_expression = self._adjust_projection_expression(
+        projection_expressions = self._adjust_projection_expression(
             projection_expression, expression_attribute_names
         )
 
@@ -800,7 +797,7 @@ class DynamoHandler(BaseResponse):
                 expression_attribute_names,
                 expression_attribute_values,
                 index_name,
-                projection_expression,
+                projection_expressions,
             )
         except ValueError as err:
             raise MockValidationException(f"Bad Filter Expression: {err}")

{moto-4.1.15.dev101 → moto-4.2.0}/moto/ec2/models/nat_gateways.py

@@ -133,6 +133,7 @@ class NatGatewayBackend:
             if eip:
                 address_set["allocationId"] = allocation_id
                 address_set["publicIp"] = eip.public_ip or None
+                address_set["associationId"] = eip.association_id or None
         address_set["networkInterfaceId"] = nat_gateway._eni.id
         address_set["privateIp"] = nat_gateway._eni.private_ip_address
         nat_gateway.address_set.append(address_set)