Example #1
0
class BasketTests(unittest.TestCase):

    def setUp(self):
        self.jarin_ostoskori = Basket("Jari",
                                      ["maito","banaani","hernekeitto"],
                                      15)

    def tearDown(self):
        del self.jarin_ostoskori

    def test_customer_is_string(self):
        self.assertTrue(isinstance(self.jarin_ostoskori.customer, str),
                        "Variable customer type should be string.")

    def test_contents_is_list(self):
        self.assertTrue(isinstance(self.jarin_ostoskori.contents, list),
                        "Variable contents type should be list.")

    def test_price_is_number(self):
        self.assertTrue(isinstance(self.jarin_ostoskori.price, Number),
                        "Variable price type should be Number")

    def test_can_add_product(self):
        self.jarin_ostoskori.add_product("kala", 5)
        self.assertIn("kala", self.jarin_ostoskori.contents,
                      "Variable contents did not contain added item.")

    def test_can_delete_product(self):
        self.jarin_ostoskori.delete_product("kala", 5)
        self.assertNotIn("kala", self.jarin_ostoskori.contents,
                         "Variable contents should not contain deleted item.")
Example #2
0
class BasketTests(unittest.TestCase):

    #setup method to create test object
    def setUp(self):
        print("setting up!")
        self.keijon_ostoskori = Basket("Keijo", ["kissa", "pasi"], 20, 0.24)

    #teardown method to delete the test object
    def tearDown(self):
        print("tearing down!")
        del self.keijon_ostoskori

    #Lets test if variable customer is a string
    def test_customer_is_string(self):
        self.assertTrue(isinstance(self.keijon_ostoskori.customer, str),
                        "variable customer name should be string")

    #let's test if the variable contents is a list
    def test_contents_is_list(self):
        self.assertTrue(isinstance(self.keijon_ostoskori.contents, list),
                        "variable contents should be a list")

    #let's test if variable price is a number
    def test_price_is_number(self):
        self.assertTrue(
            isinstance(self.keijon_ostoskori.price, numbers.Number),
            "variable price should be numbers")

    #let's test if add_product method works
    def test_list_add(self):
        self.keijon_ostoskori.add_product("kala", 5)
        self.assertIn("kala", self.keijon_ostoskori.contents,
                      "add_product did not add product to the list")

    #let's test if delete_product method works
    def test_list_delete(self):
        self.keijon_ostoskori.delete_product("kala", 5)
        self.assertNotIn(
            "kala", self.keijon_ostoskori.contents,
            "delete_product did not delete product from the list")

    #test average price
    def test_average_price(self):
        self.assertEqual(
            self.keijon_ostoskori.calculate_average_price(), 10,
            "calculate_average_price does not calculate correct value")

    #test vat
    def test_vat(self):
        self.assertEqual(self.keijon_ostoskori.calculate_vat(), 15.2,
                         "calculate_vat does not calculate")

    #test vat is number
    def test_vat_is_number(self):
        self.assertTrue(isinstance(self.keijon_ostoskori.vat, numbers.Number),
                        "variable vat should be numbers")
Example #3
0
class CashRegister:
    basket = None
    basketOnHold = None

    def __init__(self):
        pass

    def start(self):
        # verification caisse
        # Lancement nouveau panier
        self.new_basket()

    def new_basket(self):
        self.basket = Basket()
        while True:
            print("--------------------")
            print("Scan a product")
            code = input("code: ")
            print("--------------------")
            self.scan_product(code)

    def scan_product(self, code):
        product = ProductDbConnector.get_product_by_code(code)
        if product:
            product_to_add = Product(product)
            self.basket.add_product(product_to_add)
        else:
            print('Produit n\'existe pas')

    def delete_product_from_basket(self, product):
        try:
            self.basket.remove_product(product)
        except ValueError:
            return "Product not found"

    def total_price(self):
        return self.basket.totalPrice

    def pay(self):
        print('Pay')

    def put_basket_on_hold(self):
        self.basketOnHold = BasketOnHold(self.basket)
        self.basket = None
        print('On hold')

    def get_basket_on_hold(self):
        return self.basketOnHold
