def test_shopping_cart_add_item(self):
cart = ShoppingCart()
apples = Product("apples", ProductUnit.KILO)
self.assertEqual(0, len(cart._items))
cart.add_item(apples)
self.assertEqual(1, len(cart._items))
class TestShoppingCart(unittest.TestCase):
def setUp(self):
self.pan = Item("Pan", 7.0)
self.jugo = Item("Jugo", 5.0)
self.shopping_cart = ShoppingCart()
self.shopping_cart.add_item(self.pan)
def tearDown(self):
pass
def test_cinco_mas_cinco_igual_diez(self):
assert 5 + 5 == 10
def test_nombre_producto_igual_pan(self):
self.assertEqual(self.pan.name, "Pan")
def test_nombre_producto_diferente_manzana(self):
self.assertNotEqual(self.jugo.name, "Manzana")
def test_contiene_productos(self):
self.assertTrue(self.shopping_cart.contains_items())
def test_no_contiene_productos(self):
self.shopping_cart.remove_item(self.pan)
self.assertFalse(self.shopping_cart.contains_items())
def test_obener_producto_pan(self):
item = self.shopping_cart.get_item(self.pan)
self.assertIs(item, self.pan)
self.assertIsNot(item, self.jugo)
def test_exception_al_obtener_jugo(self):
with self.assertRaises(NotExistsItemError):
self.shopping_cart.get_item(self.jugo)
def test_total_con_un_producto(self):
total = self.shopping_cart.total()
self.assertGreater(total, 0)
self.assertLess(total, self.pan.price + 1.0)
self.assertEqual(total, self.pan.price)
def test_codigo_pan(self):
self.assertRegex(self.pan.code(), self.pan.name)
def test_fail(self):
if 2 > 3:
self.fail("Dos no es mayor a tres!")
# cuando el desarrollador conoce que la prueba no va a ejecutar
@unittest.skip("Colocar nuestros motivos") #decorarmos nuestra prueba
def test_prueba_skip(self):
pass
# cuando el desarrollador desconoce si la prueba va a ejecutarse
#@unittest.skipIf(True, "Colocar nuestros motivos")
#@unittest.skipIf(API_VERSION < 18, "La version es obsoleta")
#@unittest.skipUnless(False, "Colocamos nuestros motivos")
@unittest.skipUnless(3 > 5, "Tres es menor a cinco")
def test_prueba1_skip(self):
pass
def test_ten_percent_discount():
catalog = FakeCatalog()
toothbrush = Product("toothbrush", ProductUnit.EACH)
catalog.add_product(toothbrush, 0.99)
apples = Product("apples", ProductUnit.KILO)
catalog.add_product(apples, 1.99)
teller = Teller(catalog)
teller.add_special_offer(SpecialOfferType.TEN_PERCENT_DISCOUNT, toothbrush,
10.0)
cart = ShoppingCart()
cart.add_item_quantity(apples, 2.5)
receipt = teller.checks_out_articles_from(cart)
assert 4.975 == pytest.approx(receipt.total_price(), 0.01)
assert [] == receipt.discounts
assert 1 == len(receipt.items)
receipt_item = receipt.items[0]
assert apples == receipt_item.product
assert 1.99 == receipt_item.price
assert 2.5 * 1.99 == pytest.approx(receipt_item.total_price, 0.01)
assert 2.5 == receipt_item.quantity
def setUp(self):
""" Método que se ejecuta antes de cada prueba """
self.pan = Item('pan', 12)
self.jugo = Item('jugo', 5)
self.shopping_cart = ShoppingCart()
self.shopping_cart.add_item(self.pan)
def test_shopping_cart_handle_offers_ten_percent_discount(self):
catalog = FakeCatalog()
toothbrush = Product("toothbrush", ProductUnit.EACH)
apples = Product("apples", ProductUnit.KILO)
catalog.add_product(toothbrush, 0.99)
catalog.add_product(apples, 1.99)
# teller special offers 10% discount on toothbrush
teller = Teller(catalog)
teller.add_special_offer(SpecialOfferType.TEN_PERCENT_DISCOUNT,
toothbrush, 10.0)
#offers = teller.offers
#discount = Discount(product, "2 for " + str(offer.argument), discount_n)
# add apples to shopping cart
cart = ShoppingCart()
cart.add_item_quantity(apples, 2.5)
#cart.add_item_quantity(toothbrush, 2)
receipt = teller.checks_out_articles_from(cart)
# add apples to shopping cart : check no discounts and 1 item
self.assertEqual([], receipt.discounts)
self.assertEqual(len(cart.items), len(receipt.items))
receipt_item = receipt.items[0]
self.assertEqual(apples, receipt_item.product)
self.assertEqual(catalog.unit_price(apples), receipt_item.price)
self.assertEqual(cart.product_quantities[apples],
receipt_item.quantity)
self.assertAlmostEqual(
cart.product_quantities[apples] * catalog.unit_price(apples),
receipt.total_price(), 0.01)
def setUp(self):
#print("Método setUp antes de la prueba")
self.pan = Item("Pan",7.0)
self.jugo = Item("Jugo",5.0)
self.shopping_cart = ShoppingCart()
self.shopping_cart.add_item(self.pan)
def test_no_bulk_discount():
cart = ShoppingCart()
product = 'Chair'
cart.scan(product)
cart.scan(product)
assert cart.total_price() == 200
def test_validate_input_2(self):
cart_items = list([
CartItem(Item(True, True), 10.00),
CartItem(Item(False, True), 47.50),
])
shopping_cart = ShoppingCart(cart_items)
assert shopping_cart.calculate_sales_tax() == "7.65"
assert shopping_cart.calculate_total() == "65.15"
def test_buy_1_get_1_free_cushion():
cart = ShoppingCart()
product = 'Cushion'
cart.scan(product)
cart.scan(product)
assert cart.total_price() == 25
class TestShoppingCart(unittest.TestCase):
def setUp(self):
self.pan = Item("Pan", 7.0)
self.jugo = Item("Jugo", 5.0)
self.shopping_cart = ShoppingCart()
self.shopping_cart.add_item(self.pan)
def tearDown(self):
print("Método tearDown despés de la preba")
def test_cinco_mas_cinco_igual_dies(self):
assert 5 + 5 == 10
def test_nombre_producto_igual_pan(self):
self.assertEqual(self.pan.name, "Pan")
def test_nombre_producto_diferente_manzana(self):
item = Item("Pan blanco", 12.0)
self.assertNotEqual(self.jugo.name, "Manzana")
def test_contiene_productos(self):
self.assertTrue(self.shopping_cart.contains_items())
def test_no_contene_productos(self):
self.shopping_cart.remove_item(self.pan)
self.assertFalse(self.shopping_cart.contains_items())
def test_obtener_producto_pan(self):
item = self.shopping_cart.get_item(self.pan)
self.assertIs(item, self.pan)
self.assertIsNot(item, self.jugo)
def test_exceptio_al_obtener_jugo(self):
with self.assertRaises(NotExistsItemError):
self.shopping_cart.get_item(self.jugo)
def test_total_con_un_producto(self):
total = self.shopping_cart.total()
self.assertGreater(total, 0)
self.assertLess(total, self.pan.price + 1.0)
self.assertEqual(total, self.pan.price)
def test_codigo_pan(self):
self.asserNotRegex(self.pan.code(), self.pan.name)
def test_fail(self):
if 2 > 3:
self.fail('Dos no es mayor a 3')
#@unittest.skip("Colocamos nuestros motivos")
#@unittest.skipIf(CONS < 18,"La versión es obsoleta") comopara a verdadero
@unittest.skipUnless(3 > 5,
"Colocamos nuestros motivos") #compara por el falso
def test_prueba_skip(self):
pass
def test_validate_input_1(self):
cart_items = list([
CartItem(Item(True, False), 12.49),
CartItem(Item(False, False), 14.99),
CartItem(Item(True, False), 0.85),
])
shopping_cart = ShoppingCart(cart_items)
assert shopping_cart.calculate_sales_tax() == "1.50"
assert shopping_cart.calculate_total() == "29.83"
def get(self, request):
# request.session.clear()
cart_exists = request.session.get('shoppingCart', None)
if not cart_exists:
shoppingCart = ShoppingCart()
request.session['shoppingCart'] = shoppingCart.to_dictionary()
return JsonResponse(request.session['shoppingCart'])
class TestShoppingCart(unittest.TestCase):
def setUp(self):
self.carrot = Item('Carrot', 900)
self.strawberry = Item('Strawberry', 500)
self.apple = Item('Apple', 700)
self.shopping_cart = ShoppingCart()
self.shopping_cart.add_item(self.strawberry)
def tearDown(self):
pass
def test_product_name_equal_to_apple(self): #==
value_to_test = 'Apple'
self.assertEqual(
self.apple.name, value_to_test,
'Falló: {} no es igual a {}'.format(self.apple.name,
value_to_test))
def test_product_name_different_to_apple(self):
self.assertNotEqual(self.carrot.name, 'Apple')
def test_shopping_cart_contains_some_item(self):
self.assertTrue(self.shopping_cart.contains_items())
def test_shopping_cart_not_contains_any_item(self):
self.shopping_cart.clear_items()
self.assertFalse(self.shopping_cart.contains_items())
def test_get_item_strawberry(self): # is
item = self.shopping_cart.get_item(self.strawberry)
self.assertIs(item, self.strawberry)
def test_exception_to_get_item(self):
with self.assertRaises(NotExistsItemError):
self.shopping_cart.get_item(self.carrot)
def test_total_items(self):
total = self.shopping_cart.total()
self.assertGreater(total, 0)
self.assertLess(total, self.carrot.price)
def test_code_carrot(self):
self.assertRegex(self.carrot.code(), self.carrot.name)
@unittest.skip("Motivo de skip"
) #Cuando conocemos que la prueba no puede ejecutarse
def test_skip(self):
pass
@unittest.skipIf(
False, 'Motivo por el que se omite'
) #Cuando desconocemos si la prueba puede o no ejecutarse, a causa de motivos externos
def test_skip_if(self):
pass
class TestShoppingCart(unittest.TestCase):
def setUp(self):
self.bed = Product("Bed", 25.2)
self.juice = Product("Orange", 23.3)
self.shopping_cart = ShoppingCart() #before test
self.shopping_cart.add_product(self.bed)
def tearDown(self):
pass #after test
def test_five_plus_five_iqual_ten(self):
assert 5 + 5 == 10
def test_product_name_iqual_bed(self):
self.assertEqual(self.bed.name, "Bed") # ==
def test_product_name_diferent_apple(self):
self.assertNotEqual(self.juice.name, "Apple")
def test_contains_products(self):
self.assertTrue(self.shopping_cart.contains_products())
def test_not_contains_products(self):
self.shopping_cart.remove_products(self.bed)
self.assertFalse(self.shopping_cart.contains_products())
def test_obteins_product_bed(self):
product = self.shopping_cart.get_product(self.bed)
self.assertIs(product, self.bed) #is
self.assertIsNot(product, self.juice)
def test_execption_obtain_juice(self):
with self.assertRaises(NotExistsProductError):
self.shopping_cart.get_product(self.juice)
def test_total_with_one_product(self):
total = self.shopping_cart.total()
self.assertGreater(total, 0)
self.assertLess(total, self.bed.price + 1.0)
self.assertEqual(total, self.bed.price)
def test_code_bed(self):
self.assertRegex(self.bed.code(), self.bed.name)
def test_fail(self):
if 2 > 3:
self.fail("Two is not greater than three!")
#@unittest.skip("Motives")
#@unittest.skipIf(API_VERSION < 18, "Motives")
@unittest.skipUnless(3 > 5, "Motives")
def test_skip(self):
pass
def test_validate_input_3(self):
cart_items = list([
CartItem(Item(False, True), 27.99),
CartItem(Item(False, False), 18.99),
CartItem(Item(True, False), 9.75),
CartItem(Item(True, True), 11.25)
])
shopping_cart = ShoppingCart(cart_items)
assert shopping_cart.calculate_sales_tax() == "6.70"
assert shopping_cart.calculate_total() == "74.68"
def post(self, request):
cart = json.loads(request.body)
cart['unsavedChanges'] = False
cart['checkoutStatus']['review'] = False
if cart['totalItems'] == 0:
shoppingCart = ShoppingCart()
request.session['shoppingCart'] = shoppingCart.to_dictionary()
return JsonResponse(
{'shoppingCart': request.session['shoppingCart']})
else:
request.session['shoppingCart'] = cart
return JsonResponse({'status': True})
class Checkout():
def __init__(self, discounts: Discounts) -> None:
self.shopping_cart = ShoppingCart(discounts)
def add_product(self, product_code: str) -> None:
self.shopping_cart.add_product(product_code)
def empty(self) -> None:
self.shopping_cart.empty()
@property
def total(self) -> str:
return "{:.2f}€".format(self.shopping_cart.total_amount / 100)
@property
def contents(self) -> str:
return "\n".join([
"{} x{}".format(product_name, quantity) for product_name, quantity in self.shopping_cart.contents.items()
])
def test_add_multiple_products_to_cart():
cart = ShoppingCart()
product1 = 'Chair'
product2 = 'Sofa'
product3 = 'Cushion'
cart.scan(product1)
cart.scan(product2)
cart.scan(product3)
assert cart.total_price() == 625
def test_shopping_cart_add_item_quantity(self):
cart = ShoppingCart()
apples = Product("apples", ProductUnit.KILO)
cart.add_item_quantity(apples, 2.5)
self.assertEqual(2.5, cart.product_quantities[apples])
cart.add_item_quantity(apples, 1.2)
self.assertEqual(3.7, cart.product_quantities[apples])
def main():
shopping_cart = ShoppingCart()
item_1 = Item("Banana", 2.5)
item_2 = Item("Juice", 1.7)
shopping_cart.add_item(item_1)
shopping_cart.add_item(item_2)
# shopping_cart.pay(PaypalPayment("*****@*****.**", "123456"))
shopping_cart.pay(
CreditCardPayment("Ivan Ivanov", "1234 1234 1234 1234", "10/21",
"123"))
def test_shopping_handle_offers_no_offers(self):
catalog = FakeCatalog()
toothbrush = Product("toothbrush", ProductUnit.EACH)
receipt_toothbrush = ReceiptItem(toothbrush, 2, 1.5, 3)
receipt = Receipt()
receipt.items = [receipt_toothbrush]
receipt_offers = {}
cart = ShoppingCart()
cart._items = [toothbrush]
cart._product_quantities = {toothbrush: 2}
cart.handle_offers(receipt, receipt_offers, catalog)
self.assertEqual([], receipt.discounts)
class TestClass(unittest.TestCase):
def setUp(self):
self.cart = ShoppingCart()
self.shop = Shop()
def test_add_items(self):
add_item = self.cart.add_item('lambo', 3, 10)
itemstotal = self.cart.total
self.assertEqual(30, itemstotal, msg="the total is not correct")
self.assertEqual(self.cart.items['lambo'],
3,
msg='quantity of items not correct')
def test_cart_property_initialization(self):
accesing_cart_attributes = self.cart.total
accesing_item_attributes = self.cart.items
self.assertEqual(0,
accesing_cart_attributes,
msg='the total is not 0 zero')
self.assertIsInstance(accesing_item_attributes,
dict,
msg='items is not a dictionary')
def setUp(self):
self.pan = Item("Pan", 7.0)
self.jugo = Item("Jugo", 5.0)
self.shopping_cart = ShoppingCart()
self.shopping_cart.add_item(self.pan)
def create_cart(cls):
return ShoppingCart(
publishing_house_catalog=cls.get_publishing_house_catalog())
from item import Item
from shopping_cart import ShoppingCart
item1 = Item('milk', 1.5, 1)
item2 = Item('apple', 5, 0.75)
item3 = Item('bread', 2, 2.25)
cart = ShoppingCart()
cart.add_item(item1)
cart.add_item(item2)
cart.add_item(item3)
print(cart.get_total())
print(cart.get_num_items())
print(cart)
print(cart.get_items())
from product import Product
from shopping_cart import ShoppingCart
from payment_strategies import BlikStrategy, CreditCardStrategy
if __name__ == '__main__':
product1 = Product('Banana', 4.99)
product2 = Product('Apple', 2.99)
cart = ShoppingCart()
cart.add_product(product1)
cart.add_product(product2)
cart.pay(BlikStrategy('*****@*****.**', '123456'))
cart.pay(
CreditCardStrategy('4111 1111 4555 1142', 'Jon Snow', '456', '09/27'))
def main():
print("====> first cart")
cart = ShoppingCart()
cart.add_item()
cart.remove_item()
cart.add_item()
cart.add_item()
cart.add_item()
cart.remove_item()
cart.checkout()
cart.pay()
# Go shopping again
print("====> second cart")
cart = ShoppingCart()
cart.add_item()
cart.add_item()
cart.checkout()
cart.empty_cart()
cart.add_item()
cart.checkout()
cart.pay()
# Try to add another item
print('====> Expect an error here.')
cart.add_item()
import sys
from customer import Customer
from shopping_cart import ShoppingCart
args = sys.argv
if len(args) != 2:
raise Exception("Invalid argument.")
username = args[1]
try:
customer = Customer.get_customer_by_username(username)
if not customer:
raise Exception("Customer is not found.")
shopping_cart = ShoppingCart(customer.get_id())
shopping_cart.print_orders()
except Exception as e:
print(e)
def __init__(self, discounts: Discounts) -> None:
self.shopping_cart = ShoppingCart(discounts)
def new(self, car_id: ShoppingCart()):
pass
