def order_request(get_order, product, iam_auth, delivery_pricing_api_url,
payment_3p_api_url):
"""
Order Request
"""
order = get_order()
# Grab the correct delivery price from the backend
res = requests.post("{}/backend/pricing".format(delivery_pricing_api_url),
auth=iam_auth(delivery_pricing_api_url),
json={
"products": [product],
"address": order["address"]
})
delivery_price = res.json()["pricing"]
# Get a payment token
total = delivery_price + sum(
[p["price"] * p.get("quantity", 1) for p in order["products"]])
res = requests.post("{}/preauth".format(payment_3p_api_url),
json={
"cardNumber": "1234567890123456",
"amount": total
})
payment_token = res.json()["paymentToken"]
return {
"products": [product],
"address": order["address"],
"deliveryPrice": delivery_price,
"paymentToken": payment_token
}
def order(get_order):
"""
Order fixture
"""
order = get_order()
return {k: order[k] for k in [
"userId", "products", "address", "deliveryPrice", "paymentToken"
]}
def test_start_delivery(jwt_token, api_url, delivery_table_name, get_order):
"""
Test startDelivery
"""
order = get_order()
delivery = {
"orderId": order["orderId"],
"address": order["address"],
"isNew": "true",
"status": "NEW"
}
print(delivery)
# Seed the database
table = boto3.resource("dynamodb").Table(delivery_table_name) # pylint: disable=no-member
table.put_item(Item=delivery)
# Make request
query = """
mutation ($input: DeliveryInput!) {
startDelivery(input: $input) {
success
}
}
"""
res = requests.post(api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": {
"input": {
"orderId": order["orderId"]
}
}
})
data = res.json()
print(data)
assert "data" in data
assert data["data"] is not None
assert "startDelivery" in data["data"]
assert "success" in data["data"]["startDelivery"]
assert data["data"]["startDelivery"]["success"] == True
ddb_res = table.get_item(Key={"orderId": order["orderId"]})
assert "Item" in ddb_res
assert "status" in ddb_res["Item"]
assert ddb_res["Item"]["status"] == "IN_PROGRESS"
assert "isNew" not in ddb_res["Item"]
# Cleanup
table.delete_item(Key={"orderId": order["orderId"]})
def test_get_delivery_pricing(get_order, jwt_token, api_url):
"""
Test getDeliveryPricing
"""
order = get_order()
headers = {"Authorization": jwt_token}
query = """
query($input: DeliveryPricingInput!) {
getDeliveryPricing(input: $input) {
pricing
}
}
"""
variables = {
"input": {
"products": order["products"],
"address": order["address"]
}
}
print("VARIABLES", variables)
response = requests.post(api_url,
json={
"query": query,
"variables": variables
},
headers=headers)
data = response.json()
print(data)
assert "data" in data
assert "getDeliveryPricing" in data["data"]
assert "pricing" in data["data"]["getDeliveryPricing"]
def order_request(get_order, product, iam_auth, delivery_pricing_api_url):
"""
Order Request
"""
order = get_order()
# Grab the correct delivery price from the backend
res = requests.post("{}/backend/pricing".format(delivery_pricing_api_url),
auth=iam_auth(delivery_pricing_api_url),
json={
"products": [product],
"address": order["address"]
})
delivery_price = res.json()["pricing"]
return {
"products": [product],
"address": order["address"],
"deliveryPrice": delivery_price,
"paymentToken": order["paymentToken"]
}
def test_get_delivery(jwt_token, api_url, delivery_table_name, get_order):
"""
Test getDelivery
"""
order = get_order()
delivery = {
"orderId": order["orderId"],
"address": order["address"],
"isNew": "true",
"status": "NEW"
}
print(delivery)
# Seed the database
table = boto3.resource("dynamodb").Table(delivery_table_name) # pylint: disable=no-member
table.put_item(Item=delivery)
# Make request
query = """
query($input: DeliveryInput!) {
getDelivery(input: $input) {
orderId
address {
name
streetAddress
city
country
}
}
}
"""
res = requests.post(api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": {
"input": {
"orderId": order["orderId"]
}
}
})
data = res.json()
print(data)
assert "data" in data
assert data["data"] is not None
assert "getDelivery" in data["data"]
assert "orderId" in data["data"]["getDelivery"]
assert data["data"]["getDelivery"]["orderId"] == order["orderId"]
assert data["data"]["getDelivery"]["address"]["name"] == order["address"][
"name"]
assert data["data"]["getDelivery"]["address"]["streetAddress"] == order[
"address"]["streetAddress"]
assert data["data"]["getDelivery"]["address"]["city"] == order["address"][
"city"]
assert data["data"]["getDelivery"]["address"]["country"] == order[
"address"]["country"]
# Cleanup
table.delete_item(Key={"orderId": order["orderId"]})
def test_get_new_deliveries(jwt_token, api_url, delivery_table_name,
get_order):
"""
Test getNewDeliveries
"""
order = get_order()
delivery = {
"orderId": order["orderId"],
"address": order["address"],
"isNew": "true",
"status": "NEW"
}
print(delivery)
# Seed the database
table = boto3.resource("dynamodb").Table(delivery_table_name) # pylint: disable=no-member
table.put_item(Item=delivery)
# Make requests
headers = {"Authorization": jwt_token}
def get_deliveries(next_token=None):
if next_token:
req_data = {
"query": """
query ($nextToken: String) {
getNewDeliveries(nextToken: $nextToken) {
nextToken
deliveries {
orderId
address {
name
streetAddress
city
country
}
}
}
}
""",
"variables": {
"nextToken": next_token
}
}
else:
req_data = {
"query":
"""
query {
getNewDeliveries {
nextToken
deliveries {
orderId
address {
name
streetAddress
city
country
}
}
}
}
"""
}
response = requests.post(api_url, json=req_data, headers=headers)
data = response.json()
print(data)
assert "data" in data
assert data["data"] is not None
assert "getNewDeliveries" in data["data"]
return data["data"]["getNewDeliveries"]
found = False
deliveries = get_deliveries()
for delivery in deliveries["deliveries"]:
if delivery["orderId"] == order["orderId"]:
found = True
while found == False and deliveries.get("nextToken", None) is not None:
deliveries = get_deliveries(deliveries["nextToken"])
for delivery in deliveries["deliveries"]:
if delivery["orderId"] == order["orderId"]:
found = True
assert found == True
# Clean database
table.delete_item(Key={"orderId": order["orderId"]})
def test_get_packaging_request(jwt_token, api_url, warehouse_table_name,
get_order):
"""
Test getPackagingRequest
"""
# Create an order
order = get_order()
order_metadata = {
"orderId": order["orderId"],
"productId": "__metadata",
"modifiedDate": order["modifiedDate"],
"newDate": order["modifiedDate"],
"status": "NEW"
}
# Seed the table
table = boto3.resource("dynamodb").Table(warehouse_table_name) # pylint: disable=no-member
with table.batch_writer() as batch:
batch.put_item(Item=order_metadata)
for product in order["products"]:
batch.put_item(
Item={
"orderId": order["orderId"],
"productId": product["productId"],
"quantity": product.get("quantity", 1)
})
# Perform the query
query = """
query ($input: PackagingInput!) {
getPackagingRequest(input: $input) {
orderId
status
products {
productId
quantity
}
}
}
"""
response = requests.post(api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": {
"input": {
"orderId": order["orderId"]
}
}
})
data = response.json()
print(data)
assert "data" in data
assert data["data"] is not None
assert "getPackagingRequest" in data["data"]
pr = data["data"]["getPackagingRequest"]
assert pr["orderId"] == order["orderId"]
assert pr["status"] == order["status"]
assert len(pr["products"]) == len(order["products"])
products = {p["productId"]: p for p in pr["products"]}
for product in order["products"]:
assert product["productId"] in products.keys()
assert products[product["productId"]]["quantity"] == product.get(
"quantity", 1)
# Cleanup
with table.batch_writer() as batch:
batch.delete_item(Key={
"orderId": order["orderId"],
"productId": "__metadata"
})
for product in order["products"]:
batch.delete_item(Key={
"orderId": order["orderId"],
"productId": product["productId"]
})
def order(get_order):
return get_order()
def complete_order(get_order):
"""
Complete order fixture
"""
return get_order()
def order(get_order):
"""
Generate orders
"""
return get_order()
def test_happy_path(get_order, products_table, jwt_token, frontend_api_url,
payment_3p_api_url):
"""
Test an order journey with a happy path
"""
# Generate an order request
order = get_order()
order_request = {
"products": order["products"],
"address": order["address"]
}
del order
# Seed the products table
# TODO: use backoffice API instead
with products_table.batch_writer() as batch:
for product in order_request["products"]:
batch.put_item(Item=product)
# Get the delivery price
query = """
query($input: DeliveryPricingInput!) {
getDeliveryPricing(input: $input) {
pricing
}
}
"""
variables = {
"input": {
"products": order_request["products"],
"address": order_request["address"]
}
}
res = requests.post(frontend_api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": variables
})
body = res.json()
print("GET DELIVERY PRICING", body)
assert "pricing" in body["data"]["getDeliveryPricing"]
order_request["deliveryPrice"] = body["data"]["getDeliveryPricing"][
"pricing"]
# Get the paymentToken
total = order_request["deliveryPrice"] + sum(
[p["price"] * p.get("quantity", 1) for p in order_request["products"]])
res = requests.post(payment_3p_api_url + "/preauth",
json={
"cardNumber": "1234567890123456",
"amount": total
})
order_request["paymentToken"] = res.json()["paymentToken"]
# Create the order
query = """
mutation ($order: CreateOrderRequest!) {
createOrder(order: $order) {
success
message
errors
order {
orderId
}
}
}
"""
variables = {"order": order_request}
res = requests.post(frontend_api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": variables
})
body = res.json()
print("CREATE ORDER", body)
assert body["data"]["createOrder"]["success"] == True
order_id = body["data"]["createOrder"]["order"]["orderId"]
# Wait
time.sleep(5)
# Retrieve the packaging request
query = """
query ($input: PackagingInput!) {
getPackagingRequest(input: $input) {
orderId
status
products {
productId
quantity
}
}
}
"""
variables = {"input": {"orderId": order_id}}
res = requests.post(frontend_api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": variables
})
body = res.json()
print("GET PACKAGE REQUEST", body)
pr = body["data"]["getPackagingRequest"]
packaging_products = {p["productId"]: p for p in pr["products"]}
for product in order_request["products"]:
assert product["productId"] in packaging_products.keys()
assert packaging_products[
product["productId"]]["quantity"] == product.get("quantity", 1)
# Start working on the packaging request
query = """
mutation ($input: PackagingInput!) {
startPackaging(input: $input) {
success
}
}
"""
variables = {"input": {"orderId": order_id}}
res = requests.post(frontend_api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": variables
})
body = res.json()
print("START PACKAGING", body)
assert body["data"]["startPackaging"]["success"] == True
# Complete the packaging request
query = """
mutation ($input: PackagingInput!) {
completePackaging(input: $input) {
success
}
}
"""
variables = {"input": {"orderId": order_id}}
res = requests.post(frontend_api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": variables
})
body = res.json()
print("COMPLETE PACKAGING", body)
assert body["data"]["completePackaging"]["success"] == True
# Wait
time.sleep(5)
# Check the order
query = """
query($orderId: ID!) {
getOrder(orderId: $orderId) {
orderId
status
}
}
"""
variables = {"orderId": order_id}
res = requests.post(frontend_api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": variables
})
body = res.json()
print("CHECK ORDER", body)
assert body["data"]["getOrder"]["status"] == "PACKAGED"
# Retrieve the delivery request
query = """
query($input: DeliveryInput!) {
getDelivery(input: $input) {
orderId
address {
name
companyName
streetAddress
postCode
city
state
country
phoneNumber
}
}
}
"""
variables = {"input": {"orderId": order_id}}
res = requests.post(frontend_api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": variables
})
body = res.json()
print("GET DELIVERY", body)
assert body["data"]["getDelivery"]["orderId"] == order_id
assert body["data"]["getDelivery"]["address"] == order_request["address"]
# Start delivery
query = """
mutation ($input: DeliveryInput!) {
startDelivery(input: $input) {
success
}
}
"""
variables = {"input": {"orderId": order_id}}
res = requests.post(frontend_api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": variables
})
body = res.json()
print("START DELIVERY", body)
assert body["data"]["startDelivery"]["success"] == True
# Complete delivery
query = """
mutation ($input: DeliveryInput!) {
completeDelivery(input: $input) {
success
}
}
"""
variables = {"input": {"orderId": order_id}}
res = requests.post(frontend_api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": variables
})
body = res.json()
print("COMPLETE DELIVERY", body)
assert body["data"]["completeDelivery"]["success"] == True
# Wait
time.sleep(5)
# Check the order
query = """
query($orderId: ID!) {
getOrder(orderId: $orderId) {
orderId
status
}
}
"""
variables = {"orderId": order_id}
res = requests.post(frontend_api_url,
headers={"Authorization": jwt_token},
json={
"query": query,
"variables": variables
})
body = res.json()
print("CHECK ORDER", body)
assert body["data"]["getOrder"]["status"] == "FULFILLED"
# Remove products from the products table
# TODO: use backoffice API instead
with products_table.batch_writer() as batch:
for product in order_request["products"]:
batch.delete_item(Key={"productId": product["productId"]})
