Merge remote master

tests/test_dynamodb2/test_dynamodb.py

@@ -3274,6 +3274,7 @@ def test_update_supports_complex_expression_attribute_values():
 
 @mock_dynamodb2
 def test_update_supports_list_append():
+    # Verify whether the list_append operation works as expected
     client = boto3.client("dynamodb", region_name="us-east-1")
 
     client.create_table(
@@ -3307,6 +3308,132 @@ def test_update_supports_list_append():
     )
 
 
+@mock_dynamodb2
+def test_update_supports_nested_list_append():
+    # Verify whether we can append a list that's inside a map
+    client = boto3.client("dynamodb", region_name="us-east-1")
+
+    client.create_table(
+        AttributeDefinitions=[{"AttributeName": "id", "AttributeType": "S"}],
+        TableName="TestTable",
+        KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
+        ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
+    )
+    client.put_item(
+        TableName="TestTable",
+        Item={
+            "id": {"S": "nested_list_append"},
+            "a": {"M": {"b": {"L": [{"S": "bar1"}]}}},
+        },
+    )
+
+    # Update item using list_append expression
+    client.update_item(
+        TableName="TestTable",
+        Key={"id": {"S": "nested_list_append"}},
+        UpdateExpression="SET a.#b = list_append(a.#b, :i)",
+        ExpressionAttributeValues={":i": {"L": [{"S": "bar2"}]}},
+        ExpressionAttributeNames={"#b": "b"},
+    )
+
+    # Verify item is appended to the existing list
+    result = client.get_item(
+        TableName="TestTable", Key={"id": {"S": "nested_list_append"}}
+    )["Item"]
+    result.should.equal(
+        {
+            "id": {"S": "nested_list_append"},
+            "a": {"M": {"b": {"L": [{"S": "bar1"}, {"S": "bar2"}]}}},
+        }
+    )
+
+
+@mock_dynamodb2
+def test_update_supports_multiple_levels_nested_list_append():
+    # Verify whether we can append a list that's inside a map that's inside a map  (Inception!)
+    client = boto3.client("dynamodb", region_name="us-east-1")
+
+    client.create_table(
+        AttributeDefinitions=[{"AttributeName": "id", "AttributeType": "S"}],
+        TableName="TestTable",
+        KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
+        ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
+    )
+    client.put_item(
+        TableName="TestTable",
+        Item={
+            "id": {"S": "nested_list_append"},
+            "a": {"M": {"b": {"M": {"c": {"L": [{"S": "bar1"}]}}}}},
+        },
+    )
+
+    # Update item using list_append expression
+    client.update_item(
+        TableName="TestTable",
+        Key={"id": {"S": "nested_list_append"}},
+        UpdateExpression="SET a.#b.c = list_append(a.#b.#c, :i)",
+        ExpressionAttributeValues={":i": {"L": [{"S": "bar2"}]}},
+        ExpressionAttributeNames={"#b": "b", "#c": "c"},
+    )
+
+    # Verify item is appended to the existing list
+    result = client.get_item(
+        TableName="TestTable", Key={"id": {"S": "nested_list_append"}}
+    )["Item"]
+    result.should.equal(
+        {
+            "id": {"S": "nested_list_append"},
+            "a": {"M": {"b": {"M": {"c": {"L": [{"S": "bar1"}, {"S": "bar2"}]}}}}},
+        }
+    )
+
+
+@mock_dynamodb2
+def test_update_supports_nested_list_append_onto_another_list():
+    # Verify whether we can take the contents of one list, and use that to fill another list
+    # Note that the contents of the other list is completely overwritten
+    client = boto3.client("dynamodb", region_name="us-east-1")
+
+    client.create_table(
+        AttributeDefinitions=[{"AttributeName": "id", "AttributeType": "S"}],
+        TableName="TestTable",
+        KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
+        ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
+    )
+    client.put_item(
+        TableName="TestTable",
+        Item={
+            "id": {"S": "list_append_another"},
+            "a": {"M": {"b": {"L": [{"S": "bar1"}]}, "c": {"L": [{"S": "car1"}]}}},
+        },
+    )
+
+    # Update item using list_append expression
+    client.update_item(
+        TableName="TestTable",
+        Key={"id": {"S": "list_append_another"}},
+        UpdateExpression="SET a.#c = list_append(a.#b, :i)",
+        ExpressionAttributeValues={":i": {"L": [{"S": "bar2"}]}},
+        ExpressionAttributeNames={"#b": "b", "#c": "c"},
+    )
+
+    # Verify item is appended to the existing list
+    result = client.get_item(
+        TableName="TestTable", Key={"id": {"S": "list_append_another"}}
+    )["Item"]
+    result.should.equal(
+        {
+            "id": {"S": "list_append_another"},
+            "a": {
+                "M": {
+                    "b": {"L": [{"S": "bar1"}]},
+                    "c": {"L": [{"S": "bar1"}, {"S": "bar2"}]},
+                }
+            },
+        }
+    )
+
+
 @mock_dynamodb2
 def test_update_catches_invalid_list_append_operation():
     client = boto3.client("dynamodb", region_name="us-east-1")
