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)
