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_get_single_seat(self):
"""
The single-seat helper for cybersource reporting should correctly
and return the first 'seat' product encountered in a basket.
"""
get_single_seat = Cybersource.get_single_seat
# finds the seat when it's the only product in the basket.
self.assertEqual(get_single_seat(self.basket), self.product)
# finds the first seat added, when there's more than one.
basket = factories.create_basket(empty=True)
other_seat = factories.ProductFactory(product_class=self.seat_product_class, stockrecords__price_currency='USD')
basket.add_product(self.product)
basket.add_product(other_seat)
self.assertEqual(get_single_seat(basket), self.product)
# finds the seat when there's a mixture of product classes.
basket = factories.create_basket(empty=True)
other_product = factories.ProductFactory(stockrecords__price_currency='USD')
basket.add_product(other_product)
basket.add_product(self.product)
self.assertEqual(get_single_seat(basket), self.product)
self.assertNotEqual(get_single_seat(basket), other_product)
# returns None when there's no seats.
basket = factories.create_basket(empty=True)
basket.add_product(other_product)
self.assertIsNone(get_single_seat(basket))
# returns None for an empty basket.
basket = factories.create_basket(empty=True)
self.assertIsNone(get_single_seat(basket))
def setUp(self):
self.range = models.Range.objects.create(
name="All products range", includes_all_products=True)
self.basket = factories.create_basket(empty=True)
self.condition = models.CountCondition(
range=self.range, type="Count", value=2)
self.offer = mock.Mock()
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_payment_error_with_duplicate_payment_id(self):
"""
Verify that we fail gracefully when PayPal sends us the wrong payment ID,
logging the exception and redirecting the user to an LMS checkout error page.
"""
logger_name = 'ecommerce.extensions.payment.views.paypal'
with LogCapture(logger_name) as l:
self.mock_oauth2_response()
# Create payment records with different baskets which will have same payment ID
self.mock_payment_creation_response(self.basket)
self.processor.get_transaction_parameters(self.basket, request=self.request)
dummy_basket = factories.create_basket()
self.mock_payment_creation_response(dummy_basket)
self.processor.get_transaction_parameters(dummy_basket, request=self.request)
self._assert_error_page_redirect()
l.check(
(
logger_name,
'INFO',
'Payment [{payment_id}] approved by payer [{payer_id}]'.format(
payment_id=self.PAYMENT_ID,
payer_id=self.PAYER_ID
)
),
(
logger_name,
'ERROR',
'Duplicate payment ID [{payment_id}] received from PayPal.'.format(payment_id=self.PAYMENT_ID),
),
)
def test_basket_offers_are_ordered(self):
voucher = Voucher.objects.create(
name="Test voucher",
code="test",
start_date=datetime.date.today(),
end_date=datetime.date.today() + datetime.timedelta(days=12),
)
voucher.offers = [
factories.create_offer(name="A", priority=0),
factories.create_offer(name="B", priority=7),
factories.create_offer(name="C", priority=5),
factories.create_offer(name="D", priority=7),
factories.create_offer(name="E", priority=1),
]
basket = factories.create_basket()
user = mock.Mock()
# Apply voucher to basket
basket.vouchers.add(voucher)
offers = utils.Applicator().get_basket_offers(basket, user)
ordered_names = [offer.name for offer in offers]
self.assertEqual(["B", "D", "C", "E", "A"], ordered_names)
def setUp(self):
"""
Creates two orders. order_in has self.user in it's partner users list.
"""
super(PermissionBasedDashboardOrderTestsBase, self).setUp()
self.address = G(ShippingAddress)
self.basket_in = create_basket()
self.basket_out = create_basket()
# replace partner with one that has the user in it's users list
self.partner_in = G(Partner, users=[self.user])
stockrecord = self.basket_in.lines.all()[0].stockrecord
stockrecord.partner = self.partner_in
stockrecord.save()
self.order_in = create_order(basket=self.basket_in, shipping_address=self.address)
self.order_out = create_order(basket=self.basket_out, shipping_address=self.address)
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_formset_with_removed_line(self):
products = [create_product() for i in range(3)]
basket = factories.create_basket(empty=True)
basket.owner = self.user
basket.save()
add_product(basket, product=products[0])
add_product(basket, product=products[1])
add_product(basket, product=products[2])
response = self.get(reverse('basket:summary'))
formset = response.context['formset']
self.assertEqual(len(formset.forms), 3)
basket.lines.filter(product=products[0]).delete()
management_form = formset.management_form
data = {
formset.add_prefix('INITIAL_FORMS'): management_form.initial['INITIAL_FORMS'],
formset.add_prefix('MAX_NUM_FORMS'): management_form.initial['MAX_NUM_FORMS'],
formset.add_prefix('TOTAL_FORMS'): management_form.initial['TOTAL_FORMS'],
'form-0-quantity': 1,
'form-0-id': formset.forms[0].instance.id,
'form-1-quantity': 2,
'form-1-id': formset.forms[1].instance.id,
'form-2-quantity': 2,
'form-2-id': formset.forms[2].instance.id,
}
response = self.post(reverse('basket:summary'), params=data)
self.assertEqual(response.status_code, 302)
formset = response.follow().context['formset']
self.assertEqual(len(formset.forms), 2)
self.assertEqual(len(formset.forms_with_instances), 2)
self.assertEqual(basket.lines.all()[0].quantity, 2)
self.assertEqual(basket.lines.all()[1].quantity, 2)
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 setUp(self):
super(InvoiceTests, self).setUp()
self.basket = factories.create_basket(empty=True)
self.basket.owner = factories.UserFactory()
self.basket.order = factories.OrderFactory()
self.basket.save()
self.invoice = Invoice.objects.create(order=self.basket.order, state='Paid')
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 setUp(self):
User = get_user_model()
self.user = User.objects.create_user(
username='******', email='*****@*****.**', password='******'
)
self.product_class = factories.ProductClassFactory(
name='Seat', requires_shipping=False, track_stock=False
)
self.course = factories.ProductFactory(
structure='parent', upc='001', title='EdX DemoX Course', product_class=self.product_class
)
self.seat = factories.ProductFactory(
structure='child',
upc='002',
title='Seat in EdX DemoX Course with Honor Certificate',
product_class=self.product_class,
parent=self.course
)
for stock_record in self.seat.stockrecords.all():
stock_record.price_currency = 'USD'
stock_record.save()
basket = factories.create_basket(empty=True)
basket.add_product(self.seat, 1)
self.order = factories.create_order(number=1, basket=basket, user=self.user)
# Move the order from 'Open' to 'Paid' so fulfillment can be completed.
self.order.set_status(ORDER.BEING_PROCESSED)
self.order.set_status(ORDER.PAID)
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_notify_purchaser(self, mock_task):
""" Verify the notification is scheduled if the site has notifications enabled
and the refund is for a course seat.
"""
site_configuration = self.site.siteconfiguration
site_configuration.send_refund_notifications = True
user = UserFactory()
course = CourseFactory()
price = Decimal(100.00)
product = course.create_or_update_seat('verified', True, price, self.partner)
basket = create_basket(empty=True)
basket.site = self.site
basket.add_product(product)
order = create_order(basket=basket, user=user)
order_url = get_receipt_page_url(site_configuration, order.number)
refund = Refund.create_with_lines(order, order.lines.all())
with LogCapture(REFUND_MODEL_LOGGER_NAME) as l:
refund._notify_purchaser() # pylint: disable=protected-access
msg = 'Course refund notification scheduled for Refund [{}].'.format(refund.id)
l.check(
(REFUND_MODEL_LOGGER_NAME, 'INFO', msg)
)
amount = format_currency(order.currency, price)
mock_task.assert_called_once_with(
user.email, refund.id, amount, course.name, order.number, order_url, site_code=self.partner.short_code
)
def build_submission():
basket = factories.create_basket()
# Ensure taxes aren't set by default
basket.strategy = strategy.US()
# Ensure partner has an address
partner = basket.lines.all()[0].stockrecord.partner
G(partner_models.PartnerAddress, partner=partner)
shipping_address = G(models.ShippingAddress,
phone_number='')
shipping_method = methods.FixedPrice(D('0.99'))
shipping_charge = shipping_method.calculate(basket)
calculator = calculators.OrderTotalCalculator()
total = calculator.calculate(basket, shipping_charge)
return {
'user': None,
'basket': basket,
'shipping_address': shipping_address,
'shipping_method': shipping_method,
'shipping_charge': shipping_charge,
'order_total': total,
'order_kwargs': {},
'payment_kwargs': {}}
def setUp(self):
self.basket = create_basket(empty=True)
self.product = create_product(price=100)
range = RangeFactory(products=[self.product])
condition = ConditionFactory(range=range, value=2)
self.voucher = VoucherFactory()
self.voucher.offers.add(create_offer(offer_type='Voucher', range=range, condition=condition))
def setUp(self):
# Override all loggers, suppressing logging calls of severity CRITICAL and below
logging.disable(logging.CRITICAL)
user = User.objects.create_user(
username='******', email='*****@*****.**', password='******'
)
self.product_class = factories.ProductClassFactory(
name='Seat',
requires_shipping=False,
track_stock=False
)
product_attribute = factories.ProductAttributeFactory(
name='course_key',
code='course_key',
product_class=self.product_class,
type='text'
)
fried_chicken = factories.ProductFactory(
structure='parent',
title=u'𝑭𝒓𝒊𝒆𝒅 𝑪𝒉𝒊𝒄𝒌𝒆𝒏',
product_class=self.product_class,
stockrecords=None,
)
factories.ProductAttributeValueFactory(
attribute=product_attribute,
product=fried_chicken,
value_text='pollos/chickenX/2015'
)
pollos_hermanos = factories.ProductFactory(
structure='child',
parent=fried_chicken,
title=u'𝕃𝕠𝕤 ℙ𝕠𝕝𝕝𝕠𝕤 ℍ𝕖𝕣𝕞𝕒𝕟𝕠𝕤',
stockrecords__partner_sku=u'ṠÖṀЁṪḦЇṄĠ⸚ḊЁḶЇĊЇÖÜṠ',
stockrecords__price_excl_tax=D('9.99'),
)
self.attribute_value = factories.ProductAttributeValueFactory(
attribute=product_attribute,
product=pollos_hermanos,
value_text='pollos/hermanosX/2015'
)
basket = factories.create_basket(empty=True)
basket.add_product(pollos_hermanos, 1)
self.order = factories.create_order(
number=self.ORDER_NUMBER, basket=basket, user=user, status=ORDER.BEING_PROCESSED
)
# the processor will pass through a string representation of this
self.order_total = unicode(self.order.total_excl_tax)
# Remove logger override
self.addCleanup(logging.disable, logging.NOTSET)
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 test_allows_a_product_quantity_to_be_increased(self):
basket = factories.create_basket()
product = basket.all_lines()[0].product
# Add more of the same product
data = {'quantity': 1}
form = forms.AddToBasketForm(basket=basket, product=product, data=data)
self.assertTrue(form.is_valid())
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 setUp(self):
super(InvoiceTests, self).setUp()
self.basket = factories.create_basket(empty=True)
self.basket.owner = factories.UserFactory()
self.basket.order = factories.OrderFactory()
self.basket.save()
self.invoice = Invoice.objects.create(order=self.basket.order,
state='Paid')
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 _create_valid_basket(self):
""" Creates a Basket ready for checkout. """
basket = factories.create_basket()
basket.owner = self.user
basket.strategy = Selector().strategy()
basket.site = self.site
basket.thaw()
return basket
def test_checks_whether_passed_product_id_matches_a_real_product(self):
basket = factories.create_basket()
product = basket.all_lines()[0].product
# Add more of the same product
data = {'quantity': -1}
form = forms.AddToBasketForm(basket=basket, product=product, data=data)
self.assertFalse(form.is_valid())
def setUp(self):
self.applicator = Applicator()
self.basket = factories.create_basket(empty=True)
rng = G(models.Range, includes_all_products=True)
self.condition = G(models.Condition, range=rng, type="Value",
value=D('100'), proxy_class=None)
self.benefit = G(models.Benefit, range=rng, type="Absolute",
value=D('10'))
def _create_basket(self, user, site, status=Basket.OPEN):
""" Create a new Basket for the user. """
basket = factories.create_basket()
basket.owner = user
basket.site = site
basket.status = status
basket.save()
return basket
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 setUp(self):
self.range = models.Range.objects.create(
name="All products range", includes_all_products=True)
self.basket = factories.create_basket(empty=True)
self.condition = models.ValueCondition(
range=self.range, type="Value", value=D('10.00'))
self.offer = mock.Mock()
self.item = factories.create_product(price=D('5.00'))
self.expensive_item = factories.create_product(price=D('15.00'))
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):
range = models.Range.objects.create(name="All products",
includes_all_products=True)
self.condition = models.CountCondition.objects.create(
range=range, type=models.Condition.COUNT, value=2)
self.offer = mock.Mock()
self.benefit = models.AbsoluteDiscountBenefit.objects.create(
range=range, type=models.Benefit.FIXED, value=D('3.00'))
self.basket = factories.create_basket(empty=True)
def test_allows_a_product_quantity_to_be_increased(self):
basket = factories.create_basket()
product = basket.all_lines()[0].product
# Add more of the same product
data = {'quantity': 1}
form = forms.AddToBasketForm(
basket=basket, product=product, data=data)
self.assertTrue(form.is_valid())
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):
super(RetrieveOrderViewTests, self).setUp()
user = self.create_user()
self.basket = factories.create_basket()
order_number = OrderNumberGenerator.order_number(self.basket)
self.order = factories.create_order(number=order_number, basket=self.basket, user=user)
self.token = self.generate_jwt_token_header(user)
self.url = reverse('api:v1:orders:retrieve', kwargs={'number': self.order.number})
def setUp(self):
self.range = models.Range.objects.create(
name="All products", includes_all_products=True)
self.condition = models.CountCondition.objects.create(
range=self.range,
type=models.Condition.COUNT,
value=3)
self.offer = mock.Mock()
self.basket = factories.create_basket(empty=True)
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 setUp(self):
range = models.Range.objects.create(name="All products",
includes_all_products=True)
self.condition = models.CountCondition.objects.create(
range=range, type=models.Condition.COUNT, value=3)
self.benefit = models.MultibuyDiscountBenefit.objects.create(
range=range, type=models.Benefit.MULTIBUY)
self.offer = mock.Mock()
self.basket = create_basket(empty=True)
def setUp(self):
"""
Creates two orders. order_in has self.user in it's partner users list.
"""
super(PermissionBasedDashboardOrderTestsBase, self).setUp()
self.address = G(ShippingAddress)
self.basket_in = create_basket()
self.basket_out = create_basket()
# replace partner with one that has the user in it's users list
self.partner_in = G(Partner, users=[self.user])
stockrecord = self.basket_in.lines.all()[0].stockrecord
stockrecord.partner = self.partner_in
stockrecord.save()
self.order_in = create_order(basket=self.basket_in,
shipping_address=self.address)
self.order_out = create_order(basket=self.basket_out,
shipping_address=self.address)
def setUp(self):
self.products = [factories.create_product(), factories.create_product()]
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 = factories.create_basket(empty=True)
self.condition = models.CoverageCondition(
range=self.range, type="Coverage", value=2)
def test_checks_whether_passed_product_id_matches_a_real_product(self):
basket = factories.create_basket()
product = basket.all_lines()[0].product
# Add more of the same product
data = {'quantity': -1}
form = forms.AddToBasketForm(
basket=basket, product=product, data=data)
self.assertFalse(form.is_valid())
def setUp(self):
"""
Creates two orders. order_in has self.user in it's partner users list.
"""
super().setUp()
self.address = ShippingAddressFactory()
self.basket_in = create_basket()
self.basket_out = create_basket()
# replace partner with one that has the user in it's users list
self.partner_in = PartnerFactory(users=[self.user])
stockrecord = self.basket_in.lines.all()[0].stockrecord
stockrecord.partner = self.partner_in
stockrecord.save()
self.order_in = create_order(basket=self.basket_in,
shipping_address=self.address)
self.order_out = create_order(basket=self.basket_out,
shipping_address=self.address)
def setUp(self):
range = models.Range.objects.create(name="All products",
includes_all_products=True)
self.condition = models.CountCondition.objects.create(
range=range, type=models.Condition.COUNT, value=3)
self.benefit = models.FixedPriceBenefit.objects.create(
range=range, type=models.Benefit.FIXED_PRICE, value=D('20.00'))
self.offer = mock.Mock()
self.basket = factories.create_basket(empty=True)
def setUp(self):
range = models.Range.objects.create(name="All products",
includes_all_products=True)
self.condition = models.ValueCondition.objects.create(
range=range, type=models.Condition.VALUE, value=D('10.00'))
self.benefit = models.MultibuyDiscountBenefit.objects.create(
range=range, type=models.Benefit.MULTIBUY, value=1)
self.offer = mock.Mock()
self.basket = factories.create_basket(empty=True)
def test_unicode(self):
""" Verify the __unicode__ method returns the correct value. """
basket = factories.create_basket()
expected = u"{id} - {status} basket (owner: {owner}, lines: {num_lines})".format(
id=basket.id,
status=basket.status,
owner=basket.owner,
num_lines=basket.num_lines)
self.assertEqual(unicode(basket), expected)
def setUp(self):
range = models.Range.objects.create(name="All products",
includes_all_products=True)
self.condition = models.CountCondition.objects.create(
range=range, type=models.Condition.COUNT, value=2)
self.benefit = models.PercentageDiscountBenefit.objects.create(
range=range, type=models.Benefit.PERCENTAGE, value=20)
self.offer = mock.Mock()
self.offer.applies_to_tax_exclusive_prices = False
self.basket = factories.create_basket(empty=True)
def setUp(self):
self.products = [factories.create_product(), factories.create_product()]
self.range = models.Range.objects.create(name="Some products")
for product in self.products:
self.range.add_product(product)
self.range.add_product(product)
self.basket = factories.create_basket(empty=True)
self.condition = models.CoverageCondition(
range=self.range, type="Coverage", value=2)
self.offer = mock.Mock()
def setUp(self):
range = models.Range.objects.create(name="All products",
includes_all_products=True)
self.condition = models.ValueCondition.objects.create(
range=range, type=models.Condition.VALUE, value=D('10.00'))
self.benefit = models.AbsoluteDiscountBenefit.objects.create(
range=range, type=models.Benefit.FIXED, value=D('3.00'))
self.offer = mock.Mock()
self.offer.applies_to_tax_exclusive_prices = False
self.basket = factories.create_basket(empty=True)
def setUp(self):
range = models.Range.objects.create(name="All products",
includes_all_products=True)
self.condition = models.CountCondition.objects.create(
range=range, type=models.Condition.COUNT, value=2)
self.benefit = models.ShippingPercentageDiscountBenefit.objects.create(
type=models.Benefit.SHIPPING_PERCENTAGE, value=50)
self.offer = models.ConditionalOffer(condition=self.condition,
benefit=self.benefit)
self.basket = factories.create_basket(empty=True)
def setUp(self):
self.basket = create_basket(empty=True)
self.product = create_product(price=100)
range = RangeFactory(products=[self.product])
condition = ConditionFactory(range=range, value=2)
self.voucher = VoucherFactory()
self.voucher.offers.add(
create_offer(offer_type='Voucher',
range=range,
condition=condition))
def test_contains_coupon(self):
self.assertFalse(self.order.contains_coupon)
product = factories.create_product(
product_class=COUPON_PRODUCT_CLASS_NAME)
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_consumes_correct_number_of_products_for_4_product_basket(self):
basket = factories.create_basket(empty=True)
add_products(basket, [(D('1'), 2), (D('1'), 2)])
self.assertTrue(self.offer.is_condition_satisfied(basket))
discount = self.offer.apply_benefit(basket)
self.assertTrue(discount.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 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):
super(PaymentProcessorTestCaseMixin, self).setUp()
self.course = Course.objects.create(id='a/b/c', name='Demo Course')
self.product = self.course.create_or_update_seat(self.CERTIFICATE_TYPE, False, 20, self.partner)
self.processor = self.processor_class() # pylint: disable=not-callable
self.basket = factories.create_basket(empty=True)
self.basket.add_product(self.product)
self.basket.owner = factories.UserFactory()
self.basket.save()
def setUp(self):
range = models.Range.objects.create(name="All products",
includes_all_products=True)
self.condition = models.CountCondition.objects.create(
range=range, type=models.Condition.COUNT, value=2)
self.benefit = models.PercentageDiscountBenefit.objects.create(
range=range,
type=models.Benefit.PERCENTAGE,
value=20,
max_affected_items=1)
self.basket = factories.create_basket(empty=True)
def test_zero_charge_with_shipping_discount(self):
offer = factories.create_offer(benefit=Benefit.objects.create(
type=Benefit.SHIPPING_FIXED_PRICE, value=1), )
basket = factories.create_basket()
Applicator().apply_offers(basket, [offer])
# Similar to test_zero_charge_discount(),
# but now test how the repository deals with it.
method = Repository().apply_shipping_offer(basket, self.standard,
offer)
self.assertEqual(D('0.00'), method.discount(basket))
def test_prevents_event_quantities_higher_than_original_line(self):
basket = factories.create_basket(empty=True)
add_product(basket, D('10.00'), 5)
order = factories.create_order(basket=basket)
# First shipping event
lines = order.lines.all()
self.handler.handle_shipping_event(order, self.shipped, lines, [4])
with self.assertRaises(exceptions.InvalidShippingEvent):
self.handler.handle_shipping_event(order, self.shipped, lines, [4])
def setUp(self):
self.applicator = Applicator()
rng = RangeFactory(includes_all_products=True)
self.condition = ConditionFactory(
range=rng, type=ConditionFactory._meta.model.VALUE,
value=D('100'), proxy_class=None)
self.benefit = BenefitFactory(
range=rng, type=BenefitFactory._meta.model.FIXED,
value=D('10'), max_affected_items=1)
self.basket = factories.create_basket()
self.line = self.basket.all_lines()[0]
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):
"""
Creates two orders. order_in has self.user in it's partner users list.
"""
self.client = Client()
self.user = self.create_user(username='******',
is_staff=False)
self.address = G(ShippingAddress)
self.basket_in = create_basket()
self.basket_out = create_basket()
# replace partner with one that has the user in it's users list
self.partner_in = G(Partner, users=[self.user])
stockrecord = self.basket_in.lines.all()[0].stockrecord
stockrecord.partner = self.partner_in
stockrecord.save()
self.order_in = create_order(basket=self.basket_in,
shipping_address=self.address)
self.order_out = create_order(basket=self.basket_out,
shipping_address=self.address)