Example #4
0
 def order_button_handler(call):
     obj_id = str.split(call.data)[1]
     product = self.bd.find_product_by_str_obj_id(obj_id)
     if product['qty'] < 1:
         message = 'No product at store'
         self.bot.answer_callback_query(call.id,
                                        message,
                                        show_alert=True)
     else:
         basket = Basket(call.from_user.id)
         basket.add_product(product)
         message = self.make_modal_message(product)
         self.bot.answer_callback_query(call.id,
                                        message,
                                        show_alert=True)
         self.bot.send_message(
             call.from_user.id,
             product[CATEGORY_NAME],
             reply_markup=self.buttons.show_products_from_category(
                 product[CATEGORY_NAME]))
Example #5
0
class Basket_tests(unittest.TestCase):

    # define setUp for tests
    def setUp(self):
        self.product = Product("Lego1", "Lego Toy", 2.50)
        self.basket = Basket()

    # create test for instance of Product class
    def product_instance_test(self):
        # create instance of product with name, description, and price attribute
        self.product = Product("test", "This is a sample", 2.50)
        # verify attributes of instance of product
        self.assertEqual("test", self.product.name)
        self.assertEqual("This is a sample", self.product.description)
        self.assertEqual(2.50, self.product.price)

    # create test for instance of Basket class
    def basket_instance_test(self):
        # create instance of basket class
        self.basket = Basket()

    # create test to display product details
    def display_product_details_test(self):
        result = self.product.display_product_details()
        self.assertEqual("Product name: Lego1, Desc: Lego Toy, Price: £2.50", result)

    # create test to add a product to the basket
    def add_product_to_basket_test(self):
        result = self.basket.add_product(self.product)
        self.assertEqual(["Lego1", "Lego Toy", 2.50], result)

    # create a test to add product using a dictionary as the container
    def add_prod_to_basket_test(self):
        result = self.basket.add_prods(self.product, 5)
        self.assertEqual({1:["Lego1", "Lego Toy", 2.50, 5]}, result)

    # create test to remove product item from basket items
    def remove_item_from_basket_test(self):
        # add product to basket first
        self.basket.add_prods(self.product)
        result = self.basket.remove_item(self.product)
        self.assertEqual({}, result)

    # create test to raise error when item is tried to be removed from empty basket
    def error_when_item_removed_from_empty_basket_test(self):
        # remove item from empty basket
        #result = self.basket.remove_item(self.product)
        # confirm exception error message is raised
        self.assertRaises(NameError, self.basket.remove_item, self.product)
Example #6
0
    def test_basket_3(self):
        """
        Check subtotal, discount and total are as expected for basket 3
        """

        basket_3 = Basket(
            product_catalog=catalog.products,
            offers=[CheapestFree(product_category="shampoo", min_items=3)],
        )

        basket_3.add_product("shampoo-l")
        basket_3.add_product("shampoo-l")
        basket_3.add_product("shampoo-l")
        basket_3.add_product("shampoo-m")
        basket_3.add_product("shampoo-s")
        basket_3.add_product("shampoo-s")

        self.assertEqual(basket_3.subtotal(), 17)
        self.assertEqual(basket_3.discount(), 5.5)
        self.assertEqual(basket_3.total(), 11.5)
