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 find_substitute(self):
"""
This method is the client for the application
"""
# Ask the user to choose a category
menu_title = 'Choisissez une catégorie'
answers_title = 'Sélectionnez une catégorie (numéro)'
answers = API_CATEGORIES
category = SelectionMenu(menu_title, answers_title, answers)
# Ask user to choose a product to substitute
to_substitute = None
while not to_substitute:
# Display available products in the chossen category
available_products = self.database.select_products(
category.selected, NUMBER_OF_PRODUCTS,
DISCRIMINANT_NUTRISCORE_GRADE)
available_products.append('Afficher d\'autres produits au hasard')
menu_title = 'Choisissez un produit à subsituer'
answers_title = 'Sélectionnez un produit (numéro)'
answers = available_products
product = SelectionMenu(menu_title, answers_title, answers)
if product.selected != 'Afficher d\'autres produits au hasard':
to_substitute = Product(
**self.database.select_product(product.selected))
# Select in the database the potential substitutes for to the selected
# product
available_substitutes = self.database.select_substitutes(
to_substitute, NUMBER_OF_SIMILAR_CATEGORIES, NUMBER_OF_SUBSTITUTES)
if available_substitutes:
# Ask the user to choose a substitute
menu_title = 'Choisissez un substitut'
answers_title = 'Sélectionner un substitut (numéro)'
answers = available_substitutes
substitute = SelectionMenu(menu_title, answers_title, answers)
substituted = Product(
**self.database.select_product(substitute.selected))
substituted.display()
else:
print('Nous n\'avons pas de substitut à vous proposer.')
substituted = None
if substituted:
# Ask the user if she·he wants to save the product
menu_title = 'Souhaitez-vous sauvegarder le produit ?'
answers_title = 'Sélectionnez une réponse (numéro)'
answers = ['Oui', 'Non']
save = SelectionMenu(menu_title, answers_title, answers)
if save.selected == 'Oui':
self.database.save_product(to_substitute, substituted)
def test_exercise():
coffee_cup = Product("Coffee cup")
car = Product.with_location("Car", "showroom")
table = Product.with_weight("Table", 50)
assert str(coffee_cup) == "Coffee cup (1 kg) can be found from the shelf"
assert str(car) == "Car (1 kg) can be found from the showroom"
assert str(table) == "Table (50 kg) can be found from the shelf"
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 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_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_check_conditional_discount(self):
discount = DiscountService()
mango = Product('mango', 'fruit', ['yellow', 'sweet'], 7)
pear = Product('pear', 'fruit', ['green', 'sweet'], 4)
shopping_cart = ShoppingCart(Store('effect', 123, 123, None, None))
shopping_cart.add_product(mango)
self.assertFalse(
discount.check_conditional_discount(('And', pear, mango),
shopping_cart))
shopping_cart.add_product(pear)
self.assertTrue(
discount.check_conditional_discount(('And', pear, mango),
shopping_cart))
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_calculate_price(self):
basket = ShoppingBasket()
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', 'crispy'],
35)
product_b = Product('israeli schnitzel', 'schnitzel',
['hot', 'casher'], 15)
cart.add_product(product_a)
basket.shopping_carts.append(cart)
self.assertEqual(basket.calculate_price(), 35)
cart.add_product(product_b)
self.assertEqual(basket.calculate_price(), 50)
def test_has_conditional_product_discount(self):
discount = DiscountService()
apple = Product('apple', 'fruit', ['green', 'sweet'], 5)
mango = Product('mango', 'fruit', ['yellow', 'sweet'], 7)
pear = Product('pear', 'fruit', ['green', 'sweet'], 4)
start_date = datetime.datetime(2016, 2, 1, 12, 12, 12, 12)
end_date = datetime.datetime(2020, 2, 1, 12, 12, 12, 12)
self.assertFalse(discount.has_conditional_product_discount(apple))
discount.add_product_discount(apple,
70,
True,
start_date,
end_date,
condition=('And', pear, mango))
self.assertTrue(discount.has_conditional_product_discount(apple))
def first_start(self):
"""
This method initialise the database if its empty
"""
print('')
print('========== Première exécution de l\'application ===========')
print('==> Téléchargement des données depuis l\'Open Food Facts')
# Initialize the API
api = Api(API_URL_BASE, TMP_DIR)
# Download data with the API
api.download_products(API_CATEGORIES, API_PAGE_SIZE, API_PAGES)
print('')
print('==> Téléchargement des données terminé !')
# Read data downloaded and clean uncompleted products
api.read_json_with_key('products')
api.keep_required(API_DATA_FORMAT)
api.format_data(API_DATA_FORMAT)
# Define each product as an object with variables attributes
for product_data in api.data:
product = Product(**product_data)
# Insert products in the database
self.database.insert_products(product.products)
# Delete temporary files
api.delete_files()
def parse(self) -> Product:
""" Parse the URL and return Product object """
self._soup = self._parser.parse(url=self._url)
name: str = self._parse_name()
asin: str = self._parse_asin()
weight: float = self._parse_weight()
return Product(name=name, asin=asin, weight=weight)
def setUpClass(self):
self.control = BangazonControl()
self.order = Order()
self.product = Product()
self.payment_type = PaymentType()
self.product_order = ProductOrder()
self.control.set_active_customer(1)
def test_add_product_discount(self):
discount = DiscountService()
apple = Product('apple', 'fruit', ['green', 'sweet'], 5)
start_date = datetime.datetime(2016, 2, 1, 12, 12, 12, 12)
end_date = datetime.datetime(2020, 2, 1, 12, 12, 12, 12)
discount.add_product_discount(apple, 70, True, start_date, end_date)
self.assertEqual(len(discount.product_discount_table), 1)
self.assertTrue(
discount.product_discount_table[apple.catalog_number]
['RegularDiscount'][discount.DISCOUNT_TYPE] == 'RegularDiscount')
self.assertEqual(
discount.product_discount_table[apple.catalog_number]
['RegularDiscount'][discount.DISCOUNT_PERCENTAGE], 70)
self.assertTrue(discount.product_discount_table[apple.catalog_number]
['RegularDiscount'][discount.DOUBLE_DEALS])
discount.add_product_discount(apple,
60,
False,
start_date,
end_date,
coupon_code=123)
self.assertEqual(len(discount.product_discount_table), 1)
self.assertTrue(
discount.product_discount_table[apple.catalog_number]
['CouponDiscount'][discount.DISCOUNT_TYPE] == 'CouponDiscount')
self.assertTrue(
discount.product_discount_table[apple.catalog_number]
['CouponDiscount'][discount.DISCOUNT_PERCENTAGE], 60)
self.assertFalse(discount.product_discount_table[apple.catalog_number]
['CouponDiscount'][discount.DOUBLE_DEALS])
def test_has_regular_product_discount(self):
discount = DiscountService()
apple = Product('apple', 'fruit', ['green', 'sweet'], 5)
start_date = datetime.datetime(2016, 2, 1, 12, 12, 12, 12)
end_date = datetime.datetime(2020, 2, 1, 12, 12, 12, 12)
self.assertFalse(discount.has_regular_product_discount(apple))
discount.add_product_discount(apple, 70, True, start_date, end_date)
self.assertTrue(discount.has_regular_product_discount(apple))
def test_add_product_to_cart(self):
Ecommerce.get_instance().register("client1", "123456789", 24)
Ecommerce.get_instance().register("admin", "123456789", 24)
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)
self.assertTrue(Ecommerce.get_instance().add_to_cart(user.shopping_basket, existing_product.catalog_number).val)
self.assertFalse((Ecommerce.get_instance().add_to_cart(user.shopping_basket,
non_existing_product.catalog_number)).val)
self.assertTrue(user.shopping_basket.shopping_carts[0].products[existing_product.catalog_number]['product'] ==
existing_product)
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_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_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_product_from_cart(self):
basket = ShoppingBasket()
discount_service = DiscountService()
buying_policy = BuyingPolicyService()
store = Store('effect', 123, 123, discount_service, buying_policy)
product = Product('france schnitzel', 'schnitzel', ['hot', 'crispy'],
35)
cart = ShoppingCart(store)
self.assertFalse((basket.remove_product_from_cart(product, cart)).val)
basket.shopping_carts.append(cart)
self.assertFalse((basket.remove_product_from_cart(product, cart)).val)
cart.add_product(product)
self.assertTrue((basket.remove_product_from_cart(product, cart)).val)
def find_saved(self):
"""
This method display the products already saved by the user
"""
# Get all products saved in the database
saved_products = self.database.select_saved_products()
if saved_products:
# Ask the user which product she·he wants to read
menu_title = 'Quel substitut souhaitez-vous consulter ?'
answers_title = 'Sélectionnez le substitut (numéro)'
answers = saved_products
substituted = SelectionMenu(menu_title, answers_title, answers)
else:
print('Aucun substitut n\'a était sauvegardé pour l\'instant')
substituted = None
if substituted:
# Display the selected subsitute
product = Product(
**self.database.select_product(substituted.selected))
product.display()
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)
def products_from(data_path: Path) -> list:
"""
Extracts products found from the data directory.
Parameters:
data_path (Path): data directory.
Returns:
list: products.
"""
products = []
for product_dir in os.listdir(data_path):
product = Product(os.path.join(data_path, product_dir))
products.append(product)
return products
def test_calculate_individual_discount(self):
discount = DiscountService()
apple = Product('apple', 'fruit', ['green', 'sweet'], 5)
shopping_cart = ShoppingCart(Store('effect', 123, 123, None, None))
start_date = datetime.datetime(2016, 2, 1, 12, 12, 12, 12)
end_date = datetime.datetime(2020, 2, 1, 12, 12, 12, 12)
discount.add_product_discount(apple,
20,
True,
start_date,
end_date,
coupon_code=123)
x = discount.calculate_individual_discount(
discount.product_discount_table[apple.catalog_number]
['CouponDiscount'], shopping_cart)
self.assertEqual(x[0], 20)
self.assertEqual(x[1], 'CouponDiscount')
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)
class ProductTest(unittest.TestCase):
def setUp(self):
self.p1 = Product('france schnitzel', 'schnitzel', ['hot', 'crispy'], 35)
self.p1.catalog_number = 1
def test_change_detail(self):
self.assertFalse(self.p1.change_detail('unknown attribute', 'bla bla')) # SHOULD FAIL
self.p1.change_detail('name', 'new schnitzel')
self.assertEqual(self.p1.name, 'new schnitzel')
self.p1.change_detail('category', 'new category')
self.assertEqual(self.p1.category, 'new category')
self.p1.change_detail('key words', ['key words'])
self.assertEqual(self.p1.key_words, ['key words'])
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), [])
