def test_delete_item(self):
"""
TableConnection.delete_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.delete_item(
"Amazon DynamoDB",
"How do I update multiple items?")
params = {
'ReturnConsumedCapacity': 'TOTAL',
'Key': {
'ForumName': {
'S': 'Amazon DynamoDB'
},
'Subject': {
'S': 'How do I update multiple items?'
}
},
'TableName': self.test_table_name
}
self.assertEqual(req.call_args[0][1], params)
def test_query(self):
"""
TableConnection.query
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.query(
"FooForum",
key_conditions={'ForumName': {'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': ['thread']}}
)
params = {
'ReturnConsumedCapacity': 'TOTAL',
'KeyConditions': {
'ForumName': {
'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': [{
'S': 'thread'
}]
}
},
'TableName': self.test_table_name
}
self.assertEqual(req.call_args[0][1], params)
def test_batch_get_item(self):
"""
TableConnection.batch_get_item
"""
items = []
conn = TableConnection(self.test_table_name)
for i in range(10):
items.append({"ForumName": "FooForum", "Subject": "thread-{0}".format(i)})
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.batch_get_item(items)
params = {
"ReturnConsumedCapacity": "TOTAL",
"RequestItems": {
self.test_table_name: {
"Keys": [
{"ForumName": {"S": "FooForum"}, "Subject": {"S": "thread-0"}},
{"ForumName": {"S": "FooForum"}, "Subject": {"S": "thread-1"}},
{"ForumName": {"S": "FooForum"}, "Subject": {"S": "thread-2"}},
{"ForumName": {"S": "FooForum"}, "Subject": {"S": "thread-3"}},
{"ForumName": {"S": "FooForum"}, "Subject": {"S": "thread-4"}},
{"ForumName": {"S": "FooForum"}, "Subject": {"S": "thread-5"}},
{"ForumName": {"S": "FooForum"}, "Subject": {"S": "thread-6"}},
{"ForumName": {"S": "FooForum"}, "Subject": {"S": "thread-7"}},
{"ForumName": {"S": "FooForum"}, "Subject": {"S": "thread-8"}},
{"ForumName": {"S": "FooForum"}, "Subject": {"S": "thread-9"}},
]
}
},
}
self.assertEqual(req.call_args[0][1], params)
def test_create_table_with_tags(self):
conn = TableConnection(self.test_table_name)
kwargs = {
'read_capacity_units':
1,
'write_capacity_units':
1,
'attribute_definitions': [{
'attribute_name': 'key1',
'attribute_type': 'S'
}, {
'attribute_name': 'key2',
'attribute_type': 'S'
}],
'key_schema': [{
'attribute_name': 'key1',
'key_type': 'hash'
}, {
'attribute_name': 'key2',
'key_type': 'range'
}],
'tags': {
'tag-key1': 'tag-value1',
'tag-key2': 'tag-value2',
}
}
params = {
'TableName':
'ci-table',
'ProvisionedThroughput': {
'WriteCapacityUnits': 1,
'ReadCapacityUnits': 1
},
'AttributeDefinitions': [{
'AttributeType': 'S',
'AttributeName': 'key1'
}, {
'AttributeType': 'S',
'AttributeName': 'key2'
}],
'KeySchema': [{
'KeyType': 'HASH',
'AttributeName': 'key1'
}, {
'KeyType': 'RANGE',
'AttributeName': 'key2'
}],
'Tags': [{
'Key': 'tag-key1',
'Value': 'tag-value1'
}, {
'Key': 'tag-key2',
'Value': 'tag-value2'
}]
}
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.create_table(**kwargs)
kwargs = req.call_args[0][1]
self.assertEqual(kwargs, params)
def test_query(self):
"""
TableConnection.query
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.query(
"FooForum",
key_conditions={'ForumName': {'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': ['thread']}},
exclusive_start_key="test_start_key"
)
params = {
'return_consumed_capacity': 'TOTAL',
'key_conditions': {
'ForumName': {
'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': [{
'S': 'thread'
}]
}
},
'table_name': self.test_table_name,
'exclusive_start_key': {'ForumName': {'S': 'test_start_key'}}
}
self.assertEqual(req.call_args[1], params)
def test_create_table(self):
"""
TableConnection.create_table
"""
conn = TableConnection(self.test_table_name)
kwargs = {"read_capacity_units": 1, "write_capacity_units": 1}
self.assertRaises(ValueError, conn.create_table, **kwargs)
kwargs["attribute_definitions"] = [
{"attribute_name": "key1", "attribute_type": "S"},
{"attribute_name": "key2", "attribute_type": "S"},
]
self.assertRaises(ValueError, conn.create_table, **kwargs)
kwargs["key_schema"] = [
{"attribute_name": "key1", "key_type": "hash"},
{"attribute_name": "key2", "key_type": "range"},
]
params = {
"TableName": "ci-table",
"ProvisionedThroughput": {"WriteCapacityUnits": 1, "ReadCapacityUnits": 1},
"AttributeDefinitions": [
{"AttributeType": "S", "AttributeName": "key1"},
{"AttributeType": "S", "AttributeName": "key2"},
],
"KeySchema": [{"KeyType": "HASH", "AttributeName": "key1"}, {"KeyType": "RANGE", "AttributeName": "key2"}],
}
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.create_table(**kwargs)
kwargs = req.call_args[0][1]
self.assertEqual(kwargs, params)
def test_describe_table(self):
"""
TableConnection.describe_table
"""
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn = TableConnection(self.test_table_name)
conn.describe_table()
self.assertEqual(conn.table_name, self.test_table_name)
self.assertEqual(req.call_args[0][1], {"TableName": "ci-table"})
def test_describe_table(self):
"""
TableConnection.describe_table
"""
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn = TableConnection(self.test_table_name)
conn.describe_table()
self.assertEqual(conn.table_name, self.test_table_name)
self.assertEqual(req.call_args[0][1], {'TableName': 'ci-table'})
def test_delete_table(self):
"""
TableConnection.delete_table
"""
params = {"TableName": "ci-table"}
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), None
conn = TableConnection(self.test_table_name)
conn.delete_table()
kwargs = req.call_args[0][1]
self.assertEqual(kwargs, params)
def test_create_table(self):
"""
TableConnection.create_table
"""
conn = TableConnection(self.test_table_name)
kwargs = {
'read_capacity_units': 1,
'write_capacity_units': 1,
}
self.assertRaises(ValueError, conn.create_table, **kwargs)
kwargs['attribute_definitions'] = [{
'attribute_name': 'key1',
'attribute_type': 'S'
}, {
'attribute_name': 'key2',
'attribute_type': 'S'
}]
self.assertRaises(ValueError, conn.create_table, **kwargs)
kwargs['key_schema'] = [{
'attribute_name': 'key1',
'key_type': 'hash'
}, {
'attribute_name': 'key2',
'key_type': 'range'
}]
params = {
'TableName':
'ci-table',
'BillingMode':
PROVISIONED_BILLING_MODE,
'ProvisionedThroughput': {
'WriteCapacityUnits': 1,
'ReadCapacityUnits': 1
},
'AttributeDefinitions': [{
'AttributeType': 'S',
'AttributeName': 'key1'
}, {
'AttributeType': 'S',
'AttributeName': 'key2'
}],
'KeySchema': [{
'KeyType': 'HASH',
'AttributeName': 'key1'
}, {
'KeyType': 'RANGE',
'AttributeName': 'key2'
}]
}
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.create_table(**kwargs)
kwargs = req.call_args[0][1]
self.assertEqual(kwargs, params)
def test_delete_table(self):
"""
TableConnection.delete_table
"""
params = {'TableName': 'ci-table'}
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), None
conn = TableConnection(self.test_table_name)
conn.delete_table()
kwargs = req.call_args[0][1]
self.assertEqual(kwargs, params)
def test_form_failure(self):
"""
Test Case for New URL's
"""
data={'long_url': 'http://yahoo.com', 'created_time': TIME}
response = self.app.post(
'/', data=data)
self.assertEqual(response.status_code, 200)
try:
conn = TableConnection('flask-datastore', region='eu-north-1')
conn.delete_item(data['long_url'], data['created_time'])
except Exception as ex:
app.logger.info("Exception in test_form_failure {}".format(ex))
def test_get_item(self):
"""
TableConnection.get_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = GET_ITEM_DATA
item = conn.get_item("Amazon DynamoDB", "How do I update multiple items?")
self.assertEqual(item, GET_ITEM_DATA)
def test_get_item(self):
"""
TableConnection.get_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = GET_ITEM_DATA
item = conn.get_item("Amazon DynamoDB", "How do I update multiple items?")
self.assertEqual(item, GET_ITEM_DATA)
def test_scan(self):
"""
TableConnection.scan
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.scan()
params = {"ReturnConsumedCapacity": "TOTAL", "TableName": self.test_table_name}
self.assertEqual(req.call_args[0][1], params)
def test_query(self):
"""
TableConnection.query
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.query("FooForum", Path('Subject').startswith('thread'))
params = {
'ReturnConsumedCapacity': 'TOTAL',
'KeyConditionExpression': '(#0 = :0 AND begins_with (#1, :1))',
'ExpressionAttributeNames': {
'#0': 'ForumName',
'#1': 'Subject'
},
'ExpressionAttributeValues': {
':0': {
'S': 'FooForum'
},
':1': {
'S': 'thread'
}
},
'TableName': self.test_table_name
}
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.query("FooForum",
key_conditions={
'Subject': {
'ComparisonOperator': 'BEGINS_WITH',
'AttributeValueList': ['thread']
}
})
params = {
'ReturnConsumedCapacity': 'TOTAL',
'KeyConditionExpression': '(#0 = :0 AND begins_with (#1, :1))',
'ExpressionAttributeNames': {
'#0': 'ForumName',
'#1': 'Subject'
},
'ExpressionAttributeValues': {
':0': {
'S': 'FooForum'
},
':1': {
'S': 'thread'
}
},
'TableName': self.test_table_name
}
self.assertEqual(req.call_args[0][1], params)
def test_scan(self):
"""
TableConnection.scan
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.scan()
params = {
'return_consumed_capacity': 'TOTAL',
'table_name': self.test_table_name
}
self.assertEqual(req.call_args[1], params)
def connect(self, ModelObj):
conn = TableConnection(
ModelObj.Meta.table_name,
host=settings.DYNAMO['URL'],
aws_access_key_id=settings.DYNAMO_AWS_ACCESS['AWS_ACCESS_KEY_ID'],
aws_secret_access_key=settings.
DYNAMO_AWS_ACCESS['AWS_SECRET_ACCESS_KEY'])
return conn
def test_update_table(self):
"""
TableConnection.update_table
"""
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), None
conn = TableConnection(self.test_table_name)
params = {
'ProvisionedThroughput': {
'WriteCapacityUnits': 2,
'ReadCapacityUnits': 2
},
'TableName': self.test_table_name
}
conn.update_table(
read_capacity_units=2,
write_capacity_units=2
)
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), None
conn = TableConnection(self.test_table_name)
global_secondary_index_updates = [
{
"index_name": "foo-index",
"read_capacity_units": 2,
"write_capacity_units": 2
}
]
params = {
'TableName': self.test_table_name,
'ProvisionedThroughput': {
'ReadCapacityUnits': 2,
'WriteCapacityUnits': 2,
},
'GlobalSecondaryIndexUpdates': [
{
'Update': {
'IndexName': 'foo-index',
'ProvisionedThroughput': {
'ReadCapacityUnits': 2,
'WriteCapacityUnits': 2,
}
}
}
]
}
conn.update_table(
read_capacity_units=2,
write_capacity_units=2,
global_secondary_index_updates=global_secondary_index_updates
)
self.assertEqual(req.call_args[0][1], params)
def test_update_time_to_live(self):
"""
TableConnection.update_time_to_live
"""
params = {
'TableName': 'ci-table',
'TimeToLiveSpecification': {
'AttributeName': 'ttl_attr',
'Enabled': True,
}
}
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), None
conn = TableConnection(self.test_table_name)
conn.update_time_to_live('ttl_attr')
kwargs = req.call_args[0][1]
self.assertEqual(kwargs, params)
def test_update_item(self):
"""
TableConnection.update_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
attr_updates = {
'Subject': {
'Value': 'foo-subject',
'Action': 'PUT'
},
}
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.update_item(
'foo-key',
attribute_updates=attr_updates,
range_key='foo-range-key',
)
params = {
'Key': {
'ForumName': {
'S': 'foo-key'
},
'Subject': {
'S': 'foo-range-key'
}
},
'UpdateExpression': 'SET #0 = :0',
'ExpressionAttributeNames': {
'#0': 'Subject'
},
'ExpressionAttributeValues': {
':0': {
'S': 'foo-subject'
}
},
'ReturnConsumedCapacity': 'TOTAL',
'TableName': 'ci-table'
}
self.assertEqual(req.call_args[0][1], params)
def test_rate_limited_scan(self):
"""
TableConnection.rate_limited_scan
"""
conn = TableConnection(self.test_table_name)
with patch('pynamodb.connection.Connection.rate_limited_scan') as req:
req.return_value = {}
conn.rate_limited_scan(
attributes_to_get='attributes_to_get',
page_size=1,
limit=2,
conditional_operator='AND',
scan_filter={'filter': 'X'},
segment=2,
total_segments=4,
exclusive_start_key='EX',
timeout_seconds=11,
read_capacity_to_consume_per_second=12,
allow_rate_limited_scan_without_consumed_capacity=False,
max_sleep_between_retry=3,
max_consecutive_exceptions=7,
consistent_read=True,
index_name='index')
self.assertEqual(self.test_table_name, req.call_args[0][0])
params = {
'filter_condition': None,
'attributes_to_get': 'attributes_to_get',
'page_size': 1,
'limit': 2,
'conditional_operator': 'AND',
'scan_filter': {
'filter': 'X'
},
'segment': 2,
'total_segments': 4,
'exclusive_start_key': 'EX',
'timeout_seconds': 11,
'read_capacity_to_consume_per_second': 12,
'allow_rate_limited_scan_without_consumed_capacity': False,
'max_sleep_between_retry': 3,
'max_consecutive_exceptions': 7,
'consistent_read': True,
'index_name': 'index'
}
self.assertEqual(params, req.call_args[1])
def test_connection_session_set_credentials(self):
conn = TableConnection(self.test_table_name,
aws_access_key_id='access_key_id',
aws_secret_access_key='secret_access_key')
credentials = conn.connection.session.get_credentials()
self.assertEqual(credentials.access_key, 'access_key_id')
self.assertEqual(credentials.secret_key, 'secret_access_key')
def test_delete_item(self):
"""
TableConnection.delete_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.delete_item("Amazon DynamoDB", "How do I update multiple items?")
params = {
"ReturnConsumedCapacity": "TOTAL",
"Key": {"ForumName": {"S": "Amazon DynamoDB"}, "Subject": {"S": "How do I update multiple items?"}},
"TableName": self.test_table_name,
}
self.assertEqual(req.call_args[0][1], params)
def test_query(self):
"""
TableConnection.query
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.query(
"FooForum",
Path('Subject').startswith('thread')
)
params = {
'ReturnConsumedCapacity': 'TOTAL',
'KeyConditionExpression': '(#0 = :0 AND begins_with (#1, :1))',
'ExpressionAttributeNames': {
'#0': 'ForumName',
'#1': 'Subject'
},
'ExpressionAttributeValues': {
':0': {
'S': 'FooForum'
},
':1': {
'S': 'thread'
}
},
'TableName': self.test_table_name
}
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.query(
"FooForum",
key_conditions={'Subject': {'ComparisonOperator': 'BEGINS_WITH', 'AttributeValueList': ['thread']}}
)
params = {
'ReturnConsumedCapacity': 'TOTAL',
'KeyConditionExpression': '(#0 = :0 AND begins_with (#1, :1))',
'ExpressionAttributeNames': {
'#0': 'ForumName',
'#1': 'Subject'
},
'ExpressionAttributeValues': {
':0': {
'S': 'FooForum'
},
':1': {
'S': 'thread'
}
},
'TableName': self.test_table_name
}
self.assertEqual(req.call_args[0][1], params)
def test_rate_limited_scan(self):
"""
TableConnection.rate_limited_scan
"""
conn = TableConnection(self.test_table_name)
with patch('pynamodb.connection.Connection.rate_limited_scan') as req:
req.return_value = {}
conn.rate_limited_scan(attributes_to_get='attributes_to_get',
page_size=1,
limit=2,
conditional_operator='AND',
scan_filter={'filter': 'X'},
segment=2,
total_segments=4,
exclusive_start_key='EX',
timeout_seconds=11,
read_capacity_to_consume_per_second=12,
allow_rate_limited_scan_without_consumed_capacity=False,
max_sleep_between_retry=3,
max_consecutive_exceptions=7,
consistent_read=True,
index_name='index'
)
self.assertEqual(self.test_table_name, req.call_args[0][0])
params = {
'filter_condition': None,
'attributes_to_get': 'attributes_to_get',
'page_size': 1,
'limit': 2,
'conditional_operator': 'AND',
'scan_filter': {'filter': 'X'},
'segment': 2,
'total_segments': 4,
'exclusive_start_key': 'EX',
'timeout_seconds': 11,
'read_capacity_to_consume_per_second': 12,
'allow_rate_limited_scan_without_consumed_capacity': False,
'max_sleep_between_retry': 3,
'max_consecutive_exceptions': 7,
'consistent_read': True,
'index_name': 'index'
}
self.assertEqual(params, req.call_args[1])
def test_put_item(self):
"""
TableConnection.put_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.put_item("foo-key", range_key="foo-range-key", attributes={"ForumName": "foo-value"})
params = {
"ReturnConsumedCapacity": "TOTAL",
"TableName": self.test_table_name,
"Item": {"ForumName": {"S": "foo-value"}, "Subject": {"S": "foo-range-key"}},
}
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.put_item("foo-key", range_key="foo-range-key", attributes={"ForumName": "foo-value"})
params = {
"ReturnConsumedCapacity": "TOTAL",
"Item": {"ForumName": {"S": "foo-value"}, "Subject": {"S": "foo-range-key"}},
"TableName": self.test_table_name,
}
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item(
"foo-key",
range_key="foo-range-key",
attributes={"ForumName": "foo-value"},
conditional_operator="and",
expected={"ForumName": {"Exists": False}},
)
params = {
"ReturnConsumedCapacity": "TOTAL",
"Item": {"ForumName": {"S": "foo-value"}, "Subject": {"S": "foo-range-key"}},
"TableName": self.test_table_name,
"ConditionalOperator": "AND",
"Expected": {"ForumName": {"Exists": False}},
}
self.assertEqual(req.call_args[0][1], params)
def test_update_item(self):
"""
TableConnection.delete_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
attr_updates = {"Subject": {"Value": "foo-subject", "Action": "PUT"}}
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.update_item("foo-key", attribute_updates=attr_updates, range_key="foo-range-key")
params = {
"Key": {"ForumName": {"S": "foo-key"}, "Subject": {"S": "foo-range-key"}},
"AttributeUpdates": {"Subject": {"Value": {"S": "foo-subject"}, "Action": "PUT"}},
"ReturnConsumedCapacity": "TOTAL",
"TableName": "ci-table",
}
self.assertEqual(req.call_args[0][1], params)
def test_delete_item(self):
"""
TableConnection.delete_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.delete_item("Amazon DynamoDB",
"How do I update multiple items?")
params = {
'ReturnConsumedCapacity': 'TOTAL',
'Key': {
'ForumName': {
'S': 'Amazon DynamoDB'
},
'Subject': {
'S': 'How do I update multiple items?'
}
},
'TableName': self.test_table_name
}
self.assertEqual(req.call_args[0][1], params)
def test_query(self):
"""
TableConnection.query
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.query("FooForum",
key_conditions={
'ForumName': {
'ComparisonOperator': 'BEGINS_WITH',
'AttributeValueList': ['thread']
}
})
params = {
'return_consumed_capacity': 'TOTAL',
'key_conditions': {
'ForumName': {
'ComparisonOperator': 'BEGINS_WITH',
'AttributeValueList': [{
'S': 'thread'
}]
}
},
'table_name': self.test_table_name
}
self.assertEqual(req.call_args[1], params)
def test_query(self):
"""
TableConnection.query
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.query(
"FooForum",
key_conditions={"ForumName": {"ComparisonOperator": "BEGINS_WITH", "AttributeValueList": ["thread"]}},
)
params = {
"ReturnConsumedCapacity": "TOTAL",
"KeyConditions": {
"ForumName": {"ComparisonOperator": "BEGINS_WITH", "AttributeValueList": [{"S": "thread"}]}
},
"TableName": self.test_table_name,
}
self.assertEqual(req.call_args[0][1], params)
def test_batch_get_item(self):
"""
TableConnection.batch_get_item
"""
items = []
conn = TableConnection(self.test_table_name)
for i in range(10):
items.append(
{"ForumName": "FooForum", "Subject": "thread-{0}".format(i)}
)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.batch_get_item(
items
)
params = {
'ReturnConsumedCapacity': 'TOTAL',
'RequestItems': {
self.test_table_name: {
'Keys': [
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-0'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-1'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-2'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-3'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-4'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-5'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-6'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-7'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-8'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-9'}}
]
}
}
}
self.assertEqual(req.call_args[0][1], params)
def UpdateItem(uid, userType, body=None, update=False, delete=False):
try:
conn = TableConnection(
table_name=settings.TABLE_NAME,
region=os.getenv("AWS_REGION"),
aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY")
)
if delete:
return conn.delete_item(hash_key=uid), None
# return conn.delete_item(hash_key=uid, range_key=userType), None
elif update and body:
userObj = Users.get(uid)
# userObj = Users.get(uid, userType)
userObj.refresh()
r = userObj.update(actions=[
getattr(Users, k).set(v) for k, v in body.items()
])
return r, None
# return conn.put_item(hash_key=uid, range_key=userType, attributes={"firstName": body["firstName"]}), None
except Exception as e:
return None, str(e)
def test_update_table(self):
"""
TableConnection.update_table
"""
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), None
conn = TableConnection(self.test_table_name)
params = {
'ProvisionedThroughput': {
'WriteCapacityUnits': 2,
'ReadCapacityUnits': 2
},
'TableName': self.test_table_name
}
conn.update_table(
read_capacity_units=2,
write_capacity_units=2
)
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), None
conn = TableConnection(self.test_table_name)
global_secondary_index_updates = [
{
"index_name": "foo-index",
"read_capacity_units": 2,
"write_capacity_units": 2
}
]
params = {
'TableName': self.test_table_name,
'ProvisionedThroughput': {
'ReadCapacityUnits': 2,
'WriteCapacityUnits': 2,
},
'GlobalSecondaryIndexUpdates': [
{
'Update': {
'IndexName': 'foo-index',
'ProvisionedThroughput': {
'ReadCapacityUnits': 2,
'WriteCapacityUnits': 2,
}
}
}
]
}
conn.update_table(
read_capacity_units=2,
write_capacity_units=2,
global_secondary_index_updates=global_secondary_index_updates
)
self.assertEqual(req.call_args[0][1], params)
def test_put_item(self):
"""
TableConnection.put_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item(
'foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'}
)
params = {
'return_consumed_capacity': 'TOTAL',
'table_name': self.test_table_name,
'item': {'ForumName': {'S': 'foo-value'}, 'Subject': {'S': 'foo-range-key'}}
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item(
'foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'}
)
params = {
'return_consumed_capacity': 'TOTAL',
'item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
},
'table_name': self.test_table_name
}
self.assertEqual(req.call_args[1], params)
def test_scan(self):
"""
TableConnection.scan
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.scan()
params = {
'ReturnConsumedCapacity': 'TOTAL',
'TableName': self.test_table_name
}
self.assertEqual(req.call_args[0][1], params)
def test_update_item(self):
"""
TableConnection.update_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
attr_updates = {
'Subject': {
'Value': 'foo-subject',
'Action': 'PUT'
},
}
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.update_item(
'foo-key',
actions=[Path('Subject').set('foo-subject')],
range_key='foo-range-key',
)
params = {
'Key': {
'ForumName': {
'S': 'foo-key'
},
'Subject': {
'S': 'foo-range-key'
}
},
'UpdateExpression': 'SET #0 = :0',
'ExpressionAttributeNames': {
'#0': 'Subject'
},
'ExpressionAttributeValues': {
':0': {
'S': 'foo-subject'
}
},
'ReturnConsumedCapacity': 'TOTAL',
'TableName': 'ci-table'
}
self.assertEqual(req.call_args[0][1], params)
def test_update_item(self):
"""
TableConnection.delete_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table()
attr_updates = {
'Subject': {
'Value': 'foo-subject',
'Action': 'PUT'
},
}
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.update_item(
'foo-key',
attribute_updates=attr_updates,
range_key='foo-range-key',
)
params = {
'key': {
'ForumName': {
'S': 'foo-key'
},
'Subject': {
'S': 'foo-range-key'
}
},
'attribute_updates': {
'Subject': {
'Value': {
'S': 'foo-subject'
},
'Action': 'PUT'
}
},
'return_consumed_capacity': 'TOTAL',
'table_name': 'ci-table'
}
self.assertEqual(req.call_args[1], params)
def test_update_table(self):
"""
TableConnection.update_table
"""
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), None
conn = TableConnection(self.test_table_name)
params = {
"ProvisionedThroughput": {"WriteCapacityUnits": 2, "ReadCapacityUnits": 2},
"TableName": self.test_table_name,
}
conn.update_table(read_capacity_units=2, write_capacity_units=2)
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), None
conn = TableConnection(self.test_table_name)
global_secondary_index_updates = [
{"index_name": "foo-index", "read_capacity_units": 2, "write_capacity_units": 2}
]
params = {
"TableName": self.test_table_name,
"ProvisionedThroughput": {"ReadCapacityUnits": 2, "WriteCapacityUnits": 2},
"GlobalSecondaryIndexUpdates": [
{
"Update": {
"IndexName": "foo-index",
"ProvisionedThroughput": {"ReadCapacityUnits": 2, "WriteCapacityUnits": 2},
}
}
],
}
conn.update_table(
read_capacity_units=2,
write_capacity_units=2,
global_secondary_index_updates=global_secondary_index_updates,
)
self.assertEqual(req.call_args[0][1], params)
def test_batch_get_item(self):
"""
TableConnection.batch_get_item
"""
items = []
conn = TableConnection(self.test_table_name)
for i in range(10):
items.append(
{"ForumName": "FooForum", "Subject": f"thread-{i}"}
)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.batch_get_item(
items
)
params = {
'ReturnConsumedCapacity': 'TOTAL',
'RequestItems': {
self.test_table_name: {
'Keys': [
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-0'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-1'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-2'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-3'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-4'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-5'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-6'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-7'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-8'}},
{'ForumName': {'S': 'FooForum'}, 'Subject': {'S': 'thread-9'}}
]
}
}
}
self.assertEqual(req.call_args[0][1], params)
"""
Run tests against dynamodb using the table abstraction
"""
import time
import config as cfg
from pynamodb.constants import PROVISIONED_THROUGHPUT, READ_CAPACITY_UNITS
from pynamodb.connection import TableConnection
from pynamodb.types import STRING, HASH, RANGE, NUMBER
table_name = 'pynamodb-ci'
# For use with a fake dynamodb connection
# See: http://aws.amazon.com/dynamodb/developer-resources/
conn = TableConnection('pynamodb', host=cfg.DYNAMODB_HOST)
print(conn)
print("conn.describe_table...")
table = conn.describe_table()
if table is None:
params = {
'read_capacity_units':
1,
'write_capacity_units':
1,
'attribute_definitions': [{
'attribute_type': STRING,
'attribute_name': 'Forum'
}, {
'attribute_type': STRING,
'attribute_name': 'Thread'
}, {
"""
Example use of the TableConnection API
"""
from pynamodb.connection import TableConnection
# Get a table connection
table = TableConnection('table-name', host='http://localhost')
# If the table doesn't already exist, the rest of this example will not work.
# Describe the table
print(table.describe_table())
# Get an item
print(table.get_item('hash-key', 'range-key'))
# Put an item
table.put_item('hash-key', 'range-key', attributes={'name': 'value'})
# Delete an item
table.delete_item('hash-key', 'range-key')
def test_put_item(self):
"""
TableConnection.put_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.put_item('foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'})
params = {
'ReturnConsumedCapacity': 'TOTAL',
'TableName': self.test_table_name,
'Item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
}
}
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.put_item('foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'})
params = {
'ReturnConsumedCapacity': 'TOTAL',
'Item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
},
'TableName': self.test_table_name
}
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item('foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'},
condition=Path('ForumName').does_not_exist())
params = {
'ReturnConsumedCapacity': 'TOTAL',
'Item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
},
'TableName': self.test_table_name,
'ConditionExpression': 'attribute_not_exists (#0)',
'ExpressionAttributeNames': {
'#0': 'ForumName'
}
}
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item('foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'},
conditional_operator='and',
expected={'ForumName': {
'Exists': False
}})
params = {
'ReturnConsumedCapacity': 'TOTAL',
'Item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
},
'TableName': self.test_table_name,
'ConditionExpression': 'attribute_not_exists (#0)',
'ExpressionAttributeNames': {
'#0': 'ForumName'
}
}
self.assertEqual(req.call_args[0][1], params)
def test_create_connection(self):
"""
TableConnection()
"""
conn = TableConnection(self.test_table_name)
self.assertIsNotNone(conn)
"""
Run tests against dynamodb using the table abstraction
"""
import time
import config as cfg
from pynamodb.constants import PROVISIONED_THROUGHPUT, READ_CAPACITY_UNITS
from pynamodb.connection import TableConnection
from pynamodb.types import STRING, HASH, RANGE, NUMBER
table_name = 'pynamodb-ci'
# For use with a fake dynamodb connection
# See: http://aws.amazon.com/dynamodb/developer-resources/
conn = TableConnection('pynamodb', host=cfg.DYNAMODB_HOST)
print(conn)
print("conn.describe_table...")
table = conn.describe_table()
if table is None:
params = {
'read_capacity_units': 1,
'write_capacity_units': 1,
'attribute_definitions': [
{
'attribute_type': STRING,
'attribute_name': 'Forum'
},
{
'attribute_type': STRING,
'attribute_name': 'Thread'
},
def test_put_item(self):
"""
TableConnection.put_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.put_item(
'foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'}
)
params = {
'ReturnConsumedCapacity': 'TOTAL',
'TableName': self.test_table_name,
'Item': {'ForumName': {'S': 'foo-value'}, 'Subject': {'S': 'foo-range-key'}}
}
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.put_item(
'foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'}
)
params = {
'ReturnConsumedCapacity': 'TOTAL',
'Item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
},
'TableName': self.test_table_name
}
self.assertEqual(req.call_args[0][1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item(
'foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'},
conditional_operator='and',
expected={
'ForumName': {
'Exists': False
}
}
)
params = {
'ReturnConsumedCapacity': 'TOTAL',
'Item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
},
'TableName': self.test_table_name,
'ConditionalOperator': 'AND',
'Expected': {
'ForumName': {
'Exists': False
}
}
}
self.assertEqual(req.call_args[0][1], params)
def test_create_table(self):
"""
TableConnection.create_table
"""
conn = TableConnection(self.test_table_name)
kwargs = {
'read_capacity_units': 1,
'write_capacity_units': 1,
}
self.assertRaises(ValueError, conn.create_table, **kwargs)
kwargs['attribute_definitions'] = [
{
'attribute_name': 'key1',
'attribute_type': 'S'
},
{
'attribute_name': 'key2',
'attribute_type': 'S'
}
]
self.assertRaises(ValueError, conn.create_table, **kwargs)
kwargs['key_schema'] = [
{
'attribute_name': 'key1',
'key_type': 'hash'
},
{
'attribute_name': 'key2',
'key_type': 'range'
}
]
params = {
'TableName': 'ci-table',
'ProvisionedThroughput': {
'WriteCapacityUnits': 1,
'ReadCapacityUnits': 1
},
'AttributeDefinitions': [
{
'AttributeType': 'S',
'AttributeName': 'key1'
},
{
'AttributeType': 'S',
'AttributeName': 'key2'
}
],
'KeySchema': [
{
'KeyType': 'HASH',
'AttributeName': 'key1'
},
{
'KeyType': 'RANGE',
'AttributeName': 'key2'
}
]
}
with patch(PATCH_METHOD) as req:
req.return_value = {}
conn.create_table(
**kwargs
)
kwargs = req.call_args[0][1]
self.assertEqual(kwargs, params)
def test_put_item(self):
"""
TableConnection.put_item
"""
conn = TableConnection(self.test_table_name)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item('foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'})
params = {
'return_consumed_capacity': 'TOTAL',
'table_name': self.test_table_name,
'item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
}
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item('foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'})
params = {
'return_consumed_capacity': 'TOTAL',
'item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
},
'table_name': self.test_table_name
}
self.assertEqual(req.call_args[1], params)
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.put_item('foo-key',
range_key='foo-range-key',
attributes={'ForumName': 'foo-value'},
conditional_operator='and',
expected={'ForumName': {
'Exists': False
}})
params = {
'return_consumed_capacity': 'TOTAL',
'item': {
'ForumName': {
'S': 'foo-value'
},
'Subject': {
'S': 'foo-range-key'
}
},
'table_name': self.test_table_name,
'conditional_operator': 'AND',
'expected': {
'ForumName': {
'Exists': False
}
}
}
self.assertEqual(req.call_args[1], params)
def test_batch_write_item(self):
"""
TableConnection.batch_write_item
"""
items = []
conn = TableConnection(self.test_table_name)
for i in range(10):
items.append({
"ForumName": "FooForum",
"Subject": "thread-{0}".format(i)
})
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), DESCRIBE_TABLE_DATA
conn.describe_table()
with patch(PATCH_METHOD) as req:
req.return_value = HttpOK(), {}
conn.batch_write_item(put_items=items)
params = {
'return_consumed_capacity': 'TOTAL',
'request_items': {
self.test_table_name: [{
'PutRequest': {
'Item': {
'ForumName': {
'S': 'FooForum'
},
'Subject': {
'S': 'thread-0'
}
}
}
}, {
'PutRequest': {
'Item': {
'ForumName': {
'S': 'FooForum'
},
'Subject': {
'S': 'thread-1'
}
}
}
}, {
'PutRequest': {
'Item': {
'ForumName': {
'S': 'FooForum'
},
'Subject': {
'S': 'thread-2'
}
}
}
}, {
'PutRequest': {
'Item': {
'ForumName': {
'S': 'FooForum'
},
'Subject': {
'S': 'thread-3'
}
}
}
}, {
'PutRequest': {
'Item': {
'ForumName': {
'S': 'FooForum'
},
'Subject': {
'S': 'thread-4'
}
}
}
}, {
'PutRequest': {
'Item': {
'ForumName': {
'S': 'FooForum'
},
'Subject': {
'S': 'thread-5'
}
}
}
}, {
'PutRequest': {
'Item': {
'ForumName': {
'S': 'FooForum'
},
'Subject': {
'S': 'thread-6'
}
}
}
}, {
'PutRequest': {
'Item': {
'ForumName': {
'S': 'FooForum'
},
'Subject': {
'S': 'thread-7'
}
}
}
}, {
'PutRequest': {
'Item': {
'ForumName': {
'S': 'FooForum'
},
'Subject': {
'S': 'thread-8'
}
}
}
}, {
'PutRequest': {
'Item': {
'ForumName': {
'S': 'FooForum'
},
'Subject': {
'S': 'thread-9'
}
}
}
}]
}
}
self.assertEqual(req.call_args[1], params)
"""
Example use of the TableConnection API
"""
from pynamodb.connection import TableConnection
# Get a table connection
table = TableConnection("Thread", host="http://localhost:8000")
# If the table doesn't already exist, the rest of this example will not work.
# Describe the table
print(table.describe_table())
# Get an item
print(table.get_item("hash-key", "range-key"))
# Put an item
table.put_item("hash-key", "range-key", attributes={"forum_name": "value"})
# Delete an item
table.delete_item("hash-key", "range-key")
def tearDown(self):
conn = TableConnection('cut-it-datastore', region='eu-north-1')
conn.delete_item(test_long_url, test_short_url.created_time)
"""
Run tests against dynamodb using the table abstraction
"""
import time
from pynamodb.connection import TableConnection
from pynamodb.types import STRING, HASH, RANGE
conn = TableConnection('pynamodb')
table_name = 'pynamodb-ci'
# For use with a fake dynamodb connection
# See: http://aws.amazon.com/dynamodb/developer-resources/
#conn = Connection(host='http://localhost:8000')
print("conn.describe_table...")
table = conn.describe_table()
if table is None:
params = {
'read_capacity_units': 1,
'write_capacity_units': 1,
'attribute_definitions': [
{
'attribute_type': STRING,
'attribute_name': 'Forum'
},
{
'attribute_type': STRING,
'attribute_name': 'Thread'
},
{
'attribute_type': STRING,
def tearDown(self):
"""
Post tests cleanup code
"""
conn = TableConnection('flask-datastore', region='eu-north-1')
conn.delete_item(obj['long_url'], obj['created_time'])
def test_table_integration(ddb_url):
table_name = 'pynamodb-ci-table'
# For use with a fake dynamodb connection
# See: http://aws.amazon.com/dynamodb/developer-resources/
conn = TableConnection(table_name, host=ddb_url)
print(conn)
print("conn.describe_table...")
table = None
try:
table = conn.describe_table()
except TableDoesNotExist:
params = {
'read_capacity_units':
1,
'write_capacity_units':
1,
'attribute_definitions': [{
'attribute_type': STRING,
'attribute_name': 'Forum'
}, {
'attribute_type': STRING,
'attribute_name': 'Thread'
}, {
'attribute_type': STRING,
'attribute_name': 'AltKey'
}, {
'attribute_type': NUMBER,
'attribute_name': 'number'
}],
'key_schema': [{
'key_type': HASH,
'attribute_name': 'Forum'
}, {
'key_type': RANGE,
'attribute_name': 'Thread'
}],
'global_secondary_indexes': [{
'index_name':
'alt-index',
'key_schema': [{
'KeyType': 'HASH',
'AttributeName': 'AltKey'
}],
'projection': {
'ProjectionType': 'KEYS_ONLY'
},
'provisioned_throughput': {
'ReadCapacityUnits': 1,
'WriteCapacityUnits': 1,
}
}],
'local_secondary_indexes': [{
'index_name':
'view-index',
'key_schema': [{
'KeyType': 'HASH',
'AttributeName': 'Forum'
}, {
'KeyType': 'RANGE',
'AttributeName': 'AltKey'
}],
'projection': {
'ProjectionType': 'KEYS_ONLY'
}
}]
}
print("conn.create_table...")
conn.create_table(**params)
while table is None:
time.sleep(2)
table = conn.describe_table()
while table['TableStatus'] == 'CREATING':
time.sleep(5)
print(table['TableStatus'])
table = conn.describe_table()
print("conn.update_table...")
conn.update_table(read_capacity_units=table.get(
PROVISIONED_THROUGHPUT).get(READ_CAPACITY_UNITS) + 1,
write_capacity_units=2)
table = conn.describe_table()
while table['TableStatus'] != 'ACTIVE':
time.sleep(2)
table = conn.describe_table()
print("conn.put_item")
conn.put_item(
'item1-hash',
range_key='item1-range',
attributes={'foo': {
'S': 'bar'
}},
condition=NotExists(Path('Forum')),
)
conn.get_item('item1-hash', range_key='item1-range')
conn.delete_item('item1-hash', range_key='item1-range')
items = []
for i in range(10):
items.append({"Forum": "FooForum", "Thread": "thread-{}".format(i)})
print("conn.batch_write_items...")
conn.batch_write_item(put_items=items)
print("conn.batch_get_items...")
data = conn.batch_get_item(items)
print("conn.query...")
conn.query(
"FooForum",
range_key_condition=(BeginsWith(Path('Thread'), Value('thread'))),
)
print("conn.scan...")
conn.scan()
print("conn.delete_table...")
conn.delete_table()
"""
Example use of the TableConnection API
"""
from pynamodb.connection import TableConnection
# Get a table connection
table = TableConnection('Thread', host='http://localhost:8000')
# If the table doesn't already exist, the rest of this example will not work.
# Describe the table
print(table.describe_table())
# Get an item
print(table.get_item('hash-key', 'range-key'))
# Put an item
table.put_item('hash-key', 'range-key', attributes={'forum_name': 'value'})
# Delete an item
table.delete_item('hash-key', 'range-key')
