def test_select_item_count(self):
self.storage_mocker.StubOutWithMock(storage, 'query')
storage.query(
mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(),
select_type=models.SelectType.count(), index_name=mox.IgnoreArg(),
limit=mox.IgnoreArg(), exclusive_start_key=mox.IgnoreArg(),
consistent=mox.IgnoreArg(), order_type=mox.IgnoreArg()
).AndReturn(
models.SelectResult(
count=100500
)
)
self.storage_mocker.ReplayAll()
table = ddb_table.Table(
'test_table',
connection=self.DYNAMODB_CON
)
count = table.query_count(consistent=False, hash_key__eq=1)
self.assertEqual(count, 100500)
self.storage_mocker.VerifyAll()
def test_update_item(self):
self.storage_mocker.StubOutWithMock(storage, 'get_item')
hash_key = "4.5621201231232132132132132132132142354E126"
range_key = "range"
storage.get_item(
mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(),
select_type=mox.IgnoreArg(),
consistent=mox.IgnoreArg()
).AndReturn(
models.SelectResult(
items=[
{
"hash_key": models.AttributeValue('N', hash_key),
"range_key": models.AttributeValue('S', range_key),
"attr_value": models.AttributeValue('S', 'val')
}
]
)
)
self.storage_mocker.StubOutWithMock(storage, 'describe_table')
storage.describe_table(mox.IgnoreArg(), 'test_table').AndReturn(
models.TableMeta(
'00000000-0000-0000-0000-000000000000',
models.TableSchema(
{
'hash_key': models.AttributeType('N'),
'range_key': models.AttributeType('S')
},
['hash_key', 'range_key'],
),
models.TableMeta.TABLE_STATUS_ACTIVE,
None
)
)
self.storage_mocker.StubOutWithMock(storage, 'update_item')
storage.update_item(
mox.IgnoreArg(), mox.IgnoreArg(),
key_attribute_map=mox.IgnoreArg(),
attribute_action_map=mox.IgnoreArg(),
expected_condition_map=mox.IgnoreArg()).AndReturn((True, None))
self.storage_mocker.ReplayAll()
table = ddb_table.Table(
'test_table',
connection=self.DYNAMODB_CON
)
item = table.get_item(consistent=False, hash_key=1, range_key="range")
item['attr_value'] = 'updated'
item.partial_save()
self.storage_mocker.VerifyAll()
def test_put_item(self):
self.storage_mocker.StubOutWithMock(storage, 'put_item')
storage.put_item(
mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(),
if_not_exist=mox.IgnoreArg(),
expected_condition_map=mox.IgnoreArg()).AndReturn((True, None))
self.storage_mocker.ReplayAll()
table = ddb_table.Table(
'test_table',
connection=self.DYNAMODB_CON
)
blob_data1 = bytes(bytearray([1, 2, 3, 4, 5]))
blob_data2 = bytes(bytearray([5, 4, 3, 2, 1]))
table.put_item(
{
"hash_key": 1,
"range_key": "range",
"value_blob": types.Binary(blob_data1),
"value_blob_set": set([types.Binary(blob_data1),
types.Binary(blob_data2)])
},
False
)
self.storage_mocker.VerifyAll()
def test_delete_table(self):
self.storage_mocker.StubOutWithMock(storage, 'delete_table')
self.storage_mocker.StubOutWithMock(storage, 'describe_table')
storage.delete_table(mox.IgnoreArg(), 'test_table')
storage.describe_table(mox.IgnoreArg(), 'test_table').AndReturn(
models.TableMeta(
'00000000-0000-0000-0000-000000000000',
models.TableSchema(
{
'city1': models.AttributeType('S'),
'id': models.AttributeType('S'),
'name': models.AttributeType('S')
},
['id', 'name'],
{'index_name': models.IndexDefinition('id', 'city1')}
),
models.TableMeta.TABLE_STATUS_ACTIVE,
None
)
)
self.storage_mocker.ReplayAll()
table = ddb_table.Table(
'test_table',
connection=self.DYNAMODB_CON
)
self.assertTrue(table.delete())
self.storage_mocker.VerifyAll()
def test_describe_unexisting_table(self):
self.storage_mocker.StubOutWithMock(storage, 'describe_table')
storage.describe_table(
mox.IgnoreArg(), 'test_table1'
).AndRaise(exception.TableNotExistsException)
self.storage_mocker.ReplayAll()
table = ddb_table.Table(
'test_table1',
connection=self.DYNAMODB_CON
)
try:
table.describe()
except boto_exc.JSONResponseError as e:
self.assertEqual(
e.body['__type'],
'com.amazonaws.dynamodb.v20111205#ResourceNotFoundException')
self.assertEqual(
e.body['message'],
'The resource which is being requested does not exist.')
def test_query(self):
self.storage_mocker.StubOutWithMock(storage, 'query')
blob_data1 = bytes(bytearray([1, 2, 3, 4, 5]))
blob_data2 = bytes(bytearray([5, 4, 3, 2, 1]))
hash_key = "4.5621201231232132132132132132132142354E126"
range_key = "range"
storage.query(
mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(),
select_type=mox.IgnoreArg(), index_name=mox.IgnoreArg(),
limit=mox.IgnoreArg(), exclusive_start_key=mox.IgnoreArg(),
consistent=mox.IgnoreArg(), order_type=mox.IgnoreArg(),
).AndReturn(
models.SelectResult(
items=[
{
"hash_key": models.AttributeValue('N', hash_key),
"range_key": models.AttributeValue('S', range_key),
"value_blob": models.AttributeValue(
'B', decoded_value=blob_data1
),
"value_blob_set": models.AttributeValue(
'BS', decoded_value={blob_data1, blob_data2}
)
}
]
)
)
self.storage_mocker.ReplayAll()
table = ddb_table.Table(
'test_table',
connection=self.DYNAMODB_CON
)
items = list(table.query(consistent=False, hash_key__eq=1))
expected_item = {
"hash_key": decimal.Decimal(hash_key),
"range_key": range_key,
"value_blob": types.Binary(blob_data1),
"value_blob_set": set([types.Binary(blob_data1),
types.Binary(blob_data2)])
}
self.assertEqual(len(items), 1)
self.assertDictEqual(expected_item, dict(items[0].items()))
self.storage_mocker.VerifyAll()
def test_describe_table(self):
self.storage_mocker.StubOutWithMock(storage, 'describe_table')
storage.describe_table(mox.IgnoreArg(), 'test_table').AndReturn(
models.TableMeta(
'00000000-0000-0000-0000-000000000000',
models.TableSchema(
{
'city1': models.AttributeType('S'),
'id': models.AttributeType('S'),
'name': models.AttributeType('S')
},
['id', 'name'],
{'index_name': models.IndexDefinition('id', 'city1')}
),
models.TableMeta.TABLE_STATUS_ACTIVE,
None
)
)
self.storage_mocker.ReplayAll()
table = ddb_table.Table(
'test_table',
connection=self.DYNAMODB_CON
)
table_description = table.describe()
self.storage_mocker.VerifyAll()
self.assertEqual('test_table',
table_description['Table']['TableName'])
self.assertItemsEqual(
[
{
"AttributeName": "city1",
"AttributeType": "S"
},
{
"AttributeName": "id",
"AttributeType": "S"
},
{
"AttributeName": "name",
"AttributeType": "S"
}
], table_description['Table']['AttributeDefinitions'])
def test_delete_item(self):
self.storage_mocker.StubOutWithMock(storage, 'delete_item')
storage.delete_item(
mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(),
expected_condition_map=mox.IgnoreArg()
).AndReturn(True)
self.storage_mocker.ReplayAll()
table = ddb_table.Table(
'test_table',
connection=self.DYNAMODB_CON
)
table.delete_item(hash_key=1, range_key="range")
self.storage_mocker.VerifyAll()
##############################
# Global vars, consts, extra #
##############################
# Class of table names
table_prefix = config.store["dynamodb"]["table_prefix"]
class TableNames:
CUSTOMERS = table_prefix + "PolitiHack_Customers"
VOTES = table_prefix + "PolitiHack_Votes"
CUSTOMER_STATES = table_prefix + "PolitiHack_CustomerState"
# Tables
customers = dynamo_table.Table(TableNames.CUSTOMERS,
connection=service.dynamodb)
votes = dynamo_table.Table(TableNames.VOTES, connection=service.dynamodb)
customer_states = dynamo_table.Table(TableNames.CUSTOMER_STATES,
connection=service.dynamodb)
# Use boolean for the tables
customers.use_boolean()
votes.use_boolean()
customer_states.use_boolean()
# Base class for all object models
class Model:
def __init__(self, item):
if not self._atts_are_valid(item._data):
raise PolitiHackException(Errors.INVALID_DATA_PRESENT)