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 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 add_products(self, products_stores_quantity_ls: [{"store_name": str,
"product": Product,
"amount": int}]) -> {'response': bool, 'msg': str}:
"""
The function iterate over the list to see if all the arguments are valid.
If all the arguments are valid, and the basket exist, the function add the products the corresponding basket.
If all the arguments are valid, and the basket doesn't exist, the function create the basket and then
add the products the corresponding basket.
If not all the arguments are valid, the function do nothing and return false.
:param products_stores_quantity_ls: list of products to add.
:return:
If all the arguments are valid, and the basket exist, the function add the products the corresponding
basket.
If all the arguments are valid, and the basket doesn't exist, the function create the basket and then
add the products the corresponding basket.
If not all the arguments are valid, the function do nothing and return false.
"""
# Check if the arguments are valid.
for curr in products_stores_quantity_ls:
if curr is None:
return {'response': False, 'msg': "Error! invalid input"}
else:
if curr['product'] is None:
return {'response': False, 'msg': "Error! invalid input"}
if curr['amount'] <= 0:
return {'response': False, 'msg': "Error! the amount of product " + curr['product'].get_name() +
"is >= 0. A product amount must be bigger than 0"}
# Rest of the function
for curr in products_stores_quantity_ls:
basket = self.get_store_basket(curr["store_name"])
if basket:
basket.add_product(curr["product"], curr["amount"])
else:
basket = ShoppingBasket()
basket.add_product(curr["product"], curr["amount"])
self.__shopping_baskets.append({"store_name": curr["store_name"], "basket": basket})
return {'response': True, 'msg': "Products were added to shopping cart successfully"}
def setUp(self):
# self.user.logoutState = StubLogout()
# self.__valid_name = "anna9218"
# self.__valid_pass = "******"
# self.__invalid_input = ""
# self.__product = StubProduct()
# self.__store = StubStore()
# self.__product_ls_to_add = [[self.__product, self.__store, 1]] # products_stores_quantity_ls
self.__user = User()
self.__registration_state_mock = Registration()
self.__login_state_mock = Login()
self.__shopping_cart_mock = ShoppingCart()
self.__purchase_history_mock = []
self.__purchase_mock = Purchase([], 10.0, "store_name", "username")
self.__shopping_basket_mock = ShoppingBasket()
def setUp(self):
self.__basket = ShoppingBasket()
self.__product = StubProduct()
class ShoppingBasketTests(unittest.TestCase):
def setUp(self):
self.__basket = ShoppingBasket()
self.__product = StubProduct()
def test_update_amount(self):
self.__basket.add_product(self.__product, 2)
self.assertEqual(self.__basket.get_product_amount("Alcogel"), 2)
self.__basket.update_amount(self.__product.get_name(), 5)
self.assertEqual(self.__basket.get_product_amount("Alcogel"), 5)
self.__basket.update_amount(self.__product.get_name(), 1)
self.assertEqual(self.__basket.get_product_amount("Alcogel"), 1)
def test_is_empty(self):
self.assertTrue(self.__basket.is_empty())
self.__basket.add_product(self.__product, 2)
self.assertFalse(self.__basket.is_empty())
def test_add_product(self):
self.assertTrue(self.__basket.add_product(self.__product, 2))
self.assertIn({"product": self.__product, "amount": 2}, self.__basket)
def test_remove_product(self):
self.__basket.add_product(self.__product, 2)
self.assertTrue(self.__basket.remove_product(
self.__product.get_name()))
self.assertFalse(self.__basket.get_products())
self.assertNotIn([self.__product, 2], self.__basket)
def tearDown(self):
pass
if __name__ == '__main__':
unittest.main()
def __repr__(self):
return repr("ShoppingBasketTests")
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 setUp(self):
self.__basket = ShoppingBasket()
self.__product = Product("Eytan's product", 12, "Eytan's category")
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())