def test_get_orders(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=7,
user=self.user1.id,
)
OrderItem.create(
order=order2.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
resp = self.app.get('/orders/')
assert resp.status_code == OK
assert json.loads(resp.data.decode()) == [order1.json(), order2.json()]
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 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 post(self):
parser = reqparse.RequestParser()
parser.add_argument('user', type=is_valid_uuid, required=True)
parser.add_argument('items', type=is_valid_item_list, required=True)
args = parser.parse_args(strict=True)
try:
user = User.get(User.uuid == args['user'])
except User.DoesNotExist:
return None, BAD_REQUEST
if user != g.current_user:
return '', UNAUTHORIZED
total_price = 0
items = args['items']
items_uuid = [i[0] for i in items]
items_query = Item.select().where(Item.uuid << items_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():
order = Order.create(uuid=uuid.uuid4(),
total_price=total_price,
user=user.id)
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()
return order.json(), CREATED
def create_order(self, user=None, items=None):
'''Parameter format:
items = [
[Instance of Item, quantity],
...
[instance of item, quantity]
]
user = Instance of User
'''
if not user:
user = self.create_user()
if not items:
items = []
for i in range(2):
item = self.create_item()
items.append([item, i + 1])
total_price = 0
for item in items:
total_price += float(item[0].price * item[1])
order = Order.create(
uuid=uuid.uuid4(),
total_price=total_price,
user=user
)
for item in items:
item_quantity = item[1]
item = item[0]
OrderItem.create(
order=order,
item=item,
quantity=item_quantity,
subtotal=float(item.price * item_quantity)
)
return order
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 main():
database.connect()
seed(2)
fake = Factory.create('it_IT')
fake.seed(99)
items_list = []
users_list = []
for _ in range(10):
item = Item.create(
uuid=fake.uuid4(),
name=fake.word(),
price=fake.random_int(),
description=fake.sentence(),
category=fake.word(),
availability=randint(1, 10),
)
items_list.append(item)
for _ in range(20):
user = User.create(
uuid=fake.uuid4(),
first_name=fake.first_name(),
last_name=fake.last_name(),
email=fake.email(),
password=fake.password(),
)
users_list.append(user)
for user in users_list:
for x in range(randint(1, 3)):
Address.create(
uuid=fake.uuid4(),
user=user,
nation=fake.country(),
city=fake.city(),
postal_code=fake.postcode(),
local_address=fake.address(),
phone=fake.phone_number(),
)
for user in users_list:
# User has three chance on four to make an order
make_order = randint(0, 4)
# If use make an order, I insert an order and I iterate the items list
if make_order != 0:
order_total_price = 0
order_item_quantity = 0
order_item_subtotal = 0
order = Order.create(
uuid=fake.uuid4(),
total_price=order_total_price,
user=user,
)
for item in items_list:
# If item_quantity == 0, the item isn't counted in the order
order_item_quantity = randint(0, 3)
if order_item_quantity != 0:
order_item_subtotal = item.price * order_item_quantity
order_total_price += order_item_subtotal
OrderItem.create(
order=order,
item=item,
quantity=item.price,
subtotal=order_item_subtotal,
)
order.total_price = order_total_price
order.save()
