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)