def setUp(self):
super(ValueConditionTest, self).setUp()
self.condition = models.ValueCondition(range=self.range,
type="Value",
value=Decimal('10.00'))
self.item = create_product(price=Decimal('5.00'))
self.expensive_item = create_product(price=Decimal('15.00'))
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_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_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_can_delete_a_canonical_product(self):
canonical_product = create_product(title="Canonical Product")
product = create_product(title="Variant 1", parent=canonical_product)
stockrecord = product.stockrecord
category = Category.add_root(name='Test Category')
product_category = ProductCategory.objects.create(category=category,
product=product)
page = self.get(
reverse('dashboard:catalogue-product-delete',
args=(canonical_product.id, ))).form.submit()
self.assertRedirects(page, reverse('dashboard:catalogue-product-list'))
self.assertEquals(Product.objects.count(), 0)
self.assertEquals(StockRecord.objects.count(), 0)
self.assertEquals(ProductCategory.objects.count(), 0)
self.assertRaises(Product.DoesNotExist,
Product.objects.get,
id=canonical_product.id)
self.assertRaises(Product.DoesNotExist,
Product.objects.get,
id=product.id)
self.assertRaises(StockRecord.DoesNotExist,
StockRecord.objects.get,
id=stockrecord.id)
self.assertRaises(ProductCategory.DoesNotExist,
ProductCategory.objects.get,
id=product_category.id)
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.condition.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_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.condition.is_satisfied(self.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_applies_correctly_to_basket_which_exceeds_condition_with_smaller_prices_than_discount(self):
for product in [create_product(price=D("2.00")), create_product(price=D("4.00"))]:
self.basket.add_product(product, 2)
result = self.benefit.apply(self.basket, self.condition)
self.assertEqual(D("3.00"), result.discount)
self.assertEqual(4, self.basket.num_items_with_discount)
self.assertEqual(0, self.basket.num_items_without_discount)
def test_can_delete_a_canonical_product(self):
canonical_product = create_product(title="Canonical Product")
product = create_product(title="Variant 1", parent=canonical_product)
stockrecord = product.stockrecord
category = Category.add_root(name='Test Category')
product_category = ProductCategory.objects.create(category=category,
product=product)
page = self.get(reverse('dashboard:catalogue-product-delete',
args=(canonical_product.id,))).form.submit()
self.assertRedirects(page, reverse('dashboard:catalogue-product-list'))
self.assertEquals(Product.objects.count(), 0)
self.assertEquals(StockRecord.objects.count(), 0)
self.assertEquals(ProductCategory.objects.count(), 0)
self.assertRaises(Product.DoesNotExist,
Product.objects.get, id=canonical_product.id)
self.assertRaises(Product.DoesNotExist,
Product.objects.get, id=product.id)
self.assertRaises(StockRecord.DoesNotExist,
StockRecord.objects.get, id=stockrecord.id)
self.assertRaises(ProductCategory.DoesNotExist,
ProductCategory.objects.get, id=product_category.id)
def test_applies_correctly_to_basket_which_exceeds_condition(self):
for product in [create_product(price=D("12.00")), create_product(price=D("20.00"))]:
self.basket.add_product(product, 2)
discount = self.benefit.apply(self.basket, self.condition)
self.assertEqual(1 * D("12.00") * D("0.2"), discount)
# Should only consume the condition products
self.assertEqual(2, self.basket.num_items_with_discount)
self.assertEqual(2, self.basket.num_items_without_discount)
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_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_shows_pagination_navigation_for_multiple_pages(self):
per_page = ProductListView.paginate_by
title = u"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 test_shows_pagination_navigation_for_multiple_pages(self):
per_page = ProductListView.paginate_by
title = u"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 = models.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.condition = models.CoverageCondition(range=self.range, type="Coverage", value=2)
def setUp(self):
self.products = [create_product(Decimal('5.00')), create_product(Decimal('10.00'))]
self.range = models.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.condition = models.CoverageCondition(range=self.range, type="Coverage", value=2)
def test_applies_correctly_to_basket_which_exceeds_condition(self):
for product in [
create_product(price=D('4.00')),
create_product(price=D('2.00'))
]:
self.basket.add_product(product, 2)
discount = self.benefit.apply(self.basket, self.condition)
self.assertEqual(D('2.00'), discount)
self.assertEqual(3, self.basket.num_items_with_discount)
self.assertEqual(1, self.basket.num_items_without_discount)
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_applies_correctly_to_basket_which_exceeds_condition_with_smaller_prices_than_discount_and_higher_prices_first(
self):
for product in [
create_product(price=D('4.00')),
create_product(price=D('2.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_applies_correctly_to_basket_which_exceeds_condition(self):
for product in [
create_product(price=D('12.00')),
create_product(price=D('20.00'))
]:
self.basket.add_product(product, 2)
discount = self.benefit.apply(self.basket, self.condition)
self.assertEqual(1 * D('12.00') * D('0.2'), discount)
# Should only consume the condition products
self.assertEqual(2, self.basket.num_items_with_discount)
self.assertEqual(2, self.basket.num_items_without_discount)
def test_applies_correctly_to_basket_which_matches_condition_with_multiple_lines_and_lower_total_value(self):
# Use a basket with 2 lines
for product in [create_product(price=D("1.00")), create_product(price=D("1.50"))]:
self.basket.add_product(product, 1)
result = self.benefit.apply(self.basket, self.condition)
self.assertTrue(result.is_successful)
self.assertFalse(result.is_final)
self.assertEqual(D("2.50"), result.discount)
self.assertEqual(2, self.basket.num_items_with_discount)
self.assertEqual(0, self.basket.num_items_without_discount)
def test_applies_correctly_when_discounts_need_rounding(self):
# Split discount across 3 lines
for product in [create_product(price=D('2.00')),
create_product(price=D('2.00')),
create_product(price=D('2.00'))]:
self.basket.add_product(product)
result = self.benefit.apply(self.basket, self.condition)
self.assertEqual(D('4.00'), result.discount)
# Check the discount is applied equally to each line
line_discounts = [line._discount for line in self.basket.all_lines()]
self.assertItemsEqual(line_discounts, [D('1.33'), D('1.33'), D('1.34')])
def test_variant_to_parent_redirect(self):
parent_product = create_product()
kwargs = {"product_slug": parent_product.slug, "pk": parent_product.id}
parent_product_url = reverse("catalogue:detail", kwargs=kwargs)
variant = create_product(title="Variant 1", parent=parent_product)
kwargs = {"product_slug": variant.slug, "pk": variant.id}
variant_url = reverse("catalogue:detail", kwargs=kwargs)
response = self.app.get(parent_product_url)
self.assertEquals(httplib.OK, response.status_code)
response = self.app.get(variant_url)
self.assertEquals(httplib.MOVED_PERMANENTLY, response.status_code)
def test_applies_correctly_to_basket_which_matches_condition_with_multiple_lines(self):
# Use a basket with 2 lines
for product in [create_product(price=D("12.00")), create_product(price=D("12.00"))]:
self.basket.add_product(product, 1)
result = self.benefit.apply(self.basket, self.condition)
self.assertTrue(result.is_successful)
self.assertFalse(result.is_final)
self.assertEqual(D("3.00"), result.discount)
self.assertEqual(2, self.basket.num_items_with_discount)
self.assertEqual(0, self.basket.num_items_without_discount)
# Check the discount is applied equally to each line
for line in self.basket.all_lines():
self.assertEqual(D("1.50"), line._discount)
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)
def test_applies_correctly_to_basket_which_matches_condition_with_multiple_lines_and_lower_total_value(
self):
# Use a basket with 2 lines
for product in [
create_product(price=D('1.00')),
create_product(price=D('1.50'))
]:
self.basket.add_product(product, 1)
result = self.benefit.apply(self.basket, self.condition)
self.assertTrue(result.is_successful)
self.assertFalse(result.is_final)
self.assertEqual(D('2.50'), result.discount)
self.assertEqual(2, self.basket.num_items_with_discount)
self.assertEqual(0, self.basket.num_items_without_discount)
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)
def go_to_payment_detail_page(self):
product = create_product()
page = self.get(reverse(
'catalogue:detail',
args=(product.slug, product.id)
))
page = page.forms[2].submit()
self.assertEquals(Basket.objects.count(), 1)
page = self.get(reverse('checkout:index'))
self.assertRedirects(page, reverse('checkout:shipping-address'))
shipping_form = page.follow().form
shipping_form['title'] = ''
shipping_form['first_name'] = "Peter"
shipping_form['last_name'] = "Griffin"
shipping_form['line1'] = "31 Spooner St"
shipping_form['line4'] = "Quahog"
shipping_form['state'] = "Victoria"
shipping_form['country'] = 'AU'
shipping_form['postcode'] = "3070"
shipping_form['phone_number'] = "+61 (3) 121 121"
shipping_form['notes'] = "Some additional notes"
page = shipping_form.submit().follow().follow()
self.assertRedirects(page, reverse('checkout:payment-details'))
return page.follow()
def test_enforces_canonical_url(self):
p = create_product()
kwargs = {"product_slug": "wrong-slug", "pk": p.id}
wrong_url = reverse("catalogue:detail", kwargs=kwargs)
response = self.app.get(wrong_url)
self.assertEquals(httplib.MOVED_PERMANENTLY, response.status_code)
def test_applies_correctly_to_basket_which_matches_condition(self):
for product in [create_product(price=D('5.00'))]:
self.basket.add_product(product, 2)
result = self.benefit.apply(self.basket, self.condition)
self.assertEqual(D('5.00'), result.discount)
self.assertEqual(2, self.basket.num_items_with_discount)
self.assertEqual(0, self.basket.num_items_without_discount)
def test_uses_default_line_status_from_settings(self):
self.basket.add_product(create_product(price=D('12.00')))
with override_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_matches_condition(self):
for product in [create_product(price=D('12.00'))]:
self.basket.add_product(product, 2)
self.benefit.apply(self.basket, self.condition, self.offer)
self.assertEqual(2, self.basket.num_items_with_discount)
self.assertEqual(0, self.basket.num_items_without_discount)
self.assertEqual(50, self.basket.shipping_offer.benefit.value)
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 test_applies_correctly_to_basket_which_exceeds_condition(self):
for product in [create_product(price=D('12.00'))]:
self.basket.add_product(product, 3)
result = self.benefit.apply(self.basket, self.condition)
self.assertEqual(3 * D('12.00') * D('0.2'), result.discount)
self.assertEqual(3, self.basket.num_items_with_discount)
self.assertEqual(0, self.basket.num_items_without_discount)
def test_shows_add_to_basket_button_for_available_product(self):
product = create_product()
page = self.app.get(reverse("catalogue:index"))
self.assertContains(page, product.title)
self.assertContains(page, "Add to basket")
def test_applies_correctly_when_discounts_need_rounding(self):
# Split discount across 3 lines
for product in [
create_product(price=D('2.00')),
create_product(price=D('2.00')),
create_product(price=D('2.00'))
]:
self.basket.add_product(product)
result = self.benefit.apply(self.basket, self.condition)
self.assertEqual(D('4.00'), result.discount)
# Check the discount is applied equally to each line
line_discounts = [line._discount for line in self.basket.all_lines()]
self.assertItemsEqual(
line_discounts,
[D('1.33'), D('1.33'), D('1.34')])
def test_variant_to_parent_redirect(self):
parent_product = create_product()
kwargs = {'product_slug': parent_product.slug,
'pk': parent_product.id}
parent_product_url = reverse('catalogue:detail', kwargs=kwargs)
variant = create_product(title="Variant 1", parent=parent_product)
kwargs = {'product_slug': variant.slug,
'pk': variant.id}
variant_url = reverse('catalogue:detail', kwargs=kwargs)
response = self.app.get(parent_product_url)
self.assertEquals(httplib.OK, response.status_code)
response = self.app.get(variant_url)
self.assertEquals(httplib.MOVED_PERMANENTLY, response.status_code)
def test_shows_add_to_basket_button_for_available_product(self):
product = create_product()
page = self.app.get(reverse('catalogue:index'))
self.assertContains(page, product.title)
self.assertContains(page, "Add to basket")
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_shows_not_available_for_out_of_stock_product(self):
product = create_product(num_in_stock=0)
page = self.app.get(reverse("catalogue:index"))
self.assertContains(page, product.title)
self.assertContains(page, "Not available")
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_uses_default_line_status_from_settings(self):
self.basket.add_product(create_product(price=D('12.00')))
with override_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_more_than_value(self):
for product in [create_product(price=D('8.00'))]:
self.basket.add_product(product, 4)
result = self.benefit.apply(self.basket, self.condition)
self.assertEqual(D('4.00'), result.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_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_shows_not_available_for_out_of_stock_product(self):
product = create_product(num_in_stock=0)
page = self.app.get(reverse('catalogue:index'))
self.assertContains(page, product.title)
self.assertContains(page, "Not available")
def test_applies_correctly_to_multi_item_basket_which_exceeds_condition(self):
for product in [create_product(price=D('4.00'))]:
self.basket.add_product(product, 3)
result = self.benefit.apply(self.basket, self.condition)
self.assertEqual(D('3.00'), result.discount)
self.assertEqual(3, self.basket.num_items_with_discount)
self.assertEqual(0, self.basket.num_items_without_discount)
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_applies_correctly_to_basket_which_exceeds_condition(self):
for product in [create_product(price=D('12.00'))]:
self.basket.add_product(product, 3)
result = 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.assertTrue(result.affects_shipping)
def test_sets_correct_order_status(self):
self.basket.add_product(create_product(price=D('12.00')))
self.creator.place_order(basket=self.basket,
order_number='1234',
status='Active')
order = Order.objects.get(number='1234')
self.assertEqual('Active', order.status)
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 setUp(self):
self.client = Client()
self.product = create_product()
User.objects.create_user(username=self.username,
email=self.email,
password=self.password)
self.client.login(username=self.username, password=self.password)
