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_update_item(self):
self.storage_mocker.StubOutWithMock(storage, 'get_item')
hash_key = "4.5621201231232132132132132132132142354E126"
range_key = "range"
storage.get_item(
IgnoreArg(), IgnoreArg(), IgnoreArg(),
select_type=IgnoreArg(),
consistent=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(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(
IgnoreArg(), IgnoreArg(),
key_attribute_map=IgnoreArg(),
attribute_action_map=IgnoreArg(),
expected_condition_map=IgnoreArg()).AndReturn((True, None))
self.storage_mocker.ReplayAll()
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_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 __call__(self):
try:
table_name = self.action_params.get(parser.Props.TABLE_NAME, None)
# get attributes_to_get
attributes_to_get = self.action_params.get(
parser.Props.ATTRIBUTES_TO_GET, None)
select_type = (models.SelectType.all()
if attributes_to_get is None else
models.AttributeToGet.specified(attributes_to_get))
# parse key_attributes
key_attributes = parser.Parser.parse_item_attributes(
self.action_params[parser.Props.KEY])
# TODO(dukhlov):
# it would be nice to validate given table_name, key_attributes and
# attributes_to_get to schema expectation
consistent_read = self.action_params.get(
parser.Props.CONSISTENT_READ, False)
return_consumed_capacity = self.action_params.get(
parser.Props.RETURN_CONSUMED_CAPACITY,
parser.Values.RETURN_CONSUMED_CAPACITY_NONE)
except Exception:
raise exception.AWSValidationException()
try:
# get item
result = storage.get_item(self.context,
table_name,
key_attributes,
select_type=select_type,
consistent=consistent_read)
# format response
if result.count == 0:
return {}
assert result.count == 1
response = {
parser.Props.ITEM:
parser.Parser.format_item_attributes(result.items[0])
}
if (return_consumed_capacity !=
parser.Values.RETURN_CONSUMED_CAPACITY_NONE):
response[parser.Props.CONSUMED_CAPACITY] = (
parser.Parser.format_consumed_capacity(
return_consumed_capacity, None))
return response
except exception.AWSErrorResponseException as e:
raise e
except Exception:
raise exception.AWSErrorResponseException()
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(
IgnoreArg(), IgnoreArg(), IgnoreArg(),
select_type=IgnoreArg(),
consistent=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 = 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 get_item(req, project_id, table_name):
"""The Getitem operation returns an item with the given primary key. """
with probe.Probe(__name__ + '.validate'):
body = req.json_body
validation.validate_object(body, "body")
# get attributes_to_get
attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None)
if attributes_to_get:
attributes_to_get = validation.validate_set(
attributes_to_get, parser.Props.ATTRIBUTES_TO_GET
)
for attr_name in attributes_to_get:
validation.validate_attr_name(attr_name)
select_type = models.SelectType.specific_attributes(
attributes_to_get
)
else:
select_type = models.SelectType.all()
key = body.pop(parser.Props.KEY, None)
validation.validate_object(key, parser.Props.KEY)
# parse consistent_read
consistent_read = body.pop(parser.Props.CONSISTENT_READ, False)
validation.validate_boolean(consistent_read,
parser.Props.CONSISTENT_READ)
validation.validate_unexpected_props(body, "body")
# parse key_attributes
key_attributes = parser.Parser.parse_item_attributes(key)
# get item
result = storage.get_item(
project_id, table_name, key_attributes,
select_type=select_type, consistent=consistent_read)
# format response
if result.count == 0:
return {}
response = {
parser.Props.ITEM: parser.Parser.format_item_attributes(
result.items[0])
}
return response
def process_request(self, req, body, project_id, table_name):
utils.check_project_id(req.context, project_id)
req.context.tenant = project_id
with probe.Probe(__name__ + '.validate'):
validation.validate_object(body, "body")
# get attributes_to_get
attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None)
if attributes_to_get:
attributes_to_get = validation.validate_set(
attributes_to_get, parser.Props.ATTRIBUTES_TO_GET
)
for attr_name in attributes_to_get:
validation.validate_attr_name(attr_name)
select_type = models.SelectType.specific_attributes(
attributes_to_get
)
else:
select_type = models.SelectType.all()
key = body.pop(parser.Props.KEY, None)
validation.validate_object(key, parser.Props.KEY)
# parse consistent_read
consistent_read = body.pop(parser.Props.CONSISTENT_READ, False)
validation.validate_boolean(consistent_read,
parser.Props.CONSISTENT_READ)
validation.validate_unexpected_props(body, "body")
# parse key_attributes
key_attributes = parser.Parser.parse_item_attributes(key)
# get item
result = storage.get_item(
req.context, table_name, key_attributes,
select_type=select_type, consistent=consistent_read)
# format response
if result.count == 0:
return {}
response = {
parser.Props.ITEM: parser.Parser.format_item_attributes(
result.items[0])
}
return response
def process_request(self, req, body, project_id, table_name):
with probe.Probe(__name__ + '.validate'):
validation.validate_object(body, "body")
# get attributes_to_get
attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None)
if attributes_to_get:
attributes_to_get = validation.validate_set(
attributes_to_get, parser.Props.ATTRIBUTES_TO_GET)
for attr_name in attributes_to_get:
validation.validate_attr_name(attr_name)
select_type = models.SelectType.specific_attributes(
attributes_to_get)
else:
select_type = models.SelectType.all()
key = body.pop(parser.Props.KEY, None)
validation.validate_object(key, parser.Props.KEY)
# parse consistent_read
consistent_read = body.pop(parser.Props.CONSISTENT_READ, False)
validation.validate_boolean(consistent_read,
parser.Props.CONSISTENT_READ)
validation.validate_unexpected_props(body, "body")
# parse key_attributes
key_attributes = parser.Parser.parse_item_attributes(key)
# get item
result = storage.get_item(req.context,
table_name,
key_attributes,
select_type=select_type,
consistent=consistent_read)
# format response
if result.count == 0:
return {}
response = {
parser.Props.ITEM:
parser.Parser.format_item_attributes(result.items[0])
}
return response
def __call__(self):
try:
table_name = self.action_params.get(parser.Props.TABLE_NAME, None)
# get attributes_to_get
attributes_to_get = self.action_params.get(
parser.Props.ATTRIBUTES_TO_GET, None
)
select_type = (
models.SelectType.all()
if attributes_to_get is None else
models.AttributeToGet.specified(attributes_to_get)
)
# parse key_attributes
key_attributes = parser.Parser.parse_item_attributes(
self.action_params[parser.Props.KEY]
)
# TODO(dukhlov):
# it would be nice to validate given table_name, key_attributes and
# attributes_to_get to schema expectation
consistent_read = self.action_params.get(
parser.Props.CONSISTENT_READ, False
)
return_consumed_capacity = self.action_params.get(
parser.Props.RETURN_CONSUMED_CAPACITY,
parser.Values.RETURN_CONSUMED_CAPACITY_NONE
)
except Exception:
raise amz_exception.AWSValidationException()
try:
# get item
result = storage.get_item(
self.tenant, table_name, key_attributes,
select_type=select_type, consistent=consistent_read)
# format response
if result.count == 0:
return {}
assert result.count == 1
response = {
parser.Props.ITEM: parser.Parser.format_item_attributes(
result.items[0])
}
if (return_consumed_capacity !=
parser.Values.RETURN_CONSUMED_CAPACITY_NONE):
response[parser.Props.CONSUMED_CAPACITY] = (
parser.Parser.format_consumed_capacity(
return_consumed_capacity, None
)
)
return response
except Exception:
raise amz_exception.AWSErrorResponseException()
