def setUpClass(cls):
""" This runs once before the entire test suite """
app.config['TESTING'] = True
app.config['DEBUG'] = False
app.config["SQLALCHEMY_DATABASE_URI"] = DATABASE_URI
app.logger.setLevel(logging.CRITICAL) # pylint: disable=maybe-no-member
Order.init_db(app)
def test_update_an_order_not_exists(self):
""" Update a non-existing Order """
order_item1 = OrderItem(product_id=1, quantity=1, price=5, status="PLACED")
order_items = [order_item1]
order = Order(id=1234567, customer_id=111, order_items=order_items)
order.update()
self.assertRaises(DataValidationError)
def test_update_order_product(self):
"""" Update an orders product """
orders = Order.all()
self.assertEqual(orders, [])
product = self._create_product()
order = self._create_order(products=[product])
order.create()
# Assert that it was assigned an id and shows up in the database
self.assertEqual(order.id, 1)
orders = Order.all()
self.assertEqual(len(orders), 1)
# Fetch it back
order = Order.find(order.id)
old_product = order.products[0]
self.assertEqual(old_product.price, product.price)
old_product.price = 1
order.save()
# Fetch it back again
order = Order.find(order.id)
product = order.products[0]
self.assertEqual(product.price, 1)
def test_add_a_order(self):
""" Create an order and add it to the database """
orders = Order.all()
self.assertEqual(orders, [])
order = self._create_order()
order.create()
# Assert that it was assigned an id and shows up in the database
self.assertEqual(order.id, 1)
orders = Order.all()
self.assertEqual(len(orders), 1)
def test_deserialize_an_order(self):
""" Deserialize an order """
product = self._create_product()
order = self._create_order(products=[product])
serial_order = order.serialize()
new_order = Order()
new_order.deserialize(serial_order)
self.assertEqual(new_order.id, order.id)
self.assertEqual(new_order.name, order.name)
self.assertEqual(new_order.status, order.status)
def test_find_order(self):
""" Find an Order by ID """
order_items1 = [OrderItem(product_id=1, quantity=1, price=5, status="PLACED")]
order1 = Order(customer_id=111, order_items=order_items1)
order1.create()
order = Order.find(order1.id)
self.assertIsNot(order, None)
self.assertEqual(order.id, order1.id)
self.assertEqual(order.customer_id, 111)
self.assertEqual(len(order.order_items), 1)
self.assertEqual(order.order_items[0].product_id, 1)
def list_orders():
""" Returns all of the Orders """
app.logger.info("Request for orders list") # pylint: disable=maybe-no-member
orders = []
name = request.args.get("name")
if name:
orders = Order.find_by_name(name)
else:
orders = Order.all()
results = [order.serialize() for order in orders]
return make_response(jsonify(results), status.HTTP_200_OK)
def delete_all_orders():
""" Returns IDs of the Orders """
app.logger.info("Request for Order list")
orders = []
id = request.args.get("id")
if id:
orders = Order.find(id)
else:
orders = Order.all()
results = [order.delete() for order in orders]
return make_response("", status.HTTP_204_NO_CONTENT)
def test_update_order(self):
""" Update an order """
order = self._create_order()
order.create()
# Assert that it was assigned an id and shows up in the database
self.assertEqual(order.id, 1)
# Fetch it back
order = Order.find(order.id)
order.status = "Cancelled"
order.save()
# Fetch it back again
order = Order.find(order.id)
self.assertEqual(order.status, "Cancelled")
def test_delete_an_order(self):
""" Delete an order from the database """
orders = Order.all()
self.assertEqual(orders, [])
order = self._create_order()
order.create()
# Assert that it was assigned an id and shows up in the database
self.assertEqual(order.id, 1)
orders = Order.all()
self.assertEqual(len(orders), 1)
order = orders[0]
order.delete()
orders = Order.all()
self.assertEqual(len(orders), 0)
def test_create_order(self):
""" Create an order with a single item in the database """
order_item = OrderItem(product_id=1, quantity=1, price=5, status="PLACED")
order_items = [order_item]
order = Order(customer_id=123, order_items=order_items)
self.assertTrue(order is not None)
self.assertEqual(order.id, None)
self.assertEqual(len(order.order_items), 1)
self.assertEqual(order.order_items[0].item_id, None)
order.create()
self.assertEqual(order.id, 1)
self.assertEqual(order.customer_id, 123)
self.assertEqual(len(order.order_items), 1)
self.assertEqual(order.order_items[0].item_id, 1)
self.assertEqual(order.order_items[0].order_id, 1)
def list_all_orders():
""" Returns all of the Orders """
app.logger.info('Request for order list')
orders = Order.all()
results = [order.serialize() for order in orders]
return make_response(jsonify(results), status.HTTP_200_OK)
def test_create_order_with_multiple_items(self):
""" Create an order with multiple order items """
order_item1 = OrderItem(product_id=1, quantity=1, price=5, status="PLACED")
order_item2 = OrderItem(product_id=2, quantity=1, price=5, status="PLACED")
order_items = [order_item1, order_item2]
order = Order(customer_id=123, order_items=order_items)
order.create()
self.assertTrue(order.id is not None)
order_id = order.id
self.assertEqual(order.customer_id, 123)
self.assertEqual(len(order.order_items), 2)
i = order.order_items[0].item_id
for j in range(0, len(order.order_items)):
self.assertEqual(order.order_items[j].item_id, i)
self.assertEqual(order.order_items[j].order_id, order_id)
i += 1
def test_delete_an_order(self):
""" Delete an Order """
order_items1 = [OrderItem(product_id=1, quantity=1, price=5.0, status="PLACED")]
order = Order(customer_id=111, order_items=order_items1)
order.create()
self.assertEqual(len(Order.all()), 1)
# delete the order and make sure it isn't in the database
order.delete()
self.assertEqual(len(Order.all()), 0)
def test_serialize_an_order(self):
""" Serialization of an Order """
date = datetime.now
order_item = OrderItem(product_id=1, quantity=1, price=5, status="PLACED")
order_item2 = OrderItem(product_id=2, quantity=1, price=5, status="PLACED")
order_items = [order_item, order_item2]
order = Order(customer_id=123, created_date=date, order_items=order_items)
data = order.serialize()
self.assertNotEqual(data, None)
self.assertIn("id", data)
self.assertEqual(data["id"], None)
self.assertIn("customer_id", data)
self.assertEqual(data["customer_id"], 123)
self.assertIn("created_date", data)
self.assertEqual(data["created_date"], date)
self.assertIn("order_items", data)
self.assertEqual(data["order_items"], [order_item.serialize(), order_item2.serialize()])
def get_orders(order_id):
"""
Retrieve a single Order
This endpoint will return an Order based on it's id
"""
app.logger.info("Request for Order with id: %s", order_id)
order = Order.find_or_404(order_id)
return make_response(jsonify(order.serialize()), status.HTTP_200_OK)
def test_create_an_order(self):
""" Create a Order and assert that it exists """
fake_order = OrderFactory()
order = Order(name=fake_order.name, status=fake_order.status)
self.assertTrue(order is not None)
self.assertEqual(order.id, None)
self.assertEqual(order.name, fake_order.name)
self.assertEqual(order.status, fake_order.status)
def test_init_order(self):
""" Initialize an order and assert that it exists """
order_items = [OrderItem(product_id=1, quantity=1, price=5, status="PLACED")]
order = Order(customer_id=123, order_items=order_items)
self.assertTrue(order is not None)
self.assertEqual(order.id, None)
self.assertEqual(order.customer_id, 123)
self.assertEqual(len(order.order_items), 1)
def list_orders(product_id):
""" Returns all of the Orders """
app.logger.info('Request for order list')
orders = []
if product_id:
orders = Order.find_by_product(product_id)
results = [order.serialize() for order in orders]
return make_response(jsonify(results), status.HTTP_200_OK)
def test_find_by_name(self):
""" Find by name """
order = self._create_order()
order.create()
# Fetch it back by name
same_order = Order.find_by_name(order.name)[0]
self.assertEqual(same_order.id, order.id)
self.assertEqual(same_order.name, order.name)
def _create_order(self, products=[]):
""" Creates an order from a Factory """
fake_order = OrderFactory()
order = Order(
name=fake_order.name, status=fake_order.status, products=products
)
self.assertTrue(order is not None)
self.assertEqual(order.id, None)
return order
def test_deserialize_an_order(self):
""" Deserialization of an Order """
data = {"customer_id": 123,
"order_items": [
{"product_id": 1,
"quantity": 1,
"price": 5,
"status": "PLACED"}
]}
order = Order()
order.deserialize(data)
self.assertNotEqual(order, None)
self.assertEqual(order.id, None)
self.assertEqual(order.customer_id, 123)
self.assertEqual(order.created_date, None)
self.assertEqual(len(order.order_items), 1)
self.assertEqual(order.order_items[0].item_id, None)
self.assertEqual(order.order_items[0].product_id, 1)
def delete_orders(order_id):
"""
Delete an Order
This endpoint will delete an Order based the id specified in the path
"""
app.logger.info("Request to delete order with id: %s", order_id) # pylint: disable=maybe-no-member
order = Order.find(order_id)
if order:
order.delete()
return make_response("", status.HTTP_204_NO_CONTENT)
def test_find_or_404(self):
""" Find or throw 404 error """
order = self._create_order()
order.create()
# Assert that it was assigned an id and shows up in the database
self.assertEqual(order.id, 1)
# Fetch it back
order = Order.find_or_404(order.id)
self.assertEqual(order.id, 1)
def delete(self, order_id):
"""
Delete an Order
This endpoint will delete an Order based the body that is posted
"""
app.logger.info('Request to delete an order with id: %s', order_id)
order = Order.find(order_id)
if order:
order.delete()
return make_response('', status.HTTP_204_NO_CONTENT)
def test_deserialize_bad_data_with_keys_missing(self):
""" Deserialization of bad order data with few keys missing """
data = {"order_items": [{
"product_id": 1,
"quantity": 1,
"price": 5,
"status": "PLACED"
}]}
order = Order()
self.assertRaises(DataValidationError, order.deserialize, data)
def test_deserialize_a_order(self):
""" Test deserialization of an Order """
data = {
"uuid": "2edf8761-0c1f-4039-9f5c-907a5a03f39c",
"product_id": 1,
"customer_id": 1,
"price": 10,
"quantity": 1,
"status": "In Progress"
}
order = Order()
order.deserialize(data)
self.assertNotEqual(order, None)
self.assertEqual(order.id, None)
self.assertEqual(order.uuid, "2edf8761-0c1f-4039-9f5c-907a5a03f39c"),
self.assertEqual(order.product_id, 1),
self.assertEqual(order.customer_id, 1),
self.assertEqual(order.price, 10),
self.assertEqual(order.quantity, 1)
def test_delete_a_order(self):
""" Delete an Order """
uuid_str = str(uuid.uuid4())
order = Order(uuid=uuid_str,
product_id=1,
customer_id=1,
price=10,
quantity=1)
order.save()
self.assertEqual(len(Order.all()), 1)
# delete the order and make sure it isn't in the database
order.delete()
self.assertEqual(len(Order.all()), 0)
def get_orders(order_id):
"""
Retrieve an order
This endpoint will return an order based on it's id
"""
app.logger.info('Request for an order with id: %s', order_id)
order = Order.find(order_id)
if not order:
raise NotFound("Order with id '{}' was not found.".format(order_id))
return make_response(jsonify(order.serialize()), status.HTTP_200_OK)
def delete_orders(order_id):
"""
Delete an Order
This endpoint will delete an Order based the id specified in the path
"""
app.logger.info('Request to delete an order with id: %s', order_id)
order = Order.find(order_id)
if order:
order.delete()
return make_response('', status.HTTP_204_NO_CONTENT)
