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