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