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