def test_multi_site(self):
basket = factories.create_basket(empty=True)
site1 = factories.SiteFactory()
site2 = factories.SiteFactory()
request = HttpRequest()
request.META['SERVER_PORT'] = 80
request.META['SERVER_NAME'] = site1.domain
user = factories.UserFactory()
add_product(basket, D('12.00'))
shipping_method = Free()
shipping_charge = shipping_method.calculate(basket)
order_total = OrderTotalCalculator().calculate(basket, shipping_charge)
billing_address = factories.BillingAddressFactory()
shipping_address = factories.ShippingAddressFactory()
order_submission_data = {'user': user,
'order_number': '12345',
'basket': basket,
'shipping_method': shipping_method,
'shipping_charge': shipping_charge,
'order_total': order_total,
'billing_address': billing_address,
'shipping_address': shipping_address,
'request': request}
OrderPlacementMixin().place_order(**order_submission_data)
order1 = Order.objects.get(number='12345')
self.assertEqual(order1.site, site1)
add_product(basket, D('12.00'))
request.META['SERVER_NAME'] = site2.domain
order_submission_data['order_number'] = '12346'
order_submission_data['request'] = request
OrderPlacementMixin().place_order(**order_submission_data)
order2 = Order.objects.get(number='12346')
self.assertEqual(order2.site, site2)
def test_respects_maximum_applications_field(self):
add_product(self.basket, D('100'), 5)
offer = models.ConditionalOffer(
id="test", condition=self.condition, benefit=self.benefit,
max_basket_applications=1)
self.applicator.apply_offers(self.basket, [offer])
self.assertEqual(1, self.basket.offer_applications.applications["test"]['freq'])
def test_smaller_quantity_basket_passes_partial_condition(
self, count_condition, empty_basket
):
basket = empty_basket
add_product(basket)
assert count_condition.is_partially_satisfied(self.offer, basket)
assert count_condition._num_matches == 1
def test_is_satisfied_accounts_for_consumed_items(
self, count_condition, empty_basket
):
basket = empty_basket
add_product(basket, quantity=3)
count_condition.consume_items(self.offer, basket, [])
assert count_condition.is_satisfied(self.offer, basket) is False
def test_not_discountable_product_fails_condition(self):
prod1, prod2 = factories.create_product(), factories.create_product()
prod2.is_discountable = False
prod2.save()
add_product(self.basket, product=prod1)
add_product(self.basket, product=prod2)
self.assertFalse(self.condition.is_satisfied(self.basket))
def test_consume_stock_allocations_track_stock_on(self):
product_class = factories.ProductClassFactory(
requires_shipping=False, track_stock=True)
product = factories.ProductFactory(product_class=product_class)
basket = factories.create_basket(empty=True)
add_product(basket, D('10.00'), 5, product=product)
order = factories.create_order(basket=basket)
stockrecord = product.stockrecords.get()
num_in_stock = stockrecord.num_in_stock
num_allocated = stockrecord.num_allocated
lines = order.lines.all()
self.handler.consume_stock_allocations(
order, lines, [line.quantity for line in lines])
stockrecord.refresh_from_db()
self.assertEqual(
stockrecord.num_allocated,
num_allocated - 5,
"Allocated stock should have decreased, but didn't."
)
self.assertEqual(
stockrecord.num_in_stock,
num_in_stock - 5,
"Stock should have decreased, but didn't."
)
def test_uses_default_line_status_from_settings(self):
add_product(self.basket, D('12.00'))
with override_settings(OSCAR_INITIAL_LINE_STATUS='A'):
place_order(self.creator, basket=self.basket, order_number='1234')
order = Order.objects.get(number='1234')
line = order.lines.all()[0]
self.assertEqual('A', line.status)
def test_moving_from_saved_basket_more_than_stocklevel_raises(self):
self.user = User.objects.create_user(username='******', password='******',
email='*****@*****.**')
product = create_product(price=D('10.00'), num_in_stock=1)
basket, created = Basket.open.get_or_create(owner=self.user)
add_product(basket, product=product)
saved_basket, created = Basket.saved.get_or_create(owner=self.user)
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)
# 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_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 test_moving_from_saved_basket(self):
user = User.objects.create_user(username='******', password='******',
email='*****@*****.**')
client = Client()
client.login(email=user.email, password='******')
product = create_product(price=D('10.00'), num_in_stock=2)
basket = factories.create_basket(empty=True)
basket.owner = user
basket.save()
add_product(basket, product=product)
saved_basket, created = Basket.saved.get_or_create(owner=user)
saved_basket.strategy = basket.strategy
add_product(saved_basket, product=product)
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)
self.assertEqual(Basket.open.get(id=basket.id).lines.get(
product=product).quantity, 2)
self.assertRedirects(response, reverse('basket:summary'))
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_wraps_shipping_method_from_repository(self):
add_product(self.basket, D("12.00"), 1)
apply_offers(self.basket)
methods = StubRepository().get_shipping_methods(self.basket)
method = methods[0]
self.assertTrue(method.is_discounted)
self.assertEqual(D("1.00"), method.charge_incl_tax)
def test_default_site(self):
add_product(self.basket, D('12.00'))
place_order(self.creator,
basket=self.basket,
order_number='1234')
order = Order.objects.get(number='1234')
self.assertEqual(order.site_id, 1)
def setUp(self):
basket = create_basket(empty=True)
add_product(basket, D("10.00"), 4)
self.order = create_order(number="100002", basket=basket)
self.line = self.order.lines.all()[0]
self.order_placed, __ = ShippingEventType.objects.get_or_create(code="order_placed", name="Order placed")
self.dispatched, __ = ShippingEventType.objects.get_or_create(code="dispatched", name="Dispatched")
def test_multiple_payment_events(self):
basket = factories.create_basket(empty=True)
user = factories.UserFactory()
add_product(basket, D('100.00'))
order_placement = OrderPlacementMixin()
order_placement.add_payment_event('Gift Card Payment', D('10'))
order_placement.add_payment_event('Credit Card Payment', D('90'))
shipping_method = Free()
shipping_charge = shipping_method.calculate(basket)
order_total = OrderTotalCalculator().calculate(basket, shipping_charge)
billing_address = factories.BillingAddressFactory()
shipping_address = factories.ShippingAddressFactory()
order_submission_data = {'user': user,
'order_number': '12345',
'basket': basket,
'shipping_method': shipping_method,
'shipping_charge': shipping_charge,
'order_total': order_total,
'billing_address': billing_address,
'shipping_address': shipping_address}
order_placement.place_order(**order_submission_data)
order1 = Order.objects.get(number='12345')
self.assertEqual(order1.payment_events.count(), 2)
event1 = order1.payment_events.all()[0]
event2 = order1.payment_events.all()[1]
self.assertEqual(event1.event_type.name, 'Credit Card Payment')
self.assertEqual(event1.amount, D('90'))
self.assertEqual(event1.lines.count(), 1)
self.assertEqual(event2.event_type.name, 'Gift Card Payment')
self.assertEqual(event2.amount, D('10'))
self.assertEqual(event2.lines.count(), 1)
def test_applies_offer_multiple_times_by_default(self):
add_product(self.basket, D('100'), 5)
offer = ConditionalOfferFactory(
pk=1, condition=self.condition, benefit=self.benefit)
self.applicator.apply_offers(self.basket, [offer])
applications = self.basket.offer_applications.applications
self.assertEqual(5, applications[1]['freq'])
def test_wraps_shipping_method_from_repository(self):
add_product(self.basket, D('12.00'), 1)
apply_offers(self.basket)
methods = StubRepository().get_shipping_methods(self.basket)
method = methods[0]
charge = method.calculate(self.basket)
self.assertEqual(D('1.00'), charge.incl_tax)
def test_wraps_shipping_method_from_repository(self):
add_product(self.basket, D("12.00"), 1)
utils.Applicator().apply(self.basket)
methods = StubRepository().get_shipping_methods(self.basket)
method = methods[0]
charge = method.calculate(self.basket)
self.assertEqual(D("1.00"), charge.incl_tax)
def test_applies_offer_multiple_times_by_default(self):
add_product(self.basket, D('100'), 5)
offer = ConditionalOfferFactory(
pk=1, condition=self.condition, benefit=self.benefit)
self.applicator.apply
self.applicator.apply_offers(self.basket, [offer])
line = self.basket.all_lines()[0]
self.assertTrue(line.quantity_with_offer_discount(offer) == 5)
def setUp(self):
super(TestOrderPlacement, self).setUp()
self.basket = Basket.objects.create(owner=self.user)
add_product(self.basket, D('12.00'))
self.complete_shipping_address()
self.complete_shipping_method()
self.response = self.client.post(reverse('checkout:preview'), {'action': 'place_order'})
def setUp(self):
basket = create_basket(empty=True)
add_product(basket, 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")
self.returned, __ = ShippingEventType.objects.get_or_create(name="Returned")
def setUp(self):
self.order = factories.create_order()
self.handler = EventHandler()
basket = factories.create_basket(empty=True)
add_product(basket, D('10.00'), 5)
self.order = factories.create_order(basket=basket)
self.settled = models.PaymentEventType.objects.create(
name='Settled')
def test_smaller_quantity_basket_upsell_message(
self, count_condition, empty_basket
):
basket = empty_basket
add_product(basket)
assert "Buy 1 more product from " in count_condition.get_upsell_message(
self.offer, basket
)
def test_respects_maximum_applications_field(self):
add_product(self.basket, D('100'), 5)
offer = ConditionalOfferFactory(
pk=1, condition=self.condition, benefit=self.benefit,
max_basket_applications=1)
self.applicator.apply_offers(self.basket, [offer])
applications = self.basket.offer_applications.applications
self.assertEqual(1, applications[1]['freq'])
def test_applies_correctly_to_basket_which_is_more_than_value_and_max_affected_items_set(self):
self.benefit.max_affected_items = 3
self.benefit.save()
add_product(self.basket, D('8.00'), 4)
result = self.benefit.apply(self.basket, self.condition, self.offer)
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 setUp(self):
basket = create_basket(empty=True)
add_product(basket, D('10.00'), 4)
self.order = create_order(number='100002', basket=basket)
self.line = self.order.lines.all()[0]
self.order_placed, __ = ShippingEventType.objects.get_or_create(
code='order_placed', name='Order placed')
self.dispatched, __ = ShippingEventType.objects.get_or_create(
code='dispatched', name='Dispatched')
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_succcessful_application_consumes_correctly(self):
add_product(self.basket, product=self.condition_product, quantity=2)
add_product(self.basket, product=self.benefit_product, quantity=1)
self.applicator.apply_offers(self.basket, [self.offer])
discounts = self.basket.offer_applications.offer_discounts
self.assertEqual(len(discounts), 1)
self.assertEqual(discounts[0]['freq'], 1)
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 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 test_smaller_quantity_basket_passes_partial_condition(self):
add_product(self.basket)
self.assertTrue(self.condition.is_partially_satisfied(self.basket))
def test_less_value_basket_passes_partial_condition(self):
add_product(self.basket, D('5'), 1)
self.assertTrue(self.condition.is_partially_satisfied(self.basket))
def test_not_discountable_item_fails(self):
self.products[0].is_discountable = False
self.products[0].save()
add_product(self.basket, product=self.products[0])
add_product(self.basket, product=self.products[1])
self.assertFalse(self.condition.is_satisfied(self.basket))
def test_matching_basket_passes_condition(self):
add_product(self.basket, D('5'), 2)
self.assertTrue(self.condition.is_satisfied(self.basket))
def test_covering_items_pass(self):
add_product(self.basket, product=self.products[0])
add_product(self.basket, product=self.products[1])
self.assertTrue(self.condition.is_satisfied(self.basket))
def test_applies_correctly_to_basket_which_matches_condition(self):
add_product(self.basket, D('5.00'), 2)
result = self.benefit.apply(self.basket, self.condition, self.offer)
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_consumption_with_high_value_product(self):
add_product(self.basket, D('15'), 1)
self.condition.consume_items(self.basket, [])
self.assertEquals(0,
self.basket.all_lines()[0].quantity_without_discount)
def test_single_item_fails(self):
add_product(self.basket, product=self.products[0])
self.assertFalse(self.condition.is_satisfied(self.basket))
def test_not_discountable_item_fails_condition(self):
product = factories.create_product(is_discountable=False)
add_product(self.basket, D('15'), product=product)
self.assertFalse(self.condition.is_satisfied(self.basket))
def test_upsell_message(self):
add_product(self.basket, D('5'))
self.assertTrue(
'Spend' in self.condition.get_upsell_message(self.basket))
def test_default_site(self):
add_product(self.basket, D('12.00'))
place_order(self.creator, basket=self.basket, order_number='1234')
order = Order.objects.get(number='1234')
self.assertEqual(order.site_id, 1)
def test_covering_items_are_consumed(self):
add_product(self.basket, product=self.products[0])
add_product(self.basket, product=self.products[1])
self.condition.consume_items(self.basket, [])
self.assertEquals(0, self.basket.num_items_without_discount)
def test_covering_items_fail_partial_condition(self):
add_product(self.basket, product=self.products[0])
add_product(self.basket, product=self.products[1])
self.assertFalse(self.condition.is_partially_satisfied(self.basket))
def test_less_value_basket_fails_condition(self):
add_product(self.basket, D('5'))
self.assertFalse(self.condition.is_satisfied(self.basket))
def test_duplicate_item_passes_partial_condition(self):
add_product(self.basket, quantity=2, product=self.products[0])
self.assertTrue(self.condition.is_partially_satisfied(self.basket))
def test_is_satisfied_accounts_for_consumed_items(self):
add_product(self.basket, quantity=3)
self.condition.consume_items(self.basket, [])
self.assertFalse(self.condition.is_satisfied(self.basket))
def test_duplicate_item_fails(self):
add_product(self.basket, quantity=2, product=self.products[0])
self.assertFalse(self.condition.is_satisfied(self.basket))
def test_consumption(self):
add_product(self.basket, quantity=3)
self.condition.consume_items(self.basket, [])
self.assertEquals(1,
self.basket.all_lines()[0].quantity_without_discount)
def test_upsell_message(self):
add_product(self.basket, product=self.products[0])
self.assertTrue(
'Buy 1 more' in self.condition.get_upsell_message(self.basket))
def test_greater_quantity_basket_passes_condition(self):
add_product(self.basket, quantity=3)
self.assertTrue(self.condition.is_satisfied(self.basket))
def test_single_item_passes_partial_condition(self):
add_product(self.basket, product=self.products[0])
self.assertTrue(self.condition.is_partially_satisfied(self.basket))
def test_matching_quantity_basket_passes_condition(self):
add_product(self.basket, quantity=2)
self.assertTrue(self.condition.is_satisfied(self.basket))
def test_smaller_quantity_basket_upsell_message(self):
add_product(self.basket)
self.assertTrue('Buy 1 more product from ' in
self.condition.get_upsell_message(self.basket))
def test_matching_basket_fails_partial_condition(self):
add_product(self.basket, D('5'), 2)
self.assertFalse(self.condition.is_partially_satisfied(self.basket))
def test_creates_order_and_line_models(self):
add_product(self.basket, D('12.00'))
place_order(self.creator, basket=self.basket, order_number='1234')
order = Order.objects.get(number='1234')
lines = order.lines.all()
self.assertEqual(1, len(lines))
def test_is_consumed_respects_quantity_consumed(self):
add_product(self.basket, D('15'), 1)
self.assertTrue(self.condition.is_satisfied(self.basket))
self.condition.consume_items(self.basket, [])
self.assertFalse(self.condition.is_satisfied(self.basket))
def test_defaults_to_using_free_shipping(self):
add_product(self.basket, D('12.00'))
place_order(self.creator, basket=self.basket, order_number='1234')
order = Order.objects.get(number='1234')
self.assertEqual(order.total_incl_tax, self.basket.total_incl_tax)
self.assertEqual(order.total_excl_tax, self.basket.total_excl_tax)
def test_uses_default_order_status_from_settings(self):
add_product(self.basket, D('12.00'))
with override_settings(OSCAR_INITIAL_ORDER_STATUS='A'):
place_order(self.creator, basket=self.basket, order_number='1234')
order = Order.objects.get(number='1234')
self.assertEqual('A', order.status)
def test_raises_exception_if_duplicate_order_number_passed(self):
add_product(self.basket, D('12.00'))
place_order(self.creator, basket=self.basket, order_number='1234')
with self.assertRaises(ValueError):
place_order(self.creator, basket=self.basket, order_number='1234')
def test_greater_than_basket_passes_condition(self):
add_product(self.basket, D('5'), 3)
self.assertTrue(self.condition.is_satisfied(self.basket))
