def test_add_product(self):
product1: Product = Product("Chair", 100, "Furniture")
product3: Product = Product("Sofa", 1, "Furniture")
# All valid
# First Addition
self.assertTrue(self.store.add_product("Eytan", "Chair", 100, "Furniture", 5, 0))
self.assertEqual(self.store.get_inventory().len(), 1)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertEqual(self.store.get_inventory().get_amount("Chair"), 5)
# Second Addition
self.assertTrue(self.store.add_product("Eytan", "Sofa", 1, "Furniture", 0, 0))
self.assertEqual(self.store.get_inventory().len(), 2)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
self.assertEqual(self.store.get_inventory().get_amount("Sofa"), 0)
# Adding existing product
self.assertTrue(self.store.add_product("Eytan", "Chair", 100, "Furniture", 5, 0))
self.assertEqual(self.store.get_inventory().len(), 2)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
self.assertEqual(self.store.get_inventory().get_amount("Chair"), 10)
# Invalid
# Negative amount
self.assertFalse(self.store.add_product("Eytan", "Chair", 100, "Furniture", -5, 0))
self.assertEqual(self.store.get_inventory().len(), 2)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
self.assertEqual(self.store.get_inventory().get_amount("Chair"), 10)
# Negative price
self.assertFalse(self.store.add_product("Eytan", "Chair", -100, "Furniture", 5, 0))
self.assertEqual(self.store.get_inventory().len(), 2)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
self.assertEqual(self.store.get_inventory().get_amount("Chair"), 10)
# Empty name
self.assertFalse(self.store.add_product("Eytan", "", 100, "Furniture", 5, 0))
self.assertEqual(self.store.get_inventory().len(), 2)
products_names = [product.get_name() for product in self.store.get_products_by(2, "")]
self.assertFalse("" in products_names)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
self.assertEqual(self.store.get_inventory().get_amount("Chair"), 10)
# Empty category
self.assertFalse(self.store.add_product("Eytan", "Eytan's Toy", 100, "", 5, 0))
self.assertEqual(self.store.get_inventory().len(), 2)
products_names = [product.get_name() for product in self.store.get_products_by(2, "")]
self.assertFalse("Eytan's Toy" in products_names)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
def setUp(self):
self.__shopping_cart = ShoppingCart()
self.__product = Product("Eytan's product", 12, "Eytan's category")
self.__store: Store = Store("myStore")
self.__product_as_dictionary = {
"product": self.__product,
"amount": 4,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
self.__product_to_add = (self.__product_as_dictionary['product'],
self.__product_as_dictionary['amount'])
def test_remove_products(self):
product1: Product = Product("Chair", 100, "Furniture")
product3: Product = Product("Sofa", 1, "Furniture")
self.store.add_product("Eytan", "Chair", 100, "Furniture", 5, 0)
# All Valid - one product
self.assertTrue(self.store.remove_products("Eytan", ["Chair"]))
self.assertEqual(self.store.get_inventory().len(), 0)
self.store.add_product("Eytan", "Chair", 100, "Furniture", 5,0)
self.store.add_product("Eytan", "Chair", 100, "Furniture", 5, 0)
self.store.add_product("Eytan", "Sofa", 1, "Furniture", 3, 0)
# All valid - two products
self.assertEqual(self.store.get_inventory().len(), 2)
self.assertTrue(self.store.remove_products("Eytan", ["Chair", "Sofa"]))
self.assertEqual(self.store.get_inventory().len(), 0)
self.store.add_product("Eytan", "Chair", 100, "Furniture", 5, 0)
self.store.add_product("Eytan", "Chair", 100, "Furniture", 5, 0)
self.store.add_product("Eytan", "Sofa", 1, "Furniture", 3, 0)
# All valid - not all inventory removed
self.assertTrue(self.store.remove_products("Eytan", ["Chair"]))
self.assertEqual(self.store.get_inventory().len(), 1)
self.assertTrue(product3 in self.store.get_products_by(2, ""))
# All valid - Manager
self.assertTrue(self.store.remove_products("Not Eytan", ["Sofa"]))
self.assertEqual(self.store.get_inventory().len(), 0)
# Invalid product
self.assertFalse(self.store.remove_products("Not Eytan", ["Eytan's Toy"]))
# Invalid - Manager/Owner
self.assertFalse(self.store.remove_products("", ["Chair", "Sofa"]))
bad_manager = User()
bad_manager.register("Half Eytan, half not Eytan", "Definitely Password")
self.store.get_store_manager_appointments().append(
StoreAppointment(self.owner, bad_manager, [ManagerPermission.WATCH_PURCHASE_HISTORY]))
# Invalid - Manager permissions
self.store.add_product("Eytan", "Chair", 100, "Furniture", 5, 0)
self.store.add_product("Eytan", "Chair", 100, "Furniture", 5, 0)
self.assertFalse(self.store.remove_products(bad_manager.get_nickname(), ["Chair"]))
self.assertEqual(self.store.get_inventory().len(), 1)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertEqual(self.store.get_inventory().get_amount("Chair"), 10)
def test_get_products_by(self):
self.store.add_products("Eytan", [{"name": "Chair", "price": 100, "category": "Furniture", "amount": 10,
"purchase_type": 0},
{"name": "TV", "price": 10, "category": "Electric", "amount": 1,
"purchase_type": 0},
{"name": "Sofa", "price": 1, "category": "Furniture", "amount": 2,
"purchase_type": 0}])
product1: Product = Product("Chair", 100, "Furniture")
product2: Product = Product("TV", 10, "Electric")
product3: Product = Product("Sofa", 1, "Furniture")
# Option 1- All valid
ls = self.store.get_products_by(1, "Chair")
self.assertEqual(len(ls), 1)
self.assertTrue(product1 in ls)
# Option 1- Not an existing product
ls = self.store.get_products_by(1, "EytanIsTheBestEver!!!")
self.assertEqual(len(ls), 0)
# Option 2- All valid
ls = self.store.get_products_by(2, "a")
self.assertEqual(len(ls), 2)
self.assertTrue(product1 in ls)
self.assertTrue(product3 in ls)
# Option 2- Empty products list
ls = self.store.get_products_by(2, "EytanIsTheBestEver!!!")
self.assertEqual(len(ls), 0)
# Option 3 - All valid
ls = self.store.get_products_by(3, "Furniture")
self.assertEqual(len(ls), 2)
self.assertTrue(product1 in ls)
self.assertTrue(product3 in ls)
ls = self.store.get_products_by(3, "Electric")
self.assertEqual(len(ls), 1)
self.assertTrue(product2 in ls)
# Option 3 - Not an existing category
ls = self.store.get_products_by(3, "EytanIsTheBestEver!!!")
self.assertEqual(len(ls), 0)
def test_remove_product(self):
self.__shopping_cart.add_products([{"product": self.__product, "amount": 4, "store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT, "purchase_type": PurchaseType.DEFAULT},
{"product": Product("TV", 100, "Electric"), "amount": 4,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT, "purchase_type": PurchaseType.DEFAULT}])
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 1)
self.__shopping_cart.remove_products([{"product_name": "Alcogel", "store_name": "Eytan's best store"}])
ls = self.__shopping_cart.get_shopping_baskets()
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 1)
self.__shopping_cart.remove_products([{"product_name": "TV", "store_name": "Eytan's best store"}])
ls = self.__shopping_cart.get_shopping_baskets()
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 0)
def setUp(self):
self.inv = StoreInventory()
self.product1 = Product("Chair", 100, "Furniture")
self.product1.set_purchase_type(0)
self.product2 = Product("Sofa", 10, "Furniture")
self.product2.set_purchase_type(0)
self.product3 = Product("Guitar", 1000, "Musical Instruments")
self.product3.set_purchase_type(0)
def test_len(self):
# All valid -> Empty inventory
self.assertEqual(self.inv.len(), 0)
self.inv.add_product(self.product1, 4)
# All valid -> Not empty inventory -> one product.
self.assertEqual(self.inv.len(), 1)
self.inv.add_product(self.product2, 4)
# All valid -> Not empty inventory -> more then one product.
self.assertEqual(self.inv.len(), 2)
# All valid -> Check that the inventory doesn't change while adding an invalid product.
try:
self.inv.add_product(Product("Eytan", -100, "Different Eytan"), 12)
except ValueError:
""
self.assertEqual(self.inv.len(), 2)
self.inv.add_product(Product("Eytan", 100, "Different Eytan"), -12)
self.assertEqual(self.inv.len(), 2)
def test_update_quantity(self):
self.__shopping_cart.add_products([{"product": self.__product, "amount": 4, "store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT, "purchase_type": PurchaseType.DEFAULT},
{"product": Product("TV", 256, "Electric"), "amount": 4,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT, "purchase_type": PurchaseType.DEFAULT}])
self.__shopping_cart.update_quantity([{"product_name": self.__product.get_name(), "store_name": self.__store.get_name(), "amount": 16}])
basket_pair = self.__shopping_cart.get_shopping_baskets()[0]
self.assertEqual(basket_pair["store_name"], "Eytan's best store")
basket = basket_pair["basket"].get_products()[0]
self.assertEqual(basket["product"].get_name(), "Alcogel")
self.assertEqual(basket["amount"], 16)
basket = basket_pair["basket"].get_products()[1]
self.assertEqual(basket["product"].get_name(), "TV")
self.assertEqual(basket["amount"], 4)
def setUp(self):
self.__valid_name = "anna9218"
self.__valid_password = "******"
self.__user = User()
self.__user.register(self.__valid_name, self.__valid_password)
self.__product = Product("Eytan's product", 12, "Eytan's category")
self.__store: Store = Store("myStore")
self.__products_to_add = [{
"product": self.__product,
"store_name": self.__store.get_name(),
"amount": 1,
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}] # products_stores_quantity_ls
def test_remove_product(self):
product2: Product = Product("Not Chair", 1, "Furniture")
# All valid - Empty inventory
self.assertFalse(self.store.remove_product("Chair"))
self.store.add_product("Eytan", "Chair", 100, "Furniture", 5, 0)
self.store.add_product("Eytan", "Not Chair", 1, "Furniture", 3, 0)
# All valid
self.assertTrue(self.store.remove_product("Chair"))
self.assertEqual(self.store.get_inventory().len(), 1)
self.assertTrue(product2 in self.store.get_products_by(2, ""))
# Invalid - Not an existing product
self.assertFalse(self.store.remove_product("Eytan's Toy"))
def add_product(self, product: Product, amount: int) -> \
bool:
"""
This function add a product to a basket, if the amount of the product is > 0 and the product not already in the
basket.
if the product is already in the basket, then the function ADD the new amount to the old one.
:param product: the product to add
:param amount: the amount of the product to add
:param discount_type: the discount type, if exist.
:param purchase_type: the purchase type. direct by default
:return: True if added successfully,
False else
"""
if amount <= 0:
return False
for product_amount in self.__products:
if product.get_name() == product_amount["product"].get_name():
product_amount["amount"] += amount
return True
self.__products.append({"product": product, "amount": amount})
return True
def test_remove_products(self):
product1: Product = Product("not Eytan's product", 9,
"Eytan's category")
store1: Store = Store("Not my store")
product2: Product = Product("maybe Eytan's product", 8,
"Eytan's category")
product_as_dictionary_var1 = {
"product": product1,
"amount": 3,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
product_as_dictionary_var2 = {
"product": product2,
"amount": 5,
"store_name": store1.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
product_as_dictionary_var3 = {
"product": product1,
"amount": 12,
"store_name": store1.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
self.__shopping_cart.add_products([
self.__product_as_dictionary, product_as_dictionary_var1,
product_as_dictionary_var2, product_as_dictionary_var3
])
# All valid
self.assertTrue(
self.__shopping_cart.remove_products([{
"product_name":
self.__product.get_name(),
"store_name":
self.__store.get_name()
}]))
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 2)
stores = [
store_and_basket['store_name'] for store_and_basket in
self.__shopping_cart.get_shopping_baskets()
]
self.assertTrue(self.__store.get_name() in stores)
self.assertTrue(store1.get_name() in stores)
product_as_dictionary_lst_self_store = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products_self_store = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst_self_store
]
product_as_dictionary_lst_store1 = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products_store1 = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst_store1
]
self.assertTrue(product1 in products_self_store)
self.assertTrue(product1 in products_store1)
self.assertTrue(product2 in products_store1)
self.assertFalse(
self.__product in product_as_dictionary_lst_self_store)
# Invalid - product isn't in the store
self.assertFalse(
self.__shopping_cart.remove_products([{
"product_name":
product2.get_name(),
"store_name":
self.__store.get_name()
}])['response'])
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 2)
stores = [
store_and_basket['store_name'] for store_and_basket in
self.__shopping_cart.get_shopping_baskets()
]
self.assertTrue(self.__store.get_name() in stores)
self.assertTrue(store1.get_name() in stores)
product_as_dictionary_lst_self_store = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products_self_store = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst_self_store
]
product_as_dictionary_lst_store1 = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products_store1 = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst_store1
]
self.assertTrue(product1 in products_self_store)
self.assertTrue(product1 in products_store1)
self.assertTrue(product2 in products_store1)
self.assertFalse(
self.__product in product_as_dictionary_lst_self_store)
# All valid - make the basket empty
self.assertTrue(
self.__shopping_cart.remove_products([{
"product_name":
product1.get_name(),
"store_name":
self.__store.get_name()
}])['response'])
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 1)
stores = [
store_and_basket['store_name'] for store_and_basket in
self.__shopping_cart.get_shopping_baskets()
]
self.assertFalse(self.__store.get_name() in stores)
self.assertTrue(store1.get_name() in stores)
product_as_dictionary_lst = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst
]
self.assertTrue(product1 in products)
self.assertTrue(product2 in products)
# Invalid - product doesn't exist
self.assertFalse(
self.__shopping_cart.remove_products([{
"product_name":
"product1.get_name()",
"store_name":
store1.get_name()
}])['response'])
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 1)
stores = [
store_and_basket['store_name'] for store_and_basket in
self.__shopping_cart.get_shopping_baskets()
]
self.assertTrue(store1.get_name() in stores)
product_as_dictionary_lst = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst
]
self.assertTrue(product1 in products)
self.assertTrue(product2 in products)
# Invalid - store doesn't exist
self.assertFalse(
self.__shopping_cart.remove_products([{
"product_name":
product1.get_name(),
"store_name":
"store1.get_name()"
}])['response'])
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 1)
stores = [
store_and_basket['store_name'] for store_and_basket in
self.__shopping_cart.get_shopping_baskets()
]
self.assertTrue(store1.get_name() in stores)
product_as_dictionary_lst = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst
]
self.assertTrue(product1 in products)
self.assertTrue(product2 in products)
class ShoppingBasketTests(unittest.TestCase):
# @logger
def setUp(self):
self.__basket = ShoppingBasket()
self.__product = Product("Eytan's product", 12, "Eytan's category")
# @logger
# eden
def test_update_amount(self):
# def update_amount(self, product_name: str, amount: int):
self.__basket.add_product(self.__product, 2)
# All valid
self.assertTrue(
self.__basket.update_amount(self.__product.get_name(), 5))
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 5)
# Valid - Edge case - amount is zero
self.assertTrue(
self.__basket.update_amount(self.__product.get_name(), 0))
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 0)
# Invalid - Negative amount
self.assertFalse(
self.__basket.update_amount(self.__product.get_name(), -121))
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 0)
# Invalid - product doesn't exist
self.assertFalse(
self.__basket.update_amount("self.__product.get_name()", 121))
self.assertEqual(
self.__basket.get_product_amount("self.__product.get_name()"), 0)
# @logger
def test_is_empty(self):
# Is empty
self.assertTrue(self.__basket.is_empty())
# Is not empty
self.__basket.add_product(self.__product, 2)
self.assertFalse(self.__basket.is_empty())
# @logger
def test_add_product(self):
# All valid - edge case - amount = 0
self.__basket.remove_product(self.__product.get_name())
self.assertFalse(self.__basket.add_product(self.__product, 0))
self.assertNotIn({
"product": self.__product,
"amount": 0
}, self.__basket.get_products())
# All valid
self.assertTrue(self.__basket.add_product(self.__product, 2))
self.assertIn({
"product": self.__product,
"amount": 2
}, self.__basket.get_products())
# Invalid - negative amount
self.assertFalse(self.__basket.add_product(self.__product, -2))
self.assertIn({
"product": self.__product,
"amount": 2
}, self.__basket.get_products())
# @logger
def test_remove_product(self):
# All valid
self.__basket.add_product(self.__product, 2)
self.assertTrue(self.__basket.remove_product(
self.__product.get_name()))
self.assertEqual(len(self.__basket.get_products()), 0)
# Invalid - product doesn't exist
self.assertFalse(
self.__basket.remove_product("self.__product.get_name()"))
self.assertEqual(len(self.__basket.get_products()), 0)
# Invalid - product isn't in the basket
self.assertFalse(
self.__basket.remove_product(self.__product.get_name()))
self.assertEqual(len(self.__basket.get_products()), 0)
# Invalid - Empty product name
self.assertFalse(self.__basket.remove_product(""))
self.assertEqual(len(self.__basket.get_products()), 0)
# @logger
def test_get_product(self):
self.__basket.remove_product(self.__product.get_name())
self.__basket.add_product(self.__product, 12)
product_as_dictionary = {
"product": self.__product,
"amount":
self.__basket.get_product_amount(self.__product.get_name())
}
# All valid
self.assertEqual(self.__basket.get_product(self.__product.get_name()),
product_as_dictionary)
# Invalid - product doesn't exist
self.assertIsNone(
self.__basket.get_product("Eytan's very very bad product"))
# @logger
def test_get_product_amount(self):
# def get_product_amount(self, product_name: str):
self.__basket.add_product(self.__product, 12)
# All valid
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 12)
# Invalid - product doesn't exist
self.assertEqual(
self.__basket.get_product_amount("self.__product.get_name()"), 0)
#@logger
def test_complete_purchase(self):
self.__basket.remove_product(self.__product.get_name())
self.__basket.add_product(self.__product, 12)
# All valid - one product
self.__basket.complete_purchase([{
"product_name":
self.__product.get_name(),
"product_price":
self.__product.get_price(),
"amount":
1
}])
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 11)
product2 = Product("not Eytan's product", 10, "Eytan's category")
self.__basket.add_product(product2, 6)
# All valid - two products
self.__basket.complete_purchase([{
"product_name":
self.__product.get_name(),
"product_price":
self.__product.get_price(),
"amount":
1
}, {
"product_name": product2.get_name(),
"product_price": product2.get_price(),
"amount": 1
}])
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 10)
self.assertEqual(self.__basket.get_product_amount(product2.get_name()),
5)
# All valid - edge case - all amount in the basket
self.__basket.complete_purchase([{
"product_name":
self.__product.get_name(),
"product_price":
self.__product.get_price(),
"amount":
1
}, {
"product_name": product2.get_name(),
"product_price": product2.get_price(),
"amount": 5
}])
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 9)
self.assertNotIn(product2, self.__basket.get_products())
# All valid - edge case - empty parameter
self.__basket.complete_purchase([])
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 9)
self.assertNotIn(product2, self.__basket.get_products())
# Invalid - product doesn't exist
try:
self.__basket.complete_purchase([{
"product_name":
product2.get_name(),
"product_price":
product2.get_price(),
"amount":
1
}])
except ValueError:
pass
except Exception:
self.fail()
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 9)
self.assertNotIn(product2, self.__basket.get_products())
# Invalid - more then in the basket
try:
self.__basket.complete_purchase([{
"product_name":
self.__product.get_name(),
"product_price":
self.__product.get_price(),
"amount":
100
}])
except ValueError:
pass
except Exception:
self.fail()
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 9)
self.assertNotIn(product2, self.__basket.get_products())
# @logger
def tearDown(self):
self.__basket.remove_product(self.__product.get_name())
if __name__ == '__main__':
unittest.main()
def __repr__(self):
return repr("ShoppingBasketTests")
def test_complete_purchase(self):
self.__basket.remove_product(self.__product.get_name())
self.__basket.add_product(self.__product, 12)
# All valid - one product
self.__basket.complete_purchase([{
"product_name":
self.__product.get_name(),
"product_price":
self.__product.get_price(),
"amount":
1
}])
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 11)
product2 = Product("not Eytan's product", 10, "Eytan's category")
self.__basket.add_product(product2, 6)
# All valid - two products
self.__basket.complete_purchase([{
"product_name":
self.__product.get_name(),
"product_price":
self.__product.get_price(),
"amount":
1
}, {
"product_name": product2.get_name(),
"product_price": product2.get_price(),
"amount": 1
}])
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 10)
self.assertEqual(self.__basket.get_product_amount(product2.get_name()),
5)
# All valid - edge case - all amount in the basket
self.__basket.complete_purchase([{
"product_name":
self.__product.get_name(),
"product_price":
self.__product.get_price(),
"amount":
1
}, {
"product_name": product2.get_name(),
"product_price": product2.get_price(),
"amount": 5
}])
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 9)
self.assertNotIn(product2, self.__basket.get_products())
# All valid - edge case - empty parameter
self.__basket.complete_purchase([])
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 9)
self.assertNotIn(product2, self.__basket.get_products())
# Invalid - product doesn't exist
try:
self.__basket.complete_purchase([{
"product_name":
product2.get_name(),
"product_price":
product2.get_price(),
"amount":
1
}])
except ValueError:
pass
except Exception:
self.fail()
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 9)
self.assertNotIn(product2, self.__basket.get_products())
# Invalid - more then in the basket
try:
self.__basket.complete_purchase([{
"product_name":
self.__product.get_name(),
"product_price":
self.__product.get_price(),
"amount":
100
}])
except ValueError:
pass
except Exception:
self.fail()
self.assertEqual(
self.__basket.get_product_amount(self.__product.get_name()), 9)
self.assertNotIn(product2, self.__basket.get_products())
def setUp(self):
self.__basket = ShoppingBasket()
self.__product = Product("Eytan's product", 12, "Eytan's category")
def test_add_products(self):
product1: Product = Product("Chair", 100, "Furniture")
product3: Product = Product("Sofa", 1, "Furniture")
# All Valid - New Products
self.assertTrue(
self.store.add_products("Eytan", [{"name": "Chair", "price": 100, "category": "Furniture", "amount": 5,
"purchase_type": 0},
{"name": "Sofa", "price": 1, "category": "Furniture", "amount": 3,
"purchase_type": 0}]))
self.assertEqual(len(self.store.get_products_by(2, "")), 2)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
# All valid - Existing products
self.assertTrue(
self.store.add_products("Eytan", [{"name": "Chair", "price": 100, "category": "Furniture", "amount": 6,
"purchase_type": 0}]))
self.assertEqual(len(self.store.get_products_by(2, "")), 2)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
# Invalid Product - negative price
self.assertFalse(
self.store.add_products("Eytan",
[{"name": "Eytan's Toy", "price": -99, "category": "Furniture", "amount": 5,
"purchase_type": 0}])['response'])
self.assertEqual(len(self.store.get_products_by(2, "")), 2)
products_names = [product.get_name() for product in self.store.get_products_by(2, "")]
self.assertFalse("Eytan's Toy" in products_names)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
# Invalid amount - negative amount
self.assertFalse(
self.store.add_products("Eytan",
[{"name": "Eytan's Toy", "price": 1, "category": "Furniture", "amount": -5,
"purchase_type": 0}])['response'])
self.assertEqual(len(self.store.get_products_by(2, "")), 2)
products_names = [product.get_name() for product in self.store.get_products_by(2, "")]
self.assertFalse("Eytan's Toy" in products_names)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
# Invalid Product - invalid name
self.assertFalse(
self.store.add_products("Eytan", [{"name": "", "price": 100, "category": "Furniture", "amount": 5,
"purchase_type": 0}])['response'])
self.assertEqual(len(self.store.get_products_by(2, "")), 2)
products_names = [product.get_name() for product in self.store.get_products_by(2, "")]
self.assertFalse("" in products_names)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
# Invalid Product - invalid category
self.assertFalse(
self.store.add_products("Eytan", [{"name": "Eytan's Toy", "price": 100, "category": "", "amount": 5,
"purchase_type": 0}])['response'])
self.assertEqual(len(self.store.get_products_by(2, "")), 2)
products_names = [product.get_name() for product in self.store.get_products_by(2, "")]
self.assertFalse("Eytan's Toy" in products_names)
self.assertTrue(product1 in self.store.get_products_by(2, ""))
self.assertTrue(product3 in self.store.get_products_by(2, ""))
def test_edit_product(self):
product1_args = ("Chair", 100, "Furniture")
product1: Product = Product(*product1_args)
self.store.add_product("Eytan", *product1_args, 10, 0)
# OP name
# All valid - owner
self.assertTrue(self.store.edit_product(self.owner.get_nickname(), product1.get_name(), "name", "Eytan"))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 0)
product1.set_name("Eytan")
self.assertEqual(len(self.store.get_products_by(1, "Eytan")), 1)
self.assertTrue(product1 in self.store.get_products_by(1, "Eytan"))
# All valid - manager
self.assertTrue(self.store.edit_product(self.manager.get_nickname(), product1.get_name(), "name", "Chair"))
self.assertEqual(len(self.store.get_products_by(1, "Eytan")), 0)
product1.set_name("Chair")
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
self.assertTrue(product1 in self.store.get_products_by(1, "Chair"))
# Invalid - product doesn't exist
self.assertFalse(self.store.edit_product(self.manager.get_nickname(), "product1.get_name()", "name", "Chair2"))
self.assertEqual(len(self.store.get_products_by(1, "product1.get_name()")), 0)
# Invalid - Manager/owner doesn't exist
self.assertFalse(self.store.edit_product("self.manager.get_nickname()", "Chair", "name", "Eytan"))
self.assertEqual(len(self.store.get_products_by(1, "Eytan")), 0)
manager = User()
manager.register("probably eden", "password")
self.store.add_manager(self.owner, manager, [ManagerPermission.EDIT_POLICIES])
# Invalid - Manager without permissions
self.assertFalse(self.store.edit_product(manager, "Chair", "name", "Eytan"))
self.assertEqual(len(self.store.get_products_by(1, "Eytan")), 0)
# OP price
# All valid - owner
self.assertTrue(self.store.edit_product(self.owner.get_nickname(), product1.get_name(), "price", 20))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
product1.set_price(20)
self.assertTrue(product1 in self.store.get_products_by(1, "Chair"))
# All valid - manager
self.assertTrue(self.store.edit_product(self.manager.get_nickname(), product1.get_name(), "price", 2))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
product1.set_price(2)
self.assertTrue(product1 in self.store.get_products_by(1, "Chair"))
# All valid - float
self.assertTrue(self.store.edit_product(self.manager.get_nickname(), product1.get_name(), "price", 2.12))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
product1.set_price(2.12)
self.assertTrue(product1 in self.store.get_products_by(1, "Chair"))
# All valid - edge case - 0
self.assertTrue(self.store.edit_product(self.manager.get_nickname(), product1.get_name(), "price", 0))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
product1.set_price(0)
self.assertTrue(product1 in self.store.get_products_by(1, "Chair"))
# Invalid - product doesn't exist
self.assertFalse(self.store.edit_product(self.manager.get_nickname(), "product1.get_name()", "price", 20))
self.assertEqual(len(self.store.get_products_by(1, "product1.get_name()")), 0)
for product in self.store.get_products_by(2, ""):
self.assertFalse(product.get_price() == 20)
# Invalid - Manager/owner doesn't exist
self.assertFalse(self.store.edit_product("self.manager.get_nickname()", "Chair", "price", 15))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
self.assertFalse(self.store.get_products_by(1, "Chair")[0].get_price(), 15)
manager = User()
manager.register("probably eden", "password")
self.store.add_manager(self.owner, manager, [ManagerPermission.EDIT_POLICIES])
# Invalid - Manager without permissions
self.assertFalse(self.store.edit_product(manager, "Chair", "price", 13))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
self.assertFalse(self.store.get_products_by(1, "Chair")[0].get_price(), 13)
# Invalid - negative price
self.assertFalse(self.store.edit_product(manager, "Chair", "price", -13))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
self.assertFalse(self.store.get_products_by(1, "Chair")[0].get_price(), -13)
# OP amount
# All valid - owner
self.assertTrue(self.store.edit_product(self.owner.get_nickname(), product1.get_name(), "amount", 20))
self.assertEqual(self.store.get_inventory().get_amount("Chair"), 20)
# All valid - manager
self.assertTrue(self.store.edit_product(self.manager.get_nickname(), product1.get_name(), "amount", 2))
self.assertEqual(self.store.get_inventory().get_amount("Chair"), 2)
# All valid - edge case - 0
self.assertTrue(self.store.edit_product(self.manager.get_nickname(), product1.get_name(), "amount", 0))
self.assertEqual(self.store.get_inventory().get_amount("Chair"), 0)
# Invalid - product doesn't exist
self.assertFalse(self.store.edit_product(self.manager.get_nickname(), "product1.get_name()", "amount", 20))
self.assertEqual(len(self.store.get_products_by(1, "product1.get_name()")), 0)
for product in self.store.get_products_by(2, ""):
self.assertFalse(self.store.get_inventory().get_amount(product.get_name()) == 20)
# Invalid - Manager/owner doesn't exist
self.assertFalse(self.store.edit_product("self.manager.get_nickname()", "Chair", "amount", 15))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
self.assertFalse(self.store.get_inventory().get_amount("Chair"), 15)
manager = User()
manager.register("probably eden", "password")
self.store.add_manager(self.owner, manager, [ManagerPermission.EDIT_POLICIES])
# Invalid - Manager without permissions
self.assertFalse(self.store.edit_product(manager, "Chair", "amount", 13))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
self.assertFalse(self.store.get_inventory().get_amount("Chair"), 13)
# Invalid - negative price
self.assertFalse(self.store.edit_product(manager, "Chair", "amount", -13))
self.assertEqual(len(self.store.get_products_by(1, "Chair")), 1)
self.assertFalse(self.store.get_inventory().get_amount("Chair"), -13)
def test_update_quantity(self):
# def update_quantity(products_details: [{"product_name": str, "store_name": str, "amount": int}]):
product1: Product = Product("not Eytan's product", 9,
"Eytan's category")
store1: Store = Store("Not my store")
product2: Product = Product("maybe Eytan's product", 8,
"Eytan's category")
product_as_dictionary_var1 = {
"product": product1,
"amount": 3,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
product_as_dictionary_var3 = {
"product": product1,
"amount": 12,
"store_name": store1.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
product_as_dictionary_var2 = {
"product": product2,
"amount": 5,
"store_name": store1.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
self.__shopping_cart.add_products([
self.__product_as_dictionary, product_as_dictionary_var1,
product_as_dictionary_var2, product_as_dictionary_var3
])
# All Valid - product only in one store
self.assertTrue(
self.__shopping_cart.update_quantity([{
"product_name":
self.__product.get_name(),
"store_name":
self.__store.get_name(),
"amount":
123
}])['response'])
self.assertEqual(
123,
self.__shopping_cart.get_store_basket(
self.__store.get_name()).get_product_amount(
self.__product.get_name()))
# All Valid - product in two stores, but change only in one
self.assertTrue(
self.__shopping_cart.update_quantity([{
"product_name":
product1.get_name(),
"store_name":
self.__store.get_name(),
"amount":
234
}])['response'])
self.assertEqual(
234,
self.__shopping_cart.get_store_basket(
self.__store.get_name()).get_product_amount(
product1.get_name()))
self.assertEqual(
12,
self.__shopping_cart.get_store_basket(
store1.get_name()).get_product_amount(product1.get_name()))
# Invalid - product not in store
self.assertFalse(
self.__shopping_cart.update_quantity([{
"product_name":
product2.get_name(),
"store_name":
self.__store.get_name(),
"amount":
234
}])['response'])
self.assertNotEqual(
234,
self.__shopping_cart.get_store_basket(
store1.get_name()).get_product_amount(product2.get_name()))
# Invalid - negative amount
self.assertFalse(
self.__shopping_cart.update_quantity([{
"product_name":
self.__product.get_name(),
"store_name":
self.__store.get_name(),
"amount":
-999
}])['response'])
self.assertNotEqual(
-999,
self.__shopping_cart.get_store_basket(
self.__store.get_name()).get_product_amount(
self.__product.get_name()))
def __init__(self):
super().__init__()
self.__inventory = [(Product("Chair", 100, "Furniture"), 5),
(Product("Sofa", 100, "Furniture"), 5),
(Product("Guitar", 100, "Musical Instruments"), 5)]
class StoreInventoryTests(unittest.TestCase):
# @logger
def setUp(self):
self.inv = StoreInventory()
self.product1 = Product("Chair", 100, "Furniture")
self.product1.set_purchase_type(0)
self.product2 = Product("Sofa", 10, "Furniture")
self.product2.set_purchase_type(0)
self.product3 = Product("Guitar", 1000, "Musical Instruments")
self.product3.set_purchase_type(0)
# @logger
def test_add_product(self):
# All valid - None existing product
self.assertTrue(self.inv.add_product(self.product1, 5))
self.assertEqual(self.inv.get_amount("Chair"), 5)
# All valid - Existing product
self.assertTrue(self.inv.add_product(self.product1, 5))
self.assertEqual(self.inv.get_amount("Chair"), 10)
# Invalid - Illegal amount
self.assertFalse(self.inv.add_product(self.product2, -8))
# @logger
def test_get_product(self):
self.inv.add_product(self.product1, 5)
# All valid
product = self.inv.get_product("Chair")
self.assertIsNotNone(product)
self.assertEqual(product.get_name(), "Chair")
self.assertEqual(product.get_price(), 100)
self.assertEqual(product.get_category(), "Furniture")
# Invalid -> none existing product
self.assertIsNone(self.inv.get_product("Sofa"))
# @logger
def test_get_products_by(self):
self.inv.add_product(self.product1, 4)
self.inv.add_product(self.product2, 5)
self.inv.add_product(self.product3, 6)
# option 1 = search by name
# All valid
products_list = self.inv.get_products_by(1, "Chair")
self.assertEqual(len(products_list), 1)
self.assertTrue(self.product1 in products_list)
# Invalid -> none existing product
products_list = self.inv.get_products_by(1, "Eytan")
self.assertEqual(len(products_list), 0)
# option 2 = search by keyword
products_list = self.inv.get_products_by(2, "r")
self.assertEqual(len(products_list), 2)
self.assertTrue(self.product1 in products_list)
self.assertTrue(self.product3 in products_list)
# Invalid -> none existing keyword
products_list = self.inv.get_products_by(2, "Eytan")
self.assertEqual(len(products_list), 0)
# option 3 = search by category
products_list = self.inv.get_products_by(3, "Furniture")
self.assertEqual(len(products_list), 2)
self.assertTrue(self.product1 in products_list)
self.assertTrue(self.product2 in products_list)
products_list = self.inv.get_products_by(3, "Musical Instruments")
self.assertEqual(len(products_list), 1)
self.assertTrue(self.product3 in products_list)
# Invalid -> none existing category
products_list = self.inv.get_products_by(3, "Eytan")
self.assertEqual(len(products_list), 0)
# @logger
def test_remove_product(self):
self.inv.add_product(self.product1, 4)
self.inv.add_product(self.product2, 2)
# All valid
self.assertTrue(self.inv.remove_product(self.product1.get_name()))
self.assertEqual(len(self.inv.get_products_by(2, "")), 1)
self.assertTrue(self.product2 in self.inv.get_products_by(2, ""))
# Invalid -> None existing product
self.assertFalse(self.inv.remove_product("eden"))
self.assertEqual(len(self.inv.get_products_by(2, "")), 1)
# @logger
def test_change_amount(self):
self.inv.add_product(self.product1, 4)
self.inv.add_product(self.product2, 2)
# All valid
self.assertTrue(self.inv.change_amount("Chair", 16))
self.assertEqual(self.inv.get_amount("Sofa"), 2)
# All valid -> 0 amount
self.assertTrue(self.inv.change_amount("Chair", 0))
self.assertEqual(self.inv.get_amount("Chair"), 0)
self.assertEqual(self.inv.get_amount("Sofa"), 2)
# Invalid -> negative amount
self.assertFalse(self.inv.change_amount("Chair", -16))
self.assertEqual(self.inv.get_amount("Chair"), 0)
self.assertEqual(self.inv.get_amount("Sofa"), 2)
# Invalid -> none existing product name
self.assertFalse(self.inv.change_amount("Eytan", 12))
self.assertEqual(self.inv.get_amount("Chair"), 0)
self.assertEqual(self.inv.get_amount("Sofa"), 2)
product_names = [p.get_name() for p in self.inv.get_products_by(2, "")]
self.assertFalse("Eytan" in product_names)
# @logger
def test_len(self):
# All valid -> Empty inventory
self.assertEqual(self.inv.len(), 0)
self.inv.add_product(self.product1, 4)
# All valid -> Not empty inventory -> one product.
self.assertEqual(self.inv.len(), 1)
self.inv.add_product(self.product2, 4)
# All valid -> Not empty inventory -> more then one product.
self.assertEqual(self.inv.len(), 2)
# All valid -> Check that the inventory doesn't change while adding an invalid product.
try:
self.inv.add_product(Product("Eytan", -100, "Different Eytan"), 12)
except ValueError:
""
self.assertEqual(self.inv.len(), 2)
self.inv.add_product(Product("Eytan", 100, "Different Eytan"), -12)
self.assertEqual(self.inv.len(), 2)
# @logger
def test_get_amount_of_product(self):
# All valid -> none existing product
self.assertEqual(self.inv.get_amount("Chair"), 0)
self.inv.add_product(self.product1, 4)
# All valid -> amount > 0
self.assertEqual(self.inv.get_amount("Chair"), 4)
self.inv.change_amount(self.product1.get_name(), 0)
# All valid -> amount = 0
self.assertEqual(self.inv.get_amount("Chair"), 0)
# @logger
def test_is_in_stock(self):
self.inv.add_product(self.product1, 10)
# All valid
result = self.inv.is_in_stock(self.product1.get_name(), 9)
self.assertTrue(result)
# All valid - Edge case
result = self.inv.is_in_stock(self.product1.get_name(), 10)
self.assertTrue(result)
# All valid - Edge case 2
result = self.inv.is_in_stock(self.product1.get_name(), 0)
self.assertTrue(result)
# product name not valid
result = self.inv.is_in_stock("self.product1", 10)
self.assertFalse(result)
# amount not valid
result = self.inv.is_in_stock(self.product1.get_name(), -10)
self.assertFalse(result)
def __repr__(self):
return repr("StoreInventoryTests")
class StoreInventoryTests(unittest.TestCase):
def setUp(self):
self.inv = StoreInventory()
self.product1 = Product("Chair", 100, "Furniture")
self.product2 = Product("Sofa", 100, "Furniture")
self.product3 = Product("Guitar", 100, "Musical Instruments")
def test_add_product(self):
self.assertTrue(self.inv.add_product(self.product1, 5))
self.assertEqual(self.inv.get_amount("Chair"), 5)
self.assertTrue(self.inv.add_product(self.product1, 5))
self.assertEqual(self.inv.get_amount("Chair"), 10)
self.assertTrue(self.inv.add_product(self.product2, 8))
self.assertTrue(self.inv.add_product(self.product2, 8))
self.assertFalse(self.inv.add_product(self.product2, -8))
def test_get_product(self):
self.inv.add_product(self.product1, 5)
product = self.inv.get_product("Chair")
self.assertNotEqual(product, None)
self.assertEqual(product.get_name(), "Chair")
self.assertEqual(product.get_price(), 100)
self.assertEqual(product.get_category(), "Furniture")
self.assertEqual(self.inv.get_product("Sofa"), None)
def test_get_products_by(self):
self.inv.add_product(self.product1, 4)
self.inv.add_product(self.product2, 5)
self.inv.add_product(self.product3, 6)
# option 1 = search by name
products_list = self.inv.get_products_by(1, "Chair")
self.assertEqual(len(products_list), 1)
self.assertEqual(products_list[0].get_name(), "Chair")
# option 2 = search by keyword
products_list = self.inv.get_products_by(2, "r")
self.assertEqual(len(products_list), 2)
self.assertEqual(products_list[0].get_name(), "Chair")
self.assertEqual(products_list[1].get_name(), "Guitar")
# option 3 = search by category
products_list = self.inv.get_products_by(3, "Furniture")
self.assertEqual(len(products_list), 2)
self.assertEqual(products_list[0].get_name(), "Chair")
self.assertEqual(products_list[1].get_name(), "Sofa")
products_list = self.inv.get_products_by(3, "Musical Instruments")
self.assertEqual(len(products_list), 1)
self.assertEqual(products_list[0].get_name(), "Guitar")
products_list = self.inv.get_products_by(3, "Musical Instruments bbbb")
self.assertEqual(len(products_list), 0)
def test_remove_product(self):
self.inv.add_product(self.product1, 4)
self.inv.add_product(self.product2, 4)
self.assertTrue(self.inv.remove_product(self.product1.get_name()))
self.assertEqual(len(self.inv.get_products_by(2, "")), 1)
self.assertFalse(self.inv.remove_product("eden"))
self.assertEqual(len(self.inv.get_products_by(2, "")), 1)
def test_change_amount(self):
self.inv.add_product(self.product1, 4)
self.inv.add_product(self.product2, 4)
self.assertTrue(self.inv.change_amount("Chair", 16))
self.assertFalse(self.inv.change_amount("Chair", -16))
self.assertEqual(self.inv.get_amount("Chair"), 16)
self.assertEqual(self.inv.get_amount("Sofa"), 4)
def test_len(self):
self.assertEqual(self.inv.len(), 0)
self.inv.add_product(self.product1, 4)
self.assertEqual(self.inv.len(), 1)
self.inv.add_product(self.product2, 4)
self.assertEqual(self.inv.len(), 2)
def test_get_amount_of_product(self):
self.inv.add_product(self.product1, 4)
self.assertEqual(self.inv.get_amount("Chair"), 4)
self.inv.add_product(self.product2, 16)
self.assertEqual(self.inv.get_amount("Sofa"), 16)
self.assertEqual(self.inv.get_amount("Guitar"), 0)
def test_is_in_stock(self):
self.inv.add_product(self.product1, 10)
# All valid
result = self.inv.is_in_stock(self.product1.get_name(), 9)
self.assertTrue(result)
# All valid - Edge case
result = self.inv.is_in_stock(self.product1.get_name(), 10)
self.assertTrue(result)
# All valid - Edge case 2
result = self.inv.is_in_stock(self.product1.get_name(), 0)
self.assertTrue(result)
# product name not valid
result = self.inv.is_in_stock("self.product1", 10)
self.assertFalse(result)
# amount not valid
result = self.inv.is_in_stock(self.product1.get_name(), -10)
self.assertFalse(result)
def __repr__(self):
return repr("StoreInventoryTests")
class ShoppingCartTests(unittest.TestCase):
def setUp(self):
self.__shopping_cart = ShoppingCart()
self.__product = Product("Eytan's product", 12, "Eytan's category")
self.__store: Store = Store("myStore")
self.__product_as_dictionary = {
"product": self.__product,
"amount": 4,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
self.__product_to_add = (self.__product_as_dictionary['product'],
self.__product_as_dictionary['amount'])
def test_add_products(self):
basket = ShoppingBasket()
basket.add_product(*self.__product_to_add)
expected = {"store_name": self.__store.get_name(), "basket": basket}
# All valid
self.assertTrue(
self.__shopping_cart.add_products([self.__product_as_dictionary
])['response'])
res = self.__shopping_cart.get_shopping_baskets()
self.assertEqual(len(res), 1)
res = res[0]
self.assertTrue(
res['store_name'] == self.__store.get_name()
and res['basket'].get_products()[0]['product'].get_name()
== self.__product.get_name())
# self.assertIn(expected, self.__shopping_cart.get_shopping_baskets())
# Valid - empty basket
self.assertTrue(self.__shopping_cart.add_products([])['response'])
res = self.__shopping_cart.get_shopping_baskets()
# [{'store_name', 'basket': ShoppingBasket}]
# ShoppingBasket.get_products = [{'product', 'amount'}]
self.assertEqual(len(res), 1)
res = res[0]
self.assertTrue(
res['store_name'] == self.__store.get_name()
and res['basket'].get_products()[0]['product'].get_name()
== self.__product.get_name())
# self.assertIn(expected, self.__shopping_cart.get_shopping_baskets())
# invalid - basket = None
self.assertFalse(
self.__shopping_cart.add_products(
[self.__product_as_dictionary, None])['response'])
res = self.__shopping_cart.get_shopping_baskets()
# [{'store_name', 'basket': ShoppingBasket}]
# ShoppingBasket.get_products = [{'product', 'amount'}]
self.assertEqual(len(res), 1)
res = res[0]
self.assertTrue(
res['store_name'] == self.__store.get_name()
and res['basket'].get_products()[0]['product'].get_name()
== self.__product.get_name())
# self.assertIn(expected, self.__shopping_cart.get_shopping_baskets())
bad_basket = {
"product": None,
"amount": 4,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
# invalid - product = None
self.assertFalse(
self.__shopping_cart.add_products([bad_basket])['response'])
res = self.__shopping_cart.get_shopping_baskets()
# [{'store_name', 'basket': ShoppingBasket}]
# ShoppingBasket.get_products = [{'product', 'amount'}]
self.assertEqual(len(res), 1)
res = res[0]
self.assertTrue(
res['store_name'] == self.__store.get_name()
and res['basket'].get_products()[0]['product'].get_name()
== self.__product.get_name())
# self.assertIn(expected, self.__shopping_cart.get_shopping_baskets())
bad_basket = {
"product": self.__product,
"amount": -4,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
# invalid - negative amount
self.assertFalse(
self.__shopping_cart.add_products([bad_basket])['response'])
res = self.__shopping_cart.get_shopping_baskets()
# [{'store_name', 'basket': ShoppingBasket}]
# ShoppingBasket.get_products = [{'product', 'amount'}]
self.assertEqual(len(res), 1)
res = res[0]
self.assertTrue(
res['store_name'] == self.__store.get_name()
and res['basket'].get_products()[0]['product'].get_name()
== self.__product.get_name())
# self.assertIn(expected, self.__shopping_cart.get_shopping_baskets())
bad_basket = {
"product": self.__product,
"amount": 0,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
# invalid - Edge case - amount = 0
self.assertFalse(
self.__shopping_cart.add_products([bad_basket])['response'])
res = self.__shopping_cart.get_shopping_baskets()
# [{'store_name', 'basket': ShoppingBasket}]
# ShoppingBasket.get_products = [{'product', 'amount'}]
self.assertEqual(len(res), 1)
res = res[0]
self.assertTrue(
res['store_name'] == self.__store.get_name()
and res['basket'].get_products()[0]['product'].get_name()
== self.__product.get_name())
# self.assertIn(expected, self.__shopping_cart.get_shopping_baskets())
def test_remove_products(self):
product1: Product = Product("not Eytan's product", 9,
"Eytan's category")
store1: Store = Store("Not my store")
product2: Product = Product("maybe Eytan's product", 8,
"Eytan's category")
product_as_dictionary_var1 = {
"product": product1,
"amount": 3,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
product_as_dictionary_var2 = {
"product": product2,
"amount": 5,
"store_name": store1.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
product_as_dictionary_var3 = {
"product": product1,
"amount": 12,
"store_name": store1.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
self.__shopping_cart.add_products([
self.__product_as_dictionary, product_as_dictionary_var1,
product_as_dictionary_var2, product_as_dictionary_var3
])
# All valid
self.assertTrue(
self.__shopping_cart.remove_products([{
"product_name":
self.__product.get_name(),
"store_name":
self.__store.get_name()
}]))
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 2)
stores = [
store_and_basket['store_name'] for store_and_basket in
self.__shopping_cart.get_shopping_baskets()
]
self.assertTrue(self.__store.get_name() in stores)
self.assertTrue(store1.get_name() in stores)
product_as_dictionary_lst_self_store = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products_self_store = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst_self_store
]
product_as_dictionary_lst_store1 = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products_store1 = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst_store1
]
self.assertTrue(product1 in products_self_store)
self.assertTrue(product1 in products_store1)
self.assertTrue(product2 in products_store1)
self.assertFalse(
self.__product in product_as_dictionary_lst_self_store)
# Invalid - product isn't in the store
self.assertFalse(
self.__shopping_cart.remove_products([{
"product_name":
product2.get_name(),
"store_name":
self.__store.get_name()
}])['response'])
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 2)
stores = [
store_and_basket['store_name'] for store_and_basket in
self.__shopping_cart.get_shopping_baskets()
]
self.assertTrue(self.__store.get_name() in stores)
self.assertTrue(store1.get_name() in stores)
product_as_dictionary_lst_self_store = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products_self_store = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst_self_store
]
product_as_dictionary_lst_store1 = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products_store1 = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst_store1
]
self.assertTrue(product1 in products_self_store)
self.assertTrue(product1 in products_store1)
self.assertTrue(product2 in products_store1)
self.assertFalse(
self.__product in product_as_dictionary_lst_self_store)
# All valid - make the basket empty
self.assertTrue(
self.__shopping_cart.remove_products([{
"product_name":
product1.get_name(),
"store_name":
self.__store.get_name()
}])['response'])
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 1)
stores = [
store_and_basket['store_name'] for store_and_basket in
self.__shopping_cart.get_shopping_baskets()
]
self.assertFalse(self.__store.get_name() in stores)
self.assertTrue(store1.get_name() in stores)
product_as_dictionary_lst = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst
]
self.assertTrue(product1 in products)
self.assertTrue(product2 in products)
# Invalid - product doesn't exist
self.assertFalse(
self.__shopping_cart.remove_products([{
"product_name":
"product1.get_name()",
"store_name":
store1.get_name()
}])['response'])
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 1)
stores = [
store_and_basket['store_name'] for store_and_basket in
self.__shopping_cart.get_shopping_baskets()
]
self.assertTrue(store1.get_name() in stores)
product_as_dictionary_lst = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst
]
self.assertTrue(product1 in products)
self.assertTrue(product2 in products)
# Invalid - store doesn't exist
self.assertFalse(
self.__shopping_cart.remove_products([{
"product_name":
product1.get_name(),
"store_name":
"store1.get_name()"
}])['response'])
self.assertEqual(len(self.__shopping_cart.get_shopping_baskets()), 1)
stores = [
store_and_basket['store_name'] for store_and_basket in
self.__shopping_cart.get_shopping_baskets()
]
self.assertTrue(store1.get_name() in stores)
product_as_dictionary_lst = self.__shopping_cart.get_store_basket(
store1.get_name()).get_products()
products = [
product_as_dictionary['product']
for product_as_dictionary in product_as_dictionary_lst
]
self.assertTrue(product1 in products)
self.assertTrue(product2 in products)
def test_update_quantity(self):
# def update_quantity(products_details: [{"product_name": str, "store_name": str, "amount": int}]):
product1: Product = Product("not Eytan's product", 9,
"Eytan's category")
store1: Store = Store("Not my store")
product2: Product = Product("maybe Eytan's product", 8,
"Eytan's category")
product_as_dictionary_var1 = {
"product": product1,
"amount": 3,
"store_name": self.__store.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
product_as_dictionary_var3 = {
"product": product1,
"amount": 12,
"store_name": store1.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
product_as_dictionary_var2 = {
"product": product2,
"amount": 5,
"store_name": store1.get_name(),
"discount_type": DiscountType.DEFAULT,
"purchase_type": PurchaseType.DEFAULT
}
self.__shopping_cart.add_products([
self.__product_as_dictionary, product_as_dictionary_var1,
product_as_dictionary_var2, product_as_dictionary_var3
])
# All Valid - product only in one store
self.assertTrue(
self.__shopping_cart.update_quantity([{
"product_name":
self.__product.get_name(),
"store_name":
self.__store.get_name(),
"amount":
123
}])['response'])
self.assertEqual(
123,
self.__shopping_cart.get_store_basket(
self.__store.get_name()).get_product_amount(
self.__product.get_name()))
# All Valid - product in two stores, but change only in one
self.assertTrue(
self.__shopping_cart.update_quantity([{
"product_name":
product1.get_name(),
"store_name":
self.__store.get_name(),
"amount":
234
}])['response'])
self.assertEqual(
234,
self.__shopping_cart.get_store_basket(
self.__store.get_name()).get_product_amount(
product1.get_name()))
self.assertEqual(
12,
self.__shopping_cart.get_store_basket(
store1.get_name()).get_product_amount(product1.get_name()))
# Invalid - product not in store
self.assertFalse(
self.__shopping_cart.update_quantity([{
"product_name":
product2.get_name(),
"store_name":
self.__store.get_name(),
"amount":
234
}])['response'])
self.assertNotEqual(
234,
self.__shopping_cart.get_store_basket(
store1.get_name()).get_product_amount(product2.get_name()))
# Invalid - negative amount
self.assertFalse(
self.__shopping_cart.update_quantity([{
"product_name":
self.__product.get_name(),
"store_name":
self.__store.get_name(),
"amount":
-999
}])['response'])
self.assertNotEqual(
-999,
self.__shopping_cart.get_store_basket(
self.__store.get_name()).get_product_amount(
self.__product.get_name()))
def test_remove_store_basket(self):
expected_basket = ShoppingBasket()
expected_basket.add_product(*self.__product_to_add)
self.__shopping_cart.add_products([self.__product_as_dictionary])
# All valid - store exist
self.assertTrue(
self.__shopping_cart.remove_store_basket(self.__store.get_name()))
self.assertEqual(0, len(self.__shopping_cart.get_shopping_baskets()))
# Invalid - store doesn't exist
self.assertFalse(
self.__shopping_cart.remove_store_basket(
"self.__store.get_name()"))
def test_get_store_basket(self):
expected_basket = ShoppingBasket()
expected_basket.add_product(*self.__product_to_add)
self.__shopping_cart.add_products([self.__product_as_dictionary])
# All valid - store exist
res = self.__shopping_cart.get_store_basket(
self.__store.get_name()).get_products()[0]['product'].get_name()
self.assertEqual(self.__product.get_name(), res)
# self.assertEqual(expected_basket, self.__shopping_cart.get_store_basket(self.__store.get_name()))
# Invalid - store doesn't exist
self.assertIsNone(
self.__shopping_cart.get_store_basket("self.__store.get_name()"))
def tearDown(self):
pass
if __name__ == '__main__':
unittest.main()
def __repr__(self):
return repr("ShoppingCartTests")