class TestBasket(TestCase):

    def setUp(self):
        self.test_products = [
            Product('Baked Beans', 0.99),
            Product('Biscuits', 1.20),
            Product('Sardines', 1.89),
            Product('Shampoo (Small)', 2.00),
            Product('Shampoo (Medium)', 2.50),
            Product('Shampoo (Large)', 3.50),
        ]
        self.test_catalouge = Catalogue(self.test_products)

    def test_construct_basket(self):
        self.test_basket = Basket(self.test_catalouge)
        self.assertEqual(len(self.test_basket.products), 0)

    def test_construct_basket_with_product_lists(self):
        self.test_basket = Basket(self.test_catalouge)
        for product in self.test_products:
            self.test_basket.add_product(product)
        self.assertEqual(len(self.test_basket.products), len(self.test_products))

    def test_add_product_to_basket(self):
        self.test_basket = Basket(self.test_catalouge)
        self.test_basket.add_product(self.test_products[0])
        self.assertEqual(len(self.test_basket.products), 1)
        self.assertEqual(self.test_basket.products[self.test_products[0].name].quantity, 1)

    def test_add_multi_product_to_basket(self):
        self.test_basket = Basket(self.test_catalouge)
        self.test_basket.add_product(self.test_products[0])
        self.test_basket.add_product(self.test_products[0])
        self.assertEqual(len(self.test_basket.products), 1)
        self.assertEqual(self.test_basket.products[self.test_products[0].name].quantity, 2)

    def test_add_product_not_in_catalogue_to_basket(self):
        self.test_basket = Basket(self.test_catalouge)
        with self.assertRaises(ProductNotInCatalogueException):
            self.test_basket.add_product(Product('Dummy Product', 1.00))

    def test_removing_product_from_basket(self):
        self.test_basket = Basket(self.test_catalouge)
        for product in self.test_products:
            self.test_basket.add_product(product)
        self.test_basket.remove_product(self.test_products[0])
        self.assertEqual(len(self.test_basket.products), len(self.test_products) - 1)
        self.assertEqual(self.test_products[0].name in self.test_basket.products, False)

    def test_empty_basket(self):
        self.test_basket = Basket(self.test_catalouge)
        for product in self.test_products:
            self.test_basket.add_product(product)
        self.assertEqual(len(self.test_basket.products), len(self.test_products))
        self.test_basket.empty()
        self.assertEqual(len(self.test_basket.products), 0)

    def test_basket_subtotal(self):
        # One of each item
        self.test_basket = Basket(self.test_catalouge)
        for product in self.test_products:
            self.test_basket.add_product(product)
        self.assertEqual(self.test_basket.calculate_subtotal(), 12.08)

        self.test_basket.empty()

        # 4 Baked Beans and 1 Biscuits
        # Add 4 Baked Beans
        self.test_basket.add_product(self.test_products[0], 4)
        # Add 1 Biscuits
        self.test_basket.add_product(self.test_products[1])
        self.assertEqual(self.test_basket.calculate_subtotal(), 5.16)

        self.test_basket.empty()

        # With Sardines 25% discount
        self.test_basket = Basket(self.test_catalouge)
        # Add 2 Baked Beans
        self.test_basket.add_product(self.test_products[0], 2)
        # Add 1 Biscuits
        self.test_basket.add_product(self.test_products[1])
        # Add 2 Sardines
        self.test_basket.add_product(self.test_products[2], 2)
        self.assertEqual(self.test_basket.calculate_subtotal(), 6.96)

    def test_basket_discount_buy_2_get_1_free(self):
        # With Baked Beans buy 2 get 1 free
        self.buy_and_get_free_offer = BuyAndGetFreeOffer(self.test_products[0], 2, 1)
        self.test_basket = Basket(self.test_catalouge, [self.buy_and_get_free_offer])
        # Add 4 Baked Beans
        self.test_basket.add_product(self.test_products[0], 4)
        # Add 1 Biscuits
        self.test_basket.add_product(self.test_products[1])
        self.assertEqual(self.test_basket.calculate_discount(), 0.99)
        # Add 4 Baked Beans
        self.test_basket.add_product(self.test_products[0], 4)
        self.assertEqual(self.test_basket.calculate_discount(), 1.98)
        self.assertEqual(self.test_basket.calculate_total(),
                         round_half_up(self.test_products[0].price * 8 +
                         self.test_products[1].price -
                         self.test_basket.calculate_discount(), 2))

    def test_basket_discount_percent_offer(self):
        # With Sardines 25% discount
        self.percentage_offer = PercentageOffer(self.test_products[2], 0.25)
        self.test_basket = Basket(self.test_catalouge, [self.percentage_offer])
        # Add 2 Baked Beans
        self.test_basket.add_product(self.test_products[0], 2)
        # Add 1 Biscuits
        self.test_basket.add_product(self.test_products[1])
        # Add 2 Sardines
        self.test_basket.add_product(self.test_products[2], 2)
        self.assertEqual(self.test_basket.calculate_discount(), 2 * round_half_up(self.test_products[2].price * 0.25, 2))
        self.assertEqual(self.test_basket.calculate_total(),
                         round_half_up(self.test_products[0].price * 2 +
                         self.test_products[1].price +
                         self.test_products[2].price * 2 -
                         self.test_basket.calculate_discount(), 2))

    def test_basket_discount_percent_and_buy_2_get_1_free_offers(self):
        # With Baked Beans buy 2 get 1 free and 25% discount
        self.buy_and_get_free_offer = BuyAndGetFreeOffer(self.test_products[0], 2, 1)
        self.percentage_offer = PercentageOffer(self.test_products[0], 0.25)
        self.test_basket = Basket(self.test_catalouge, [self.buy_and_get_free_offer, self.percentage_offer])
        # Add 4 Baked Beans
        self.test_basket.add_product(self.test_products[0], 4)
        # Add 1 Biscuits
        self.test_basket.add_product(self.test_products[1])
        # Baked Beans Buy 2 get one free: 0.99
        # Baked Beans 25% percent discount: 0.99 * 0.25 =  0.25
        # Total: 0.99 + 0.25 = 1.24
        self.assertEqual(self.test_basket.calculate_discount(), 1.24)
        self.assertEqual(self.test_basket.calculate_total(),
                         round_half_up(self.test_products[0].price * 4 +
                         self.test_products[1].price -
                         self.test_basket.calculate_discount(), 2))
        # Add 4 Baked Beans
        self.test_basket.add_product(self.test_products[0], 4)
        # Buy 2 get 1 free twice: 0.99 * 2 = 1.98
        # Percentage discount on remaining 2: 0.99 * 0.25 * 2 = 0.50
        # total: 1.98 + 0.50 = 2.48
        self.assertEqual(self.test_basket.calculate_discount(), 2.48)
        self.assertEqual(self.test_basket.calculate_total(),
                         round_half_up(self.test_products[0].price * 8 +
                         self.test_products[1].price -
                         self.test_basket.calculate_discount(), 2))

        # With Baked Beans buy 2 get 1 free and 50% discount
        self.buy_and_get_free_offer = BuyAndGetFreeOffer(self.test_products[0], 2, 1)
        self.percentage_offer = PercentageOffer(self.test_products[0], 0.50)
        self.test_basket = Basket(self.test_catalouge, [self.buy_and_get_free_offer, self.percentage_offer])
        # Add 4 Baked Beans
        self.test_basket.add_product(self.test_products[0], 4)
        # Add 1 Biscuits
        self.test_basket.add_product(self.test_products[1])
        # Baked Beans Buy 2 get one free: 0
        # Baked Beans 50% percent discount: 0.99 * 0.5 = 2.00
        # Total: 2.00
        self.assertEqual(self.test_basket.calculate_discount(), 2.00)
        self.assertEqual(self.test_basket.calculate_total(),
                         round_half_up(self.test_products[0].price * 4 +
                         self.test_products[1].price -
                         self.test_basket.calculate_discount(), 2))

    def test_basket_discount_bundle_offer(self):
        # With bundle offer on all shampoo buy 3 get the cheapest free
        self.test_offer = BundleOffer([self.test_products[3],
                                       self.test_products[4],
                                       self.test_products[5]
                                      ], 3)
        self.test_basket = Basket(self.test_catalouge, [self.test_offer])
        # Add 2 small shampoo
        self.test_basket.add_product(self.test_products[3], 2)
        # Add 1 medium shampoo
        self.test_basket.add_product(self.test_products[4])
        # Add 3 large shampoo
        self.test_basket.add_product(self.test_products[5], 3)
        # One large shampoo for free (3.5) and One small shampoo for free (2.00)
        # Total: 5.5
        self.assertEqual(self.test_basket.calculate_discount(), 5.5)
        self.assertEqual(self.test_basket.calculate_total(),
                         round_half_up(self.test_products[3].price * 2 +
                         self.test_products[4].price +
                         self.test_products[5].price * 3 -
                         self.test_basket.calculate_discount(), 2))

    def test_basket_discount_multiple_bundle_offers(self):
        # With bundle offer on all shampoo buy 3 get the cheapest free
        self.bundle_offer_all_shampoo = BundleOffer([self.test_products[3],
                                       self.test_products[4],
                                       self.test_products[5]
                                      ], 3)
        # With bundle offer on small shampoo and sardines buy 2 get the cheapest free
        self.bundle_offer_small_shampoo_and_sardines = BundleOffer([self.test_products[3],
                                        self.test_products[2]
                                      ], 2)
        self.test_basket = Basket(self.test_catalouge, [
                                        self.bundle_offer_all_shampoo,
                                        self.bundle_offer_small_shampoo_and_sardines
                                    ])
        # Add 1 sardines
        self.test_basket.add_product(self.test_products[2], 1)
        # Add 3 small shampoo
        self.test_basket.add_product(self.test_products[3], 3)
        # Add 2 medium shampoo
        self.test_basket.add_product(self.test_products[4], 2)
        # Add 3 large shampoo
        self.test_basket.add_product(self.test_products[5], 3)
        # One large shampoo for free (3.5)
        # Two small shampoo for free (4.00)
        # Total: 7.5
        self.assertEqual(self.test_basket.calculate_discount(), 7.5)
        self.assertEqual(self.test_basket.calculate_total(),
                         round_half_up(self.test_products[2].price +
                         self.test_products[3].price * 3 +
                         self.test_products[4].price * 2 +
                         self.test_products[5].price * 3 -
                         self.test_basket.calculate_discount(), 2))

    def test_basket_discount_all_offers(self):
        # With bundle offer on all shampoo buy 3 get the cheapest free
        self.bundle_offer_all_shampoo = BundleOffer([self.test_products[3],
                                       self.test_products[4],
                                       self.test_products[5]
                                      ], 3)
        # With bundle offer on small shampoo and sardines buy 2 get the cheapest free
        self.bundle_offer_small_shampoo_and_sardines = BundleOffer([self.test_products[3],
                                        self.test_products[2]
                                      ], 2)

        self.buy_and_get_free_offer_baked_beans = BuyAndGetFreeOffer(self.test_products[0], 2, 1)
        self.percentage_offer_baked_beans = PercentageOffer(self.test_products[0], 0.25)
        self.test_basket = Basket(self.test_catalouge, [
                                        self.bundle_offer_all_shampoo,
                                        self.bundle_offer_small_shampoo_and_sardines,
                                        self.buy_and_get_free_offer_baked_beans,
                                        self.percentage_offer_baked_beans
                                    ])
        # Add 4 Baked Beans
        self.test_basket.add_product(self.test_products[0], 4)
        # Add 1 Biscuits
        self.test_basket.add_product(self.test_products[1])
        # Add 1 sardines
        self.test_basket.add_product(self.test_products[2], 1)
        # Add 3 small shampoo
        self.test_basket.add_product(self.test_products[3], 3)
        # Add 2 medium shampoo
        self.test_basket.add_product(self.test_products[4], 2)
        # Add 3 large shampoo
        self.test_basket.add_product(self.test_products[5], 3)
        # Baked Beans Buy 2 get one free: 0.99
        # Baked Beans 25% percent discount: 0.99 * 0.25 =  0.25
        # One large shampoo for free (3.5)
        # Two small shampoo for free (4.00)
        # Total: 7.5 + 0.99 + 0.25 = 8.74
        self.assertEqual(self.test_basket.calculate_discount(), 8.74)
        self.assertEqual(self.test_basket.calculate_total(),
                         round_half_up(self.test_products[0].price * 4 +
                         self.test_products[1].price +
                         self.test_products[2].price +
                         self.test_products[3].price * 3 +
                         self.test_products[4].price * 2 +
                         self.test_products[5].price * 3 -
                         self.test_basket.calculate_discount(), 2))
