moto 5.0.10.dev8__tar.gz → 5.0.10.dev10__tar.gz

{moto-5.0.10.dev8/moto.egg-info → moto-5.0.10.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 5.0.10.dev8
+Version: 5.0.10.dev10
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: spulec@gmail.com

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/moto/__init__.py

@@ -1,4 +1,4 @@
 from moto.core.decorator import mock_aws as mock_aws
 
 __title__ = "moto"
-__version__ = "5.0.10.dev8"
+__version__ = "5.0.10.dev10"

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/moto/dynamodb/comparisons.py

@@ -7,6 +7,14 @@ from moto.dynamodb.models.dynamo_type import Item
 from moto.dynamodb.parsing.reserved_keywords import ReservedKeywords
 
 
+def create_condition_expression_parser(
+    expr: Optional[str],
+    names: Optional[Dict[str, str]],
+    values: Optional[Dict[str, Dict[str, str]]],
+) -> "ConditionExpressionParser":
+    return ConditionExpressionParser(expr, names, values)
+
+
 def get_filter_expression(
     expr: Optional[str],
     names: Optional[Dict[str, str]],
@@ -19,7 +27,7 @@ def get_filter_expression(
         expr = 'Id > 5 AND attribute_exists(test) AND Id BETWEEN 5 AND 6 OR length < 6 AND contains(test, 1) AND 5 IN (4,5, 6) OR (Id < 5 AND 5 > Id)'
         expr = 'Id > 5 AND Subs < 7'
     """
-    parser = ConditionExpressionParser(expr, names, values)
+    parser = create_condition_expression_parser(expr, names, values)
     return parser.parse()
 
 
@@ -151,6 +159,8 @@ class ConditionExpressionParser:
         self.expression_attribute_names = expression_attribute_names
         self.expression_attribute_values = expression_attribute_values
 
+        self.expr_attr_names_found: List[str] = []
+
     def parse(self) -> Union[Op, "Func"]:
         """Returns a syntax tree for the expression.
 
@@ -202,6 +212,9 @@ class ConditionExpressionParser:
         nodes = self._apply_between(nodes)
         nodes = self._apply_parens_and_booleans(nodes)
         node = nodes[0]
+
+        self.expr_attr_names_found.extend(self._find_literals(node))
+
         op = self._make_op_condition(node)
         return op
 
@@ -248,6 +261,16 @@ class ConditionExpressionParser:
 
     Node = namedtuple("Node", ["nonterminal", "kind", "text", "value", "children"])
 
+    @classmethod
+    def _find_literals(cls, parent: Node) -> List[str]:  # type: ignore
+        literals: List[str] = []
+        if parent.kind == "LITERAL" and parent.nonterminal == "IDENTIFIER":
+            literals.append(parent.text)
+        else:
+            for child in parent.children:
+                literals.extend(cls._find_literals(child))
+        return literals
+
     @classmethod
     def raise_exception_if_keyword(cls, attribute: str) -> None:
         if attribute.upper() in ReservedKeywords.get_reserved_keywords():

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/moto/dynamodb/models/__init__.py

@@ -6,7 +6,11 @@ from typing import Any, Dict, List, Optional, Set, Tuple, Union
 from moto.core.base_backend import BackendDict, BaseBackend
 from moto.core.exceptions import JsonRESTError
 from moto.core.utils import unix_time
-from moto.dynamodb.comparisons import get_expected, get_filter_expression
+from moto.dynamodb.comparisons import (
+    create_condition_expression_parser,
+    get_expected,
+    get_filter_expression,
+)
 from moto.dynamodb.exceptions import (
     BackupNotFoundException,
     ConditionalCheckFailed,
@@ -36,7 +40,10 @@ from moto.dynamodb.models.table import (
 from moto.dynamodb.models.table_import import TableImport
 from moto.dynamodb.parsing import partiql
 from moto.dynamodb.parsing.executors import UpdateExpressionExecutor
-from moto.dynamodb.parsing.expressions import UpdateExpressionParser  # type: ignore
+from moto.dynamodb.parsing.expressions import (  # type: ignore
+    ExpressionAttributeName,
+    UpdateExpressionParser,
+)
 from moto.dynamodb.parsing.validators import UpdateExpressionValidator
 
 
@@ -469,11 +476,12 @@ class DynamoDBBackend(BaseBackend):
 
         if not get_expected(expected).expr(item):
             raise ConditionalCheckFailed
-        condition_op = get_filter_expression(
+        condition_expression_parser = create_condition_expression_parser(
             condition_expression,
             expression_attribute_names,
             expression_attribute_values,
         )
+        condition_op = condition_expression_parser.parse()
         if not condition_op.expr(item):
             if (
                 return_values_on_condition_check_failure == "ALL_OLD"
@@ -510,6 +518,7 @@ class DynamoDBBackend(BaseBackend):
             item.validate_no_empty_key_values(attribute_updates, table.attribute_keys)  # type: ignore[union-attr]
 
         if update_expression:
+            # Validate the UpdateExpression itself has all information
             validator = UpdateExpressionValidator(
                 update_expression_ast,
                 expression_attribute_names=expression_attribute_names,
@@ -527,6 +536,24 @@ class DynamoDBBackend(BaseBackend):
                 ).execute()
             except ItemSizeTooLarge:
                 raise ItemSizeToUpdateTooLarge()
+
+            # Ensure all ExpressionAttributeNames are requested
+            # Either in the Condition, or in the UpdateExpression
+            attr_name_clauses = update_expression_ast.find_clauses(
+                [ExpressionAttributeName]
+            )
+            attr_names_in_expression = [
+                attr.get_attribute_name_placeholder() for attr in attr_name_clauses
+            ]
+            attr_names_in_condition = condition_expression_parser.expr_attr_names_found
+            for attr_name in expression_attribute_names:
+                if (
+                    attr_name not in attr_names_in_expression
+                    and attr_name not in attr_names_in_condition
+                ):
+                    raise MockValidationException(
+                        f"Value provided in ExpressionAttributeNames unused in expressions: keys: {{{attr_name}}}"
+                    )
         else:
             item.update_with_attribute_updates(attribute_updates)  # type: ignore
         if table.stream_shard is not None:

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/moto/dynamodb/parsing/ast_nodes.py

@@ -5,7 +5,11 @@ from collections import deque
 
 from moto.dynamodb.models import DynamoType
 
-from ..exceptions import DuplicateUpdateExpression, TooManyAddClauses
+from ..exceptions import (
+    DuplicateUpdateExpression,
+    MockValidationException,
+    TooManyAddClauses,
+)
 
 
 class Node(metaclass=abc.ABCMeta):
@@ -23,7 +27,7 @@ class Node(metaclass=abc.ABCMeta):
     def set_parent(self, parent_node):
         self.parent = parent_node
 
-    def validate(self) -> None:
+    def validate(self, limit_set_actions: bool = False) -> None:
         if self.type == "UpdateExpression":
             nr_of_clauses = len(self.find_clauses([UpdateExpressionAddClause]))
             if nr_of_clauses > 1:
@@ -36,6 +40,11 @@ class Node(metaclass=abc.ABCMeta):
             if len(set_attributes) != len(set(set_attributes)):
                 raise DuplicateUpdateExpression(set_attributes)
 
+            if limit_set_actions and len(set_actions) > 1:
+                raise MockValidationException(
+                    'Invalid UpdateExpression: The "SET" section can only be used once in an update expression;'
+                )
+
     def normalize(self):
         """
         Flatten the Add-/Delete-/Remove-/Set-Action children within this Node
@@ -83,6 +92,8 @@ class Node(metaclass=abc.ABCMeta):
                 clauses.append(child)
             elif isinstance(child, Expression):
                 clauses.extend(child.find_clauses(clause_types))
+            elif isinstance(child, UpdateExpressionFunction):
+                clauses.extend(child.find_clauses(clause_types))
         return clauses
 
 

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/moto/dynamodb/parsing/expressions.py

@@ -481,7 +481,7 @@ class UpdateExpressionParser(ExpressionParser, NestableExpressionParserMixin):
         return self._create_node()
 
     @classmethod
-    def make(cls, expression_str):
+    def make(cls, expression_str) -> UpdateExpression:
         token_list = ExpressionTokenizer.make_list(expression_str)
         return cls(token_list).parse()
 

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/moto/dynamodb/responses.py

@@ -8,6 +8,7 @@ from moto.core.common_types import TYPE_RESPONSE
 from moto.core.responses import BaseResponse
 from moto.dynamodb.models import DynamoDBBackend, Table, dynamodb_backends
 from moto.dynamodb.models.utilities import dynamo_json_dump
+from moto.dynamodb.parsing.expressions import UpdateExpressionParser  # type: ignore
 from moto.dynamodb.parsing.key_condition_expression import parse_expression
 from moto.dynamodb.parsing.reserved_keywords import ReservedKeywords
 from moto.utilities.aws_headers import amz_crc32
@@ -1097,6 +1098,10 @@ class DynamoHandler(BaseResponse):
                     table,
                     custom_error_msg="One or more parameter values are not valid. The AttributeValue for a key attribute cannot contain an empty string value. Key: {}",
                 )
+                update_expression = item["Update"]["UpdateExpression"]
+                UpdateExpressionParser.make(update_expression).validate(
+                    limit_set_actions=True
+                )
         self.dynamodb_backend.transact_write_items(transact_items)
         response: Dict[str, Any] = {"ConsumedCapacity": [], "ItemCollectionMetrics": {}}
         return dynamo_json_dump(response)

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/moto/ec2/models/route_tables.py

@@ -122,6 +122,12 @@ class RouteTable(TaggedEC2Resource, CloudFormationModel):
                 for route in self.routes.values()
                 if route.nat_gateway is not None
             ]
+        elif filter_name == "route.transit-gateway-id":
+            return [
+                route.transit_gateway.id
+                for route in self.routes.values()
+                if route.transit_gateway is not None
+            ]
         else:
             return super().get_filter_value(filter_name, "DescribeRouteTables")
 

{moto-5.0.10.dev8 → moto-5.0.10.dev10/moto.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 5.0.10.dev8
+Version: 5.0.10.dev10
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: spulec@gmail.com

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = moto
-version = 5.0.10.dev8
+version = 5.0.10.dev10
 long_description = file:README.md
 long_description_content_type = text/markdown
 author = Steve Pulec

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/tests/test_dynamodb/exceptions/test_dynamodb_exceptions.py

@@ -194,6 +194,44 @@ def test_update_item_range_key_set():
     )
 
 
+@pytest.mark.aws_verified
+@dynamodb_aws_verified()
+def test_update_item_unused_attribute_name(table_name=None):
+    ddb = boto3.resource("dynamodb", region_name="us-east-1")
+
+    # Create the DynamoDB table.
+    table = ddb.Table(table_name)
+    table.put_item(Item={"pk": "pk1", "spec": {}, "am": 0})
+
+    with pytest.raises(ClientError) as exc:
+        table.update_item(
+            Key={"pk": "pk1"},
+            UpdateExpression="SET spec.#limit = :limit",
+            ExpressionAttributeNames={"#count": "count", "#limit": "limit"},
+            ExpressionAttributeValues={":countChange": 1, ":limit": "limit"},
+        )
+    err = exc.value.response["Error"]
+    assert err["Code"] == "ValidationException"
+    assert (
+        err["Message"]
+        == "Value provided in ExpressionAttributeNames unused in expressions: keys: {#count}"
+    )
+
+    with pytest.raises(ClientError) as exc:
+        table.update_item(
+            Key={"pk": "pk1"},
+            UpdateExpression="ADD am :limit",
+            ExpressionAttributeNames={"#count": "count"},
+            ExpressionAttributeValues={":limit": 2},
+        )
+    err = exc.value.response["Error"]
+    assert err["Code"] == "ValidationException"
+    assert (
+        err["Message"]
+        == "Value provided in ExpressionAttributeNames unused in expressions: keys: {#count}"
+    )
+
+
 @mock_aws
 def test_batch_get_item_non_existing_table():
     client = boto3.client("dynamodb", region_name="us-west-2")

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/tests/test_dynamodb/exceptions/test_dynamodb_transactions.py

@@ -46,29 +46,17 @@ def test_multiple_transactions_on_same_item():
     )
 
 
-@mock_aws
-def test_transact_write_items__put_and_delete_on_same_item():
-    schema = {
-        "KeySchema": [
-            {"AttributeName": "pk", "KeyType": "HASH"},
-            {"AttributeName": "sk", "KeyType": "RANGE"},
-        ],
-        "AttributeDefinitions": [
-            {"AttributeName": "pk", "AttributeType": "S"},
-            {"AttributeName": "sk", "AttributeType": "S"},
-        ],
-    }
+@pytest.mark.aws_verified
+@dynamodb_aws_verified(add_range=True)
+def test_transact_write_items__put_and_delete_on_same_item(table_name=None):
     dynamodb = boto3.client("dynamodb", region_name="us-east-1")
-    dynamodb.create_table(
-        TableName="test-table", BillingMode="PAY_PER_REQUEST", **schema
-    )
 
     with pytest.raises(ClientError) as exc:
         dynamodb.transact_write_items(
             TransactItems=[
                 {
                     "Put": {
-                        "TableName": "test-table",
+                        "TableName": table_name,
                         "Item": {
                             "pk": {"S": "test-pk"},
                             "sk": {"S": "test-sk"},
@@ -78,7 +66,7 @@ def test_transact_write_items__put_and_delete_on_same_item():
                 },
                 {
                     "Delete": {
-                        "TableName": "test-table",
+                        "TableName": table_name,
                         "Key": {
                             "pk": {"S": "test-pk"},
                             "sk": {"S": "test-sk"},
@@ -95,6 +83,36 @@ def test_transact_write_items__put_and_delete_on_same_item():
     )
 
 
+@pytest.mark.aws_verified
+@dynamodb_aws_verified(add_range=True)
+def test_transact_write_items__update_with_multiple_sets(table_name=None):
+    dynamodb = boto3.client("dynamodb", region_name="us-east-1")
+
+    with pytest.raises(ClientError) as exc:
+        dynamodb.transact_write_items(
+            TransactItems=[
+                {
+                    "Update": {
+                        "TableName": table_name,
+                        "Key": {"pk": {"S": "s"}},
+                        "UpdateExpression": "SET expire_at_utc = :expire_at_utc SET is_final = :true ADD version :one",
+                        "ExpressionAttributeValues": {
+                            ":true": {"BOOL": True},
+                            ":one": {"N": "1"},
+                            ":expire_at_utc": {"S": "asdf"},
+                        },
+                    }
+                }
+            ]
+        )
+    err = exc.value.response["Error"]
+    assert err["Code"] == "ValidationException"
+    assert (
+        err["Message"]
+        == 'Invalid UpdateExpression: The "SET" section can only be used once in an update expression;'
+    )
+
+
 @mock_aws
 def test_transact_write_items__too_many_transactions():
     schema = {

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/tests/test_dynamodb/test_dynamodb.py

@@ -2335,22 +2335,21 @@ def test_remove_top_level_attribute():
     assert result == {"id": {"S": "foo"}}
 
 
-@mock_aws
-def test_remove_top_level_attribute_non_existent():
+@pytest.mark.aws_verified
+@dynamodb_aws_verified()
+def test_remove_top_level_attribute_non_existent(table_name=None):
     """
     Remove statements do not require attribute to exist they silently pass
     """
-    table_name = "test_remove"
-    client = create_table_with_list(table_name)
-    ddb_item = {"id": {"S": "foo"}, "item": {"S": "bar"}}
+    client = boto3.client("dynamodb", "us-east-1")
+    ddb_item = {"pk": {"S": "foo"}, "item": {"S": "bar"}}
     client.put_item(TableName=table_name, Item=ddb_item)
     client.update_item(
         TableName=table_name,
-        Key={"id": {"S": "foo"}},
+        Key={"pk": {"S": "foo"}},
         UpdateExpression="REMOVE non_existent_attribute",
-        ExpressionAttributeNames={"#i": "item"},
     )
-    result = client.get_item(TableName=table_name, Key={"id": {"S": "foo"}})["Item"]
+    result = client.get_item(TableName=table_name, Key={"pk": {"S": "foo"}})["Item"]
     assert result == ddb_item
 
 
@@ -4301,46 +4300,33 @@ def test_lsi_projection_type_keys_only():
     }
 
 
-@mock_aws
-@pytest.mark.parametrize(
-    "attr_name",
-    ["orders", "#placeholder"],
-    ids=["use attribute name", "use expression attribute name"],
-)
-def test_set_attribute_is_dropped_if_empty_after_update_expression(attr_name):
-    table_name, item_key, set_item = "test-table", "test-id", "test-data"
-    expression_attribute_names = {"#placeholder": "orders"}
+@pytest.mark.aws_verified
+@dynamodb_aws_verified()
+def test_set_attribute_is_dropped_if_empty_after_update_expression(table_name=None):
+    set_item = "test-data"
     client = boto3.client("dynamodb", region_name="us-east-1")
-    client.create_table(
-        TableName=table_name,
-        KeySchema=[{"AttributeName": "customer", "KeyType": "HASH"}],
-        AttributeDefinitions=[{"AttributeName": "customer", "AttributeType": "S"}],
-        ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
-    )
 
     client.update_item(
         TableName=table_name,
-        Key={"customer": {"S": item_key}},
-        UpdateExpression=f"ADD {attr_name} :order",
-        ExpressionAttributeNames=expression_attribute_names,
+        Key={"pk": {"S": "item1"}},
+        UpdateExpression="ADD orders :order",
         ExpressionAttributeValues={":order": {"SS": [set_item]}},
     )
-    resp = client.scan(TableName=table_name, ProjectionExpression="customer, orders")
-    item = resp["Items"][0]
-    assert "customer" in item
-    assert "orders" in item
+    items = client.scan(TableName=table_name, ProjectionExpression="pk, orders")[
+        "Items"
+    ]
+    assert items == [{"pk": {"S": "item1"}, "orders": {"SS": ["test-data"]}}]
 
     client.update_item(
         TableName=table_name,
-        Key={"customer": {"S": item_key}},
-        UpdateExpression=f"DELETE {attr_name} :order",
-        ExpressionAttributeNames=expression_attribute_names,
+        Key={"pk": {"S": "item1"}},
+        UpdateExpression="DELETE orders :order",
         ExpressionAttributeValues={":order": {"SS": [set_item]}},
     )
-    resp = client.scan(TableName=table_name, ProjectionExpression="customer, orders")
-    item = resp["Items"][0]
-    assert "customer" in item
-    assert "orders" not in item
+    items = client.scan(TableName=table_name, ProjectionExpression="pk, orders")[
+        "Items"
+    ]
+    assert items == [{"pk": {"S": "item1"}}]
 
 
 @mock_aws

{moto-5.0.10.dev8 → moto-5.0.10.dev10}/tests/test_ec2/test_route_tables.py

@@ -269,6 +269,35 @@ def test_route_tables_filters_vpc_peering_connection():
     all(vpc_pcx_id == vpc_pcx.id for vpc_pcx_id in vpc_pcx_ids)
 
 
+@mock_aws
+def test_route_tables_filters_transit_gateway():
+    client = boto3.client("ec2", region_name="us-east-1")
+    ec2 = boto3.resource("ec2", region_name="us-east-1")
+    vpc = ec2.create_vpc(CidrBlock="10.0.0.0/16")
+    main_route_table_id = client.describe_route_tables(
+        Filters=[{"Name": "vpc-id", "Values": [vpc.id]}]
+    )["RouteTables"][0]["RouteTableId"]
+    main_route_table = ec2.RouteTable(main_route_table_id)
+
+    response = client.create_transit_gateway()
+
+    gateway = response["TransitGateway"]
+    main_route_table.create_route(TransitGatewayId=gateway["TransitGatewayId"])
+
+    route_tables = client.describe_route_tables(
+        Filters=[
+            {
+                "Name": "route.transit-gateway-id",
+                "Values": [gateway["TransitGatewayId"]],
+            }
+        ]
+    )["RouteTables"]
+
+    assert len(route_tables) == 1
+    route_table = route_tables[0]
+    assert route_table["RouteTableId"] == main_route_table_id
+
+
 @mock_aws
 def test_route_table_associations():
     client = boto3.client("ec2", region_name="us-east-1")