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):
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
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 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
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):
""" 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
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
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")
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