def show_order_summary(self):
items = {}
invalid_character = False
for row in range(0, self.max_row_count):
if not self.tableWidget.item(row, 2).text().isdigit():
invalid_character = True
QMessageBox.information(self, "Error",
"Please enter a whole number")
break
else:
qty = int(self.tableWidget.item(row, 2).text())
name = self.entries[row][0]
if not qty == 0:
if self.order == None:
items[name] = qty
else:
self.order.set_qty(name, qty)
elif self.order != None and self.order.items.keys().count(
name) == 1:
self.order.remove_item(name)
if self.order == None:
self.order = Order(self.menu, items,
self.database.order_number)
if not invalid_character:
self.hide()
self.window = OrderSummary(self.customer, self.database,
self.order)
self.window.show()
def test_get_discount_when_discount_applies(self):
order = Order()
products = ['VOUCHER', 'TSHIRT', 'VOUCHER']
for product in products:
order.add_product(product)
discount = TwoForOneDiscount('VOUCHER')
assert discount.get_discount(order) == 5.0
def test_order_drink_can_invalid(os):
# ===== ORDERS DRINKS UNTIL NEXT ORDER WILL BE INVALID =====
x = 1
pepsi_q = drink_quantity("pepsi", "can")
end = pepsi_q
while x <= pepsi_q:
orderx = Order()
orderx.add_drink(Drink("pepsi", "can", 1))
assert orderx.calculate_price() == 2
assert os.add_order(orderx) == True
assert drink_quantity("pepsi", "can") == pepsi_q - x
x += 1
assert len(os._orders) == end
# ===== MAKES A NEW ORDER =====
invalid_order = Order()
invalid_order.add_drink(Drink("pepsi", "can", 1))
assert invalid_order.calculate_price() == 2
# ===== MAKES SURE THE ERROR IS CATCHED AND THE CORRECT MESSAGE IS DISPLAYED=====
try:
os.add_order(invalid_order)
assert False
except Exception as err:
assert str(err) == "Not enough ingredients available."
assert True
# ASSERT THAT LENGTH IS SAME AS BEFORE SHOWING THAT ORDER WASN'T ADDED
assert len(os._orders) == end
def new_order(self, id):
new_order = Order()
new_order.set_ID(id)
self._orders.append(new_order)
return new_order
def test_order_fries_invalid(os):
# ===== ORDERS FRIES UNTIL NEXT ORDER WILL BE INVALID =====
friesQ = side_quantity(Fries(""))
end = friesQ / 640
x = 0
iterate = friesQ - 640
if friesQ % 640 == 0:
iterate = friesQ
while x < iterate:
orderx = Order()
orderx.add_side(Fries("large"))
assert orderx.calculate_price() == 3.50
assert os.add_order(orderx) == True
x += 640
assert len(os._orders) == int(end)
# ===== MAKES A NEW ORDER =====
invalid_order = Order()
invalid_order.add_side(Fries("large"))
assert invalid_order.calculate_price() == 3.5
# ===== MAKES SURE THE ERROR IS CATCHED AND THE CORRECT MESSAGE IS DISPLAYED=====
try:
os.add_order(invalid_order)
assert False
except Exception as err:
assert str(err) == "Not enough ingredients available."
assert True
# ASSERT THAT LENGTH IS SAME AS BEFORE SHOWING THAT ORDER WASN'T ADDED
assert len(os._orders) == int(end)
def test_order_drinks_invalid(os):
# ===== ORDERS DRINKS UNTIL NEXT ORDER WILL BE INVALID =====
orange_q = drink_quantity("orange juice", "")
end = orange_q / 640
x = 1
while x < orange_q - 640:
orderx = Order()
orderx.add_drink(Drink("orange juice", "large", 640))
assert orderx.calculate_price() == 2.95
assert os.add_order(orderx) == True
x += 640
assert len(os._orders) == int(end)
# ===== MAKES A NEW ORDER =====
invalid_order = Order()
invalid_order.add_drink(Drink("orange juice", "large", 640))
assert invalid_order.calculate_price() == 2.95
# ===== MAKES SURE THE ERROR IS CATCHED AND THE CORRECT MESSAGE IS DISPLAYED=====
try:
os.add_order(invalid_order)
assert False
except Exception as err:
assert str(err) == "Not enough ingredients available."
assert True
# ASSERT LENGTH OF ORDERS IS THE SAME - NO ORDER WAS ADDED
assert len(os._orders) == int(end)
def test_order_invalid_nuggets(os):
# ===== ORDERS NUGGETS UNTIL NEXT ORDER WILL BE INVALID =====
x = 0
nuggetq = side_quantity(Nuggets(6))
end = nuggetq / 6
iterate = nuggetq - 6
if nuggetq % 6 == 0:
iterate = nuggetq
while x < iterate:
orderx = Order()
orderx.add_side(Nuggets(6))
assert orderx.calculate_price() == 4.50
assert os.add_order(orderx) == True
x += 6
assert len(os._orders) == int(end)
# ===== MAKES A NEW ORDER =====
invalid_order = Order()
invalid_order.add_side(Nuggets(6))
assert invalid_order.calculate_price() == 4.50
# ===== MAKES SURE THE ERROR IS CATCHED AND THE CORRECT MESSAGE IS DISPLAYED=====
try:
os.add_order(invalid_order)
assert False
except Exception as err:
assert str(err) == "Not enough ingredients available."
assert True
# ASSERT THAT LENGTH IS SAME AS BEFORE SHOWING THAT ORDER WASN'T ADDED
assert len(os._orders) == int(end)
def test_invalid_order_main(os):
# ===== ORDERS A BURGER WITH TOO MANY BUNS =====
b_ingres = []
x1 = Ingredient("sesame", "bun", "sesame bun", 1000, 1.5)
x2 = Ingredient("lettuce", "vegetable", 2, 0.5)
b_ingres.append(x1)
b_ingres.append(x2)
order1 = Order()
bunQ = ing_quantity("sesame", "bun")
m1 = Main("Burger", b_ingres)
order1.add_main(m1)
# ===== MAKES SURE THE ERROR IS CATCHED AND THE CORRECT MESSAGE IS DISPLAYED =====
try:
os.add_order(order1)
assert False
except Exception as err:
assert str(err) == "Not enough ingredients available."
assert True
# ===== MAKE SURE INVENTORY WASN'T UPDATED =====
assert ing_quantity("sesame", "bun") == bunQ
# ASSERT NO ORDER LOGGED
assert len(os._orders) == 0
def test_get_discount_when_discount_applies(self):
order = Order()
products = ['TSHIRT', 'TSHIRT', 'TSHIRT', 'VOUCHER', 'TSHIRT']
for product in products:
order.add_product(product)
discount = BulkPurchaseDiscount('TSHIRT', 3, 1.00)
assert discount.get_discount(order) == 4.0
def test_add_main_success():
o = Order()
o.add_main(burger)
assert len(o) == 1
assert len(o.mains) == 1
assert len(o.others) == 0
assert o.total_price == 44
def test_order_drink_bottle_invalid(os):
# ===== ORDERS DRINKS UNTIL NEXT ORDER WILL BE INVALID =====
x = 1
sprite_q = drink_quantity("sprite", "bottle")
end = sprite_q
while x <= sprite_q:
orderx = Order()
orderx.add_drink(Drink("sprite", "bottle", 1))
assert orderx.calculate_price() == 3
assert os.add_order(orderx) == True
assert drink_quantity("sprite", "bottle") == sprite_q - x
x += 1
assert len(os._orders) == end
# ===== MAKES A NEW ORDER =====
invalid_order = Order()
invalid_order.add_drink(Drink("sprite", "bottle", 1))
assert invalid_order.calculate_price() == 3
# ===== MAKES SURE THE ERROR IS CATCHED AND THE CORRECT MESSAGE IS DISPLAYED=====
try:
os.add_order(invalid_order)
assert False
except Exception as err:
assert str(err) == "Not enough ingredients available."
assert True
# ASSERT LENGTH IS THE SAME
assert len(os._orders) == end
def test_cancel_nuggets(os):
# ===== ORDERING 3 NUGGETS =====
order1 = Order()
originalq = nuggetq = side_quantity(Nuggets(3))
nuggetq = side_quantity(Nuggets(3))
order1.add_side(Nuggets(3))
assert order1.calculate_price() == 3
assert os.add_order(order1) == True
assert side_quantity(Nuggets(3)) == nuggetq - 3
# ===== ORDERING 6 NUGGETS =====
order2 = Order()
nuggetq = side_quantity(Nuggets(6))
order2.add_side(Nuggets(6))
assert order2.calculate_price() == 4.50
assert os.add_order(order2) == True
assert side_quantity(Nuggets(6)) == nuggetq - 6
assert len(os._orders) == 2
# ===== TESTING CANCEL ORDER UPDATES INVENTORY CORRECTLY =====
os.cancel_order(order1._order_id)
assert side_quantity(Nuggets(6)) == nuggetq - 3
os.cancel_order(order2._order_id)
assert side_quantity(Nuggets(6)) == originalq
def setUpClass(self):
self.control = BangazonControl()
self.order = Order()
self.product = Product()
self.payment_type = PaymentType()
self.product_order = ProductOrder()
self.control.set_active_customer(1)
def test_add_sidedrink():
order = Order(1)
ing = WeightIngredient(2, 'fries', 's', 2000, 60, 100, 140, 2, 2.8, 3.4)
order.add_sideDrink(ing, 2, 'l')
assert order.sideDrinks[0][0] == ing
assert order.sideDrinks[0][1] == 2
assert order.sideDrinks[0][2] == 'l'
def test_map_department_to_orders(self):
dept_to_order = {
"16": [Order("2", "1"), Order("3", "1")],
"4": [Order("3", "1")]
}
self.assertEqual(
dept_to_order.keys(),
map_department_to_orders(self.products, self.order_to_product))
class TestOrder(unittest.TestCase):
@classmethod
def setUpClass(self):
self.control = BangazonControl()
self.order = Order()
self.product = Product()
self.payment_type = PaymentType()
self.product_order = ProductOrder()
self.control.set_active_customer(1)
def test_if_order_exists_in_database(self):
payment_type_id = None
self.order.create_order_in_database(self.control.active_customer)
customer_order = self.order.retrieve_order_by_attributes(
self.control.active_customer, payment_type_id)
self.assertEqual(customer_order['customer_id'],
self.control.active_customer)
self.assertEqual(customer_order['payment_type_id'], payment_type_id)
def test_if_payment_type_can_be_created_in_database(self):
new_payment_type = self.control.create_payment_type(
self.control.active_customer, "visa", 1234567899999999)
self.payment_type.add_payment_type_to_database(new_payment_type)
retrieved_payment_type = self.payment_type.retrieve_payment_type_from_database_by_all_attributes(
new_payment_type)
self.assertEqual(new_payment_type["name"],
retrieved_payment_type['name'])
self.assertEqual(new_payment_type["account_number"],
retrieved_payment_type['account_number'])
def test_complete_order(self):
self.control.save_all_products()
self.assertIsNotNone(self.control.products)
selected_product = 1
self.control.add_product_to_order(selected_product)
active_order = self.order.make_order_active(
self.control.active_customer)
current_products_in_order = self.product_order.retrieve_products_by_active_order(
active_order)
self.assertIsNotNone(active_order)
self.assertIn(selected_product, current_products_in_order)
self.control.get_sum_of_products_for_current_order(active_order)
payment_types = self.payment_type.get_active_users_payment_types(
self.control.active_customer)
payment_type_id = 1
self.assertIsNotNone(payment_types)
self.control.update_payment_type_for_order(active_order,
payment_type_id)
closed_order = self.order.get_specific_order(active_order)
self.assertIsNotNone(closed_order)
def newOrder(self):
if not self._orders:
order = Order(0)
self._orders.append(order)
self._currOrder = order
else:
order = Order(len(self._orders))
self._orders.append(order)
self._currOrder = order
return order
def setup_method(self):
self.order = Order(1)
self.order.add_side(Side("Fries", 1, 10), 1)
self.order.add_side(Side("Cake", 3, 10), 2)
self.order.add_drink(Drink("Juice", 3, 10), 2)
self.order.add_drink(Drink("Soda", 3, 10), 1)
burger = Burger()
burger.add_ingredient(Ingredient("Patty", 1, 10), 1)
burger.add_ingredient(Ingredient("Cheese", 1, 10), 2)
self.order.add_creation(burger)
def _pay_order(self, order: Order):
print('Order: {}, total price: ${:.2f}'.format(order.order_id,
order.price))
answer = 'yes' #input('Authorise payment? (yes/no) ')
if answer.lower() == 'yes':
print('Payment authorised.', file=sys.stderr)
order.update_payment_status(True)
else:
print('Payment not authorised.', file=sys.stderr)
def load_data(self):
with open('order.dat', 'rb') as f:
self._orders = load(f)
# make id continues to count
Order.assign_id(len(self._orders))
# update id of current order
self._current_order._id = len(self._orders)
print(self._orders)
with open('inv.dat', 'rb') as f:
self._inventory = load(f)
def test_update_pizzas():
order = Order(1, [['pepperoni', 'medium', ['olives', 'chicken']]],
[['pepsi', 'small']])
order.update_pizzas([['vegetarian', 'small', ['beef']]])
assert order.get_pizzas()[0].get_type() == 'vegetarian'
assert order.get_pizzas()[0].get_size() == 'small'
assert order.get_pizzas()[0].get_toppings() == ['beef']
order.update_pizzas([['margherita', 'medium', ['tomatoes', 'olives']]])
assert order.get_pizzas()[0].get_type() == 'margherita'
assert order.get_pizzas()[0].get_size() == 'medium'
assert order.get_pizzas()[0].get_toppings() == ['tomatoes', 'olives']
def test_cancel_fries(os):
# ===== ORDERING SMALL FRIES =====
order1 = Order()
friesQ = side_quantity(Fries(""))
order1.add_side(Fries("small"))
assert order1.calculate_price() == 2
assert os.add_order(order1) == True
assert side_quantity(Fries("")) == friesQ - 250
os.cancel_order(order1.order_id)
assert side_quantity(Fries("")) == friesQ
def test_cancel_drinks(os):
# ===== ORDERING SMALL OJ =====
order1 = Order()
ojQ = drink_quantity("orange juice", "")
order1.add_drink(Drink("orange juice", "small", 250))
assert order1.calculate_price() == 2
assert os.add_order(order1) == True
assert drink_quantity("orange juice", "") == ojQ - 250
os.cancel_order(order1.order_id)
assert drink_quantity("orange juice", "") == ojQ
def order_fixture():
o = Order()
o.add_main(burger)
o.add_others(side, 1)
o.add_others(drink, 1)
return o
def test_checkout_all(self, restaurant_fixture):
order = Order()
#adding a burger
burger = Burger()
bun = restaurant_fixture.menu.get_item("Bun")
patty = restaurant_fixture.menu.get_item("Patty")
cheese = restaurant_fixture.menu.get_item("Cheese")
burger.add_item(bun, 2)
burger.add_item(patty, 1)
burger.add_item(cheese, 1)
order.add_main(burger)
#adding sides and drinks
coke = restaurant_fixture.menu.get_item("Canned Coke")
nugget = restaurant_fixture.menu.get_item("Small Chicken Nugget")
order.add_others(coke, 1)
order.add_others(nugget, 1)
#placing the order and checking out
restaurant_fixture.place_order(order)
restaurant_fixture.checkout(1)
assert restaurant_fixture.inventory.items[0].quantity == 98
assert restaurant_fixture.inventory.items[1].quantity == 99
assert restaurant_fixture.inventory.items[2].quantity == 99
assert restaurant_fixture.inventory.items[3].quantity == 99
assert restaurant_fixture.inventory.items[4].quantity == 94
assert len(restaurant_fixture.orders) == 1
def setUp(self):
self.orders = [("2", "33120", "1", "1"), ("3", "17668", "1", "1"),
("3", "46667", "2", "1")]
self.products = [
("33120", "Organic Egg Whites", "86", "16"),
("17668", "Unsweetened Chocolate Almond Breeze Almond Milk", "91",
"16"), ("46667", "Organic Ginger Root", "83", "4")
]
self.order_to_product = {
"33120": [Order("2", "1")],
"17668": [Order("3", "1")],
"46667": [Order("3", "1")]
}
def order(self, pizza_data, drinks):
"""Makes an order using the order class and the given parameters. This order is given an
order number and stored in the orders list. This order's order number is returned."""
order = Order(self.num_orders, pizza_data, drinks)
self.orders.append(order)
self.num_orders += 1
return self.num_orders - 1
def __init__(self):
self._orders = []
self._inventory = inventory()
self._menu = Menu()
self._current_order = Order()
self._base_burger = None
self._base_wrap = None
def test_get_drinks():
order = Order(1, [['pepperoni', 'medium', ['olives', 'chicken']]],
[['pepsi', 'small']])
assert order.get_drinks()[0].get_type() == 'pepsi'
assert order.get_drinks()[0].get_size() == 'small'
order = Order(2, [['pepperoni', 'medium', ['olives', 'chicken']]],
[['coke', 'medium'], ['pepsi', 'medium']])
assert order.get_drinks()[0].get_type() == 'coke'
assert order.get_drinks()[0].get_size() == 'medium'
assert order.get_drinks()[1].get_type() == 'pepsi'
assert order.get_drinks()[1].get_size() == 'medium'
order.add_drink(['coke', 'small'])
assert order.get_drinks()[2].get_type() == 'coke'
assert order.get_drinks()[2].get_size() == 'small'
def test_cancel_main(os):
# ===== MAKE LIST OF INGREDIENTS =====
b_ingres = []
x1 = Ingredient("sesame", "bun", "sesame bun", 3, 1.5)
x2 = Ingredient("beef", "patty", "beef patty", 2, 3.0)
x3 = Ingredient("tomato", "vegetable", "tomato", 2, 0.5)
x4 = Ingredient("cheddar", "cheese", "cheddar cheese", 2, 1)
x5 = Ingredient("tomato", "sauce", "tomato sauce", 2, 0.5)
for x in [x1, x2, x3, x4, x5]:
b_ingres.append(x)
# ===== STORE CURRENT INVENTORY LEVELS =====
bunQ = ing_quantity("sesame", "bun")
pattyQ = ing_quantity("beef", "patty")
vegQ = ing_quantity("tomato", "vegetable")
cheQ = ing_quantity("cheddar", "cheese")
sauQ = ing_quantity("tomato", "sauce")
# ===== ORDER A MAIN =====
order1 = Order()
m1 = Main("burger", b_ingres)
order1.add_main(m1)
os.add_order(order1)
assert len(os._orders) == 1
assert order1.calculate_price() == 14.5
assert len(order1.mains) == 1
assert len(order1.mains[0]._ingredients) == 5
# ===== MAKE SURE INVENTORY UPDATED CORRECTLY =====
assert ing_quantity("sesame", "bun") == bunQ - 3
assert ing_quantity("beef", "patty") == pattyQ - 2
assert ing_quantity("tomato", "vegetable") == vegQ - 2
assert ing_quantity("cheddar", "cheese") == cheQ - 2
assert ing_quantity("tomato", "sauce") == sauQ - 2
os.cancel_order(order1._order_id)
# ===== IF AN ORDER IS CANCELLED MAKE SURE THE INGREDIENTS ARE PUT BACK IN THE INVENTORY SYSTEM =====
assert ing_quantity("sesame", "bun") == bunQ
assert ing_quantity("beef", "patty") == pattyQ
assert ing_quantity("tomato", "vegetable") == vegQ
assert ing_quantity("cheddar", "cheese") == cheQ
assert ing_quantity("tomato", "sauce") == sauQ