def setUp(self):
self.product = factories.create_product()
self.stockrecord = factories.create_stockrecord(self.product,
D('12.00'),
num_in_stock=5)
self.basket = factories.create_basket(empty=True)
add_product(self.basket, product=self.product)
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, "Unavailable")
def test_adding_more_than_threshold_raises(self):
dummy_product = create_product(price=D('10.00'), num_in_stock=10)
url = reverse('basket:add', kwargs={'pk': dummy_product.pk})
post_params = {
'product_id': dummy_product.id,
'action': 'add',
'quantity': 2
}
response = self.app.post(url, params=post_params)
self.assertTrue('wshop_open_basket' in response.test_app.cookies)
post_params = {
'product_id': dummy_product.id,
'action': 'add',
'quantity': 2
}
response = self.app.post(url, params=post_params)
expected = ugettext(
"Due to technical limitations we are not able to ship more "
"than %(threshold)d items in one order. Your basket currently "
"has %(basket)d items.") % ({
'threshold': 3,
'basket': 2
})
self.assertTrue(expected in response.test_app.cookies['messages'])
def test_basket_prices_calculation_for_unavailable_pricing(self):
new_product = factories.create_product()
factories.create_stockrecord(new_product, price_excl_tax=D('5.00'))
self.basket.add(new_product, 1)
class UnavailableProductStrategy(strategy.Default):
""" A test strategy that makes a specific product unavailable """
def availability_policy(self, product, stockrecord):
if product == new_product:
return availability.Unavailable()
return super(UnavailableProductStrategy,
self).availability_policy(product, stockrecord)
def pricing_policy(self, product, stockrecord):
if product == new_product:
return prices.Unavailable()
return super(UnavailableProductStrategy,
self).pricing_policy(product, stockrecord)
self.basket.strategy = UnavailableProductStrategy()
line = self.basket.all_lines()[1]
self.assertEqual(
line.get_warning(),
u"'D\xf9\uff4d\u03fb\u03d2 title' is no longer available")
self.assertIsNone(line.line_price_excl_tax)
self.assertIsNone(line.line_price_incl_tax)
self.assertIsNone(line.line_price_excl_tax_incl_discounts)
self.assertIsNone(line.line_price_incl_tax_incl_discounts)
self.assertIsNone(line.line_tax)
self.assertEqual(self.basket.total_excl_tax, 100)
self.assertEqual(self.basket.total_incl_tax, 100)
self.assertEqual(self.basket.total_excl_tax_excl_discounts, 100)
self.assertEqual(self.basket.total_incl_tax_excl_discounts, 100)
def test_applies_correctly_to_basket_with_no_discountable_products(self):
product = factories.create_product(is_discountable=False)
add_product(self.basket, D('12.00'), 2, product=product)
result = self.benefit.apply(self.basket, self.condition, self.offer)
self.assertEqual(D('0.00'), result.discount)
self.assertEqual(0, self.basket.num_items_with_discount)
self.assertEqual(2, self.basket.num_items_without_discount)
def test_moving_from_saved_basket(self):
self.user = User.objects.create_user(username='******',
password='******',
email='*****@*****.**')
product = create_product(price=D('10.00'), num_in_stock=2)
basket = factories.create_basket(empty=True)
basket.owner = self.user
basket.save()
add_product(basket, product=product)
saved_basket, created = Basket.saved.get_or_create(owner=self.user)
saved_basket.strategy = basket.strategy
add_product(saved_basket, product=product)
response = self.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 = self.post(reverse('basket:saved'), params=data)
self.assertEqual(
Basket.open.get(id=basket.id).lines.get(product=product).quantity,
2)
self.assertRedirects(response, reverse('basket:summary'))
def test_means_another_currency_product_cannot_be_added(self):
product = factories.create_product()
factories.create_stockrecord(currency='USD',
product=product,
price_excl_tax=D('20.00'))
with self.assertRaises(ValueError):
self.basket.add(product)
def test_line_quantity_max_attribute_per_basket_threshold(self):
self.basket.flush()
product = factories.create_product(num_in_stock=20)
add_product(self.basket, D('100'), 4, product)
self.line = self.basket.all_lines()[0]
form = self.build_form()
self.assertIn('max="6"', str(form['quantity']))
def setUp(self):
product = factories.create_product(attributes={'weight': 5},
num_in_stock=10)
factories.create_shipping_weight_band(10, 10)
self.basket = factories.create_basket(empty=True)
self.basket.add_product(product)
self.offer = create_offer()
def test_child_to_parent_redirect(self):
parent_product = create_product(structure='parent')
kwargs = {'product_slug': parent_product.slug,
'pk': parent_product.id}
parent_product_url = reverse('catalogue:detail', kwargs=kwargs)
child = create_product(
title="Variant 1", structure='child', parent=parent_product)
kwargs = {'product_slug': child.slug,
'pk': child.id}
child_url = reverse('catalogue:detail', kwargs=kwargs)
response = self.app.get(parent_product_url)
self.assertEqual(http_client.OK, response.status_code)
response = self.app.get(child_url)
self.assertEqual(http_client.MOVED_PERMANENTLY, response.status_code)
def setUp(self):
self.user = UserFactory()
self.product = create_product()
self.stockrecord = create_stockrecord(self.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_product_which_doesnt_track_stock(self):
product_class = models.ProductClass.objects.create(name="Digital",
track_stock=False)
product = factories.create_product(product_class=product_class,
price=D('1.99'),
num_in_stock=None)
info = self.strategy.fetch_for_product(product)
self.assertTrue(info.availability.is_available_to_buy)
def setUp(self):
self.basket = Basket()
self.basket.strategy = strategy.Default()
self.product = factories.create_product()
self.record = factories.create_stockrecord(self.product,
price_excl_tax=D('10.00'))
self.purchase_info = factories.create_purchase_info(self.record)
self.basket.add(self.product, 10)
def setUp(self):
self.product = create_product()
self.user = UserFactory()
self.voter = UserFactory()
self.review = self.product.reviews.create(title='This is nice',
score=3,
body="This is the body",
user=self.user)
def test_images_are_in_consecutive_order(self):
product = factories.create_product()
for i in range(4):
factories.create_product_image(product=product, display_order=i)
product.images.all()[2].delete()
for idx, im in enumerate(product.images.all()):
self.assertEqual(im.display_order, idx)
def test_redirects_customers_with_invalid_basket(self):
product = factories.create_product(num_in_stock=1)
self.add_product_to_basket(product)
self.enter_guest_details()
self.enter_shipping_address()
product.stockrecords.all().update(num_in_stock=0)
response = self.get(reverse('checkout:shipping-method'))
self.assertRedirectsTo(response, 'basket:summary')
def setUp(self):
self.product = create_product(price=D('10.00'), num_in_stock=10)
url = reverse('basket:add', kwargs={'pk': self.product.pk})
post_params = {
'product_id': self.product.id,
'action': 'add',
'quantity': 1
}
self.response = self.app.post(url, params=post_params)
def setUp(self):
self.product = create_product(num_in_stock=10)
self.user_basket = Basket()
self.user_basket.strategy = strategy.Default()
add_product(self.user_basket, product=self.product)
self.cookie_basket = Basket()
self.cookie_basket.strategy = strategy.Default()
add_product(self.cookie_basket, quantity=2, product=self.product)
self.user_basket.merge(self.cookie_basket, add_quantities=False)
def test_variant_images_fallback_to_parent(self):
parent = factories.ProductFactory(structure='parent')
variant = factories.create_product(parent=parent)
factories.create_product_image(product=parent,
caption='Parent Product Image')
all_images = variant.get_all_images()
self.assertEquals(all_images.count(), 1)
product_image = all_images.first()
self.assertEquals(product_image.caption, 'Parent Product Image')
def test_enforces_canonical_url(self):
p = create_product()
kwargs = {'product_slug': '1_wrong-but-valid-slug_1',
'pk': p.id}
wrong_url = reverse('catalogue:detail', kwargs=kwargs)
response = self.app.get(wrong_url)
self.assertEqual(http_client.MOVED_PERMANENTLY, response.status_code)
self.assertTrue(p.get_absolute_url() in response.location)
def test_enforce_max_line_quantity_for_existing_product(self):
self.basket.flush()
product = factories.create_product(num_in_stock=20)
add_product(self.basket, D('100'), 4, product)
self.line = self.basket.all_lines()[0]
form = self.build_form(quantity=6)
self.assertTrue(form.is_valid())
form.save()
form = self.build_form(quantity=11)
self.assertFalse(form.is_valid())
def setUp(self):
self.product = create_product()
self.user = UserFactory(first_name="Tom", last_name="Thumb")
self.data = {
'product': self.product,
'title': 'This product is lovely',
'body': 'I really like this cheese',
'score': 0,
'user': self.user
}
def test_partner_name_is_optional(self):
for partner_name, order_number in [('', 'A'), ('p1', 'B')]:
self.basket = factories.create_basket(empty=True)
product = factories.create_product(partner_name=partner_name)
add_product(self.basket, D('12.00'), product=product)
place_order(
self.creator, basket=self.basket, order_number=order_number)
line = Order.objects.get(number=order_number).lines.all()[0]
partner = product.stockrecords.all()[0].partner
self.assertTrue(partner_name == line.partner_name == partner.name)
def setUp(self):
self.product = create_product()
self.data = {
'product': self.product,
'title': 'This product is lovely',
'body': 'I really like this cheese',
'score': 0,
'name': 'JR Hartley',
'email': '*****@*****.**'
}
def test_line_tax_for_zero_tax_strategies(self):
basket = Basket()
basket.strategy = strategy.Default()
product = factories.create_product()
# Tax for the default strategy will be 0
factories.create_stockrecord(product,
price_excl_tax=D('75.00'),
num_in_stock=10)
basket.add(product, 1)
self.assertEqual(basket.lines.first().line_tax, D('0'))
def test_redirects_customers_with_invalid_basket(self):
# Add product to basket but then remove its stock so it is not
# purchasable.
product = factories.create_product(num_in_stock=1)
self.add_product_to_basket(product)
self.enter_guest_details()
product.stockrecords.all().update(num_in_stock=0)
response = self.get(reverse('checkout:shipping-address'))
self.assertRedirectsTo(response, 'basket:summary')
def test_included_excluded_products_in_all_products(self):
count = 5
included_products = [create_product() for _ in range(count)]
excluded_products = [create_product() for _ in range(count)]
for product in included_products:
models.RangeProduct.objects.create(
product=product, range=self.range)
self.range.excluded_products.add(*excluded_products)
all_products = self.range.all_products()
self.assertEqual(all_products.count(), count)
self.assertEqual(self.range.num_products(), count)
for product in included_products:
self.assertTrue(product in all_products)
for product in excluded_products:
self.assertTrue(product not in all_products)
def test_descendant_categories_in_all_products(self):
parent_category = catalogue_models.Category.add_root(name="parent")
child_category = parent_category.add_child(name="child")
grand_child_category = child_category.add_child(name="grand-child")
c_product = create_product()
gc_product = create_product()
catalogue_models.ProductCategory.objects.create(
product=c_product, category=child_category)
catalogue_models.ProductCategory.objects.create(
product=gc_product, category=grand_child_category)
self.range.included_categories.add(parent_category)
all_products = self.range.all_products()
self.assertTrue(c_product in all_products)
self.assertTrue(gc_product in all_products)
self.assertEqual(self.range.num_products(), 2)
def test_categories_in_all_products(self):
included_category = catalogue_models.Category.add_root(name="root")
product_in_included_category = create_product()
excluded_product_in_included_category = create_product()
catalogue_models.ProductCategory.objects.create(
product=product_in_included_category, category=included_category)
catalogue_models.ProductCategory.objects.create(
product=excluded_product_in_included_category,
category=included_category)
self.range.included_categories.add(included_category)
self.range.excluded_products.add(excluded_product_in_included_category)
all_products = self.range.all_products()
self.assertTrue(product_in_included_category in all_products)
self.assertTrue(excluded_product_in_included_category not in
all_products)
self.assertEqual(self.range.num_products(), 1)
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)
