def test_finish_order_with_unfinished_products(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
self.try_add_entities([
Product(id='0001', name='Product 1', price=10, weight=10),
Product(id='0002', name='Product 2', price=10, weight=10),
Product(id='0003', name='Product 3', price=10, weight=10),
Order(id=gen_id)
])
self.try_add_entities([
Suborder(id=gen_id, order_id=gen_id),
OrderProduct(suborder_id=gen_id,
product_id='0001',
quantity=1,
status=OrderProductStatus.pending),
OrderProduct(suborder_id=gen_id,
product_id='0002',
quantity=1,
status=OrderProductStatus.pending),
OrderProduct(suborder_id=gen_id,
product_id='0003',
quantity=1,
status=OrderProductStatus.pending)
])
res = self.try_admin_operation(lambda: self.client.post(
f'/api/v1/admin/order/{gen_id}', json={'status': 'shipped'}))
self.assertEqual(res.status_code, 409)
def test_set_order_product_unavailable(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
op_id = datetime.now().microsecond
order = Order(id=gen_id, user=self.user)
self.try_add_entities([
Product(id='0000', name='Test product', price=10, weight=10),
Product(id='0001', name='Test product 1', price=10, weight=10)
])
self.try_add_entities([
order,
Suborder(id=op_id, order=order),
OrderProduct(id=op_id,
suborder_id=op_id,
product_id='0000',
price=10,
quantity=10),
OrderProduct(id=op_id + 1,
suborder_id=op_id,
product_id='0001',
price=10,
quantity=1)
])
self.try_admin_operation(lambda: self.client.post(
f'/api/v1/admin/order/product/{op_id + 1}/status/unavailable'))
order = Order.query.get(gen_id)
self.assertEqual(order.subtotal_krw, 2600)
def test_get_order_product_status_history(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
subcustomer = Subcustomer()
order = Order(id=gen_id,
user_id=self.user.id,
status='pending',
country_id='c1',
tracking_id='T00',
tracking_url='https://tracking.fake/T00')
suborder = Suborder(order=order, subcustomer=subcustomer)
self.try_add_entities([
order, subcustomer, suborder,
OrderProduct(id=10,
suborder=suborder,
product_id='0000',
price=10,
quantity=10),
OrderProductStatusEntry(order_product_id=10,
user_id=self.admin.id,
when_created=datetime(2020, 1, 1, 1, 0, 0),
status=OrderProductStatus.pending)
])
res = self.try_user_operation(
lambda: self.client.get('/api/v1/order/product/10/status/history'))
res = self.client.get('/api/v1/order/product/10/status/history')
self.assertEqual(res.json, [{
'when_created': '2020-01-01 01:00:00',
'set_by': 'root_test_orders_api',
'status': 'pending'
}])
res = self.client.get('/api/v1/order/product/30/status/history')
self.assertEqual(res.status_code, 404)
def test_create_purchase_order(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
gen_int_id = int(datetime.now().timestamp())
self.try_add_entities([
Order(id=gen_id, user=self.user, status=OrderStatus.can_be_paid),
Subcustomer(id=gen_int_id),
Subcustomer(id=gen_int_id + 1),
Suborder(id=gen_id, order_id=gen_id, subcustomer_id=gen_int_id),
Suborder(id=gen_id + '1',
order_id=gen_id,
subcustomer_id=gen_int_id + 1),
OrderProduct(suborder_id=gen_id, product_id='0000'),
OrderProduct(suborder_id=gen_id + '1', product_id='0000'),
Address(id=gen_int_id, zip='00000'),
Company(id=gen_int_id, address_id=gen_int_id)
])
def test_postpone_order_product(self):
op_id = datetime.now().microsecond
self.try_add_entities([
Product(id='0000', name='Test product', price=10, weight=10),
Product(id='0001', name='Test product 1', price=10, weight=10),
Country(id='c1', name='country1'),
Shipping(id=1, name='Shipping1'),
PostponeShipping(),
ShippingRate(shipping_method_id=1,
destination='c1',
weight=1000,
rate=100),
ShippingRate(shipping_method_id=1,
destination='c1',
weight=10000,
rate=200),
])
order1 = Order(user=self.user, shipping_method_id=1, country_id='c1')
self.try_add_entity(order1)
order2 = Order(user=self.user, shipping_method_id=1, country_id='c1')
self.try_add_entity(order2)
suborder = Suborder(order=order1, subcustomer=Subcustomer())
suborder1 = Suborder(order=order2, subcustomer=Subcustomer())
self.try_add_entities([
OrderProduct(suborder=suborder, product_id='0000', quantity=1),
OrderProduct(id=op_id,
suborder=suborder,
product_id='0001',
quantity=1),
OrderProduct(id=op_id + 1,
suborder=suborder1,
product_id='0001',
quantity=1)
])
res = self.try_user_operation(lambda: self.client.post(
f'/api/v1/order/product/{op_id}/postpone'))
self.assertEqual(res.status_code, 200)
orders = Order.query.all()
self.assertEqual(len(orders), 3)
self.assertEqual(orders[0].total_krw, 2610)
self.assertEqual(orders[2].total_krw, 2510)
self.client.post(f'/api/v1/order/product/{op_id + 1}/postpone')
orders = Order.query.all()
self.assertEqual(len(orders), 3)
self.assertEqual(orders[0].total_krw, 2610)
self.assertEqual(orders[2].total_krw, 5020)
def test_finish_order_with_unavailable_products(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
self.try_add_entities([
Product(id='0001',
name='Product 1',
price=10,
weight=10,
points=10),
Product(id='0002',
name='Product 2',
price=10,
weight=10,
points=10),
Product(id='0003',
name='Product 3',
price=10,
weight=10,
points=10),
Order(id=gen_id,
country_id='c1',
shipping_method_id=1,
user=self.user)
])
self.try_add_entities([
Suborder(id=gen_id, order_id=gen_id),
OrderProduct(suborder_id=gen_id,
product_id='0001',
quantity=1,
status=OrderProductStatus.purchased),
OrderProduct(suborder_id=gen_id,
product_id='0002',
quantity=1,
status=OrderProductStatus.purchased),
OrderProduct(suborder_id=gen_id,
product_id='0003',
quantity=1,
status=OrderProductStatus.unavailable)
])
res = self.try_admin_operation(lambda: self.client.post(
f'/api/v1/admin/order/{gen_id}', json={'status': 'shipped'}))
self.assertEqual(res.status_code, 200)
order = Order.query.get(gen_id)
self.assertEqual(order.total_krw, 2620)
self.assertEqual(order.get_total_points(), 20)
def test_delete_last_order_item_in_suborder(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
self.try_add_entities([
Product(id='0001',
name='Product 1',
price=10,
weight=10,
points=10),
Order(id=gen_id,
country_id='c1',
shipping_method_id=1,
user=self.user)
])
self.try_add_entities([
Suborder(id=gen_id, order_id=gen_id),
OrderProduct(suborder_id=gen_id,
product_id='0001',
quantity=1,
status=OrderProductStatus.pending),
Suborder(id=gen_id + "2", order_id=gen_id),
OrderProduct(suborder_id=gen_id + "2",
product_id='0001',
quantity=1,
status=OrderProductStatus.pending)
])
res = self.try_admin_operation(
admin_only=True,
operation=lambda: self.client.post(
f'/api/v1/order/{gen_id}',
json={
"suborders": [{
'subcustomer':
'A001, Subcustomer1, P@ssw0rd',
"items": [{
'item_code': '0001',
'quantity': 1
}]
}]
}))
self.assertEqual(res.status_code, 200)
order = Order.query.get(gen_id)
self.assertEqual(order.suborders.count(), 1)
def test_cancel_order_product(self):
self.try_add_entities([
Product(id='0000', name='Test product', price=10, weight=10),
Product(id='0001', name='Test product 1', price=10, weight=10),
Country(id='c1', name='country1'),
Shipping(id=1, name='Shipping1'),
PostponeShipping(),
ShippingRate(shipping_method_id=1,
destination='c1',
weight=1000,
rate=100),
ShippingRate(shipping_method_id=1,
destination='c1',
weight=10000,
rate=200),
])
op_id = datetime.now().microsecond
order = Order(user=self.user, shipping_method_id=1, country_id='c1')
suborder = Suborder(order=order)
op1 = OrderProduct(suborder=suborder,
product_id='0000',
quantity=75,
price=10,
status=OrderProductStatus.pending)
op2 = OrderProduct(id=op_id,
suborder=suborder,
product_id='0001',
quantity=10,
price=10,
status=OrderProductStatus.pending)
self.try_add_entities(
[Product(id='0001', name='Test product 1', price=10, weight=100)])
self.try_add_entities([order, suborder, op1, op2])
res = self.try_user_operation(
lambda: self.client.delete(f'/api/v1/order/product/{op_id}'))
self.assertEqual(res.status_code, 200)
op = OrderProduct.query.get(op_id)
self.assertEqual(op, None)
def test_delete_order(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
order = Order(id=gen_id, user=self.user, status=OrderStatus.pending)
order1 = Order(id=gen_id + '1',
user=self.user,
status=OrderStatus.shipped)
order2 = Order(id=gen_id + '2', user=self.user)
suborder = Suborder(order=order)
self.try_add_entities([
Order(user=self.user), order, order1, order2, suborder,
OrderProduct(suborder=suborder, product_id='0000'),
OrderProduct(suborder=suborder, product_id='0000')
])
res = self.try_admin_operation(
lambda: self.client.delete(f'/api/v1/admin/order/{gen_id}'))
self.assertEqual(res.status_code, 200)
self.assertEqual(Order.query.count(), 3)
res = self.client.delete(f'/api/v1/admin/order/{order1.id}')
self.assertEqual(res.status_code, 409)
self.assertEqual(Order.query.count(), 3)
res = self.client.delete(f'/api/v1/admin/order/{order2.id}')
self.assertEqual(res.status_code, 200)
self.assertEqual(Order.query.count(), 2)
def test_pay_order(self):
self.user.balance = 2600
order = Order(user=self.user, status=OrderStatus.pending)
suborder = Suborder(order=order)
self.try_add_entities([
order, suborder,
OrderProduct(suborder=suborder,
product_id='0000',
price=10,
quantity=10,
status='purchased')
])
res = self.try_admin_operation(lambda: self.client.post(
f'/api/v1/admin/order/{order.id}', json={'status': 'shipped'}))
self.assertEqual(res.status_code, 200)
self.assertEqual(self.user.balance, 0)
def test_set_order_product_status(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
op_id = datetime.now().microsecond
order = Order(id=gen_id, user=self.user)
self.try_add_entities(
[Product(id='0000', name='Test product', price=10, weight=10)])
self.try_add_entities([
order,
Suborder(id=op_id, order=order),
OrderProduct(id=op_id,
suborder_id=op_id,
product_id='0000',
price=10,
quantity=10)
])
self.try_user_operation(lambda: self.client.post(
f'/api/v1/admin/order/product/{op_id}/status/pending'))
def test_get_order_excel(self):
order = Order(user=self.user,
status=OrderStatus.shipped,
when_created=datetime.now(),
country_id='c1')
suborder = Suborder(order=order,
subcustomer=Subcustomer(username='******'))
self.try_add_entities([
order, suborder,
OrderProduct(suborder=suborder,
product_id='0000',
price=10,
quantity=10)
])
res = self.try_user_operation(
lambda: self.client.get(f'/api/v1/order/{order.id}/excel'))
self.assertEqual(res.status_code, 200)
def test_create_invoice_item(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
order = Order(id=gen_id)
self.try_add_entities([
Product(id=gen_id, name='Product 1')
])
self.try_add_entities([
order,
Suborder(id=gen_id, order=order),
OrderProduct(suborder_id=gen_id, product_id=gen_id, price=10, quantity=10),
Invoice(id=gen_id, order_id=gen_id)
])
self.try_admin_operation(
lambda: self.client.post(f'/api/v1/admin/invoice/{gen_id}/item/new')
)
res = self.client.post(f'/api/v1/admin/invoice/{gen_id}/item/new',
json={'invoice_id': gen_id, 'product_id': gen_id, 'price': 10, 'quantity': 10})
self.assertTrue(res.status_code, 200)
def test_get_orders(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
order = Order(id=gen_id,
user=self.user,
country_id='c1',
shipping_method_id=1)
suborder = Suborder(order=order)
self.try_add_entities([
order, suborder,
OrderProduct(id=10,
suborder=suborder,
product_id='0000',
price=10,
quantity=10)
])
res = self.try_user_operation(lambda: self.client.get('/api/v1/order'))
self.assertEqual(res.json[0]['total'], 2700)
def test_get_old_invoice(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
self.try_add_entities([
Product(id=gen_id, name='Product 1', weight=10),
Invoice(id=gen_id,
country_id='c1',
when_created=datetime(2020, 1, 1, 1, 0, 0),
when_changed=datetime(2020, 1, 1, 1, 0, 0)),
Order(id=gen_id, invoice_id=gen_id, country_id='c1')
])
suborder = Suborder(order_id=gen_id)
self.try_add_entities([
suborder,
OrderProduct(suborder=suborder, product_id=gen_id, price=10, quantity=1)
])
res = self.try_admin_operation(
lambda: self.client.get(f'/api/v1/admin/invoice/{gen_id}'))
self.assertEqual(res.status_code, 200)
self.assertEqual(len(res.json), 1)
self.assertEqual(res.json[0], {
'address': None,
'country': 'country1',
'customer': None,
'payee': None,
'id': gen_id,
'invoice_items': [{
'id': 1,
'invoice_id': gen_id,
'product_id': gen_id,
'product': 'Product 1',
'price': 5.0,
'weight': 10,
'quantity': 1,
'subtotal': 5.0,
'when_created': None,
'when_changed': None
}],
'orders': [gen_id],
'phone': None,
'total': 5.0,
'weight': 10,
'when_changed': '2020-01-01 01:00:00',
'when_created': '2020-01-01 01:00:00'
})
def add_order_product(suborder, item, errors):
# with db.session.no_autoflush:
try:
product = Product.get_product_by_id(item['item_code'])
if product:
order_product = OrderProduct(suborder=suborder,
product=product,
price=product.price,
quantity=int(item['quantity']),
status=OrderProductStatus.pending)
# db.session.add(order_product)
suborder.order_products.append(order_product)
suborder.order.total_weight += product.weight * order_product.quantity
suborder.order.subtotal_krw += product.price * order_product.quantity
return order_product
raise ProductNotFoundError(item['item_code'])
except Exception as ex:
errors.append(ex.args)
raise ex
def test_delete_invoice_item(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
order = Order(id=gen_id)
self.try_add_entities([
Product(id=gen_id, name='Product 1')
])
self.try_add_entities([
order,
Suborder(id=gen_id, order=order),
OrderProduct(suborder_id=gen_id, product_id=gen_id, price=10, quantity=10),
Invoice(id=gen_id, order_id=gen_id),
InvoiceItem(id=10, invoice_id=gen_id, product_id=gen_id, price=10,
quantity=10)
])
res = self.try_admin_operation(
lambda: self.client.delete(f'/api/v1/admin/invoice/{gen_id}/item/10')
)
self.assertEqual(res.status_code, 200)
invoice_item = InvoiceItem.query.get(10)
self.assertEqual(invoice_item, None)
def test_increase_order_amount_over_free_shipping_threshold(self):
order = Order(user=self.user)
subcustomer = Subcustomer(name='A000', username='******')
suborder = Suborder(order=order, subcustomer=subcustomer)
self.try_add_entities([
order, suborder, subcustomer,
OrderProduct(suborder=suborder,
product_id='0000',
price=10,
quantity=10)
])
res = self.try_admin_operation(
admin_only=True,
operation=lambda: self.client.post(
f'/api/v1/order/{order.id}',
json={
'address':
'Address1',
'country':
'c1',
'customer_name':
"Customer1",
'phone':
'1',
'zip':
'1',
'shipping':
'999',
'suborders':
[{
'subcustomer': 'A000',
'seq_num': 1,
'items': [{
'item_code': '0000',
'quantity': 3000
}]
}]
}))
self.assertEqual(res.status_code, 200)
order = Order.query.get(order.id)
self.assertEqual(order.total_krw, 30000)
def test_save_order_product(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
op_id = datetime.now().microsecond
order = Order(id=gen_id, user=self.user)
suborder = Suborder(id=op_id, order=order)
self.try_add_entities([
order, suborder,
OrderProduct(id=op_id,
suborder_id=op_id,
product_id='0000',
price=10,
quantity=10,
status='pending')
])
res = self.try_admin_operation(lambda: self.client.post(
f'/api/v1/admin/order/product/{op_id}', json={'quantity': 100}))
self.assertEqual(res.status_code, 200)
self.assertEqual(res.json['quantity'], 100)
res = self.client.get(f'/api/v1/admin/order/{gen_id}')
self.assertTrue(res.json['total_krw'], 1010)
def test_create_invoice(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
id_prefix = datetime.now().strftime('INV-%Y-%m-')
self.try_add_entities([
Product(id=gen_id, name='Product 1', price=1)
])
order = Order(id=gen_id)
suborder = Suborder(order=order)
self.try_add_entities([
order, suborder,
OrderProduct(suborder=suborder, product_id=gen_id, quantity=1, price=1)
])
res = self.try_admin_operation(
lambda: self.client.post('/api/v1/admin/invoice/new/0.5',
json={
'order_ids': [gen_id]
})
)
self.assertEqual(res.json['invoice_id'], f'{id_prefix}0001')
invoice = Invoice.query.get(res.json['invoice_id'])
self.assertEqual(len(invoice.orders), 1)
self.assertEqual(invoice.invoice_items_count, 2)
def test_get_order(self):
gen_id = f'{__name__}-{int(datetime.now().timestamp())}'
order = Order(id=gen_id, user=self.user)
suborder = Suborder(order=order)
self.try_add_entities([Product(id=gen_id, price=10, weight=10)])
self.try_add_entities([
order, suborder,
OrderProduct(suborder=suborder,
product_id=gen_id,
price=10,
quantity=10),
Order(id=gen_id + '1', user=self.user, status=OrderStatus.pending)
])
res = self.try_user_operation(
lambda: self.client.get(f'/api/v1/order/{gen_id}'))
self.assertEqual(res.json['total'], 2600)
self.assertEqual(res.json['total_rur'], 1300.0)
self.assertEqual(res.json['total_usd'], 1300.0)
self.assertEqual(res.json['user'], self.user.username)
self.assertEqual(len(res.json['order_products']), 1)
res = self.client.get('/api/v1/order')
self.assertEqual(len(res.json), 2)
res = self.client.get('/api/v1/order?status=pending')
self.assertEqual(res.json[0]['status'], 'pending')
def test_postponed_orders(self):
postpone_shipping = PostponeShipping()
postponed_order = Order(shipping=postpone_shipping,
user=self.user,
status=OrderStatus.pending)
suborder = Suborder(order=postponed_order)
self.try_add_entities([
postpone_shipping, postponed_order, suborder,
OrderProduct(suborder=suborder,
product_id='0000',
price=10,
quantity=10)
])
postponed_order1 = Order(shipping=postpone_shipping,
user=self.user,
status=OrderStatus.pending)
suborder1 = Suborder(order=postponed_order1)
self.try_add_entities([
postponed_order1, suborder1,
OrderProduct(suborder=suborder1,
product_id='0000',
price=10,
quantity=10)
])
postponed_order.update_total()
postponed_order1.update_total()
res = self.try_admin_operation(
admin_only=True,
operation=lambda: self.client.post(
'/api/v1/order',
json={
"customer_name":
"User1",
"address":
"Address1",
"country":
"c1",
'zip':
'0000',
"shipping":
"1",
"phone":
"1",
"comment":
"",
"suborders": [{
"subcustomer":
"A000, Subcustomer1, P@ssw0rd",
"items": [{
"item_code": "0000",
"quantity": "100"
}]
}],
"attached_orders": [postponed_order.id]
}))
self.assertEqual(res.status_code, 200)
order = Order.query.get(res.json['order_id'])
self.assertEqual(order.attached_orders.count(), 1)
self.assertEqual(order.shipping_krw, 200)
self.assertEqual(order.total_krw, 3700)
res = self.client.post(f'/api/v1/order/{order.id}',
json={
'address':
'Address1',
'country':
'c1',
'customer_name':
"User1",
'phone':
'1',
'zip':
'0000',
'shipping':
'1',
"attached_orders":
[postponed_order.id, postponed_order1.id],
"suborders": [{
"subcustomer":
"A000, Subcustomer1, P@ssw0rd",
"items": [{
"item_code": "0000",
"quantity": "100"
}]
}]
})
self.assertEqual(order.attached_orders.count(), 2)
self.assertEqual(order.shipping_krw, 200)
self.assertEqual(order.total_krw, 3700)
