def test_on_order_modified_new(lambda_module, order, order_products, order_metadata):
"""
Test on_order_modified() with a new event
"""
table = mock_table(
lambda_module.table, "get_item", ["orderId", "productId"]
)
mock_table(
table, "batch_write_item",
["orderId", "productId"],
table_name=lambda_module.table.name,
items=[
{"PutRequest": {"Item": product}}
for product in order_products
]
)
order_metadata = copy.deepcopy(order_metadata)
order_metadata["newDate"] = order_metadata["modifiedDate"]
mock_table(
table, "put_item", ["orderId", "productId"],
table_name=lambda_module.table.name,
items=order_metadata
)
lambda_module.on_order_modified(order, order)
table.assert_no_pending_responses()
table.deactivate()
def test_handler(lambda_module, event, context, order, url, ddb_item):
"""
Test handler()
"""
# Mock boto3
table = mock_table(
lambda_module.table, "get_item",
["orderId"]
)
table = mock_table(
table, "put_item",
["orderId"],
items=ddb_item,
table_name=lambda_module.table.name
)
with requests_mock.Mocker() as m:
# Mock requests
m.get(url, text=json.dumps(order))
lambda_module.handler(event, context)
# Assertions
assert m.called
assert m.call_count == 1
assert m.request_history[0].method == "GET"
assert m.request_history[0].url == url
table.assert_no_pending_responses()
table.deactivate()
def test_on_order_deleted(lambda_module, order, order_products, order_metadata):
"""
Test on_order_deleted()
"""
table = mock_table(
lambda_module.table, "get_item", ["orderId", "productId"],
items=order_metadata
)
mock_table(
table, "batch_write_item",
["orderId", "productId"],
table_name=lambda_module.table.name,
items=[
{"DeleteRequest": {"Key": {
"orderId": product["orderId"],
"productId": product["productId"]
}}}
for product in order_products
]
)
mock_table(
table, "delete_item",
["orderId", "productId"],
table_name=lambda_module.table.name,
items=order_metadata
)
lambda_module.on_order_deleted(order)
table.assert_no_pending_responses()
table.deactivate()
def test_handler_created(lambda_module, context, order, order_products, order_metadata):
"""
Test handler() with OrderCreated
"""
table = mock_table(
lambda_module.table, "get_item", ["orderId", "productId"]
)
mock_table(
table, "batch_write_item",
["orderId", "productId"],
table_name=lambda_module.table.name,
items=[
{"PutRequest": {"Item": product}}
for product in order_products
]
)
order_metadata = copy.deepcopy(order_metadata)
order_metadata["newDate"] = order_metadata["modifiedDate"]
mock_table(
table, "put_item", ["orderId", "productId"],
table_name=lambda_module.table.name,
items=order_metadata
)
lambda_module.handler({
"source": "ecommerce.orders",
"resources": [order["orderId"]],
"detail-type": "OrderCreated",
"detail": order
}, context)
table.assert_no_pending_responses()
table.deactivate()
def test_handler_metadata_completed_empty(lambda_module, context,
ddb_record_metadata_completed,
event_metadata_failed, order,
order_products):
"""
Test handler() with a metadata completed item but no products
"""
event_metadata_failed = copy.deepcopy(event_metadata_failed)
table = mock_table(lambda_module.table, "query", ["orderId", "productId"])
# Stubbing Event Bridge
eventbridge = stub.Stubber(lambda_module.eventbridge)
# Ignore time and detail
event_metadata_failed["Time"] = stub.ANY
event_metadata_failed["Detail"] = stub.ANY
expected_params = {"Entries": [event_metadata_failed]}
eventbridge.add_response("put_events", {}, expected_params)
eventbridge.activate()
event = {"Records": [ddb_record_metadata_completed]}
lambda_module.handler(event, context)
table.assert_no_pending_responses()
table.deactivate()
eventbridge.assert_no_pending_responses()
eventbridge.deactivate()
def test_save_shipping_request(lambda_module, order, ddb_item):
"""
Test save_shipping_request()
"""
table = mock_table(
lambda_module.table, "get_item",
["orderId"]
)
table = mock_table(
table, "put_item",
["orderId"],
items=ddb_item,
table_name=lambda_module.table.name
)
lambda_module.save_shipping_request(order)
table.assert_no_pending_responses()
table.deactivate()
def test_on_order_deleted_idempotent(lambda_module, order):
"""
Test on_order_deleted() with an already deleted item
"""
table = mock_table(
lambda_module.table, "get_item", ["orderId", "productId"]
)
lambda_module.on_order_deleted(order)
table.assert_no_pending_responses()
table.deactivate()
def test_store_order(lambda_module, order):
"""
Test store_order()
"""
table = mock_table(lambda_module.table,
"put_item", ["orderId"],
items=order)
lambda_module.store_order(order)
table.assert_no_pending_responses()
table.deactivate()
def test_get_products_next(lambda_module, order, order_products):
"""
Test get_products() with a LastEvaluatedKey value
"""
table = mock_table(
lambda_module.table, "query",
["orderId", "productId"],
response={
"Items": order_products,
"LastEvaluatedKey": {
"orderId": {"S": order_products[-1]["orderId"]},
"productId": {"S": order_products[-1]["productId"]}
}
},
items=order_products
)
mock_table(
table, "query",
["orderId", "productId"],
expected_params={
"TableName": lambda_module.table.name,
"KeyConditionExpression": stub.ANY,
"Limit": 100,
"ExclusiveStartKey": {
"orderId": order_products[-1]["orderId"],
"productId": order_products[-1]["productId"]
}
},
items=order_products
)
response = lambda_module.get_products(order["orderId"])
table.assert_no_pending_responses()
table.deactivate()
assert response == order_products + order_products
def test_delete_id(lambda_module):
"""
Test delete_id()
"""
connection_id = str(uuid.uuid4())
table = mock_table(lambda_module.table,
"delete_item", ["id"],
items={"id": connection_id})
lambda_module.delete_id(connection_id)
table.assert_no_pending_responses()
table.deactivate()
def test_on_order_modified_idempotent(lambda_module, order, order_metadata):
"""
Test on_order_modified() with an already processed event
"""
table = mock_table(
lambda_module.table, "get_item", ["orderId", "productId"],
items=order_metadata
)
lambda_module.on_order_modified(order, order)
table.assert_no_pending_responses()
table.deactivate()
def test_handler_deleted(lambda_module, context, order, order_products, order_metadata):
"""
Test handler() with OrderDeleted
"""
table = mock_table(
lambda_module.table, "get_item", ["orderId", "productId"],
items=order_metadata
)
mock_table(
table, "batch_write_item",
["orderId", "productId"],
table_name=lambda_module.table.name,
items=[
{"DeleteRequest": {"Key": {
"orderId": product["orderId"],
"productId": product["productId"]
}}}
for product in order_products
]
)
mock_table(
table, "delete_item",
["orderId", "productId"],
table_name=lambda_module.table.name,
items=order_metadata
)
lambda_module.handler({
"source": "ecommerce.orders",
"resources": [order["orderId"]],
"detail-type": "OrderDeleted",
"detail": order
}, context)
table.assert_no_pending_responses()
table.deactivate()
def test_get_products(lambda_module, order, order_products):
"""
Test get_products()
"""
table = mock_table(lambda_module.table,
"query", ["orderId", "productId"],
items=order_products)
response = lambda_module.get_products(order["orderId"])
table.assert_no_pending_responses()
table.deactivate()
assert response == order_products
def test_delete_metadata(lambda_module, order_metadata):
"""
Test delete_metadata()
"""
table = mock_table(
lambda_module.table, "delete_item",
["orderId", "productId"],
items=order_metadata
)
lambda_module.delete_metadata(order_metadata["orderId"])
table.assert_no_pending_responses()
table.deactivate()
def test_get_payment_token_no_item(lambda_module, order_id, payment_token):
"""
Test get_payment_token() without an item
"""
table = mock_table(lambda_module.table,
action="get_item",
keys=["orderId"])
try:
lambda_module.get_payment_token(order_id)
assert 1 == 2
except:
pass
table.assert_no_pending_responses()
table.deactivate()
def test_delete_payment_token(lambda_module, order_id, payment_token):
"""
Test delete_payment_token()
"""
table = mock_table(lambda_module.table,
action="delete_item",
keys=["orderId"],
items={
"orderId": order_id,
"paymentToken": payment_token
})
lambda_module.delete_payment_token(order_id)
table.assert_no_pending_responses()
table.deactivate()
def test_store_id(lambda_module):
"""
Test store_id()
"""
connection_id = str(uuid.uuid4())
table = mock_table(lambda_module.table,
"put_item", ["id"],
items={
"id": connection_id,
"ttl": stub.ANY
})
lambda_module.store_id(connection_id)
table.assert_no_pending_responses()
table.deactivate()
def test_parse_record_metadata_completed_empty(lambda_module,
ddb_record_metadata_completed,
event_metadata_failed, order,
order_products):
"""
Test parse_record() with a metadata completed item without products
"""
table = mock_table(lambda_module.table, "query", ["orderId", "productId"])
response = lambda_module.parse_record(ddb_record_metadata_completed)
table.assert_no_pending_responses()
table.deactivate()
assert response is not None
compare_event(event_metadata_failed, response)
def test_get_metadata(lambda_module, order_metadata):
"""
Test get_metadata()
"""
table = mock_table(
lambda_module.table, "get_item",
["orderId", "productId"],
items=order_metadata
)
response = lambda_module.get_metadata(order_metadata["orderId"])
table.assert_no_pending_responses()
table.deactivate()
assert response == order_metadata
def test_update_products_new(lambda_module, order, order_products):
"""
Test update_products() with new products only
"""
table = mock_table(
lambda_module.table, "batch_write_item",
["orderId", "productId"],
items=[
{"PutRequest": {"Item": product}}
for product in order_products
]
)
lambda_module.update_products(order["orderId"], [], order["products"])
table.assert_no_pending_responses()
table.deactivate()
def test_register_service(lambda_module):
"""
Test register_service()
"""
connection_id = str(uuid.uuid4())
service_name = "test"
table = mock_table(
lambda_module.table, "put_item", ["id"],
items={
"id": connection_id,
"service": service_name,
"ttl": stub.ANY
}
)
lambda_module.register_service(connection_id, service_name)
table.assert_no_pending_responses()
table.deactivate()
def test_save_shipping_request_in_progress(lambda_module, order, ddb_item):
"""
Test save_shipping_request() with an in progress shipping request
"""
# Mock boto3
ddb_item = copy.deepcopy(ddb_item)
del ddb_item["isNew"]
ddb_item["status"] = "IN_PROGRESS"
table = mock_table(
lambda_module.table, "get_item",
["orderId"],
items=ddb_item
)
# Call
lambda_module.save_shipping_request(order)
# Assertions
table.assert_no_pending_responses()
table.deactivate()
def test_update_products_old(lambda_module, order, order_products):
"""
Test update_products() with old products only
"""
table = mock_table(
lambda_module.table, "batch_write_item",
["orderId", "productId"],
items=[
{"DeleteRequest": {"Key": {
"orderId": product["orderId"],
"productId": product["productId"]
}}}
for product in order_products
]
)
lambda_module.update_products(order["orderId"], order["products"], [])
table.assert_no_pending_responses()
table.deactivate()
def test_save_metadata(lambda_module, order_metadata):
"""
Test save_metadata()
"""
item = copy.deepcopy(order_metadata)
item["newDate"] = order_metadata["modifiedDate"]
table = mock_table(
lambda_module.table, "put_item",
["orderId", "productId"],
items=item
)
lambda_module.save_metadata(
order_metadata["orderId"],
order_metadata["modifiedDate"],
order_metadata["status"]
)
table.assert_no_pending_responses()
table.deactivate()
def test_delete_products(lambda_module, order, order_products):
"""
Test delete_products()
"""
table = mock_table(
lambda_module.table, "batch_write_item",
["orderId", "productId"],
items=[
{"DeleteRequest": {"Key": {
"orderId": product["orderId"],
"productId": product["productId"]
}}}
for product in order_products
]
)
products = order["products"] + [{"orderId": order["orderId"], "productId": METADATA_KEY}]
lambda_module.delete_products(order["orderId"], products)
table.assert_no_pending_responses()
table.deactivate()
