def test_update_order__non_existing_items(self):
item1 = Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=2,
category='scarpe',
)
item2 = Item.create(
uuid='577ad826-a79d-41e9-a5b2-7955bcf03499',
name='GINO',
price=30.20,
description='svariati GINIIIII',
availability=1,
category='accessori',
)
user = add_user('*****@*****.**', TEST_USER_PSW)
addr = add_address(user=user)
add_address(user=user, id='429994bf-784e-47cc-a823-e0c394b823e8')
order1 = Order.create(delivery_address=addr, user=user)
order1.add_item(item1, 2).add_item(item2)
order_item_before = [o.json() for o in OrderItem.select()]
# order_uuid = str(order1.uuid)
order = {
'relationships': {
'items': [{
'id': '577ad826-a79d-41e9-a5b2-7955bcf00000',
'type': 'item',
'quantity': 1
}, {
'id': '577ad826-a79d-41e9-a5b2-7955bcf2222',
'type': 'item',
'quantity': 1
}, {
'id': '577ad826-a79d-41e9-a5b2-7955bcf9999',
'type': 'item',
'quantity': 2
}],
'delivery_address': {
'type': 'address',
'id': '429994bf-784e-47cc-a823-e0c394b823e8'
},
'user': {
'type': 'user',
'id': '86ba7e70-b3c0-4c9c-8d26-a14f49360e47'
}
}
}
data = format_jsonapi_request('order', order)
path = 'orders/{}'.format(order1.uuid)
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'PATCH',
user.email, TEST_USER_PSW, 'application/json',
json.dumps(data))
order_item_after = [o.json() for o in OrderItem.select()]
assert resp.status_code == BAD_REQUEST
assert order_item_before == order_item_after
def test_delete_order__success(self):
order1 = self.create_order(self.user1)
order2 = self.create_order(self.user1)
items_quantity = {
oi.item.uuid: (oi.item.availability, oi.quantity)
for oi in order1.order_items
}
resp = self.open_with_auth('/orders/{}'.format(str(order1.uuid)),
'delete',
self.user1.email,
'p4ssw0rd',
data='')
assert resp.status_code == NO_CONTENT
orders = Order.select()
assert len(orders) == 1
assert Order.get(Order.uuid == order2.uuid)
order_items = OrderItem.select().where(OrderItem.order == order1)
assert len(order_items) == 0
for item_uuid, (availability, quantity) in items_quantity.items():
item = Item.get(Item.uuid == item_uuid)
assert item.availability == availability + quantity
def test_modify_order__success(self):
order1 = self.create_order(self.user1)
order2 = self.create_order(self.user1)
start_availability = self.item2.availability
updates = {'items': json.dumps([[str(self.item2.uuid), 2]])}
resp = self.open_with_auth('/orders/{}'.format(order1.uuid),
'put',
self.user1.email,
'p4ssw0rd',
data=updates)
assert resp.status_code == OK
order1_upd = Order.get(Order.uuid == order1.uuid).json()
total_price = self.item2.price * 2
assert order1_upd['total_price'] == total_price
order2_db = Order.get(Order.uuid == order2.uuid).json()
assert order2_db == order2.json()
order1_items = OrderItem.select().where(OrderItem.order == order1)
assert len(order1_items) == 1
assert str(order1_items[0].item.uuid) == str(self.item2.uuid)
temp_item = Item.get(Item.uuid == self.item2.uuid)
assert temp_item.availability == (start_availability - 2)
def test_delete_order__success_admin_not_own_order(self):
user = add_user('*****@*****.**', TEST_USER_PSW)
addr_A = add_address(user=user)
addr_B = add_address(user=user)
item1 = Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=2,
category='scarpe',
)
order1 = Order.create(delivery_address=addr_A, user=user)
order1.add_item(item1, 2)
order2 = Order.create(delivery_address=addr_B, user=user)
user_B = add_admin_user('*****@*****.**', TEST_USER_PSW)
path = 'orders/{}'.format(order1.uuid)
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'DELETE',
user_B.email, TEST_USER_PSW, None, None)
assert resp.status_code == NO_CONTENT
assert len(Order.select()) == 1
assert len(OrderItem.select()) == 0
assert Order.get(uuid=order2.uuid)
def test_delete_order__success(self):
order1 = Order.create(
uuid=uuid.uuid4(),
total_price=10,
user=self.user1,
)
OrderItem.create(
order=order1.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
order2 = Order.create(
uuid=uuid.uuid4(),
total_price=12,
user=self.user1,
)
OrderItem.create(
order=order2.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
resp = self.app.delete('/orders/{}'.format(order1.uuid))
assert resp.status_code == NO_CONTENT
orders = Order.select()
assert len(orders) == 1
assert Order.get(Order.uuid == order2.uuid)
order_items = OrderItem.select().where(OrderItem.order_id == order1.id)
assert len(order_items) == 0
def test_create_order__success(self):
Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=4,
category='scarpe',
)
Item.create(
uuid='577ad826-a79d-41e9-a5b2-7955bcf03499',
name='GINO',
price=30.20,
description='svariati GINIIIII',
availability=10,
category='accessori',
)
user = add_user('*****@*****.**',
TEST_USER_PSW,
id='e736a9a6-448b-4b92-9e38-4cf745b066db')
add_address(user=user, id='8473fbaa-94f0-46db-939f-faae898f001c')
order = {
'relationships': {
'items': [{
'id': '429994bf-784e-47cc-a823-e0c394b823e8',
'type': 'item',
'quantity': 4
}, {
'id': '577ad826-a79d-41e9-a5b2-7955bcf03499',
'type': 'item',
'quantity': 10
}],
'delivery_address': {
'type': 'address',
'id': '8473fbaa-94f0-46db-939f-faae898f001c'
},
'user': {
'type': 'user',
'id': 'e736a9a6-448b-4b92-9e38-4cf745b066db'
}
}
}
data = format_jsonapi_request('order', order)
path = 'orders/'
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'POST',
user.email, TEST_USER_PSW, 'application/json',
json.dumps(data))
assert resp.status_code == CREATED
assert len(Order.select()) == 1
assert len(OrderItem.select()) == 2
order = Order.get()
expected_result = EXPECTED_RESULTS['create_order__success']
assert_valid_response(resp.data, expected_result)
def test_create_order__failure_user_auth(self):
Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=4,
category='scarpe',
)
Item.create(
uuid='577ad826-a79d-41e9-a5b2-7955bcf03499',
name='GINO',
price=30.20,
description='svariati GINIIIII',
availability=10,
category='scarpe',
)
user = add_user('*****@*****.**',
TEST_USER_PSW,
id='e736a9a6-448b-4b92-9e38-4cf745b066db')
other_user = add_user('*****@*****.**',
TEST_USER_PSW,
id='d41ad9db-9d60-45c6-9fa6-51f66cd3d99a')
add_address(user=user, id='8473fbaa-94f0-46db-939f-faae898f001c')
order = {
'relationships': {
'items': [{
'id': '429994bf-784e-47cc-a823-e0c394b823e8',
'type': 'item',
'quantity': 4
}, {
'id': '577ad826-a79d-41e9-a5b2-7955bcf03499',
'type': 'item',
'quantity': 10
}],
'delivery_address': {
'type': 'address',
'id': '8473fbaa-94f0-46db-939f-faae898f001c'
},
'user': {
'type': 'user',
'id': str(other_user.uuid)
}
}
}
data = format_jsonapi_request('order', order)
path = 'orders/'
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'POST',
user.email, TEST_USER_PSW, 'application/json',
json.dumps(data))
assert resp.status_code == UNAUTHORIZED
assert len(Order.select()) == 0
assert len(OrderItem.select()) == 0
def put(self, uuid):
try:
order = (Order.select().where(Order.uuid == uuid).where(
Order.user == g.current_user).get())
except Order.DoesNotExist:
return None, NOT_FOUND
parser = reqparse.RequestParser()
parser.add_argument('items', type=is_valid_item_list, required=True)
args = parser.parse_args(strict=True)
total_price = 0
items = args['items']
uuid = [i[0] for i in items]
items_query = Item.select().where(Item.uuid << uuid)
if items_query.count() != len(items) or len(items) == 0:
return None, BAD_REQUEST
for item in items_query:
item_quantity = [x[1] for x in items if x[0] == str(item.uuid)][0]
total_price += float(item.price * item_quantity)
for item in items_query:
item_quantity = [x[1] for x in items if x[0] == str(item.uuid)][0]
if item_quantity > item.availability:
return None, BAD_REQUEST
with database.transaction():
temp_query = OrderItem.select().where(OrderItem.order == order.id)
for order_item in temp_query:
order_item.item.availability = (order_item.item.availability +
order_item.quantity)
order_item.item.save()
OrderItem.delete().where(OrderItem.order == order.id).execute()
for item in items_query:
item_quantity = [
x[1] for x in items if x[0] == str(item.uuid)
][0]
OrderItem.create(order=order,
item=item.id,
quantity=item_quantity,
subtotal=float(item.price * item_quantity))
item.availability = (item.availability - item_quantity)
item.save()
order.total_price = total_price
order.save()
return order.json(), OK
def test_delete_order__success(self):
order1 = self.create_order(self.user1)
order2 = self.create_order(self.user1)
resp = self.app.delete('/orders/{}'.format(order1.uuid))
assert resp.status_code == NO_CONTENT
orders = Order.select()
assert len(orders) == 1
assert Order.get(Order.uuid == order2.uuid)
order_items = OrderItem.select().where(OrderItem.order == order1)
assert len(order_items) == 0
def delete(self, uuid):
try:
order = Order.get(Order.uuid == uuid)
except Order.DoesNotExist:
return None, NOT_FOUND
with database.transaction():
order_items = OrderItem.select().where(OrderItem.order == order)
for order_item in order_items:
order_item.delete_instance()
order.delete_instance()
return None, NO_CONTENT
def test_create_order__not_json_failure(self):
Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=4,
category='scarpe',
)
Item.create(
uuid='577ad826-a79d-41e9-a5b2-7955bcf03499',
name='GINO',
price=30.20,
description='svariati GINIIIII',
availability=10,
category='accessori',
)
user = add_user('*****@*****.**', TEST_USER_PSW)
add_address(user=user, id='429994bf-784e-47cc-a823-e0c394b823e8')
order = {
'order': {
'items': [{
'id': '429994bf-784e-47cc-a823-e0c394b823e8',
'type': 'item',
'quantity': 4
}, {
'id': '577ad826-a79d-41e9-a5b2-7955bcf03499',
'type': 'item',
'quantity': 10
}],
'delivery_address':
'429994bf-784e-47cc-a823-e0c394b823e8',
'user':
'******'
}
}
path = 'orders/'
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'POST',
user.email, TEST_USER_PSW, 'application/json',
wrong_dump(order))
assert resp.status_code == BAD_REQUEST
assert len(Order.select()) == 0
assert len(OrderItem.select()) == 0
def test_modify_order__success(self):
order1 = self.create_order(self.user1)
order2 = self.create_order(self.user1)
updates = {'items': json.dumps([[str(self.item2.uuid), 2]])}
resp = self.app.put('/orders/{}'.format(order1.uuid), data=updates)
assert resp.status_code == OK
order1_upd = Order.get(Order.uuid == order1.uuid).json()
total_price = self.item2.price * 2
assert order1_upd['total_price'] == total_price
order2_db = Order.get(Order.uuid == order2.uuid).json()
assert order2_db == order2.json()
order1_items = OrderItem.select().where(OrderItem.order == order1)
assert len(order1_items) == 1
assert str(order1_items[0].item.uuid) == str(self.item2.uuid)
def test_modify_order__success(self):
order1 = Order.create(
uuid=uuid.uuid4(),
total_price=10,
user=self.user1.id,
)
OrderItem.create(
order=order1.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
order2 = Order.create(
uuid=uuid.uuid4(),
total_price=12,
user=self.user1.id,
)
OrderItem.create(
order=order2.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
updates = {'items': json.dumps([[self.item2.uuid, 2]])}
resp = self.app.put('/orders/{}'.format(order1.uuid), data=updates)
assert resp.status_code == OK
order1_upd = Order.get(Order.uuid == order1.uuid).json()
total_price = self.item2.price * 2
assert order1_upd['total_price'] == total_price
order2_db = Order.get(Order.uuid == order2.uuid).json()
assert order2_db == order2.json()
order1_items = OrderItem.select().where(
OrderItem.order_id == order1.id)
assert len(order1_items) == 1
assert str(order1_items[0].item.uuid) == self.item2.uuid
def test_update_order__failure_availability(self, mocker):
mocker.patch('views.orders.database', new=self.TEST_DB)
user = add_user('*****@*****.**',
TEST_USER_PSW,
id='90c3e1c1-b51c-4224-b69d-17f84f6a8dfc')
addr = add_address(user=user,
id='8f3b518e-9c17-4103-9a47-b274740726e7')
item = Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=4,
category='scarpe',
)
order = Order.create(
delivery_address=addr,
user=user,
).add_item(item, 2)
update_order = {
'relationships': {
'items': [{
'id': '429994bf-784e-47cc-a823-e0c394b823e8',
'type': 'item',
'quantity': 5
}]
}
}
post_data = format_jsonapi_request('order', update_order)
path = 'orders/{}'.format(order.uuid)
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'PATCH',
'*****@*****.**', TEST_USER_PSW,
'application/json', json.dumps(post_data))
assert resp.status_code == BAD_REQUEST
assert OrderItem.select().count() == 1
assert OrderItem.get() == order.order_items[0]
assert order.order_items[0].quantity == 2
def test_order_add_remove_item(self):
"""
Test add_item and remove_item function from Order and OrderItem
models.
"""
user = add_user(None, TEST_USER_PSW)
addr = add_address(user=user)
item1 = Item.create(
uuid=uuid4(),
name='Item',
description='Item description',
price=10,
availability=2,
category='scarpe',
)
item2 = Item.create(
uuid=uuid4(),
name='Item 2',
description='Item 2 description',
price=15,
availability=2,
category='accessori',
)
item3 = Item.create(
uuid=uuid4(),
name='Item 3',
description='Item 3 description',
price=15,
availability=2,
category='scarpe',
)
order = Order.create(delivery_address=addr, user=user)
order.add_item(item1, 2).add_item(item2, 2)
assert len(order.order_items) == 2
assert OrderItem.select().count() == 2
assert count_order_items(order) == 4
# test removing one of two item1
order.update_items({item1: 1})
assert len(order.order_items) == 2
assert count_order_items(order) == 3
# remove more item1 than existing in order
with pytest.raises(WrongQuantity):
order.update_items({item1: -1})
assert len(order.order_items) == 2
assert OrderItem.select().count() == 2
assert count_order_items(order) == 3
# Check that the total price is correctly updated
assert order.total_price == item1.price + item2.price * 2
# remove non existing item3 from order
with pytest.raises(WrongQuantity):
order.update_items({item3: 0})
assert count_order_items(order) == 3
assert len(order.order_items) == 2
order.empty_order()
assert len(order.order_items) == 0
assert OrderItem.select().count() == 0
