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_total_excludes_unavailable_products_with_unknown_price(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)
try:
self.basket.strategy = UnavailableProductStrategy()
self.assertEqual(
self.basket.all_lines()[1].get_warning(),
u"'D\xf9\uff4d\u03fb\u03d2 title' is no longer available")
self.assertEqual(self.basket.total_excl_tax, 100)
finally:
self.basket.strategy = strategy.Default()
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_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().availability_policy(product, stockrecord)
def pricing_policy(self, product, stockrecord):
if product == new_product:
return prices.Unavailable()
return super().pricing_policy(product, stockrecord)
self.basket.strategy = UnavailableProductStrategy()
line = self.basket.all_lines()[1]
self.assertEqual(line.get_warning(), "'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_total_excludes_unavailable_products_with_unknown_price(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)
try:
self.basket.strategy = UnavailableProductStrategy()
self.assertEqual(self.basket.all_lines()[1].get_warning(), u"'D\xf9\uff4d\u03fb\u03d2 title' is no longer available")
self.assertEqual(self.basket.total_excl_tax, 100)
finally:
self.basket.strategy = strategy.Default()
def test_handle_shipping_event_email_opt_in(self, expected_opt_in):
"""
Verify that the shipping sends email opt in if specified.
"""
basket = create_basket()
product = factories.create_product()
factories.create_stockrecord(product, num_in_stock=2)
basket.add_product(product)
order = create_order(basket=basket)
lines = order.lines.all()
with mock.patch(
'ecommerce.extensions.order.processing.fulfillment_api.fulfill_order'
) as mock_fulfill:
EventHandler().handle_shipping_event(
order,
self.shipping_event_type,
lines,
[1, 1],
email_opt_in=expected_opt_in,
)
mock_fulfill.assert_called_once_with(order,
lines,
email_opt_in=expected_opt_in)
def setUp(self):
# Create a product
self.product_main = create_product(product_class='Stuff')
create_stockrecord(self.product_main, D('5000.00'), num_in_stock=100)
# Create a range
self.range_main = Range.objects.create(name='Stuff')
self.range_main.add_product(self.product_main)
# Create an offer which gives $500 off a product
cond = Condition()
cond.proxy_class = 'oscarbluelight.offer.conditions.BluelightCountCondition'
cond.value = 1
cond.range = self.range_main
cond.save()
benefit = Benefit()
benefit.proxy_class = 'oscarbluelight.offer.benefits.BluelightAbsoluteDiscountBenefit'
benefit.value = 500
benefit.range = self.range_main
benefit.save()
offer = ConditionalOffer()
offer.condition = cond
offer.benefit = benefit
offer.save()
self.basket = create_basket(empty=True)
def test_contains_coupon(self):
self.assertFalse(self.order.contains_coupon)
product = factories.create_product(product_class=COUPON_PRODUCT_CLASS_NAME)
basket = create_basket(empty=True)
factories.create_stockrecord(product, num_in_stock=1)
basket.add_product(product)
order = create_order(basket=basket)
self.assertTrue(order.contains_coupon)
def test_is_partially_satisfied_or(self):
offer = self._build_offer(CompoundCondition.OR)
product = create_product()
create_stockrecord(product, D('1.00'), num_in_stock=10)
basket = create_basket(empty=True)
self.assertFalse( offer.condition.is_partially_satisfied(offer, basket) )
basket.add_product(product, quantity=1)
self.assertTrue( offer.condition.is_partially_satisfied(offer, basket) )
def test_get_upsell_message_or(self):
offer = self._build_offer(CompoundCondition.OR)
product = create_product()
create_stockrecord(product, D('1.00'), num_in_stock=10)
basket = create_basket(empty=True)
basket.add_product(product, quantity=1)
self.assertEqual(offer.condition.proxy().get_upsell_message(offer, basket), 'Spend $9.00 more from site or Buy 1 more product from site')
def test_hurry_mode_not_set_when_stock_high(self):
# One alert, 5 items in stock. No need to hurry.
create_stockrecord(self.product, num_in_stock=5)
ProductAlert.objects.create(user=self.user, product=self.product)
self.dispatcher.send_product_alert_email_for_user(self.product)
assert len(mail.outbox) == 1
assert 'Beware that the amount of items in stock is limited' not in mail.outbox[
0].body
def test_hurry_mode_not_set_multiple_stockrecords(self):
# Two stockrecords, 5 items in stock for one. No need to hurry.
create_stockrecord(self.product, num_in_stock=1)
create_stockrecord(self.product, num_in_stock=5)
ProductAlert.objects.create(user=self.user, product=self.product)
self.dispatcher.send_product_alert_email_for_user(self.product)
assert 'Beware that the amount of items in stock is limited' not in mail.outbox[
0].body
def test_contains_coupon(self):
self.assertFalse(self.order.contains_coupon)
product_class = u'Coupon'
product = factories.create_product(product_class=product_class)
basket = factories.create_basket(empty=True)
factories.create_stockrecord(product, num_in_stock=1)
basket.add_product(product)
order = factories.create_order(basket=basket)
self.assertTrue(order.contains_coupon)
def test_hurry_mode_not_set_when_stock_high(self):
# One alert, 5 items in stock. No need to hurry.
create_stockrecord(self.product, num_in_stock=5)
ProductAlert.objects.create(user=self.user, product=self.product)
send_product_alerts(self.product)
self.assertEqual(1, len(mail.outbox))
self.assertNotIn('Beware that the amount of items in stock is limited',
mail.outbox[0].body)
def create_basket(self, owner, site, status=Basket.OPEN, empty=False):
owner = owner or factories.UserFactory()
site = site or self.site
basket = Basket.objects.create(owner=owner, site=site, status=status)
basket.strategy = Default()
if not empty:
product = factories.create_product()
factories.create_stockrecord(product, num_in_stock=2)
basket.add_product(product)
return basket
def test_hurry_mode_not_set_multiple_stockrecords(self):
# Two stockrecords, 5 items in stock for one. No need to hurry.
create_stockrecord(self.product, num_in_stock=1)
create_stockrecord(self.product, num_in_stock=5)
ProductAlert.objects.create(user=self.user, product=self.product)
send_product_alerts(self.product)
self.assertNotIn('Beware that the amount of items in stock is limited',
mail.outbox[0].body)
def test_hurry_mode_not_set_when_stock_high(self):
# One alert, 5 items in stock. No need to hurry.
create_stockrecord(self.product, num_in_stock=5)
ProductAlert.objects.create(user=self.user, product=self.product)
send_product_alerts(self.product)
self.assertEqual(1, len(mail.outbox))
self.assertNotIn('Beware that the amount of items in stock is limited',
mail.outbox[0].body)
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_hurry_mode_set_multiple_stockrecords(self):
# Two stockrecords, low stock on both. Hurry mode should be set.
create_stockrecord(self.product, num_in_stock=1)
create_stockrecord(self.product, num_in_stock=1)
ProductAlert.objects.create(user=self.user, product=self.product)
ProductAlert.objects.create(user=UserFactory(), product=self.product)
self.dispatcher.send_product_alert_email_for_user(self.product)
assert 'Beware that the amount of items in stock is limited' in mail.outbox[
0].body
def test_hurry_mode_set_when_stock_low(self):
# Two alerts, 1 item in stock. Hurry mode should be set.
create_stockrecord(self.product, num_in_stock=1)
ProductAlert.objects.create(user=self.user, product=self.product)
ProductAlert.objects.create(user=UserFactory(), product=self.product)
self.dispatcher.send_product_alert_email_for_user(self.product)
assert len(mail.outbox) == 2
assert 'Beware that the amount of items in stock is limited' in mail.outbox[
0].body
def test_hurry_mode_set_multiple_stockrecords(self):
# Two stockrecords, low stock on both. Hurry mode should be set.
create_stockrecord(self.product, num_in_stock=1)
create_stockrecord(self.product, num_in_stock=1)
ProductAlert.objects.create(user=self.user, product=self.product)
ProductAlert.objects.create(user=UserFactory(), product=self.product)
send_product_alerts(self.product)
self.assertIn('Beware that the amount of items in stock is limited',
mail.outbox[0].body)
def test_hurry_mode_set_when_stock_low(self):
# Two alerts, 1 item in stock. Hurry mode should be set.
create_stockrecord(self.product, num_in_stock=1)
ProductAlert.objects.create(user=self.user, product=self.product)
ProductAlert.objects.create(user=UserFactory(), product=self.product)
send_product_alerts(self.product)
self.assertEqual(2, len(mail.outbox))
self.assertIn('Beware that the amount of items in stock is limited',
mail.outbox[0].body)
def test_hurry_mode_set_when_stock_low(self):
# Two alerts, 1 item in stock. Hurry mode should be set.
create_stockrecord(self.product, num_in_stock=1)
ProductAlert.objects.create(user=self.user, product=self.product)
ProductAlert.objects.create(user=UserFactory(), product=self.product)
send_product_alerts(self.product)
self.assertEqual(2, len(mail.outbox))
self.assertIn('Beware that the amount of items in stock is limited',
mail.outbox[0].body)
def test_totals_for_free_products(self):
basket = Basket()
basket.strategy = strategy.Default()
# Add a zero-priced product to the basket
product = factories.create_product()
factories.create_stockrecord(product, price=D('0.00'), num_in_stock=10)
basket.add(product, 1)
self.assertEqual(basket.lines.count(), 1)
self.assertEqual(basket.total_excl_tax, 0)
self.assertEqual(basket.total_incl_tax, 0)
def test_totals_for_free_products(self):
basket = Basket()
basket.strategy = strategy.Default()
# Add a zero-priced product to the basket
product = factories.create_product()
factories.create_stockrecord(
product, price_excl_tax=D('0.00'), num_in_stock=10)
basket.add(product, 1)
self.assertEqual(basket.lines.count(), 1)
self.assertEqual(basket.total_excl_tax, 0)
self.assertEqual(basket.total_incl_tax, 0)
def test_line_tax_for_unknown_tax_strategies(self):
class UnknownTaxStrategy(strategy.Default):
""" A test strategy where the tax is not known """
def pricing_policy(self, product, stockrecord):
return prices.FixedPrice('GBP', stockrecord.price, tax=None)
basket = Basket()
basket.strategy = UnknownTaxStrategy()
product = factories.create_product()
factories.create_stockrecord(product, num_in_stock=10)
basket.add(product, 1)
self.assertEqual(basket.lines.first().line_tax, None)
def test_execution_for_bulk_purchase(self):
"""
Verify redirection to LMS receipt page after attempted payment
execution if the Otto receipt page is disabled for bulk purchase and
also that the order is linked to the provided business client..
"""
toggle_switch(ENROLLMENT_CODE_SWITCH, True)
self.mock_oauth2_response()
course = CourseFactory(partner=self.partner)
course.create_or_update_seat('verified',
True,
50,
create_enrollment_code=True)
self.basket = create_basket(owner=UserFactory(), site=self.site)
enrollment_code = Product.objects.get(
product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
factories.create_stockrecord(enrollment_code,
num_in_stock=2,
price_excl_tax='10.00')
self.basket.add_product(enrollment_code, quantity=1)
# Create a payment record the view can use to retrieve a basket
self.mock_payment_creation_response(self.basket)
self.processor.get_transaction_parameters(self.basket,
request=self.request)
self.mock_payment_execution_response(self.basket)
self.mock_payment_creation_response(self.basket, find=True)
# Manually add organization attribute on the basket for testing
self.RETURN_DATA.update({'organization': 'Dummy Business Client'})
self.RETURN_DATA.update({PURCHASER_BEHALF_ATTRIBUTE: 'False'})
basket_add_organization_attribute(self.basket, self.RETURN_DATA)
response = self.client.get(reverse('paypal:execute'), self.RETURN_DATA)
self.assertRedirects(
response,
get_receipt_page_url(
order_number=self.basket.order_number,
site_configuration=self.basket.site.siteconfiguration,
disable_back_button=True,
),
fetch_redirect_response=False)
# Now verify that a new business client has been created and current
# order is now linked with that client through Invoice model.
order = Order.objects.filter(basket=self.basket).first()
business_client = BusinessClient.objects.get(
name=self.RETURN_DATA['organization'])
assert Invoice.objects.get(
order=order).business_client == business_client
def setUp(self):
super(DonationsFromCheckoutTestFulfillmentModuleTest, self).setUp()
donation_class = ProductClass.objects.get(
name=DONATIONS_FROM_CHECKOUT_TESTS_PRODUCT_TYPE_NAME,
track_stock=False)
donation = factories.create_product(product_class=donation_class,
title='Test product')
user = factories.UserFactory()
basket = factories.BasketFactory(owner=user, site=self.site)
factories.create_stockrecord(donation,
num_in_stock=2,
price_excl_tax=10)
basket.add_product(donation, 1)
self.order = create_order(number=1, basket=basket, user=user)
def test_consume_items_when_benefit_consumes_other_items(self):
# Create two products, each in a different product class
product_main = create_product(product_class='Expensive Stuff')
create_stockrecord(product_main, D('5000.00'), num_in_stock=100)
product_accessory = create_product(product_class='Less Expensive Stuff')
create_stockrecord(product_accessory, D('100.00'), num_in_stock=100)
# Create two ranges, one for each product we just made
range_main = Range.objects.create(name='Expensive Stuff')
range_main.add_product(product_main)
range_accessories = Range.objects.create(name='Less Expensive Stuff')
range_accessories.add_product(product_accessory)
# Create an offer which gives $5 off an accessory product when the basket contains a main product.
# This offer, when applied, should consume the main and the accessory products. Not just the accessory.
cond_has_main = Condition()
cond_has_main.proxy_class = 'oscarbluelight.offer.conditions.BluelightCountCondition'
cond_has_main.value = 1
cond_has_main.range = range_main
cond_has_main.save()
benefit_5off_accessory = Benefit()
benefit_5off_accessory.proxy_class = 'oscarbluelight.offer.benefits.BluelightAbsoluteDiscountBenefit'
benefit_5off_accessory.value = 5
benefit_5off_accessory.range = range_accessories
benefit_5off_accessory.save()
offer = ConditionalOffer()
offer.condition = cond_has_main
offer.benefit = benefit_5off_accessory
offer.save()
basket = create_basket(empty=True)
basket.add_product(product_main, quantity=1)
basket.add_product(product_accessory, quantity=1)
self.assertEqual(basket.total_excl_tax_excl_discounts, D('5100.00'))
self.assertEqual(basket.total_excl_tax, D('5100.00'))
self.assertEqual(basket.num_items_without_discount, 2)
self.assertEqual(basket.num_items_with_discount, 0)
Applicator().apply_offers(basket, [offer])
self.assertEqual(basket.total_excl_tax_excl_discounts, D('5100.00'))
self.assertEqual(basket.total_excl_tax, D('5095.00'))
self.assertEqual(basket.num_items_without_discount, 0)
self.assertEqual(basket.num_items_with_discount, 2)
def test_line_tax_for_unknown_tax_strategies(self):
class UnknownTaxStrategy(strategy.Default):
""" A test strategy where the tax is not known """
def pricing_policy(self, product, stockrecord):
return prices.FixedPrice('GBP', stockrecord.price_excl_tax, tax=None)
basket = Basket()
basket.strategy = UnknownTaxStrategy()
product = factories.create_product()
factories.create_stockrecord(product, num_in_stock=10)
basket.add(product, 1)
self.assertEqual(basket.lines.first().line_tax, None)
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 setUp(self):
self.product = factories.create_product()
self.stockrecord = factories.create_stockrecord(self.product)
self.assertTrue(self.product.get_product_class().track_stock)
self.availability = availability.DelegateToStockRecord(
self.product, self.stockrecord)
def test_basket_below_threshold(self):
record = factories.create_stockrecord(price=D('5.00'))
self.basket.add_product(record.product)
charge = self.method.calculate(self.basket)
self.assertEqual(D('10.00'), charge.incl_tax)
def setUp(self):
self.product = factories.create_product()
self.stockrecord = factories.create_stockrecord(self.product)
self.assertTrue(self.product.get_product_class().track_stock)
self.availability = availability.DelegateToStockRecord(
self.product, self.stockrecord)
def test_basket_above_threshold(self):
record = factories.create_stockrecord(price_excl_tax=D('5.00'))
self.basket.add_product(record.product, quantity=8)
charge = self.method.calculate(self.basket)
self.assertEqual(D('0.00'), charge.incl_tax)
def test_can_delete_an_individual_product(self):
product = create_product()
stockrecord = create_stockrecord(product)
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=(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=product.id)
self.assertRaises(StockRecord.DoesNotExist,
StockRecord.objects.get,
id=stockrecord.id)
self.assertRaises(ProductCategory.DoesNotExist,
ProductCategory.objects.get,
id=product_category.id)
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 test_can_delete_a_canonical_product(self):
canonical_product = create_product(title="Canonical Product",
partner_users=[self.user,])
product = create_product(title="Variant 1", parent=canonical_product)
stockrecord = create_stockrecord(product)
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.assertEqual(Product.objects.count(), 0)
self.assertEqual(StockRecord.objects.count(), 0)
self.assertEqual(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_signals(self):
product = factories.create_product()
record = factories.create_stockrecord(
currency='USD',
product=product,
price_excl_tax=D('10.00'))
factories.create_purchase_info(record)
basket = Basket()
basket.strategy = USStrategy()
basket.add(product)
basket.save()
uat1 = cache.get_basket_uat(basket)
# Add another product
basket.add(product)
# Timestamp should have gotten bumped by the BasketLine postsave signal
uat2 = cache.get_basket_uat(basket)
self.assertTrue(uat2 > uat1)
# Save the basket
basket.save()
# Timestamp should have gotten bumped by the Basket postsave signal
uat3 = cache.get_basket_uat(basket)
self.assertTrue(uat3 > uat2)
def test_basket_above_threshold(self):
record = factories.create_stockrecord(price_excl_tax=D('5.00'))
self.basket.add_product(record.product, quantity=8)
charge = self.method.calculate(self.basket)
self.assertEqual(D('0.00'), charge.incl_tax)
def test_multi_item_basket(self):
basket = factories.create_basket(empty=True)
record = factories.create_stockrecord()
basket.add_product(record.product, 7)
charge = self.method.calculate(basket)
self.assertEqual(D('5.00') + 7*D('1.00'), charge.incl_tax)
def test_multi_item_basket(self):
basket = factories.create_basket(empty=True)
record = factories.create_stockrecord()
basket.add_product(record.product, 7)
charge = self.method.calculate(basket)
self.assertEqual(D('5.00') + 7 * D('1.00'), charge.incl_tax)
def test_allocate_does_nothing(self):
product = factories.ProductFactory(product_class=self.product_class)
stockrecord = factories.create_stockrecord(
product, price_excl_tax=D('10.00'), num_in_stock=10)
self.assertFalse(stockrecord.can_track_allocations)
stockrecord.allocate(5)
self.assertEqual(stockrecord.num_allocated, None)
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.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 setUp(self):
self.user = G(User)
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_single_item_basket_that_doesnt_require_shipping(self):
# Create a product that doesn't require shipping
record = factories.create_stockrecord()
product = record.product
product.product_class.requires_shipping = False
product.product_class.save()
self.basket.add_product(record.product)
self.assertEqual(D('5.00'), self.method.charge_incl_tax)
def test_returns_correct_quantity_for_existing_product_and_stockrecord_and_options(self):
product = factories.create_product()
record = factories.create_stockrecord(product, price_excl_tax=D("5.00"))
option = Option.objects.create(name="Message")
options = [{"option": option, "value": "2"}]
self.basket.add(product, options=options)
self.assertEqual(0, self.basket.line_quantity(product, record))
self.assertEqual(1, self.basket.line_quantity(product, record, options))
def setUp(self):
self.basket = Basket()
self.basket.strategy = strategy.Default()
self.product = factories.create_product()
self.record = factories.create_stockrecord(
currency='GBP',
product=self.product, price_excl_tax=D('10.00'))
self.stockinfo = factories.create_stockinfo(self.record)
self.basket.add(self.product)
def test_allocate_does_nothing(self):
product = factories.ProductFactory(product_class=self.product_class)
stockrecord = factories.create_stockrecord(product,
price=D('10.00'),
num_in_stock=10)
self.assertFalse(stockrecord.can_track_allocations)
stockrecord.allocate(5)
self.assertEqual(stockrecord.num_allocated, None)
def _create_product(self):
product = factories.create_product(title='My Product',
product_class='My Product Class')
record = factories.create_stockrecord(currency='USD',
product=product,
num_in_stock=10,
price_excl_tax=Decimal('10.00'))
factories.create_purchase_info(record)
return product
def setUp(self):
self.basket = Basket()
self.basket.strategy = strategy.Default()
self.product = factories.create_product()
self.record = factories.create_stockrecord(currency='GBP',
product=self.product,
price=D('10.00'))
self.purchase_info = factories.create_purchase_info(self.record)
self.basket.add(self.product)
def test_single_item_basket_that_doesnt_require_shipping(self):
# Create a product that doesn't require shipping
record = factories.create_stockrecord()
product = record.product
product.product_class.requires_shipping = False
product.product_class.save()
self.basket.add_product(record.product)
self.assertEquals(D('5.00'), self.method.charge_incl_tax)
def _create_product(self, price=D('10.00')):
product = factories.create_product(
title='My Product',
product_class='My Product Class')
record = factories.create_stockrecord(
currency='USD',
product=product,
num_in_stock=10,
price_excl_tax=price)
factories.create_purchase_info(record)
return product
def test_allocate_does_nothing_for_child_product(self):
parent_product = factories.ProductFactory(
structure='parent', product_class=self.product_class)
child_product = factories.ProductFactory(
parent=parent_product, product_class=None, structure='child')
stockrecord = factories.create_stockrecord(
child_product, price_excl_tax=D('10.00'), num_in_stock=10)
self.assertFalse(stockrecord.can_track_allocations)
stockrecord.allocate(5)
self.assertEqual(stockrecord.num_allocated, None)
def test_consume_items(self):
basket = create_basket(empty=True)
for i in range(5):
product = create_product()
create_stockrecord(product, D('10.00'), num_in_stock=10)
basket.add_product(product, quantity=5)
offer = self._build_offer('oscarbluelight.offer.conditions.BluelightCoverageCondition', 2)
affected_lines = offer.condition.proxy().consume_items(offer, basket, [])
self.assertEqual(len(affected_lines), 2, 'Consumed 2 lines')
self.assertEqual(affected_lines[0][2], 1, 'Consumed quantity of 1')
self.assertEqual(affected_lines[1][2], 1, 'Consumed quantity of 1')
self.assertEqual(basket.all_lines()[0].quantity_with_discount, 1)
self.assertEqual(basket.all_lines()[0].quantity_without_discount, 4)
self.assertEqual(basket.all_lines()[1].quantity_with_discount, 1)
self.assertEqual(basket.all_lines()[1].quantity_without_discount, 4)
self.assertEqual(basket.all_lines()[2].quantity_with_discount, 0)
self.assertEqual(basket.all_lines()[2].quantity_without_discount, 5)
affected_lines = offer.condition.proxy().consume_items(offer, basket, affected_lines)
self.assertEqual(len(affected_lines), 2, 'Consumed 2 lines')
self.assertEqual(affected_lines[0][2], 1, 'Consumed quantity of 1')
self.assertEqual(affected_lines[1][2], 1, 'Consumed quantity of 1')
self.assertEqual(basket.all_lines()[0].quantity_with_discount, 1)
self.assertEqual(basket.all_lines()[0].quantity_without_discount, 4)
self.assertEqual(basket.all_lines()[1].quantity_with_discount, 1)
self.assertEqual(basket.all_lines()[1].quantity_without_discount, 4)
self.assertEqual(basket.all_lines()[2].quantity_with_discount, 0)
self.assertEqual(basket.all_lines()[2].quantity_without_discount, 5)
affected_lines = offer.condition.proxy().consume_items(offer, basket, [])
self.assertEqual(len(affected_lines), 2, 'Consumed 2 lines')
self.assertEqual(affected_lines[0][2], 1, 'Consumed quantity of 1')
self.assertEqual(affected_lines[1][2], 1, 'Consumed quantity of 1')
self.assertEqual(basket.all_lines()[0].quantity_with_discount, 2)
self.assertEqual(basket.all_lines()[0].quantity_without_discount, 3)
self.assertEqual(basket.all_lines()[1].quantity_with_discount, 2)
self.assertEqual(basket.all_lines()[1].quantity_without_discount, 3)
self.assertEqual(basket.all_lines()[2].quantity_with_discount, 0)
self.assertEqual(basket.all_lines()[2].quantity_without_discount, 5)
def setUp(self):
super(RangeTests, self).setUp()
self.range = factories.RangeFactory()
self.range_with_catalog = factories.RangeFactory()
self.catalog = Catalog.objects.create(partner=self.partner)
self.product = factories.create_product()
self.range.add_product(self.product)
self.range_with_catalog.catalog = self.catalog
self.stock_record = factories.create_stockrecord(self.product, num_in_stock=2)
self.catalog.stock_records.add(self.stock_record)
def setUp(self):
super(UtilTests, self).setUp()
self.catalog = Catalog.objects.create(partner=self.partner)
self.coupon_product_class, _ = ProductClass.objects.get_or_create(name='coupon')
self.coupon = factories.create_product(
product_class=self.coupon_product_class,
title='Test product'
)
self.stock_record = factories.create_stockrecord(self.coupon, num_in_stock=2)
self.catalog.stock_records.add(self.stock_record)
