def test_put_item(self):
self.storage_mocker.StubOutWithMock(storage, 'put_item')
storage.put_item(IgnoreArg(),
IgnoreArg(),
if_not_exist=IgnoreArg(),
expected_condition_map=IgnoreArg()).AndReturn(True)
self.storage_mocker.ReplayAll()
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_select_item(self):
self.storage_mocker.StubOutWithMock(storage, 'select_item')
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.select_item(
IgnoreArg(),
IgnoreArg(),
IgnoreArg(),
select_type=IgnoreArg(),
index_name=IgnoreArg(),
limit=IgnoreArg(),
exclusive_start_key=IgnoreArg(),
consistent=IgnoreArg(),
order_type=IgnoreArg(),
).AndReturn(
models.SelectResult(items=[{
"hash_key":
models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER,
decimal.Decimal(hash_key)),
"range_key":
models.AttributeValue(models.ATTRIBUTE_TYPE_STRING, range_key),
"value_blob":
models.AttributeValue(models.ATTRIBUTE_TYPE_BLOB, blob_data1),
"value_blob_set":
models.AttributeValue(models.ATTRIBUTE_TYPE_BLOB_SET,
set([blob_data1, blob_data2]))
}]))
self.storage_mocker.ReplayAll()
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_decoding_to_dynamodb(self):
dynamizer = types.Dynamizer()
self.assertEqual(dynamizer.decode({'S': 'foo'}), 'foo')
self.assertEqual(dynamizer.decode({'N': '54'}), 54)
self.assertEqual(dynamizer.decode({'N': '1.1'}), Decimal('1.1'))
self.assertEqual(dynamizer.decode({'NS': ['1', '2', '3']}),
set([1, 2, 3]))
self.assertEqual(dynamizer.decode({'SS': ['foo', 'bar']}),
set(['foo', 'bar']))
self.assertEqual(dynamizer.decode({'B': 'AQ=='}), types.Binary('\x01'))
self.assertEqual(dynamizer.decode({'BS': ['AQ==']}),
set([types.Binary('\x01')]))
def test_encoding_to_dynamodb(self):
dynamizer = types.Dynamizer()
self.assertEqual(dynamizer.encode('foo'), {'S': 'foo'})
self.assertEqual(dynamizer.encode(54), {'N': '54'})
self.assertEqual(dynamizer.encode(Decimal('1.1')), {'N': '1.1'})
self.assertEqual(dynamizer.encode(set([1, 2, 3])),
{'NS': ['1', '2', '3']})
self.assertEqual(dynamizer.encode(set(['foo', 'bar'])),
{'SS': ['foo', 'bar']})
self.assertEqual(dynamizer.encode(types.Binary('\x01')), {'B': 'AQ=='})
self.assertEqual(dynamizer.encode(set([types.Binary('\x01')])),
{'BS': ['AQ==']})
def test_get_item(self):
self.storage_mocker.StubOutWithMock(storage, 'get_item')
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.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),
"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
)
item = table.get_item(consistent=False, hash_key=1, range_key="range")
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.assertDictEqual(expected_item, dict(item.items()))
self.storage_mocker.VerifyAll()
def test_decoding_to_dynamodb(self):
dynamizer = types.Dynamizer()
self.assertEqual(dynamizer.decode({'S': 'foo'}), 'foo')
self.assertEqual(dynamizer.decode({'N': '54'}), 54)
self.assertEqual(dynamizer.decode({'N': '1.1'}), Decimal('1.1'))
self.assertEqual(dynamizer.decode({'NS': ['1', '2', '3']}),
set([1, 2, 3]))
self.assertEqual(dynamizer.decode({'SS': ['foo', 'bar']}),
set(['foo', 'bar']))
self.assertEqual(dynamizer.decode({'B': 'AQ=='}),
types.Binary(b'\x01'))
self.assertEqual(dynamizer.decode({'BS': ['AQ==']}),
set([types.Binary(b'\x01')]))
self.assertEqual(
dynamizer.decode(
{'L': [{
'S': 'foo'
}, {
'N': '54'
}, {
'L': [{
'N': '1'
}]
}]}), ['foo', 54, [1]])
self.assertEqual(
dynamizer.decode({
'M': {
'foo': {
'S': 'bar'
},
'hoge': {
'M': {
'sub': {
'N': '1'
}
}
}
}
}), {
'foo': 'bar',
'hoge': {
'sub': 1
}
})
self.assertEqual(dynamizer.decode({'NULL': True}), None)
self.assertEqual(dynamizer.decode({'BOOL': False}), False)
def test_unicode_py2(self):
# It's dirty. But remains for backward compatibility.
data = types.Binary(u'\x01')
self.assertEqual(data, b'\x01')
self.assertEqual(bytes(data), b'\x01')
# Delegate to built-in b'\x01' == u'\x01'
# In Python 2.x these are considered equal
self.assertEqual(data, u'\x01')
def test_unicode_py3(self):
with self.assertRaises(TypeError):
types.Binary(u'\x01')
def test_bytes_input(self):
data = types.Binary(1)
self.assertEqual(data, b'\x00')
self.assertEqual(data.value, b'\x00')
def test_bad_input(self):
with self.assertRaises(TypeError):
types.Binary(1)
def test_non_ascii_good_input(self):
# Binary data that is out of ASCII range
data = types.Binary(b'\x88')
self.assertEqual(b'\x88', data)
self.assertEqual(b'\x88', bytes(data))
def test_good_input(self):
data = types.Binary(b'\x01')
self.assertEqual(b'\x01', data)
self.assertEqual(b'\x01', bytes(data))
