def test_weight_calculation_of_basket(self): basket = Basket() basket.add_product(create_product(attributes={'weight': 1})) basket.add_product(create_product(attributes={'weight': 2})) scales = Scales(attribute_code='weight') self.assertEquals(1+2, scales.weigh_basket(basket))
def test_dupe_skus_are_available(self): product = create_product(partner_sku='123123') create_product(partner_sku='123124') self.range.included_products.add(product) form = self.submit_form({'query': '123123, 123124'}) self.assertTrue(form.is_valid()) self.assertTrue('123123' in form.get_duplicate_skus())
def test_not_discountable_product_fails_condition(self): prod1, prod2 = create_product(), create_product() prod2.is_discountable = False prod2.save() self.basket.add_product(prod1) self.basket.add_product(prod2) self.assertFalse(self.cond.is_satisfied(self.basket))
def test_weight_calculation_of_basket_with_line_quantity(self): basket = Basket() basket.add_product(create_product(attributes={"weight": 1}), quantity=3) basket.add_product(create_product(attributes={"weight": 2}), quantity=4) scales = Scales(attribute_code="weight") self.assertEquals(1 * 3 + 2 * 4, scales.weigh_basket(basket))
def test_items_are_flushed_by_importer(self): upc = "0000000000000" create_product(price=D('10.00'), upc=upc) self.importer.handle(TEST_BOOKS_CSV) with self.assertRaises(Product.DoesNotExist): Product.objects.get(upc=upc)
def test_applies_correctly_to_basket_which_exceeds_condition(self): for product in [create_product(price=D('12.00')), create_product(price=D('10.00'))]: self.basket.add_product(product, 2) discount = self.benefit.apply(self.basket, self.condition) self.assertEqual(D('3.00'), discount) self.assertEqual(2, self.basket.num_items_with_discount) self.assertEqual(2, self.basket.num_items_without_discount)
def test_shows_pagination_navigation_for_multiple_pages(self): per_page = ProductListView.paginate_by title = "Product #%d" for idx in range(0, int(1.5 * per_page)): create_product(title=title % idx) page = self.app.get(reverse('catalogue:index')) self.assertContains(page, "Page 1 of 2")
def setUp(self): self.products = [create_product(Decimal('5.00')), create_product(Decimal('10.00'))] self.range = Range.objects.create(name="Some products") for product in self.products: self.range.included_products.add(product) self.range.included_products.add(product) self.basket = Basket.objects.create() self.cond = CoverageCondition(range=self.range, type="Coverage", value=2)
def test_consumes_correct_number_of_products_for_4_product_basket(self): basket = G(Basket) for product in [create_product(), create_product()]: basket.add_product(product, 2) self.assertTrue(self.offer.is_condition_satisfied(basket)) discount = self.offer.apply_benefit(basket) self.assertTrue(discount > 0) self.assertEqual(3, basket.num_items_with_discount) self.assertEqual(1, basket.num_items_without_discount) self.assertFalse(self.offer.is_condition_satisfied(basket))
def test_correct_discount_is_returned(self): products = [create_product(D('8.00')), create_product(D('4.00'))] range = models.Range.objects.create(name="Dummy range") for product in products: range.included_products.add(product) range.included_products.add(product) basket = Basket.objects.create() [basket.add_product(p) for p in products] condition = models.CoverageCondition(range=range, type="Coverage", value=2) discount = self.benefit.apply(basket, condition) self.assertEquals(D('2.00'), discount)
def test_no_discount_is_returned_when_value_is_greater_than_product_total(self): products = [create_product(Decimal('4.00')), create_product(Decimal('4.00'))] range = Range.objects.create(name="Dummy range") for product in products: range.included_products.add(product) range.included_products.add(product) basket = Basket.objects.create() [basket.add_product(p) for p in products] condition = CoverageCondition(range=range, type="Coverage", value=2) discount = self.benefit.apply(basket, condition) self.assertEquals(Decimal('0.00'), discount)
def test_default_line_status_comes_from_settings(self): self.basket.add_product(create_product(price=D('12.00'))) with patch_settings(OSCAR_INITIAL_LINE_STATUS='A'): self.creator.place_order(basket=self.basket, order_number='1234') order = Order.objects.get(number='1234') line = order.lines.all()[0] self.assertEqual('A', line.status)
def test_applies_correctly_to_basket_which_is_worth_the_same_as_value(self): for product in [create_product(price=D('5.00'))]: self.basket.add_product(product, 4) discount = self.benefit.apply(self.basket, self.condition) self.assertEqual(D('0.00'), discount) self.assertEqual(0, self.basket.num_items_with_discount) self.assertEqual(4, self.basket.num_items_without_discount)
def test_applies_correctly_to_basket_which_is_more_than_value(self): for product in [create_product(price=D('8.00'))]: self.basket.add_product(product, 4) discount = self.benefit.apply(self.basket, self.condition) self.assertEqual(D('4.00'), discount) self.assertEqual(3, self.basket.num_items_with_discount) self.assertEqual(1, self.basket.num_items_without_discount)
def test_applies_correctly_to_multi_item_basket_which_matches_condition_but_with_lower_prices_than_discount(self): for product in [create_product(price=D('2.00'))]: self.basket.add_product(product, 6) discount = self.benefit.apply(self.basket, self.condition) self.assertEqual(D('2.00'), discount) self.assertEqual(5, self.basket.num_items_with_discount) self.assertEqual(1, self.basket.num_items_without_discount)
def test_applies_correctly_to_multi_item_basket_which_exceeds_condition_but_matches_boundary(self): for product in [create_product(price=D('5.00'))]: self.basket.add_product(product, 3) discount = self.benefit.apply(self.basket, self.condition) self.assertEqual(D('3.00'), discount) self.assertEqual(2, self.basket.num_items_with_discount) self.assertEqual(1, self.basket.num_items_without_discount)
def test_applies_correctly_to_single_item_basket_which_matches_condition(self): for product in [create_product(price=D('10.00'))]: self.basket.add_product(product, 1) discount = self.benefit.apply(self.basket, self.condition) self.assertEqual(D('3.00'), discount) self.assertEqual(1, self.basket.num_items_with_discount) self.assertEqual(0, self.basket.num_items_without_discount)
def setUp(self): self.product = create_product() self.user_basket = Basket() self.user_basket.add_product(self.product) self.cookie_basket = Basket() self.cookie_basket.add_product(self.product, 2) self.user_basket.merge(self.cookie_basket, add_quantities=False)
def test_condition_consumes_most_expensive_lines_first_when_products_are_repeated(self): for i in range(5, 0, -1): product = create_product(price=Decimal(i), title='%i'%i, upc='upc_%i' % i) self.basket.add_product(product, 2) condition = CountCondition(range=self.range, type="Count", value=2) # initial basket: [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)] self.assertTrue(condition.is_satisfied(self.basket)) # consume 1 and 5 first_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('1.00'), first_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 1 and 5 second_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('1.00'), second_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 2 and 4 third_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('2.00'), third_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 2 and 4 third_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('2.00'), third_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 3 and 3 third_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('3.00'), third_discount) # end of items (one not discounted item in basket) self.assertFalse(condition.is_satisfied(self.basket))
def test_applies_correctly_to_basket_which_exceeds_condition(self): for product in [create_product(price=D('12.00'))]: self.basket.add_product(product, 3) self.benefit.apply(self.basket, self.condition, self.offer) self.assertEqual(2, self.basket.num_items_with_discount) self.assertEqual(1, self.basket.num_items_without_discount) self.assertEqual(50, self.basket.shipping_offer.benefit.value)
def test_consumes_correct_quantity_for_multi_item_basket_more_expensive_than_threshold(self): product = create_product(price=D('6.00')) self.basket.add_product(product, 3) self.benefit.apply(self.basket) line = self.basket.all_lines()[0] self.assertTrue(line.has_discount) self.assertEqual(1, line.quantity_without_discount)
def _test_anonymous_checkout(self): # Add a product to the basket p = create_product(price=D("10.00")) response = self.client.post(reverse("basket:add"), {"action": "add", "product_id": str(p.id), "quantity": 1}) self.assertEqual(302, response.status_code) # Submit shipping address response = self.client.post( reverse("oscar-checkout-shipping-address"), {"last_name": "Smith", "line1": "1 Portland Street", "postcode": "N12 9ET", "country": "GB"}, ) self.assertEqual(302, response.status_code) # Choose shipping method response = self.client.post( reverse("oscar-checkout-shipping-method"), {"method_code": "royal-mail-first-class"} ) self.assertEqual(302, response.status_code) # Shipping method response = self.client.get(reverse("oscar-checkout-payment-method")) self.assertEqual(302, response.status_code) # View preview response = self.client.get(reverse("oscar-checkout-preview")) self.assertEqual(302, response.status_code) # Submit response = self.client.post(reverse("oscar-checkout-payment-details"), {}) self.assertEqual(302, response.status_code)
def setUp(self): self.user = G(User) self.product = create_product(num_in_stock=0) product_page = self.app.get(self.product.get_absolute_url(), user=self.user) form = product_page.forms['alert_form'] form.submit()
def test_moving_from_saved_basket_more_than_stocklevel_raises(self): user = User.objects.create_user(username='******', password='******', email='*****@*****.**') client = Client() client.login(username=user.username, password='******') product = create_product(price=D('10.00'), num_in_stock=1) basket, created = Basket.open.get_or_create(owner=user) basket.add_product(product=product, quantity=1) saved_basket, created = Basket.saved.get_or_create(owner=user) saved_basket.add_product(product=product, quantity=1) response = client.get(reverse('basket:summary')) saved_formset = response.context['saved_formset'] saved_form = saved_formset.forms[0] data = { saved_formset.add_prefix('INITIAL_FORMS'): 1, saved_formset.add_prefix('MAX_NUM_FORMS'): 1, saved_formset.add_prefix('TOTAL_FORMS'): 1, saved_form.add_prefix('id'): saved_form.initial['id'], saved_form.add_prefix('move_to_basket'): True, } response = client.post(reverse('basket:saved'), data=data) # we can't add more than stock level into basket self.assertEqual(Basket.open.get(id=basket.id).lines.get(product=product).quantity, 1) self.assertRedirects(response, reverse('basket:summary'))
def test_gives_correct_discounts_when_applied_multiple_times(self): product = create_product(price=D('5.00')) self.basket.add_product(product, 3) self.assertEquals(D('10.00'), self.benefit.apply(self.basket)) self.assertEquals(D('5.00'), self.benefit.apply(self.basket)) self.assertEquals(D('0.00'), self.benefit.apply(self.basket))
def setUp(self): self.product = create_product(price=D('10.00')) url = reverse('basket:add') post_params = {'product_id': self.product.id, 'action': 'add', 'quantity': 1} self.response = self.client.post(url, post_params)
def test_consumes_all_lines_for_multi_item_basket_cheaper_than_threshold(self): product = create_product(price=D('2.00')) self.basket.add_product(product, 3) self.benefit.apply(self.basket) for line in self.basket.all_lines(): self.assertTrue(line.has_discount) self.assertEqual(0, line.quantity_without_discount)
def setUp(self): super(AbsoluteDiscountBenefitTest, self).setUp() self.benefit = AbsoluteDiscountBenefit(range=self.range, type="Absolute", value=Decimal('10.00')) self.item = create_product(price=Decimal('5.00')) self.original_offer_rounding_function = getattr(settings, 'OSCAR_OFFER_ROUNDING_FUNCTION', None) if self.original_offer_rounding_function is not None: delattr(settings, 'OSCAR_OFFER_ROUNDING_FUNCTION')
def test_condition_consumes_most_expensive_lines_first(self): for i in range(10, 0, -1): product = create_product(price=Decimal(i), title='%i'%i, upc='upc_%i' % i) self.basket.add_product(product, 1) condition = CountCondition(range=self.range, type="Count", value=2) self.assertTrue(condition.is_satisfied(self.basket)) # consume 1 and 10 first_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('1.00'), first_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 2 and 9 second_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('2.00'), second_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 3 and 8 third_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('3.00'), third_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 4 and 7 fourth_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('4.00'), fourth_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 5 and 6 fifth_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('5.00'), fifth_discount) # end of items (one not discounted item in basket) self.assertFalse(condition.is_satisfied(self.basket))
def test_consumes_correct_number_of_products_for_6_product_basket(self): basket = G(Basket) for product in [create_product(), create_product()]: basket.add_product(product, 3) # First application discount = self.offer.apply_benefit(basket) self.assertTrue(discount > 0) self.assertEqual(3, basket.num_items_with_discount) self.assertEqual(3, basket.num_items_without_discount) # Second application discount = self.offer.apply_benefit(basket) self.assertTrue(discount > 0) self.assertEqual(6, basket.num_items_with_discount) self.assertEqual(0, basket.num_items_without_discount)
def test_basket_totals_are_used_by_default(self): self.basket.add_product(create_product(price=D('12.00'))) method = Mock() method.basket_charge_incl_tax = Mock(return_value=D('2.00')) method.basket_charge_excl_tax = Mock(return_value=D('2.00')) self.creator.place_order(basket=self.basket, order_number='1234', shipping_method=method) order = Order.objects.get(number='1234') self.assertEqual(order.total_incl_tax, self.basket.total_incl_tax + D('2.00')) self.assertEqual(order.total_excl_tax, self.basket.total_excl_tax + D('2.00'))
def setUp(self): self.product = create_product(price=D('10.00')) url = reverse('basket:add') post_params = { 'product_id': self.product.id, 'action': 'add', 'quantity': 1 } self.client = Client() self.response = self.client.post(url, post_params)
def test_anonymous_add_to_basket_creates_cookie(self): dummy_product = create_product(price=D('10.00')) url = reverse('basket:add') post_params = { 'product_id': dummy_product.id, 'action': 'add', 'quantity': 1 } response = self.client.post(url, post_params) self.assertTrue('oscar_open_basket' in response.cookies)
def setUp(self): super(AbsoluteDiscountBenefitTest, self).setUp() self.benefit = AbsoluteDiscountBenefit(range=self.range, type="Absolute", value=Decimal('10.00')) self.item = create_product(price=Decimal('5.00')) self.original_offer_rounding_function = getattr( settings, 'OSCAR_OFFER_ROUNDING_FUNCTION', None) if self.original_offer_rounding_function is not None: delattr(settings, 'OSCAR_OFFER_ROUNDING_FUNCTION')
def setUp(self): basket = Basket() basket.add_product(create_product(price=D('10.00')), 4) self.order = create_order(number='100002', basket=basket) self.line = self.order.lines.all()[0] self.shipped, _ = ShippingEventType.objects.get_or_create( name='Shipped', is_required=True, sequence_number=0) self.returned, _ = ShippingEventType.objects.get_or_create( name='Returned', is_required=False, sequence_number=1)
def setUp(self): username = str(randint(0, maxint)) self.user = User.objects.create_user(username, '*****@*****.**' % username, '%spass123' % username) self.anon_user = AnonymousUser() self.product = create_product() self.review = ProductReview.objects.create(product=self.product, title="Dummy review", score=3, user=self.user)
def test_consumes_correct_number_of_products_for_3_product_basket(self): basket = G(Basket) for product in [create_product()]: basket.add_product(product, 3) self.assertTrue(self.offer.is_condition_satisfied(basket)) discount = self.offer.apply_benefit(basket) self.assertTrue(discount > 0) self.assertEqual(3, basket.num_items_with_discount) self.assertEqual(0, basket.num_items_without_discount) self.assertFalse(self.offer.is_condition_satisfied(basket))
def setUp(self): Order.objects.all().delete() super(TestOrderPlacement, self).setUp() self.basket = Basket.objects.create(owner=self.user) self.basket.add_product(create_product(price=D('12.00'))) self.complete_shipping_address() self.complete_shipping_method() self.response = self.client.post(reverse('checkout:preview'), {'action': 'place_order'})
def test_can_create_a_stock_alert(self): product = create_product(num_in_stock=0) product_page = self.app.get(product.get_absolute_url()) form = product_page.forms['alert_form'] form['email'] = '*****@*****.**' form.submit() alerts = ProductAlert.objects.filter(email='*****@*****.**') self.assertEqual(1, len(alerts)) alert = alerts[0] self.assertEqual(ProductAlert.UNCONFIRMED, alert.status) self.assertEqual(alert.product, product)
def test_can_create_a_stock_alert(self): user = G(User) product = create_product(num_in_stock=0) product_page = self.app.get(product.get_absolute_url(), user=user) form = product_page.forms['alert_form'] form.submit() alerts = ProductAlert.objects.filter(user=user) self.assertEqual(1, len(alerts)) alert = alerts[0] self.assertEqual(ProductAlert.ACTIVE, alert.status) self.assertEqual(alert.product, product)
def test_consumed_items_checks_affected_items(self): # Create new offer range = models.Range.objects.create(name="All products", includes_all_products=True) cond = models.CoverageCondition(range=range, type="Coverage", value=2) # Get 4 distinct products in the basket self.products.extend([ create_product(Decimal('15.00')), create_product(Decimal('20.00')) ]) for product in self.products: self.basket.add_product(product) self.assertTrue(cond.is_satisfied(self.basket)) cond.consume_items(self.basket, []) self.assertEquals(2, self.basket.num_items_without_discount) self.assertTrue(cond.is_satisfied(self.basket)) cond.consume_items(self.basket, []) self.assertEquals(0, self.basket.num_items_without_discount)
def setUp(self): self.applicator = Applicator() self.basket = Basket.objects.create() self.product = create_product(price=D('100')) rng = G(models.Range, includes_all_products=True) self.condition = G(models.Condition, range=rng, type="Value", value=D('100')) self.benefit = G(models.Benefit, range=rng, type="Absolute", value=D('10'))
def test_product_does_consume_item_if_not_in_condition_range(self): # Set up condition using a different range from benefit range = Range.objects.create(name="Small range") other_product = create_product(price=Decimal('15.00')) range.included_products.add(other_product) cond = ValueCondition(range=range, type="Value", value=Decimal('10.00')) self.basket.add_product(self.item, 1) self.benefit.apply(self.basket, cond) line = self.basket.all_lines()[0] self.assertEqual(line.quantity_without_discount, 0)
def test_correct_discount_for_count_condition(self): products = [ create_product(Decimal('7.00')), create_product(Decimal('8.00')), create_product(Decimal('12.00')) ] # Create range that includes the products range = Range.objects.create(name="Dummy range") for product in products: range.included_products.add(product) condition = CountCondition(range=range, type="Count", value=3) # Create basket that satisfies condition but with one extra product basket = Basket.objects.create() [basket.add_product(p, 2) for p in products] benefit = FixedPriceBenefit(range=range, type="FixedPrice", value=Decimal('20.00')) self.assertEquals(Decimal('2.00'), benefit.apply(basket, condition)) self.assertEquals(Decimal('12.00'), benefit.apply(basket, condition)) self.assertEquals(Decimal('0.00'), benefit.apply(basket, condition))
def test_discount_when_more_products_than_required(self): products = [ create_product(Decimal('4.00')), create_product(Decimal('8.00')), create_product(Decimal('12.00')) ] # Create range that includes the products range = Range.objects.create(name="Dummy range") for product in products: range.included_products.add(product) condition = CoverageCondition(range=range, type="Coverage", value=3) # Create basket that satisfies condition but with one extra product basket = Basket.objects.create() [basket.add_product(p) for p in products] basket.add_product(products[0]) benefit = FixedPriceBenefit(range=range, type="FixedPrice", value=Decimal('20.00')) discount = benefit.apply(basket, condition) self.assertEquals(Decimal('4.00'), discount)
def test_count_condition_is_applied_multpile_times(self): benefit = AbsoluteDiscountBenefit(range=self.range, type="Absolute", value=Decimal('10.00')) for i in range(10): self.basket.add_product( create_product(price=Decimal('5.00'), upc='upc_%i' % i), 1) product_range = Range.objects.create(name="All products", includes_all_products=True) condition = CountCondition(range=product_range, type="Count", value=2) first_discount = benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('10.00'), first_discount) second_discount = benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('10.00'), second_discount)
def test_adding_more_than_threshold_raises(self): dummy_product = create_product(price=D('10.00')) url = reverse('basket:add') post_params = { 'product_id': dummy_product.id, 'action': 'add', 'quantity': 2 } response = self.client.post(url, post_params) self.assertTrue('oscar_open_basket' in response.cookies) post_params = { 'product_id': dummy_product.id, 'action': 'add', 'quantity': 2 } response = self.client.post(url, post_params) self.assertTrue('Your basket currently has 2 items.' in response.cookies['messages'].value)
def test_cannot_reorder_line_when_basket_maximum_exceeded(self): order = create_order(user=self.user) line = order.lines.all()[0] Basket.objects.all().delete() #add a product product = create_product(price=D('12.00')) self.client.post(reverse('basket:add'), { 'product_id': product.id, 'quantity': 1 }) basket = Basket.objects.all()[0] self.assertEquals(len(basket.all_lines()), 1) self.client.post( reverse('customer:order-line', args=(order.number, line.pk)), {'action': 'reorder'}) self.assertEquals(len(basket.all_lines()), 1) self.assertNotEqual(line.product.pk, product.pk)
def _test_anonymous_checkout(self): # Add a product to the basket p = create_product(price=D('10.00')) response = self.client.post(reverse('basket:add'), { 'action': 'add', 'product_id': str(p.id), 'quantity': 1 }) self.assertEqual(302, response.status_code) # Submit shipping address response = self.client.post( reverse('oscar-checkout-shipping-address'), { 'last_name': 'Smith', 'line1': '1 Portland Street', 'postcode': 'N12 9ET', 'country': 'GB' }) self.assertEqual(302, response.status_code) # Choose shipping method response = self.client.post(reverse('oscar-checkout-shipping-method'), {'method_code': 'royal-mail-first-class'}) self.assertEqual(302, response.status_code) # Shipping method response = self.client.get(reverse('oscar-checkout-payment-method')) self.assertEqual(302, response.status_code) # View preview response = self.client.get(reverse('oscar-checkout-preview')) self.assertEqual(302, response.status_code) # Submit response = self.client.post(reverse('oscar-checkout-payment-details'), {}) self.assertEqual(302, response.status_code)
def test_condition_consumes_most_expensive_lines_first_when_products_are_repeated( self): for i in range(5, 0, -1): product = create_product(price=Decimal(i), title='%i' % i, upc='upc_%i' % i) self.basket.add_product(product, 2) condition = CountCondition(range=self.range, type="Count", value=2) # initial basket: [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)] self.assertTrue(condition.is_satisfied(self.basket)) # consume 1 and 5 first_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('1.00'), first_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 1 and 5 second_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('1.00'), second_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 2 and 4 third_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('2.00'), third_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 2 and 4 third_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('2.00'), third_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 3 and 3 third_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('3.00'), third_discount) # end of items (one not discounted item in basket) self.assertFalse(condition.is_satisfied(self.basket))
def test_condition_consumes_most_expensive_lines_first(self): for i in range(10, 0, -1): product = create_product(price=Decimal(i), title='%i' % i, upc='upc_%i' % i) self.basket.add_product(product, 1) condition = CountCondition(range=self.range, type="Count", value=2) self.assertTrue(condition.is_satisfied(self.basket)) # consume 1 and 10 first_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('1.00'), first_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 2 and 9 second_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('2.00'), second_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 3 and 8 third_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('3.00'), third_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 4 and 7 fourth_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('4.00'), fourth_discount) self.assertTrue(condition.is_satisfied(self.basket)) # consume 5 and 6 fifth_discount = self.benefit.apply(self.basket, condition=condition) self.assertEquals(Decimal('5.00'), fifth_discount) # end of items (one not discounted item in basket) self.assertFalse(condition.is_satisfied(self.basket))
def test_wrapper_availability_gets_called(self): product = create_product(price=D('10.00'), partner="Acme", num_in_stock=10) self.assertEquals(u"Dummy response", unicode(product.stockrecord.availability))
def test_dispatch_date_for_out_of_stock(self): product = create_product(price=D('10.00'), partner="Acme", num_in_stock=0) date = datetime.date.today() + datetime.timedelta(days=7) self.assertEquals(date, product.stockrecord.dispatch_date)
def test_dispatch_date_for_in_stock(self): product = create_product(price=D('10.00'), partner="Acme", num_in_stock=1) tomorrow = datetime.date.today() + datetime.timedelta(days=1) self.assertEquals(tomorrow, product.stockrecord.dispatch_date)
def test_default_wrapper_for_out_of_stock(self): product = create_product(price=D('10.00'), partner="Acme", num_in_stock=0) self.assertEquals("Out of stock", product.stockrecord.availability)
def test_default_wrapper_for_in_stock(self): product = create_product(price=D('10.00'), partner="Acme", num_in_stock=10) self.assertEquals("In stock (10 available)", product.stockrecord.availability)
def setUp(self): self.product = create_product(price=D('10.00'), num_in_stock=10)
def test_wrapper_dispatch_date_gets_called(self): product = create_product(price=D('10.00'), partner="Acme", num_in_stock=10) self.assertEquals("Another dummy response", product.stockrecord.dispatch_date)
def setUp(self): self.product = create_product(price=D('10.00'))
def test_canonical_urls_are_enforced(self): p = create_product() args = {'product_slug': 'wrong-slug', 'pk': p.id} wrong_url = reverse('catalogue:detail', kwargs=args) response = self.client.get(wrong_url) self.assertEquals(httplib.MOVED_PERMANENTLY, response.status_code)