def test_404_delete_nonexistent_order(self):
'''
create and insert customer and item to be included in mock order.
insert mock order, assign mock order's id to variable<br>
and then delete mock order prior to the test to ensure<br>
that order pending delete does not exist
'''
customer = Customer(name='test_name', email='test_email')
item = Item(name='test_name', brand='test_brand', price=1)
customer.insert()
item.insert()
mock_order = Orders(customer_id=customer.id,
item_id=item.id,
quantity=1)
mock_order.insert()
nonexistent_order_id = mock_order.id
mock_order.delete()
# after mock order is deleted delete customer and item too
customer.delete()
item.delete()
# attempt to delete nonexistent order
res = self.client().delete(
'/delete_order/{}'.format(nonexistent_order_id),
headers=manager_jwt)
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertFalse(data['success'])
def test_422_submit_order_with_unavailable_item(self):
# create and insert customer to be included in order
customer = Customer(name='test_name', email='test_email')
# create and insert item that is unavailable to be included in order
unavailable_item = Item(name='unavailable item',
brand='unavailable brand',
price=100,
available=False)
customer.insert()
unavailable_item.insert()
# attempt to submit order with unavailable item
res = self.client().post('/submit_order',
headers=manager_jwt,
json={
'customer_id': customer.id,
'item_id': unavailable_item.id,
'quantity': 5
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertFalse(data['success'])
# delete customer and item after test is completed
customer.delete()
unavailable_item.delete()
def test_delete_order(self):
# create customer, item and order and insert into<br>
# database pending deletion request
customer = Customer(name=self.new_customer['name'],
email=self.new_customer['email'])
customer.insert()
item = Item(name=self.new_item['name'],
brand=self.new_item['brand'],
price=self.new_item['price'])
item.insert()
order = Orders(customer_id=customer.id, item_id=item.id, quantity=10)
order.insert()
# assign order id to variable prior to deletion for testing purposes
order_id = order.id
# delete order that was currently created
res = self.client().delete('/delete_order/{}'.format(order.id),
headers=manager_jwt)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
# verify that deleted order id matched id included in request
self.assertEqual(data['deleted_order_id'], order_id)
self.assertEqual(data['current_orders'], (data['previous_orders'] - 1))
# delete customer and item
customer.delete()
item.delete()
def test_submit_order(self):
# create a customer to be inserted into database
customer = Customer(name=self.new_customer['name'],
email=self.new_customer['email'])
customer.insert()
# create an item to be inserted into database
item = Item(name=self.new_item['name'],
brand=self.new_item['brand'],
price=self.new_item['price'])
item.insert()
'''
assign the created customer and item id's to the created order.<br>
The created customer and order were implemented to esure that<br>
the tests are self sufficient in order to provide a<br>
predictable outcome and confirm that the units being tested do exist.
'''
res = self.client().post('/submit_order',
headers=manager_jwt,
json={
'customer_id': customer.id,
'item_id': item.id,
'quantity': 10
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
self.assertTrue(data['order_id'])
order = Orders.query.filter_by(id=data['order_id']).one_or_none()
# after tests are passed delete all mock data(order, customer, item)
order.delete()
customer.delete()
item.delete()
def delete(self):
try:
Customer.get(email_address=self.email)
customer = Customer.delete().where(
Customer.email_address == self.email)
customer.execute()
return {"message": "Customer deleted successfully"}
except DoesNotExist:
return {"message": "Customer does not exist"}
def test_update_customer(self):
# create customer to updated
customer = Customer(name=self.new_customer['name'],
email=self.new_customer['email'])
# insert customer to database
customer.insert()
# send request to update customer that was just<br>
# entered into database
res = self.client().patch('/update_customer/{}'.format(customer.id),
headers=manager_jwt,
json={'name': 'updated name'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(data['customer_name'], 'updated name')
# delete customer after test
customer.delete()
def test_404_delete_non_existent_customer(self):
'''
insert mock customer, assign mock customer's id to variable and<br>
then delete mock customer prior to the test to ensure that<br>
customer pending delete does not exist
'''
mock_customer = Customer(name='test_name', email='test_email')
mock_customer.insert()
nonexistent_customer_id = mock_customer.id
mock_customer.delete()
# send request to delete nonexistent customer
res = self.client().delete(
'/delete_customer/{}'.format(nonexistent_customer_id),
headers=manager_jwt)
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertFalse(data['success'])
