def test_change_details_of_product(self):
user1 = User("amir", 1)
user1.identifier = 0
user1.username = "******"
user1.password = "******"
user1.state = State.STORE_OWNER
user1.is_logged_in = True
store1 = Store("mega", 1, "123123", None, None)
store1.store_number = 1
product1 = Product('chocholate', 'Food', ['Food', 'Sweet'], 10)
product1.catalog_number = 1
store1.owners = [0]
store1.add_new_product(product1)
Ecommerce.get_instance().subscribers = [user1]
Ecommerce.get_instance().stores = [store1]
self.assertTrue(
user1.change_details_of_product(1, "name", "whiteChocholate").val,
"need return True")
self.assertFalse(
user1.change_details_of_product(2, "name", "whiteChocholate").val,
"need return False")
def test_search_product(self): #ok
store1 = Store("ramiLevi", 0, "123123", None, None)
store1.store_number = 0
product1 = Product('Apple', 'Fruits', ['Food', 'Fruit', 'Apple'], 5)
product1.catalog_number = 0
store1.add_new_product(product1)
Ecommerce.get_instance().stores = [store1]
self.assertEqual(len(User.search_product("name", "Apple").val), 1,
'bad')
def test_add_to_cart(self): #ok
user1 = User("amir", 12)
product1 = Product('chocholate', 'Food', ['Food', 'Sweet'], 10)
product1.catalog_number = 1
store1 = Store("ramiLevi", 0, "123123", None, None)
store1.add_new_product(product1)
Ecommerce.get_instance().stores = [store1]
store1.inc_product_amount(1, 5)
self.assertTrue(user1.add_to_cart(1).val, "need return True")
self.assertFalse(user1.add_to_cart(9).val, "need return False")
def test_contains_product(self):
store = Store('schnitzale', 23444, 4, None, None)
cart = ShoppingCart(store)
product = Product('france schnitzel', 'schnitzel', ['hot', 'crispy'],
35)
self.assertFalse(cart.contains_product(product))
store.add_new_product(product)
store.inc_product_amount(product.catalog_number, 5)
cart.products[product.catalog_number] = {
'product': product,
'amount': 1
}
self.assertTrue(cart.contains_product(product))
def test_remove_from_cart(self): #ok
user1 = User("amir", 32)
user1.identifier = 1
user1.state = State.STORE_OWNER
product1 = Product('chocholate', 'Food', ['Food', 'Sweet'], 10)
product1.catalog_number = 1
store1 = Store("ramiLevi", 0, "123123", None, None)
store1.store_number = 0
store1.supervisor = 1
store1.add_new_product(product1)
store1.owners = [user1.identifier]
Ecommerce.get_instance().stores = [store1]
self.assertTrue(user1.remove_product(0, 1).val, "need return True")
self.assertFalse(user1.remove_product(0, 1).val, "need return False")
def test_remove_product(self): #ok
user1 = User("amir", 12)
user1.identifier = 0
store1 = Store("mega", 0, "456456", None, None)
store1.store_number = 1
product1 = Product('chocholate', 'Food', ['Food', 'Sweet'], 10)
product1.catalog_number = 1
store1.add_new_product(product1)
Ecommerce.get_instance().stores = [store1]
user1.state = State.GUEST
self.assertFalse(user1.remove_product(1, 1).val, "need return False")
user1.state = State.STORE_OWNER
self.assertTrue(user1.remove_product(1, 1), "need return True")
self.assertFalse(user1.remove_product(1, 10).val, "need return False")
def test_remove_product(self):
store = Store('schnitzale', 23444, 4, None, None)
cart = ShoppingCart(store)
product = Product('france schnitzel', 'schnitzel', ['hot', 'crispy'],
35)
store.add_new_product(product)
store.inc_product_amount(product.catalog_number, 5)
cart.products[product.catalog_number] = {
'product': product,
'amount': 2
}
cart.remove_product(product)
self.assertEqual(cart.products[product.catalog_number], {
'product': product,
'amount': 1
})
cart.remove_product(product)
self.assertEqual(len(cart.products), 0)
def test_inc_product_amount(self): #ok
user1 = User("amir", 13)
user1.identifier = 0
store1 = Store("ramiLevi", 0, "123123", None, None)
store1.store_number = 0
product1 = Product('Banana', 'Fruits', ['Food', 'Fruit', 'Apple'], 5)
product1.catalog_number = 0
store1.add_new_product(product1)
Ecommerce.get_instance().stores = [store1]
user1.state = State.GUEST
self.assertFalse(
user1.inc_product_amount(0, 0, 3).val, "need return False")
user1.state = State.STORE_OWNER
self.assertTrue(
user1.inc_product_amount(0, 0, 3).val, "need return True")
self.assertFalse(
user1.inc_product_amount(100, 0, 3).val, "need return False")
self.assertFalse(
user1.inc_product_amount(0, 10, 3).val, "need return False")
def test_get_transactions_by_identifier(self):
discount_service = DiscountService()
buying_policy = BuyingPolicyService()
store = Store('effect', 123, 123, discount_service, buying_policy)
cart = ShoppingCart(store)
product_a = Product('france schnitzel', 'schnitzel', ['hot', 'krispy'],
35)
store.add_new_product(product_a)
store.inc_product_amount(product_a.catalog_number, 5)
cart.add_product(product_a)
delivery_address = DeliveryAddress(123, 'Israel')
trans = (self.transaction_management.execute_transaction(
123, cart, 'paypal',
['ofek', '4580160114431651', '7', '20', '458'], delivery_address,
123)).val
self.assertEqual(
self.transaction_management.get_transactions_by_identifier(123),
[trans])
self.assertEqual(
self.transaction_management.get_transactions_by_store(12), [])
def test_remove_product_from_cart(self):
user = User('Shlomo', 18)
user.state = State.SUBSCRIBER
store = Store("Fruit Store", 5, 123456, None, None)
store.store_number = 0
existing_product = Product('Mexican Schnitzel', 'Schnitzels', ['hot', 'crispy', 'spicy'], 45)
non_existing_product = Product('African Schnitzel', 'Schnitzels', ['???'], 567)
Ecommerce.get_instance().subscribers = [user]
Ecommerce.get_instance().stores = [store]
store.add_new_product(existing_product)
store.inc_product_amount(existing_product.catalog_number, 5)
Ecommerce.get_instance().add_to_cart(user.shopping_basket, existing_product.catalog_number)
self.assertFalse((Ecommerce.get_instance().remove_from_cart(user.shopping_basket,
non_existing_product.catalog_number)).val)
self.assertTrue(user.shopping_basket.shopping_carts[store.store_number].products[existing_product.catalog_number]['product'] == existing_product)
self.assertTrue(Ecommerce.get_instance().remove_from_cart(user.shopping_basket, existing_product.catalog_number))
self.assertTrue(len(user.shopping_basket.shopping_carts[store.store_number].products) == 0)
def test_add_product_to_cart(self):
basket = ShoppingBasket()
discount_service = DiscountService()
buying_policy = BuyingPolicyService()
store = Store('effect', 123, 123, discount_service, buying_policy)
product_a = Product('france schnitzel', 'schnitzel', ['hot', 'crispy'],
35)
self.assertFalse((basket.add_product_to_cart(product_a, store)).val)
store.add_new_product(product_a)
self.assertFalse((basket.add_product_to_cart(product_a, store)).val)
store.inc_product_amount(product_a.catalog_number, 5)
self.assertTrue((basket.add_product_to_cart(product_a, store)).val)
self.assertEqual(len(basket.shopping_carts), 1)
product_b = Product('israeli schnitzel', 'schnitzel',
['hot', 'casher'], 15)
store.add_new_product(product_b)
store.inc_product_amount(product_b.catalog_number, 5)
self.assertTrue((basket.add_product_to_cart(product_b, store)).val)
self.assertEqual(len(basket.shopping_carts), 1)
self.assertEqual(len(basket.shopping_carts[0].products), 2)
def test_execute_transaction(self):
discount_service = DiscountService()
buying_policy = BuyingPolicyService()
store = Store('effect', 123, 123, discount_service, buying_policy)
cart = ShoppingCart(store)
product_a = Product('france schnitzel', 'schnitzel', ['hot', 'krispy'],
35)
cart.add_product(product_a)
delivery_address = DeliveryAddress(123, 'Israel')
store.add_new_product(product_a)
store.inc_product_amount(product_a.catalog_number, 5)
trans = (self.transaction_management.execute_transaction(
123, cart, 'paypal',
['ofek', '4580160114431651', '7', '20', '458'], delivery_address,
123)).val
self.assertEqual(trans.total_price, 35)
self.assertEqual(trans.buyer_identifier, 123)
self.assertEqual(trans.products[product_a.catalog_number]['product'],
product_a)
self.assertEqual(trans.store_number, store.store_number)
self.assertEqual(trans.store_account, store.account_number)
self.assertEqual(len(self.transaction_management.get_transactions()),
1)
product_b = Product('israeli schnitzel', 'schnitzel',
['hot', 'casher'], 15)
store.add_new_product(product_b)
store.inc_product_amount(product_b.catalog_number, 5)
cart.add_product(product_b)
trans = (self.transaction_management.execute_transaction(
12, cart, 'paypal', ['ofek', '4580160114431651', '7', '20', '458'],
delivery_address, 123)).val
self.assertEqual(trans.total_price, 50)
self.assertEqual(trans.buyer_identifier, 12)
self.assertEqual(trans.products[product_a.catalog_number]['product'],
product_a)
self.assertEqual(trans.products[product_b.catalog_number]['product'],
product_b)
self.assertEqual(trans.store_number, store.store_number)
self.assertEqual(trans.store_account, store.account_number)
self.assertEqual(len(self.transaction_management.get_transactions()),
2)
def test_calculate_price(self):
discount_service = DiscountService()
buying_policy = BuyingPolicyService()
store = Store('schnitzale', 23444, 4, discount_service, buying_policy)
cart = ShoppingCart(store)
product_a = Product('france schnitzel', 'schnitzel', ['hot', 'crispy'],
35)
product_b = Product('israeli schnitzel', 'schnitzel',
['hot', 'casher'], 15)
store.add_new_product(product_a)
store.inc_product_amount(product_a.catalog_number, 5)
store.add_new_product(product_b)
store.inc_product_amount(product_b.catalog_number, 5)
cart.products[product_a.catalog_number] = {
'product': product_a,
'amount': 2
}
self.assertEqual(cart.calculate_price(), 70)
cart.products[product_b.catalog_number] = {
'product': product_b,
'amount': 1
}
self.assertEqual(cart.calculate_price(), 85)
class StoreTest(unittest.TestCase):
def setUp(self):
self.store = Store('schnitzale', 23444, 4, None, None)
self.store.store_number = 0
self.productA = Product('france schnitzel', 'schnitzel',
['hot', 'crispy'], 35)
self.productB = Product('italian schnitzel', 'hotSchnitzel',
['hot', 'sweet'], 35)
self.productA.catalog_number = 0
self.productB.catalog_number = 1
def test_add_new_product(self):
# add first product
self.assertTrue(self.store.add_new_product(self.productA))
self.assertEqual(self.store.get_product(0), self.productA)
self.assertFalse(self.store.add_new_product(
self.productA).val) # Can't add twice
# add second product
self.assertTrue(self.store.add_new_product(self.productB))
self.assertEqual(self.store.get_product(0), self.productA)
self.assertEqual(self.store.get_product(1), self.productB)
self.assertFalse(self.store.add_new_product(
self.productB).val) # Can't add twice
def test_inc_product_amount(self):
# no such product
self.assertFalse(
self.store.inc_product_amount(self.productA.catalog_number, 4).val)
# add product and inc amount to 4
self.store.add_new_product(self.productA)
self.assertTrue(
self.store.inc_product_amount(self.productA.catalog_number, 4).val)
self.assertEqual(self.store.products[0]['amount'], 4)
def test_dec_product_amount(self):
# no such product
self.assertFalse(
self.store.dec_product_amount(self.productA.catalog_number, 4).val)
# add product, inc amount to 4 and dec by 1
self.store.add_new_product(self.productA)
self.store.inc_product_amount(self.productA.catalog_number, 4)
self.store.dec_product_amount(self.productA.catalog_number, 1)
self.assertEqual(self.store.products[0]['amount'], 3)
# do not allow negative inventory
self.assertFalse(
self.store.dec_product_amount(self.productA.catalog_number,
10).val)
def test_remove_product(self):
# no such product
self.assertFalse(
self.store.remove_product(self.productA.catalog_number).val)
# add product and then remove it
self.store.add_new_product(self.productA)
self.assertTrue(
self.store.remove_product(self.productA.catalog_number).val)
self.assertEqual(len(self.store.products), 0)
def test_search_product(self):
# no such product
self.assertFalse(self.store.search_product('name', 'france schnitzel'))
# no such attribute
self.store.add_new_product(self.productA)
self.assertFalse(
self.store.search_product('bla bla', 'france schnitzel'))
# search by name. 1 product in store
self.store.add_new_product(self.productA)
self.assertEqual(self.store.search_product('name', 'france schnitzel'),
[self.productA])
# search by name. 2 products in store
self.store.add_new_product(self.productA)
self.store.add_new_product(self.productB)
self.assertEqual(self.store.search_product('name', 'france schnitzel'),
[self.productA])
self.assertEqual(
self.store.search_product('name', 'italian schnitzel'),
[self.productB])
# search by category. 1 product in store
self.store.remove_product(1) # remove product B
self.assertEqual(self.store.search_product('category', 'schnitzel'),
[self.productA])
# search by category. 2 products in store
self.store.add_new_product(self.productB)
self.assertEqual(self.store.search_product('category', 'schnitzel'),
[self.productA])
self.assertEqual(self.store.search_product('category', 'hotSchnitzel'),
[self.productB])
# search by key words. 1 product in store
self.store.remove_product(1) # remove product B
self.assertEqual(
self.store.search_product('key words', ['hot', 'crispy']),
[self.productA])
# search by key words. 2 products in store - key words not shared by both
self.store.add_new_product(self.productB)
self.assertEqual(self.store.search_product('key words', ['crispy']),
[self.productA])
self.assertEqual(self.store.search_product('key words', ['sweet']),
[self.productB])
# search by key words. 2 products in store - key words shared by both
self.assertEqual(self.store.search_product('key words', ['hot']),
[self.productA, self.productB])
def test_get_product(self):
# no such product
self.assertEqual(self.store.get_product(0), None)
# get productA
self.store.add_new_product(self.productA)
self.assertEqual(self.store.get_product(0), self.productA)