@@ -3372,7 +3499,7 @@ def test_update_item_if_original_value_is_none():
     table.update_item(
         Key={"job_id": "a"},
         UpdateExpression="SET job_name = :output",
-        ExpressionAttributeValues={":output": "updated",},
+        ExpressionAttributeValues={":output": "updated"},
     )
     table.scan()["Items"][0]["job_name"].should.equal("updated")
 
@@ -3391,7 +3518,7 @@ def test_update_nested_item_if_original_value_is_none():
     table.update_item(
         Key={"job_id": "a"},
         UpdateExpression="SET job_details.job_name = :output",
-        ExpressionAttributeValues={":output": "updated",},
+        ExpressionAttributeValues={":output": "updated"},
     )
     table.scan()["Items"][0]["job_details"]["job_name"].should.equal("updated")
 

tests/test_dynamodb2/test_dynamodb_table_with_range_key.py

@@ -1289,6 +1289,16 @@ def test_update_item_add_with_expression():
     current_item["str_set"] = current_item["str_set"].union({"item4"})
     dict(table.get_item(Key=item_key)["Item"]).should.equal(current_item)
 
+    # Update item to add a string value to a non-existing set
+    # Should just create the set in the background
+    table.update_item(
+        Key=item_key,
+        UpdateExpression="ADD non_existing_str_set :v",
+        ExpressionAttributeValues={":v": {"item4"}},
+    )
+    current_item["non_existing_str_set"] = {"item4"}
+    dict(table.get_item(Key=item_key)["Item"]).should.equal(current_item)
+
     # Update item to add a num value to a num set
     table.update_item(
         Key=item_key,
@@ -1336,6 +1346,69 @@ def test_update_item_add_with_expression():
     ).should.have.raised(ClientError)
 
 
+@mock_dynamodb2
+def test_update_item_add_with_nested_sets():
+    table = _create_table_with_range_key()
+
+    item_key = {"forum_name": "the-key", "subject": "123"}
+    current_item = {
+        "forum_name": "the-key",
+        "subject": "123",
+        "nested": {"str_set": {"item1", "item2", "item3"}},
+    }
+
+    # Put an entry in the DB to play with
+    table.put_item(Item=current_item)
+
+    # Update item to add a string value to a nested string set
+    table.update_item(
+        Key=item_key,
+        UpdateExpression="ADD nested.str_set :v",
+        ExpressionAttributeValues={":v": {"item4"}},
+    )
+    current_item["nested"]["str_set"] = current_item["nested"]["str_set"].union(
+        {"item4"}
+    )
+    dict(table.get_item(Key=item_key)["Item"]).should.equal(current_item)
+
+    # Update item to add a string value to a non-existing set
+    # Should just create the set in the background
+    table.update_item(
+        Key=item_key,
+        UpdateExpression="ADD #ns.#ne :v",
+        ExpressionAttributeNames={"#ns": "nested", "#ne": "non_existing_str_set"},
+        ExpressionAttributeValues={":v": {"new_item"}},
+    )
+    current_item["nested"]["non_existing_str_set"] = {"new_item"}
+    dict(table.get_item(Key=item_key)["Item"]).should.equal(current_item)
+
+
+@mock_dynamodb2
+def test_update_item_delete_with_nested_sets():
+    table = _create_table_with_range_key()
+
+    item_key = {"forum_name": "the-key", "subject": "123"}
+    current_item = {
+        "forum_name": "the-key",
+        "subject": "123",
+        "nested": {"str_set": {"item1", "item2", "item3"}},
+    }
+
+    # Put an entry in the DB to play with
+    table.put_item(Item=current_item)
+
+    # Update item to add a string value to a nested string set
+    table.update_item(
+        Key=item_key,
+        UpdateExpression="DELETE nested.str_set :v",
+        ExpressionAttributeValues={":v": {"item3"}},
+    )
+    current_item["nested"]["str_set"] = current_item["nested"]["str_set"].difference(
+        {"item3"}
+    )
+    dict(table.get_item(Key=item_key)["Item"]).should.equal(current_item)
+
+
 @mock_dynamodb2
 def test_update_item_delete_with_expression():
     table = _create_table_with_range_key()