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_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 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_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 _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_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_find_order_by_product(self):
""" Find an Order by Product ID """
uuid_str = str(uuid.uuid4())
Order(uuid=uuid_str, product_id=1, customer_id=1, price=10,
quantity=1).save()
next_order = Order(uuid="2edf8761-0c1f-4039-9f5c-907a5a03f39c",
product_id=2,
customer_id=1,
price=10,
quantity=1)
next_order.save()
order = Order.find_by_product(2)[0]
self.assertIsNot(order, None)
self.assertEqual(order.id, next_order.id)
self.assertEqual(order.uuid, "2edf8761-0c1f-4039-9f5c-907a5a03f39c")
self.assertEqual(order.product_id, 2),
self.assertEqual(order.customer_id, 1),
self.assertEqual(order.price, 10),
self.assertEqual(order.quantity, 1)
def test_find_or_404_found(self):
""" Find or return 404 found """
uuid_str = str(uuid.uuid4())
Order(uuid=uuid_str, product_id=1, customer_id=1, price=10,
quantity=1).save()
next_order = Order(uuid="2edf8761-0c1f-4039-9f5c-907a5a03f39c",
product_id=1,
customer_id=1,
price=10,
quantity=1)
next_order.save()
order = Order.find_or_404(next_order.id)
self.assertIsNot(order, None)
self.assertEqual(order.id, next_order.id)
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_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 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 post(self):
"""
Creates an Order
This endpoint will create an Order based the data in the body that is posted
"""
app.logger.info('Request to create an order')
check_content_type('application/json')
order = Order()
order.deserialize(request.get_json())
order.save()
message = order.serialize()
location_url = api.url_for(OrderCollection, order_id=order.id, _external=True)
return order.serialize(), status.HTTP_201_CREATED, {'Location': location_url }
def test_update_an_order(self):
""" Update an existing Order """
order_item1 = OrderItem(product_id=1, quantity=1, price=5, status="PLACED")
order_items = [order_item1]
order = Order(customer_id=111, order_items=order_items)
order.create()
self.assertTrue(order.id is not None)
order.customer_id = 234
order.update()
new_order = Order.find(order.id)
self.assertEqual(new_order.id, order.id)
self.assertEqual(new_order.customer_id, 234)
def order_post():
"""
Creates an order
This endpoint will create an order based the data in the body that is posted
"""
app.logger.info('Request to create an order')
check_content_type('application/json')
order = Order()
order.deserialize(request.get_json())
order.save()
message = order.serialize()
location_url = url_for('get_orders', order_id=order.id, _external=True)
return make_response(jsonify(message), status.HTTP_201_CREATED,
{'Location': location_url})
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 test_create_a_order(self):
""" Create a order and assert that it exists """
uuid_str = str(uuid.uuid4())
order = Order(uuid=uuid_str,
product_id=1,
customer_id=1,
price=10,
quantity=1)
self.assertTrue(order != None)
self.assertEqual(order.id, None)
self.assertEqual(order.uuid, uuid_str)
self.assertEqual(order.product_id, 1)
self.assertEqual(order.customer_id, 1)
self.assertEqual(order.price, 10)
self.assertEqual(order.quantity, 1)
def create_orders():
"""
Creates an Order
This endpoint will create an Order based the data in the body that is posted
"""
app.logger.info("Request to create an Order") # pylint: disable=maybe-no-member
app.logger.info(request.get_json()) # pylint: disable=maybe-no-member
check_content_type("application/json")
order = Order()
order.deserialize(request.get_json())
order.create()
message = order.serialize()
location_url = url_for("get_orders", order_id=order.id, _external=True)
return make_response(jsonify(message), status.HTTP_201_CREATED,
{"Location": location_url})
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_add_a_order(self):
""" Create a order and add it to the database """
orders = Order.all()
self.assertEqual(orders, [])
uuid_str = str(uuid.uuid4())
order = Order(uuid=uuid_str,
product_id=1,
customer_id=1,
price=10,
quantity=1)
self.assertTrue(order != None)
self.assertEqual(order.id, None)
order.save()
# Asert 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_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 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 test_update_a_order(self):
""" Update 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(order.id, 1)
# Change it an save it
order.product_id = 2
order.save()
self.assertEqual(order.id, 1)
# Fetch it back and make sure the id hasn't changed
# but the data did change
orders = Order.all()
self.assertEqual(len(orders), 1)
self.assertEqual(orders[0].product_id, 2)
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_serialize_a_order(self):
""" Test serialization of an Order """
uuid_str = str(uuid.uuid4())
order = Order(uuid=uuid_str,
product_id=1,
customer_id=1,
price=10,
quantity=1)
data = order.serialize()
self.assertNotEqual(data, None)
self.assertIn('id', data)
self.assertEqual(data['id'], None)
self.assertIn('uuid', data)
self.assertEqual(data['uuid'], uuid_str)
self.assertIn('product_id', data)
self.assertEqual(data['product_id'], 1)
self.assertIn('customer_id', data)
self.assertEqual(data['customer_id'], 1)
self.assertIn('price', data)
self.assertEqual(data['price'], 10)
self.assertIn('quantity', data)
self.assertEqual(data['quantity'], 1)
def test_repr(self):
""" Create an order and test it's repr """
order = Order(id=1, customer_id=123)
self.assertEqual(order.__repr__(), "<Order 1>")
def test_update_order_with_no_order_items(self):
""" Update an order with no order items"""
order = Order(id=1, customer_id=123)
self.assertRaises(DataValidationError, order.update)
def test_deserialize_bad_data(self):
""" Test deserialization of bad data """
data = "this is not a dictionary"
order = Order()
self.assertRaises(DataValidationError, order.deserialize, data)
def test_create_order_with_no_item(self):
""" Create an order with no items in the database """
order_items = []
order = Order(customer_id=123, order_items=order_items)
self.assertRaises(DataValidationError, order.create)
def test_create_order_with_no_customer_id(self):
""" Create an order with no customer id """
order_item = OrderItem(product_id=1, quantity=1, price=5, status="PLACED")
order_items = [order_item]
order = Order(order_items=order_items)
self.assertRaises(DataValidationError, order.create)
def test_repr_with_no_item_id(self):
""" Create an order and test it's repr with no item id """
order = Order(customer_id=123)
self.assertEqual(order.__repr__(), "<Order None>")