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