1124 lines
35 KiB
Python
1124 lines
35 KiB
Python
import boto
|
|
import boto3
|
|
from boto3.dynamodb.conditions import Key
|
|
import sure # noqa # pylint: disable=unused-import
|
|
import pytest
|
|
from datetime import datetime
|
|
from freezegun import freeze_time
|
|
from boto.exception import JSONResponseError
|
|
from botocore.exceptions import ClientError
|
|
from moto import mock_dynamodb2, mock_dynamodb2_deprecated
|
|
from tests.helpers import requires_boto_gte
|
|
import botocore
|
|
|
|
try:
|
|
from boto.dynamodb2.fields import HashKey
|
|
from boto.dynamodb2.table import Table
|
|
from boto.dynamodb2.table import Item
|
|
from boto.dynamodb2.exceptions import ConditionalCheckFailedException, ItemNotFound
|
|
except ImportError:
|
|
pass
|
|
|
|
|
|
def create_table():
|
|
table = Table.create(
|
|
"messages", schema=[HashKey("forum_name")], throughput={"read": 10, "write": 10}
|
|
)
|
|
return table
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
@freeze_time("2012-01-14")
|
|
def test_create_table():
|
|
create_table()
|
|
expected = {
|
|
"Table": {
|
|
"AttributeDefinitions": [
|
|
{"AttributeName": "forum_name", "AttributeType": "S"}
|
|
],
|
|
"ProvisionedThroughput": {
|
|
"NumberOfDecreasesToday": 0,
|
|
"WriteCapacityUnits": 10,
|
|
"ReadCapacityUnits": 10,
|
|
},
|
|
"TableSizeBytes": 0,
|
|
"TableName": "messages",
|
|
"TableStatus": "ACTIVE",
|
|
"TableArn": "arn:aws:dynamodb:us-east-1:123456789011:table/messages",
|
|
"KeySchema": [{"KeyType": "HASH", "AttributeName": "forum_name"}],
|
|
"ItemCount": 0,
|
|
"CreationDateTime": 1326499200.0,
|
|
"GlobalSecondaryIndexes": [],
|
|
"LocalSecondaryIndexes": [],
|
|
}
|
|
}
|
|
conn = boto.dynamodb2.connect_to_region(
|
|
"us-east-1", aws_access_key_id="ak", aws_secret_access_key="sk"
|
|
)
|
|
|
|
conn.describe_table("messages").should.equal(expected)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_create_table_boto3():
|
|
client = boto3.client("dynamodb", region_name="us-east-1")
|
|
client.create_table(
|
|
TableName="messages",
|
|
KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[
|
|
{"AttributeName": "id", "AttributeType": "S"},
|
|
{"AttributeName": "gsi_col", "AttributeType": "S"},
|
|
],
|
|
ProvisionedThroughput={"ReadCapacityUnits": 1, "WriteCapacityUnits": 1},
|
|
GlobalSecondaryIndexes=[
|
|
{
|
|
"IndexName": "test_gsi",
|
|
"KeySchema": [{"AttributeName": "gsi_col", "KeyType": "HASH"}],
|
|
"Projection": {"ProjectionType": "ALL"},
|
|
"ProvisionedThroughput": {
|
|
"ReadCapacityUnits": 1,
|
|
"WriteCapacityUnits": 1,
|
|
},
|
|
}
|
|
],
|
|
)
|
|
|
|
actual = client.describe_table(TableName="messages")["Table"]
|
|
|
|
actual.should.have.key("AttributeDefinitions").equal(
|
|
[
|
|
{"AttributeName": "id", "AttributeType": "S"},
|
|
{"AttributeName": "gsi_col", "AttributeType": "S"},
|
|
]
|
|
)
|
|
actual.should.have.key("CreationDateTime").be.a(datetime)
|
|
actual.should.have.key("GlobalSecondaryIndexes").equal(
|
|
[
|
|
{
|
|
"IndexName": "test_gsi",
|
|
"KeySchema": [{"AttributeName": "gsi_col", "KeyType": "HASH"}],
|
|
"Projection": {"ProjectionType": "ALL"},
|
|
"IndexStatus": "ACTIVE",
|
|
"ProvisionedThroughput": {
|
|
"ReadCapacityUnits": 1,
|
|
"WriteCapacityUnits": 1,
|
|
},
|
|
}
|
|
]
|
|
)
|
|
actual.should.have.key("LocalSecondaryIndexes").equal([])
|
|
actual.should.have.key("ProvisionedThroughput").equal(
|
|
{"NumberOfDecreasesToday": 0, "ReadCapacityUnits": 1, "WriteCapacityUnits": 1}
|
|
)
|
|
actual.should.have.key("TableSizeBytes").equal(0)
|
|
actual.should.have.key("TableName").equal("messages")
|
|
actual.should.have.key("TableStatus").equal("ACTIVE")
|
|
actual.should.have.key("TableArn").equal(
|
|
"arn:aws:dynamodb:us-east-1:123456789011:table/messages"
|
|
)
|
|
actual.should.have.key("KeySchema").equal(
|
|
[{"AttributeName": "id", "KeyType": "HASH"}]
|
|
)
|
|
actual.should.have.key("ItemCount").equal(0)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_delete_table():
|
|
create_table()
|
|
conn = boto.dynamodb2.layer1.DynamoDBConnection()
|
|
conn.list_tables()["TableNames"].should.have.length_of(1)
|
|
|
|
conn.delete_table("messages")
|
|
conn.list_tables()["TableNames"].should.have.length_of(0)
|
|
|
|
conn.delete_table.when.called_with("messages").should.throw(JSONResponseError)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_delete_table_boto3():
|
|
conn = boto3.client("dynamodb", region_name="us-west-2")
|
|
conn.create_table(
|
|
TableName="messages",
|
|
KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[{"AttributeName": "id", "AttributeType": "S"}],
|
|
ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
|
|
)
|
|
conn.list_tables()["TableNames"].should.have.length_of(1)
|
|
|
|
conn.delete_table(TableName="messages")
|
|
conn.list_tables()["TableNames"].should.have.length_of(0)
|
|
|
|
with pytest.raises(ClientError) as ex:
|
|
conn.delete_table(TableName="messages")
|
|
|
|
ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
|
|
ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
|
|
ex.value.response["Error"]["Message"].should.equal("Requested resource not found")
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_update_table_throughput():
|
|
table = create_table()
|
|
table.throughput["read"].should.equal(10)
|
|
table.throughput["write"].should.equal(10)
|
|
|
|
table.update(throughput={"read": 5, "write": 6})
|
|
|
|
table.throughput["read"].should.equal(5)
|
|
table.throughput["write"].should.equal(6)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_update_table_throughput_boto3():
|
|
conn = boto3.resource("dynamodb", region_name="us-west-2")
|
|
table = conn.create_table(
|
|
TableName="messages",
|
|
KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[{"AttributeName": "id", "AttributeType": "S"}],
|
|
ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
|
|
)
|
|
table.provisioned_throughput["ReadCapacityUnits"].should.equal(5)
|
|
table.provisioned_throughput["WriteCapacityUnits"].should.equal(5)
|
|
|
|
table.update(
|
|
ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 6}
|
|
)
|
|
|
|
table.provisioned_throughput["ReadCapacityUnits"].should.equal(5)
|
|
table.provisioned_throughput["WriteCapacityUnits"].should.equal(6)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_item_add_and_describe_and_update():
|
|
table = create_table()
|
|
|
|
data = {
|
|
"forum_name": "LOLCat Forum",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
}
|
|
|
|
table.put_item(data=data)
|
|
returned_item = table.get_item(forum_name="LOLCat Forum")
|
|
returned_item.should_not.be.none
|
|
|
|
dict(returned_item).should.equal(
|
|
{
|
|
"forum_name": "LOLCat Forum",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
}
|
|
)
|
|
|
|
returned_item["SentBy"] = "User B"
|
|
returned_item.save(overwrite=True)
|
|
|
|
returned_item = table.get_item(forum_name="LOLCat Forum")
|
|
dict(returned_item).should.equal(
|
|
{
|
|
"forum_name": "LOLCat Forum",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User B",
|
|
}
|
|
)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_item_add_and_describe_and_update_boto3():
|
|
conn = boto3.resource("dynamodb", region_name="us-west-2")
|
|
table = conn.create_table(
|
|
TableName="messages",
|
|
KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[{"AttributeName": "id", "AttributeType": "S"}],
|
|
ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
|
|
)
|
|
|
|
data = {
|
|
"id": "LOLCat Forum",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
}
|
|
|
|
table.put_item(Item=data)
|
|
returned_item = table.get_item(Key={"id": "LOLCat Forum"})
|
|
returned_item.shouldnt.have.key("ConsumedCapacity")
|
|
|
|
dict(returned_item["Item"]).should.equal(
|
|
{"id": "LOLCat Forum", "Body": "http://url_to_lolcat.gif", "SentBy": "User A",}
|
|
)
|
|
|
|
table.update_item(
|
|
Key={"id": "LOLCat Forum"},
|
|
UpdateExpression="SET SentBy=:user",
|
|
ExpressionAttributeValues={":user": "User B"},
|
|
)
|
|
|
|
returned_item = table.get_item(Key={"id": "LOLCat Forum"})
|
|
returned_item["Item"].should.equal(
|
|
{"id": "LOLCat Forum", "Body": "http://url_to_lolcat.gif", "SentBy": "User B",}
|
|
)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_item_partial_save():
|
|
table = create_table()
|
|
|
|
data = {
|
|
"forum_name": "LOLCat Forum",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
}
|
|
|
|
table.put_item(data=data)
|
|
returned_item = table.get_item(forum_name="LOLCat Forum")
|
|
|
|
returned_item["SentBy"] = "User B"
|
|
returned_item.partial_save()
|
|
|
|
returned_item = table.get_item(forum_name="LOLCat Forum")
|
|
dict(returned_item).should.equal(
|
|
{
|
|
"forum_name": "LOLCat Forum",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User B",
|
|
}
|
|
)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_item_put_without_table():
|
|
conn = boto.dynamodb2.layer1.DynamoDBConnection()
|
|
|
|
conn.put_item.when.called_with(
|
|
table_name="undeclared-table",
|
|
item={
|
|
"forum_name": "LOLCat Forum",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
},
|
|
).should.throw(JSONResponseError)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_item_put_without_table_boto3():
|
|
conn = boto3.client("dynamodb", region_name="us-west-2")
|
|
|
|
with pytest.raises(ClientError) as ex:
|
|
conn.put_item(
|
|
TableName="messages",
|
|
Item={
|
|
"forum_name": {"S": "LOLCat Forum"},
|
|
"Body": {"S": "http://url_to_lolcat.gif"},
|
|
"SentBy": {"S": "User A"},
|
|
},
|
|
)
|
|
|
|
ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
|
|
ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
|
|
ex.value.response["Error"]["Message"].should.equal("Requested resource not found")
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_get_item_with_undeclared_table():
|
|
conn = boto.dynamodb2.layer1.DynamoDBConnection()
|
|
|
|
conn.get_item.when.called_with(
|
|
table_name="undeclared-table", key={"forum_name": {"S": "LOLCat Forum"}}
|
|
).should.throw(JSONResponseError)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_get_item_with_undeclared_table_boto3():
|
|
conn = boto3.client("dynamodb", region_name="us-west-2")
|
|
|
|
with pytest.raises(ClientError) as ex:
|
|
conn.get_item(TableName="messages", Key={"forum_name": {"S": "LOLCat Forum"}})
|
|
|
|
ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
|
|
ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
|
|
ex.value.response["Error"]["Message"].should.equal("Requested resource not found")
|
|
|
|
|
|
@requires_boto_gte("2.30.0")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_delete_item():
|
|
table = create_table()
|
|
|
|
item_data = {
|
|
"forum_name": "LOLCat Forum",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
"ReceivedTime": "12/9/2011 11:36:03 PM",
|
|
}
|
|
item = Item(table, item_data)
|
|
item.save()
|
|
table.count().should.equal(1)
|
|
|
|
response = item.delete()
|
|
|
|
response.should.equal(True)
|
|
|
|
table.count().should.equal(0)
|
|
|
|
# Deletes are idempotent and 'False' here would imply an error condition
|
|
item.delete().should.equal(True)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_delete_item_boto3():
|
|
conn = boto3.resource("dynamodb", region_name="us-west-2")
|
|
table = conn.create_table(
|
|
TableName="messages",
|
|
KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[{"AttributeName": "id", "AttributeType": "S"}],
|
|
ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
|
|
)
|
|
|
|
item_data = {
|
|
"id": "LOLCat Forum",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
"ReceivedTime": "12/9/2011 11:36:03 PM",
|
|
}
|
|
table.put_item(Item=item_data)
|
|
|
|
table.item_count.should.equal(1)
|
|
|
|
table.delete_item(Key={"id": "LOLCat Forum"})
|
|
|
|
table.item_count.should.equal(0)
|
|
|
|
table.delete_item(Key={"id": "LOLCat Forum"})
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_delete_item_with_undeclared_table():
|
|
conn = boto.dynamodb2.layer1.DynamoDBConnection()
|
|
|
|
conn.delete_item.when.called_with(
|
|
table_name="undeclared-table", key={"forum_name": {"S": "LOLCat Forum"}}
|
|
).should.throw(JSONResponseError)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_delete_item_with_undeclared_table_boto3():
|
|
conn = boto3.client("dynamodb", region_name="us-west-2")
|
|
|
|
with pytest.raises(ClientError) as ex:
|
|
conn.delete_item(
|
|
TableName="messages", Key={"forum_name": {"S": "LOLCat Forum"}}
|
|
)
|
|
|
|
ex.value.response["Error"]["Code"].should.equal("ConditionalCheckFailedException")
|
|
ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
|
|
ex.value.response["Error"]["Message"].should.equal(
|
|
"A condition specified in the operation could not be evaluated."
|
|
)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_query():
|
|
table = create_table()
|
|
|
|
item_data = {
|
|
"forum_name": "the-key",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
"ReceivedTime": "12/9/2011 11:36:03 PM",
|
|
}
|
|
item = Item(table, item_data)
|
|
item.save(overwrite=True)
|
|
table.count().should.equal(1)
|
|
table = Table("messages")
|
|
|
|
results = table.query(forum_name__eq="the-key")
|
|
sum(1 for _ in results).should.equal(1)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_query_with_undeclared_table():
|
|
conn = boto.dynamodb2.layer1.DynamoDBConnection()
|
|
|
|
conn.query.when.called_with(
|
|
table_name="undeclared-table",
|
|
key_conditions={
|
|
"forum_name": {
|
|
"ComparisonOperator": "EQ",
|
|
"AttributeValueList": [{"S": "the-key"}],
|
|
}
|
|
},
|
|
).should.throw(JSONResponseError)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_scan():
|
|
table = create_table()
|
|
|
|
item_data = {
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
"ReceivedTime": "12/9/2011 11:36:03 PM",
|
|
}
|
|
item_data["forum_name"] = "the-key"
|
|
|
|
item = Item(table, item_data)
|
|
item.save()
|
|
|
|
item["forum_name"] = "the-key2"
|
|
item.save(overwrite=True)
|
|
|
|
item_data = {
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User B",
|
|
"ReceivedTime": "12/9/2011 11:36:03 PM",
|
|
"Ids": set([1, 2, 3]),
|
|
"PK": 7,
|
|
}
|
|
item_data["forum_name"] = "the-key3"
|
|
item = Item(table, item_data)
|
|
item.save()
|
|
|
|
results = table.scan()
|
|
sum(1 for _ in results).should.equal(3)
|
|
|
|
results = table.scan(SentBy__eq="User B")
|
|
sum(1 for _ in results).should.equal(1)
|
|
|
|
results = table.scan(Body__beginswith="http")
|
|
sum(1 for _ in results).should.equal(3)
|
|
|
|
results = table.scan(Ids__null=False)
|
|
sum(1 for _ in results).should.equal(1)
|
|
|
|
results = table.scan(Ids__null=True)
|
|
sum(1 for _ in results).should.equal(2)
|
|
|
|
results = table.scan(PK__between=[8, 9])
|
|
sum(1 for _ in results).should.equal(0)
|
|
|
|
results = table.scan(PK__between=[5, 8])
|
|
sum(1 for _ in results).should.equal(1)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_scan_with_undeclared_table():
|
|
conn = boto.dynamodb2.layer1.DynamoDBConnection()
|
|
|
|
conn.scan.when.called_with(
|
|
table_name="undeclared-table",
|
|
scan_filter={
|
|
"SentBy": {
|
|
"AttributeValueList": [{"S": "User B"}],
|
|
"ComparisonOperator": "EQ",
|
|
}
|
|
},
|
|
).should.throw(JSONResponseError)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_scan_with_undeclared_table_boto3():
|
|
conn = boto3.client("dynamodb", region_name="us-west-2")
|
|
|
|
with pytest.raises(ClientError) as ex:
|
|
conn.scan(TableName="messages")
|
|
|
|
ex.value.response["Error"]["Code"].should.equal("ResourceNotFoundException")
|
|
ex.value.response["ResponseMetadata"]["HTTPStatusCode"].should.equal(400)
|
|
ex.value.response["Error"]["Message"].should.equal("Requested resource not found")
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_write_batch():
|
|
table = create_table()
|
|
|
|
with table.batch_write() as batch:
|
|
batch.put_item(
|
|
data={
|
|
"forum_name": "the-key",
|
|
"subject": "123",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
"ReceivedTime": "12/9/2011 11:36:03 PM",
|
|
}
|
|
)
|
|
batch.put_item(
|
|
data={
|
|
"forum_name": "the-key2",
|
|
"subject": "789",
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User B",
|
|
"ReceivedTime": "12/9/2011 11:36:03 PM",
|
|
}
|
|
)
|
|
|
|
table.count().should.equal(2)
|
|
with table.batch_write() as batch:
|
|
batch.delete_item(forum_name="the-key", subject="789")
|
|
|
|
table.count().should.equal(1)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_batch_read():
|
|
table = create_table()
|
|
|
|
item_data = {
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User A",
|
|
"ReceivedTime": "12/9/2011 11:36:03 PM",
|
|
}
|
|
item_data["forum_name"] = "the-key1"
|
|
item = Item(table, item_data)
|
|
item.save()
|
|
|
|
item = Item(table, item_data)
|
|
item_data["forum_name"] = "the-key2"
|
|
item.save(overwrite=True)
|
|
|
|
item_data = {
|
|
"Body": "http://url_to_lolcat.gif",
|
|
"SentBy": "User B",
|
|
"ReceivedTime": "12/9/2011 11:36:03 PM",
|
|
"Ids": set([1, 2, 3]),
|
|
"PK": 7,
|
|
}
|
|
item = Item(table, item_data)
|
|
item_data["forum_name"] = "another-key"
|
|
item.save(overwrite=True)
|
|
|
|
results = table.batch_get(
|
|
keys=[{"forum_name": "the-key1"}, {"forum_name": "another-key"}]
|
|
)
|
|
|
|
# Iterate through so that batch_item gets called
|
|
count = len([x for x in results])
|
|
count.should.equal(2)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_get_key_fields():
|
|
table = create_table()
|
|
kf = table.get_key_fields()
|
|
kf[0].should.equal("forum_name")
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_get_key_schema():
|
|
conn = boto3.resource("dynamodb", region_name="us-west-2")
|
|
table = conn.create_table(
|
|
TableName="messages",
|
|
KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[{"AttributeName": "id", "AttributeType": "S"}],
|
|
ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
|
|
)
|
|
|
|
table.key_schema.should.equal([{"AttributeName": "id", "KeyType": "HASH"}])
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_get_missing_item():
|
|
table = create_table()
|
|
table.get_item.when.called_with(forum_name="missing").should.throw(ItemNotFound)
|
|
|
|
|
|
@requires_boto_gte("2.9")
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_get_special_item():
|
|
table = Table.create(
|
|
"messages",
|
|
schema=[HashKey("date-joined")],
|
|
throughput={"read": 10, "write": 10},
|
|
)
|
|
|
|
data = {"date-joined": 127549192, "SentBy": "User A"}
|
|
table.put_item(data=data)
|
|
returned_item = table.get_item(**{"date-joined": 127549192})
|
|
dict(returned_item).should.equal(data)
|
|
|
|
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_update_item_remove():
|
|
conn = boto.dynamodb2.connect_to_region("us-east-1")
|
|
table = Table.create("messages", schema=[HashKey("username")])
|
|
|
|
data = {"username": "steve", "SentBy": "User A", "SentTo": "User B"}
|
|
table.put_item(data=data)
|
|
key_map = {"username": {"S": "steve"}}
|
|
|
|
# Then remove the SentBy field
|
|
conn.update_item("messages", key_map, update_expression="REMOVE SentBy, SentTo")
|
|
|
|
returned_item = table.get_item(username="steve")
|
|
dict(returned_item).should.equal({"username": "steve"})
|
|
|
|
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_update_item_nested_remove():
|
|
conn = boto.dynamodb2.connect_to_region("us-east-1")
|
|
table = Table.create("messages", schema=[HashKey("username")])
|
|
|
|
data = {"username": "steve", "Meta": {"FullName": "Steve Urkel"}}
|
|
table.put_item(data=data)
|
|
key_map = {"username": {"S": "steve"}}
|
|
|
|
# Then remove the Meta.FullName field
|
|
conn.update_item("messages", key_map, update_expression="REMOVE Meta.FullName")
|
|
|
|
returned_item = table.get_item(username="steve")
|
|
dict(returned_item).should.equal({"username": "steve", "Meta": {}})
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_update_item_double_nested_remove():
|
|
conn = boto3.client("dynamodb", region_name="us-east-1")
|
|
conn.create_table(
|
|
TableName="messages",
|
|
KeySchema=[{"AttributeName": "username", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[{"AttributeName": "username", "AttributeType": "S"}],
|
|
BillingMode="PAY_PER_REQUEST",
|
|
)
|
|
|
|
item = {
|
|
"username": {"S": "steve"},
|
|
"Meta": {
|
|
"M": {"Name": {"M": {"First": {"S": "Steve"}, "Last": {"S": "Urkel"}}}}
|
|
},
|
|
}
|
|
conn.put_item(TableName="messages", Item=item)
|
|
key_map = {"username": {"S": "steve"}}
|
|
|
|
# Then remove the Meta.FullName field
|
|
conn.update_item(
|
|
TableName="messages",
|
|
Key=key_map,
|
|
UpdateExpression="REMOVE Meta.#N.#F",
|
|
ExpressionAttributeNames={"#N": "Name", "#F": "First"},
|
|
)
|
|
|
|
returned_item = conn.get_item(TableName="messages", Key=key_map)
|
|
expected_item = {
|
|
"username": {"S": "steve"},
|
|
"Meta": {"M": {"Name": {"M": {"Last": {"S": "Urkel"}}}}},
|
|
}
|
|
dict(returned_item["Item"]).should.equal(expected_item)
|
|
|
|
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_update_item_set():
|
|
conn = boto.dynamodb2.connect_to_region("us-east-1")
|
|
table = Table.create("messages", schema=[HashKey("username")])
|
|
|
|
data = {"username": "steve", "SentBy": "User A"}
|
|
table.put_item(data=data)
|
|
key_map = {"username": {"S": "steve"}}
|
|
|
|
conn.update_item(
|
|
"messages",
|
|
key_map,
|
|
update_expression="SET foo=:bar, blah=:baz REMOVE SentBy",
|
|
expression_attribute_values={":bar": {"S": "bar"}, ":baz": {"S": "baz"}},
|
|
)
|
|
|
|
returned_item = table.get_item(username="steve")
|
|
dict(returned_item).should.equal({"username": "steve", "foo": "bar", "blah": "baz"})
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_update_item_set_boto3():
|
|
conn = boto3.resource("dynamodb", region_name="us-east-1")
|
|
table = conn.create_table(
|
|
TableName="messages",
|
|
KeySchema=[{"AttributeName": "username", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[{"AttributeName": "username", "AttributeType": "S"}],
|
|
BillingMode="PAY_PER_REQUEST",
|
|
)
|
|
|
|
data = {"username": "steve", "SentBy": "User A"}
|
|
table.put_item(Item=data)
|
|
key_map = {"username": "steve"}
|
|
|
|
table.update_item(
|
|
Key=key_map,
|
|
UpdateExpression="SET foo=:bar, blah=:baz REMOVE SentBy",
|
|
ExpressionAttributeValues={":bar": "bar", ":baz": "baz"},
|
|
)
|
|
|
|
returned_item = table.get_item(Key=key_map)["Item"]
|
|
dict(returned_item).should.equal({"username": "steve", "foo": "bar", "blah": "baz"})
|
|
|
|
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_failed_overwrite():
|
|
table = Table.create(
|
|
"messages", schema=[HashKey("id")], throughput={"read": 7, "write": 3}
|
|
)
|
|
|
|
data1 = {"id": "123", "data": "678"}
|
|
table.put_item(data=data1)
|
|
|
|
data2 = {"id": "123", "data": "345"}
|
|
table.put_item(data=data2, overwrite=True)
|
|
|
|
data3 = {"id": "123", "data": "812"}
|
|
table.put_item.when.called_with(data=data3).should.throw(
|
|
ConditionalCheckFailedException
|
|
)
|
|
|
|
returned_item = table.lookup("123")
|
|
dict(returned_item).should.equal(data2)
|
|
|
|
data4 = {"id": "124", "data": 812}
|
|
table.put_item(data=data4)
|
|
|
|
returned_item = table.lookup("124")
|
|
dict(returned_item).should.equal(data4)
|
|
|
|
|
|
# Has boto3 equivalent
|
|
@mock_dynamodb2_deprecated
|
|
def test_conflicting_writes():
|
|
table = Table.create("messages", schema=[HashKey("id")])
|
|
|
|
item_data = {"id": "123", "data": "678"}
|
|
item1 = Item(table, item_data)
|
|
item2 = Item(table, item_data)
|
|
item1.save()
|
|
|
|
item1["data"] = "579"
|
|
item2["data"] = "912"
|
|
|
|
item1.save()
|
|
item2.save.when.called_with().should.throw(ConditionalCheckFailedException)
|
|
|
|
|
|
"""
|
|
boto3
|
|
"""
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_create_table():
|
|
dynamodb = boto3.resource("dynamodb", region_name="us-east-1")
|
|
|
|
table = dynamodb.create_table(
|
|
TableName="users",
|
|
KeySchema=[{"AttributeName": "username", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[{"AttributeName": "username", "AttributeType": "S"}],
|
|
ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
|
|
)
|
|
table.name.should.equal("users")
|
|
|
|
|
|
def _create_user_table():
|
|
dynamodb = boto3.resource("dynamodb", region_name="us-east-1")
|
|
|
|
dynamodb.create_table(
|
|
TableName="users",
|
|
KeySchema=[{"AttributeName": "username", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[{"AttributeName": "username", "AttributeType": "S"}],
|
|
ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
|
|
)
|
|
return dynamodb.Table("users")
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_conditions():
|
|
table = _create_user_table()
|
|
|
|
table.put_item(Item={"username": "johndoe"})
|
|
table.put_item(Item={"username": "janedoe"})
|
|
|
|
response = table.query(KeyConditionExpression=Key("username").eq("johndoe"))
|
|
response["Count"].should.equal(1)
|
|
response["Items"].should.have.length_of(1)
|
|
response["Items"][0].should.equal({"username": "johndoe"})
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_put_item_conditions_pass():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "bar"})
|
|
table.put_item(
|
|
Item={"username": "johndoe", "foo": "baz"},
|
|
Expected={"foo": {"ComparisonOperator": "EQ", "AttributeValueList": ["bar"]}},
|
|
)
|
|
final_item = table.get_item(Key={"username": "johndoe"})
|
|
assert dict(final_item)["Item"]["foo"].should.equal("baz")
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_put_item_conditions_pass_because_expect_not_exists_by_compare_to_null():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "bar"})
|
|
table.put_item(
|
|
Item={"username": "johndoe", "foo": "baz"},
|
|
Expected={"whatever": {"ComparisonOperator": "NULL"}},
|
|
)
|
|
final_item = table.get_item(Key={"username": "johndoe"})
|
|
assert dict(final_item)["Item"]["foo"].should.equal("baz")
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_put_item_conditions_pass_because_expect_exists_by_compare_to_not_null():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "bar"})
|
|
table.put_item(
|
|
Item={"username": "johndoe", "foo": "baz"},
|
|
Expected={"foo": {"ComparisonOperator": "NOT_NULL"}},
|
|
)
|
|
final_item = table.get_item(Key={"username": "johndoe"})
|
|
assert dict(final_item)["Item"]["foo"].should.equal("baz")
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_put_item_conditions_fail():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "bar"})
|
|
table.put_item.when.called_with(
|
|
Item={"username": "johndoe", "foo": "baz"},
|
|
Expected={"foo": {"ComparisonOperator": "NE", "AttributeValueList": ["bar"]}},
|
|
).should.throw(botocore.client.ClientError)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_update_item_conditions_fail():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "baz"})
|
|
table.update_item.when.called_with(
|
|
Key={"username": "johndoe"},
|
|
UpdateExpression="SET foo=:bar",
|
|
Expected={"foo": {"Value": "bar"}},
|
|
ExpressionAttributeValues={":bar": "bar"},
|
|
).should.throw(botocore.client.ClientError)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_update_item_conditions_fail_because_expect_not_exists():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "baz"})
|
|
table.update_item.when.called_with(
|
|
Key={"username": "johndoe"},
|
|
UpdateExpression="SET foo=:bar",
|
|
Expected={"foo": {"Exists": False}},
|
|
ExpressionAttributeValues={":bar": "bar"},
|
|
).should.throw(botocore.client.ClientError)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_update_item_conditions_fail_because_expect_not_exists_by_compare_to_null():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "baz"})
|
|
table.update_item.when.called_with(
|
|
Key={"username": "johndoe"},
|
|
UpdateExpression="SET foo=:bar",
|
|
Expected={"foo": {"ComparisonOperator": "NULL"}},
|
|
ExpressionAttributeValues={":bar": "bar"},
|
|
).should.throw(botocore.client.ClientError)
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_update_item_conditions_pass():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "bar"})
|
|
table.update_item(
|
|
Key={"username": "johndoe"},
|
|
UpdateExpression="SET foo=:baz",
|
|
Expected={"foo": {"Value": "bar"}},
|
|
ExpressionAttributeValues={":baz": "baz"},
|
|
)
|
|
returned_item = table.get_item(Key={"username": "johndoe"})
|
|
assert dict(returned_item)["Item"]["foo"].should.equal("baz")
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_update_item_conditions_pass_because_expect_not_exists():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "bar"})
|
|
table.update_item(
|
|
Key={"username": "johndoe"},
|
|
UpdateExpression="SET foo=:baz",
|
|
Expected={"whatever": {"Exists": False}},
|
|
ExpressionAttributeValues={":baz": "baz"},
|
|
)
|
|
returned_item = table.get_item(Key={"username": "johndoe"})
|
|
assert dict(returned_item)["Item"]["foo"].should.equal("baz")
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_update_item_conditions_pass_because_expect_not_exists_by_compare_to_null():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "bar"})
|
|
table.update_item(
|
|
Key={"username": "johndoe"},
|
|
UpdateExpression="SET foo=:baz",
|
|
Expected={"whatever": {"ComparisonOperator": "NULL"}},
|
|
ExpressionAttributeValues={":baz": "baz"},
|
|
)
|
|
returned_item = table.get_item(Key={"username": "johndoe"})
|
|
assert dict(returned_item)["Item"]["foo"].should.equal("baz")
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_update_item_conditions_pass_because_expect_exists_by_compare_to_not_null():
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe", "foo": "bar"})
|
|
table.update_item(
|
|
Key={"username": "johndoe"},
|
|
UpdateExpression="SET foo=:baz",
|
|
Expected={"foo": {"ComparisonOperator": "NOT_NULL"}},
|
|
ExpressionAttributeValues={":baz": "baz"},
|
|
)
|
|
returned_item = table.get_item(Key={"username": "johndoe"})
|
|
assert dict(returned_item)["Item"]["foo"].should.equal("baz")
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_boto3_update_settype_item_with_conditions():
|
|
class OrderedSet(set):
|
|
"""A set with predictable iteration order"""
|
|
|
|
def __init__(self, values):
|
|
super(OrderedSet, self).__init__(values)
|
|
self.__ordered_values = values
|
|
|
|
def __iter__(self):
|
|
return iter(self.__ordered_values)
|
|
|
|
table = _create_user_table()
|
|
table.put_item(Item={"username": "johndoe"})
|
|
table.update_item(
|
|
Key={"username": "johndoe"},
|
|
UpdateExpression="SET foo=:new_value",
|
|
ExpressionAttributeValues={":new_value": OrderedSet(["hello", "world"])},
|
|
)
|
|
|
|
table.update_item(
|
|
Key={"username": "johndoe"},
|
|
UpdateExpression="SET foo=:new_value",
|
|
ExpressionAttributeValues={":new_value": set(["baz"])},
|
|
Expected={
|
|
"foo": {
|
|
"ComparisonOperator": "EQ",
|
|
"AttributeValueList": [
|
|
OrderedSet(["world", "hello"]) # Opposite order to original
|
|
],
|
|
}
|
|
},
|
|
)
|
|
returned_item = table.get_item(Key={"username": "johndoe"})
|
|
assert dict(returned_item)["Item"]["foo"].should.equal(set(["baz"]))
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_scan_pagination():
|
|
table = _create_user_table()
|
|
|
|
expected_usernames = ["user{0}".format(i) for i in range(10)]
|
|
for u in expected_usernames:
|
|
table.put_item(Item={"username": u})
|
|
|
|
page1 = table.scan(Limit=6)
|
|
page1["Count"].should.equal(6)
|
|
page1["Items"].should.have.length_of(6)
|
|
page1.should.have.key("LastEvaluatedKey")
|
|
|
|
page2 = table.scan(Limit=6, ExclusiveStartKey=page1["LastEvaluatedKey"])
|
|
page2["Count"].should.equal(4)
|
|
page2["Items"].should.have.length_of(4)
|
|
page2.should_not.have.key("LastEvaluatedKey")
|
|
|
|
results = page1["Items"] + page2["Items"]
|
|
usernames = set([r["username"] for r in results])
|
|
usernames.should.equal(set(expected_usernames))
|
|
|
|
|
|
@mock_dynamodb2
|
|
def test_scan_by_index():
|
|
dynamodb = boto3.client("dynamodb", region_name="us-east-1")
|
|
|
|
dynamodb.create_table(
|
|
TableName="test",
|
|
KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
|
|
AttributeDefinitions=[
|
|
{"AttributeName": "id", "AttributeType": "S"},
|
|
{"AttributeName": "gsi_col", "AttributeType": "S"},
|
|
],
|
|
ProvisionedThroughput={"ReadCapacityUnits": 1, "WriteCapacityUnits": 1},
|
|
GlobalSecondaryIndexes=[
|
|
{
|
|
"IndexName": "test_gsi",
|
|
"KeySchema": [{"AttributeName": "gsi_col", "KeyType": "HASH"}],
|
|
"Projection": {"ProjectionType": "ALL"},
|
|
"ProvisionedThroughput": {
|
|
"ReadCapacityUnits": 1,
|
|
"WriteCapacityUnits": 1,
|
|
},
|
|
}
|
|
],
|
|
)
|
|
|
|
dynamodb.put_item(
|
|
TableName="test",
|
|
Item={"id": {"S": "1"}, "col1": {"S": "val1"}, "gsi_col": {"S": "gsi_val1"}},
|
|
)
|
|
|
|
dynamodb.put_item(
|
|
TableName="test",
|
|
Item={"id": {"S": "2"}, "col1": {"S": "val2"}, "gsi_col": {"S": "gsi_val2"}},
|
|
)
|
|
|
|
dynamodb.put_item(TableName="test", Item={"id": {"S": "3"}, "col1": {"S": "val3"}})
|
|
|
|
res = dynamodb.scan(TableName="test")
|
|
assert res["Count"] == 3
|
|
assert len(res["Items"]) == 3
|
|
|
|
res = dynamodb.scan(TableName="test", IndexName="test_gsi")
|
|
assert res["Count"] == 2
|
|
assert len(res["Items"]) == 2
|
|
|
|
res = dynamodb.scan(TableName="test", IndexName="test_gsi", Limit=1)
|
|
assert res["Count"] == 1
|
|
assert len(res["Items"]) == 1
|
|
last_eval_key = res["LastEvaluatedKey"]
|
|
assert last_eval_key["id"]["S"] == "1"
|
|
assert last_eval_key["gsi_col"]["S"] == "gsi_val1"
|