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
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
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
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"))
class TestShoppingCart(unittest.TestCase):
def setUp(self):
self.bread = Item('Bread', 3.5)
self.beer = Item('Beer', 1.75)
self.shopping_cart = ShoppingCart()
self.shopping_cart.add_item({'item':self.bread, 'quantity': 2})
def tearDown(self):
pass
def test_item_name_eq_bread(self):
self.assertEqual(self.bread.name, 'Bread')
def test_item_name_dif_bread(self):
self.assertNotEqual(self.beer.name, 'Bread')
def test_shopping_cart_has_item_bread(self):
self.assertTrue(self.shopping_cart.contains_item())
def test_shopping_cart_has_no_item(self):
self.shopping_cart.remove_item(self.bread)
self.assertFalse(self.shopping_cart.contains_item())
def test_shopping_cart_get_item_bread(self):
item = self.shopping_cart.get_item(self.bread)
self.assertIs(item, self.bread)
def test_get_item_exception(self):
with self.assertRaises(NotExistsItemError):
self.shopping_cart.get_item(self.beer)
def test_get_total_eq_seven(self):
self.assertGreater(self.shopping_cart.total(), 0)
self.assertLessEqual(self.shopping_cart.total(), 7.0)
def test_item_code(self):
self.assertRegex(self.beer.code(), self.beer.name)
def test_clear_cart(self):
self.shopping_cart.clear_cart()
self.assertFalse(self.shopping_cart.contains_item())
def test_fail(self):
if 2**0.5 > 1:
self.fail('The square rooot of 2 is greater than 1')
#@unittest.skip('Not implemented ')
@unittest.skipIf( True, ' Shopping Cart has items')
def test_skip(self):
pass
def main():
cart = ShoppingCart()
cart.add_item()
cart.remove_item()
cart.add_item()
cart.add_item()
cart.add_item()
cart.remove_item()
cart.checkout()
cart.paid_for()
cart.add_item()
cart.checkout()
cart.paid_for()
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')
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())
# -*- coding: utf-8 -*-
"""
Created on Sat Feb 23 14:11:57 2019
@author: james
"""
#Import our custom package
from shopping_cart import ShoppingCart
#Initialize an instance of our shopping cart class
shopping_cart = ShoppingCart()
shopping_cart = ShoppingCart(
) #Add a line to reinitialize an instance of the class
print(shopping_cart.total)
print(shopping_cart.employee_discount)
print(shopping_cart.items)
shopping_cart.add_item("rainbow sandals", 45.99) # 45.99
shopping_cart.add_item("agyle socks", 10.50) # 56.49
shopping_cart.add_item("jeans", 50.00, 3) # 206.49
shopping_cart.mean_item_price() # 41.29
my_cart = ShoppingCart()
my_toy1 = BabyToy(18, 0, 100, 'Baby Toy', 'Animal Doll', 'Choking Hazard',
'1 YEAR OLD +')
my_toy2 = BabyToy(40, 0, 10, 'Baby Toy', 'Kids Drum set',
'Warning:Content under pressure', '5 YEAR OLD +')
my_desert_1 = FrozenDessert(5, 0, 50, 'Frozen Dessert', 'Ice Cream', '1 quart',
'-5'
'\u00b0'
'F', '10/2017')
my_desert_2 = FrozenDessert(30, 0, 20, 'Frozen Dessert', 'Baked Alaska',
'3 quarts', '0'
'\u00b0'
'F', '09/2017')
my_cart.add_item(my_toy1, 3)
my_cart.add_item(my_toy2, 2)
my_cart.add_item(my_desert_1, 5)
my_cart.add_item(my_desert_2, 2)
print(__doc__)
print(text1.format('add_item'))
print('*' * len(text1.format('add_item')))
print('Expecting 3', '{}'.format(my_toy1.name), '{:>11}:'.format('Received'),
my_toy1.shop_quantity, ' Resulted inventory qty:', my_toy1.inventory)
print('Expecting 2', '{}'.format(my_toy2.name), '{:>10}'.format('Received:'),
my_toy2.shop_quantity, ' Resulted inventory qty:', my_toy2.inventory)
print('Expecting 5', '{}'.format(my_desert_1.name),
'{:>14}'.format('Received:'), my_desert_1.shop_quantity,
' Resulted inventory qty:', my_desert_1.inventory)
print('Expecting 2', '{}'.format(my_desert_2.name),
class TestShoppingCart(unittest.TestCase):
"""A Class to Test ShoppingCart Class"""
def setUp(self):
"""Setting up the ShoppingCart Class"""
self.my_cart = ShoppingCart()
self.my_cart2 = Shop()
def test_add_item_total(self):
"""Test if the method add_item updates total accordingly"""
my_total = self.my_cart.add_item('Cookies', 2, 400)
self.assertEqual(my_total, 800)
self.assertDictEqual(self.my_cart.items, {'Cookies', 2},
msg="Invalid Dictionary")
def test_add_item_entry(self):
"""Tests whether an entry is added accordingly in the items dict"""
my_total = self.my_cart.add_item('Cookies', 2, 400)
self.assertEqual(my_total, 800)
def test_remove_item_total(self):
"""Tests whether an item is removed accordingly in the items dict"""
self.my_cart.add_item('Cookies', 5, 1500)
self.my_cart.remove_item('Cookies', 2, 300)
self.assertEqual(self.my_cart.total, 900, "Inacurate remove method")
def test_remove_item_entry(self):
"""Tests whether the dictionary is updated accordingly"""
self.my_cart.add_item('Cookies', 5, 1500)
self.my_cart.remove_item('Cookies', 2, 300)
self.assertDictEqual(self.my_cart.items, {'Cookies', 3},
msg="Invalid Dictionary")
def test_exceeds_current_quantity(self):
"""Test that all entries are removed if the quantity exceeds the current"""
self.my_cart.add_item('Cookies', 5, 1500)
self.my_cart.remove_item('Cookies', 2, 300)
self.assertEqual(
self.my_cart.items, {},
msg="Doesnt remove all if the quantity exceeds the current")
def test_checkout(self):
"""Test whether it returns the correct balance"""
self.my_cart.add_item('Cookies', 5, 1500)
self.my_cart.checkout(self.my_cart.checkout(700), 100)
def test_checkout_not_enough(self):
"""Tests if the payment is enough"""
self.my_cart.add_item('Cookies', 5, 1500)
self.assertEqual(self.my_cart.checkout(100), "Cash paid not enough")
def test_shop_if_subclass(self):
"""Tests whether shop inherits from ShoppingCart"""
self.assertTrue(issubclass(Shop, ShoppingCart),
msg="Shop doesnt inherits from ShoppingCart")
def test_shop_quantity(self):
"""Tests whether Shop quantity attribute is initialized to 100"""
self.assertEqual(self.my_cart2.quantity, 100)
def test_override_remove_item(self):
"""Tests whether calling Shop's remove_item with no arguments decrements quantity by one."""
self.my_cart2.add_item('Cookies', 5, 1500)
self.my_cart2.remove_item()
self.assertDictEqual(self.my_cart2.items, {'Cookies': 5},
msg="Does not remove quantity by one")
from shopping_cart import ShoppingCart
shopping_cart = ShoppingCart()
shopping_cart.add_item("rainbow sandals", 45.99)
shopping_cart.add_item("agyle socks", 10.50)
shopping_cart.add_item("jeans", 50.00, 3)
shopping_cart.add_item("plants", 20.00, 2)
print(shopping_cart.get_total())
print(shopping_cart.median_item_price()) # 50.00 <<< how is that the answer to the median question? should be $45.99 when have the 1st 3 items in cart
print(shopping_cart.mean_item_price())
discount_shopping_cart = ShoppingCart(20)
print(shopping_cart.apply_discount())
print(shopping_cart.item_names())
print(shopping_cart.void_last_item())
class ShoppinCartTestCase(unittest.TestCase):
"""Testing the ShoppingCart """
def setUp(self):
"""
Setting up the instance and assigning attributes for testing
"""
self.my_cart = ShoppingCart()
self.my_cart_2 = Shop()
def test_add_item_total(self):
"""Test if method adds items and updates total accordingly"""
my_total = self.my_cart.add_item('Cookies', 2, 400)
self.assertEqual(my_total, 800)
# def test_add_item_entry(self):
# """Test if items dictionary is updated after adding an item"""
# self.assertDictEqual(self.my_cart.items,{'Cookies':2},msg="Invalid dictionary")
def test_remove_item_total(self):
"""Test whether total cash is updated after removing an item"""
self.my_cart.add_item('Chocolate', 5, 300)
self.my_cart.remove_item('Chocolate', 2, 300)
self.assertEqual(self.my_cart.total,
900,
msg='Remove item method inaccurate')
def test_remove_item_entry(self):
"""Tests whether items dictionary is updated after removing an item"""
self.my_cart.add_item('Chocolate', 5, 300)
self.my_cart.remove_item('Chocolate', 2, 300)
self.assertDictEqual(self.my_cart.items, {'Chocolate': 3},
msg="Invalid dictionary")
def test_exceeding_current_quantity(self):
"""Tests that all entries of an item are to be removed if quantity exeeds current."""
self.my_cart.add_item('Chocolate', 5, 300)
self.my_cart.remove_item('Chocolate', 7, 300)
self.assertDictEqual(
self.my_cart.items, {},
msg="Doesn't remove all entries if quantity exeeds the current")
def test_checkout(self):
"""Tests balance after payment"""
self.my_cart.add_item('Chocolate', 2, 300)
self.assertEqual(self.my_cart.checkout(700), 100)
def test_checkout_not_enough(self):
"""Tests if payment is enough """
self.my_cart.add_item('Chocolate', 2, 300)
self.assertEqual(self.my_cart.checkout(100), "Cash paid not enough")
def test_shop_if_subclass(self):
"""Tests whether Shop is a subclass of ShoppingCart"""
self.assertTrue(issubclass(Shop, ShoppingCart),
msg="Shop doesn't inherit from ShoppingCart")
def test_shop_quantity(self):
"""Tests whether Shop quantity attribute is initialized to 100"""
self.assertEqual(self.my_cart_2.quantity,
100,
msg="Shop quantity attribute not equal to 100")
def test_override_remove_item(self):
"""Tests that calling Shop's remove_item with no arguments decrements quantity by one"""
self.my_cart_2.add_item('Chocolate', 5, 300)
self.my_cart_2.remove_item()
self.assertDictEqual(self.my_cart_2.items, {'Chocolate': 4},
msg="Does not remove quantity by one")
# def test_cart_property_initialization(self):
# self.assertEqual(self.cart.total, 0, msg='Initial value of total not correct')
# self.assertIsInstance(self.cart.items, dict, msg='Items is not a dictionary')
def test_add_item(self):
self.cart.add_item('Mango', 3, 10)
self.assertEqual(self.cart.total,
30,
msg='Cart total not correct after adding items')
self.assertEqual(self.cart.items['Mango'],
3,
msg='Quantity of items not correct after adding item')
class TestShoppingCart(unittest.TestCase):
def setUp(self): # metodo que se ejecuta antes de la pruebas
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): # metodo que se ejecuta desues de la pruebas
pass
def test_cinco_mas_cinco_igual_dies(self):
assert 5 + 5 == 10
def test_nombre_producto_igual_pan(
self): # comprobar si el nombre del producto se igual a otro
self.assertEqual(self.pan.name, "Pan")
def test_nombre_producto_diferente_manzana(
self): # comprobar si el nombre del producto No es igual a otro
self.assertNotEqual(self.jugo.name, "Manzana")
def test_contiene_productos(
self): # comprobar si un carrito contiene un producto
self.assertTrue(self.shopping_cart.constains_items())
def test_no_contiene_productos(
self): # comprobar si un carrito No contiene un producto
self.shopping_cart.remove_item(self.pan)
self.assertFalse(self.shopping_cart.constains_items())
def test_obtener_productos_pan(
self): # comprobar si dos objetos son los mismos
item = self.shopping_cart.get_item(self.pan)
self.assertIs(item, self.pan)
self.assertIsNot(
item, self.jugo) # comprobar si dos objetos No son los mismos
def test_exeption_al_obtener_jugo(
self): # lanzar error si no consigue el producto
with self.assertRaises(NotExistsItemError):
self.shopping_cart.get_item(self.jugo)
def test_total_com_un_productos(self): # comprobar el total del carrito
total = self.shopping_cart.total()
self.assertGreater(total, 0) # mayor a 0
self.assertLess(total, self.pan.price + 1.0) # menor a 1.0
self.assertEqual(total, self.pan.price) # igual
def test_codigo_pan(
self
): # validar que el nombre del prodcuto se encuentar dentro del codigo
self.assertRegex(self.pan.code(), self.pan.name)
def test_fail(
self
): # no esta dentro de la libreria y sirve para hacer test manual
if 2 > 3:
self.fail("Dos no es mayor a test!")
API_VERSION = 17
# @unittest.skip("Colocamos nuestros motivos") # el programador quiere saltarse la prueba y sabe el porque
# @unittest.skipIf(API_VERSION < 18,"la version es obsoleta") # el programador quiere saltarse la prueba y debe cumplirse una condicion
@unittest.skipUnless(3 > 5, "Colocamos nuestros motivos")
def test_prueba_skip(self):
pass
class TestShoppingCart(unittest.TestCase):
#realizar acciones antes de realizar la prueba unitaria
#conectarse a una base de datos, consumir una api, leer variables de entorno,escribir sobre un archivo
#metodo que se ejecuta antes de cada una de las pruebas
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)
#metodo que se ejecuta despues de cada una de las pruebas unitarias
def tearDown(self):
#print("Método tearDown despues de la prueba")
pass
# a cada prueba le corresponde un mensaje de setUp y tearDown
def test_cinco_mas_cinco_igual_diez(self):
assert 5 + 5 == 10
"""def test_nombre_producto_igual_manzana(self):
item = Item("Manzana",12.0)
self.assertEqual(item.name,"Manzana")
def test_nombre_producto_diferente_manzana(self):
item = Item("Pan Blanco",15.0)
self.assertNotEqual(item.name,"Manzana")
"""
def test_nombre_producto_igual_pan(self):
self.assertEqual(self.pan.name,"Pan")
def test_nombre_producto_igual_jugo(self):
#compara dos valores
self.assertEqual(self.jugo.name,"Jugo") # ==
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())
#comprobar si dos objetos son el mismo
def test_obtener_producto_pan(self):
item = self.shopping_cart.get_item(self.pan)
# se puede utilizar dos en una misma funcion
#compara dos objetos
# se puede colocar mas de un assert
self.assertIs(item,self.pan) # is evaluamos un objeto
self.assertIsNot(item,self.jugo)
def test_exception_al_obtener_jugo(self):
# con with y assertRaises se puede agregar la excepcion creada
with self.assertRaises(NotExistsItemError):
item = self.shopping_cart.get_item(self.jugo)
def test_total_con_un_producto(self):
total = self.shopping_cart.total()
# sea mayor
self.assertGreater(total,0)
# sea menor
self.assertLess(total,self.pan.price + 1.0)
# es igual a lo que debe de ser
self.assertEqual(total, self.pan.price)
def test_codigo_pan(self):
# revisa si contiene el nombre del producto
#self.assertRegex(self.pan.code(),self.pan.name) este python 3.7
self.assertRegexpMatches(self.pan.code(),self.pan.name) #python 2.7
#validar de forma manual utilizando el metodo fail
def test_fail(self):
if 2 > 3:
self.fail("Dos no es mayor a tres!")
"""
salida si falla
....F.....
======================================================================
FAIL: test_fail (__main__.TestShoppingCart)
----------------------------------------------------------------------
Traceback (most recent call last):
File "shopping_cart/test_shopping_cart.py", line 79, in test_fail
self.fail("Dos no es mayor a tres")
AssertionError: Dos no es mayor a tres
----------------------------------------------------------------------
Ran 10 tests in 0.004s
FAILED (failures=1)
"""
#saltar una prueba para que no se ocupe
#desarrollador conoce
@unittest.skip("Colocamos nuestros motivos")
def test_prueba_skip(self):
pass
"""
.........s.
----------------------------------------------------------------------
Ran 11 tests in 0.003s
OK (skipped=1)
para tener mas informacion colocar al final la bandera -v
"""
#cuando el desarrollador desconoce puede o no puede ejecutarse
#True la prueba se salta False la prueba se ejecuta
#@unittest.skipIf(True,"Colocamos nuestros motivos")
#evaluando a falso si es false no se ejecuta si es True no se salta
@unittest.skipUnless(False,"Colocamos nuestros motivos")
def test_prueba_skip2(self):
pass
from shopping_cart import ShoppingCart
shopping_cart = ShoppingCart()
print(shopping_cart.total)
print(shopping_cart.employee_discount)
print(shopping_cart.add_item("rainbow sandals", 45.99)) # 45.99
print(shopping_cart.add_item("agyle socks", 10.50)) # 56.49)
print(shopping_cart.add_item("jeans", 50.00, 3))
# print(shopping_cart.mean_item_price())
print(shopping_cart.median_item_price())
discount_shopping_cart = ShoppingCart(20)
print(discount_shopping_cart.add_item("rainbow sandals", 45.00)) # 45.00
print(discount_shopping_cart.add_item("agyle socks", 15.00)) # 60.00
print(discount_shopping_cart.apply_discount()) # 48.00
print(discount_shopping_cart.add_item("macbook air", 1000.00)) # 1060.00
print(discount_shopping_cart.apply_discount()) # 848.00
print(shopping_cart.apply_discount()
) # Sorry, there is no discount to apply to your cart :(
print("item names", shopping_cart.item_names())
print("before: ", shopping_cart.total)
shopping_cart.void_last_item()
print("after: ", shopping_cart.total)
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()
class TestShoppingCart(unittest.TestCase):
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 tearDown(self):
""" Método que se ejecuta después da cada prueba """
pass
def test_cinco_mas_cinco_igual_diez(self):
""" Test sencillo que siempre debe pasar """
assert 5 + 5 == 10
def test_nombre_producto_pan(self):
""" Test para el nombre de producto """
self.assertEqual(self.pan.name, 'pan')
def test_nombre_producto_no_manzana(self):
""" Test para nombre de producto """
self.assertNotEqual(self.jugo.name, 'manzana')
def test_contiene_productos(self):
""" Test para productos en el carrito """
self.assertTrue(self.shopping_cart.contains_items())
def test_no_contiene_productos(self):
""" Test de eliminar items del carrito """
self.shopping_cart.remove_item(self.pan)
self.assertFalse(self.shopping_cart.contains_items())
def test_obtener_producto_pan(self):
""" Test para obtener un producto (pan) """
item = self.shopping_cart.get_item(self.pan)
self.assertIs(item, self.pan)
self.assertIsNot(item, self.jugo)
def test_excepcion_obtener_jugo(self):
""" Test para verificar la excepcion lanzada
al obtener producto que no esté en el carrito
"""
with self.assertRaises(NotExistsItemError):
self.shopping_cart.get_item(self.jugo)
def test_total_con_un_producto(self):
""" Test para validar que el precio total sea el correcto """
total = self.shopping_cart.total()
self.assertGreater(total, 0)
self.assertLess(total, self.pan.price + 1)
self.assertEqual(total, self.pan.price)
def test_codigo_producto(self):
""" Test para validar que el código del producto
contenga el nombre del producto
"""
self.assertRegex(self.pan.code(), self.pan.name)
def test_fail(self):
""" Test para probar el método fail """
if 2 > 3: # 3 > 2 para ejecutar el método
self.fail('2 no es mayor a 3')
# @unittest.skip("Motivos para saltar la prueba")
# @unittest.skipUnless(False, "Motivos para saltar la prueba")
@unittest.skipIf(True, "Motivos para saltar la prueba")
def test_prueba_skip(self):
""" Test que será omitido, decoramos para indicar que no será ejecutado """
pass