class TestOffer(TestCase):

    def setUp(self):
        self.test_products = [
            Product('Baked Beans', 0.99),
            Product('Biscuits', 1.20),
            Product('Sardines', 1.89),
            Product('Shampoo (Small)', 2.00),
            Product('Shampoo (Medium)', 2.50),
            Product('Shampoo (Large)', 3.50),
        ]
        self.test_catalouge = Catalogue(self.test_products)

    def test_buy_and_get_free_offer(self):
        """
        Tests the creation of a valid buy and get free offer
        """
        # Baked Beans buy one get one free
        self.test_offer = BuyAndGetFreeOffer(self.test_products[0], 1, 1)
        self.assertEqual(self.test_offer.product, self.test_products[0].name)
        self.assertEqual(self.test_offer.buy_quantity, 1)
        self.assertEqual(self.test_offer.free_quantity, 1)

    def test_buy_and_get_free_offer_discount(self):
        # Baked Beans buy one get one free
        self.test_offer = BuyAndGetFreeOffer(self.test_products[0], 1, 1)
        self.test_basket = Basket(self.test_catalouge)
        self.test_basket.add_product(self.test_products[0], 1)
        self.assertEqual(self.test_offer.get_discount(self.test_basket.products)[0], 0.00)
        # Add 1 more Baked Beans for a total of 2
        self.test_basket.add_product(self.test_products[0], 1)
        self.assertEqual(self.test_offer.get_discount(self.test_basket.products)[0], self.test_products[0].price)

    def test_percentage_offer(self):
        """
        Tests the creation of a valid percentage offer
        """
        # Baked Beans 25% off
        self.test_offer = PercentageOffer(self.test_products[0], 0.25)
        self.assertEqual(self.test_offer.product, self.test_products[0].name)
        self.assertEqual(self.test_offer.discount_percent, 0.25)

    def test_percentage_offer_discount(self):
        # Baked Beans buy one get one free
        self.test_offer = PercentageOffer(self.test_products[0], 0.25)
        self.test_basket = Basket(self.test_catalouge)
        self.assertEqual(self.test_offer.get_discount(self.test_basket.products)[0], 0.00)
        self.test_basket.add_product(self.test_products[0], 1)
        self.assertEqual(self.test_offer.get_discount(
            self.test_basket.products)[0],
            round_half_up(self.test_products[0].price * 0.25, 2)
        )
        # Add 1 more Baked Beans for a total of 2
        self.test_basket.add_product(self.test_products[0], 1)
        self.assertEqual(self.test_offer.get_discount(
            self.test_basket.products)[0],
            round_half_up(self.test_products[0].price * 0.25, 2)
        )

    def test_bundle_offer(self):
        """
        Tests the creation of a valid percentage offer
        """
        # Baked Beans, Biscuits, Sardines
        self.test_offer = BundleOffer([self.test_products[0],
                                           self.test_products[1],
                                           self.test_products[2]
                                          ], 3)
        self.assertEqual(len(self.test_offer.bundle_items), 3)
        self.assertEqual(type(self.test_offer.bundle_items), list)
        self.assertEqual(type(self.test_offer.bundle_items[0]), str)
        self.assertEqual(self.test_offer.required_items, 3)

    def test_bundle_offer_discount(self):
        # Baked Beans, Biscuits, Sardines
        self.test_offer = BundleOffer([self.test_products[0],
                                           self.test_products[1],
                                           self.test_products[2]
                                          ], 3)
        self.test_basket = Basket(self.test_catalouge)
        self.assertEqual(self.test_offer.get_discount(self.test_basket.products)[0], 0.00)
        self.test_basket.add_product(self.test_products[0], 1)
        self.assertEqual(self.test_offer.get_discount(self.test_basket.products)[0], 0.00)
        self.test_basket.add_product(self.test_products[1], 1)
        self.test_basket.add_product(self.test_products[2], 1)
        self.test_basket.add_product(self.test_products[3], 1)
        self.assertEqual(self.test_offer.get_discount(self.test_basket.products)[0], self.test_products[0].price)
        # Add 1 more Baked Beans for a total of 2
        self.test_basket.add_product(self.test_products[0], 1)
        self.assertEqual(self.test_offer.get_discount(self.test_basket.products)[0], self.test_products[0].price)
        # Add 1 more Biscuits for a total of 2
        self.test_basket.add_product(self.test_products[1], 1)
        self.assertEqual(self.test_offer.get_discount(self.test_basket.products)[0], self.test_products[1].price)
Example #9
0
class TestBasket(unittest.TestCase):
    """
    Check the Basket performs as expected
    """
    def setUp(self):
        """
        Create the two baskets described in assignment.py
        """

        offers = [
            GetOneFree(product_sku="beans", min_items=2),
            PercentageDiscount(product_sku="sardines", discount_percent=25),
        ]

        self.basket_1 = Basket(product_catalog=catalog.products, offers=offers)

        self.basket_1.add_product("beans")
        self.basket_1.add_product("beans")
        self.basket_1.add_product("beans")
        self.basket_1.add_product("beans")
        self.basket_1.add_product("biscuits")

        self.basket_2 = Basket(product_catalog=catalog.products, offers=offers)

        self.basket_2.add_product("beans")
        self.basket_2.add_product("beans")
        self.basket_2.add_product("biscuits")
        self.basket_2.add_product("sardines")
        self.basket_2.add_product("sardines")

    def test_subtotal(self):
        """
        Check subtotal() returns the expected sum of all products' prices
        """

        self.assertEqual(self.basket_1.subtotal(), 5.16)
        self.assertEqual(self.basket_2.subtotal(), 6.96)

    def test_discount(self):
        """
        Check discount() tells us how much is discounted based on added offers
        """

        self.assertEqual(self.basket_1.discount(), 0.99)
        self.assertEqual(self.basket_2.discount(), 0.95)

    def test_total(self):
        """
        Check total() returns the expected total for both baskets
        """

        self.assertEqual(self.basket_1.total(), 4.17)
        self.assertEqual(self.basket_2.total(), 6.01)

    def test_basket_3(self):
        """
        Check subtotal, discount and total are as expected for basket 3
        """

        basket_3 = Basket(
            product_catalog=catalog.products,
            offers=[CheapestFree(product_category="shampoo", min_items=3)],
        )

        basket_3.add_product("shampoo-l")
        basket_3.add_product("shampoo-l")
        basket_3.add_product("shampoo-l")
        basket_3.add_product("shampoo-m")
        basket_3.add_product("shampoo-s")
        basket_3.add_product("shampoo-s")

        self.assertEqual(basket_3.subtotal(), 17)
        self.assertEqual(basket_3.discount(), 5.5)
        self.assertEqual(basket_3.total(), 11.5)