def setUp(self):
self.country = factories.CountryFactory.build()
self.user = factories.UserFactory()
def create_user(self, **kwargs):
"""Create a user, with overrideable defaults."""
return factories.UserFactory(password=self.password, **kwargs)
def create_coupon(self,
benefit_type=Benefit.PERCENTAGE,
benefit_value=100,
catalog=None,
catalog_query=None,
client=None,
code='',
course_seat_types=None,
email_domains=None,
enterprise_customer=None,
max_uses=None,
note=None,
partner=None,
price=100,
quantity=5,
title='Test coupon',
voucher_type=Voucher.SINGLE_USE,
course_catalog=None,
program_uuid=None):
"""Helper method for creating a coupon.
Arguments:
benefit_type(str): The voucher benefit type
benefit_value(int): The voucher benefit value
catalog(Catalog): Catalog of courses for which the coupon applies
catalog_query(str): Course query string
client (BusinessClient): Optional business client object
code(str): Custom coupon code
course_catalog (int): Course catalog id from Discovery Service
course_seat_types(str): A string of comma-separated list of seat types
enterprise_customer (str): Hex-encoded UUID for an Enterprise Customer object from the Enterprise app.
email_domains(str): A comma seperated list of email domains
max_uses (int): Number of Voucher max uses
note (str): Coupon note.
partner(Partner): Partner used for creating a catalog
price(int): Price of the coupon
quantity (int): Number of vouchers to be created and associated with the coupon
title(str): Title of the coupon
voucher_type (str): Voucher type
program_uuid (str): Program UUID
Returns:
coupon (Coupon)
"""
if partner is None:
partner = PartnerFactory(name='Tester')
if client is None:
client, __ = BusinessClient.objects.get_or_create(
name='Test Client')
if catalog is None and not ((catalog_query or course_catalog
or program_uuid) and course_seat_types):
catalog = Catalog.objects.create(partner=partner)
if code is not '':
quantity = 1
coupon = create_coupon_product(
benefit_type=benefit_type,
benefit_value=benefit_value,
catalog=catalog,
catalog_query=catalog_query,
category=self.category,
code=code,
course_catalog=course_catalog,
course_seat_types=course_seat_types,
email_domains=email_domains,
end_datetime=datetime.datetime(2020, 1, 1),
enterprise_customer=enterprise_customer,
max_uses=max_uses,
note=note,
partner=partner,
price=price,
quantity=quantity,
start_datetime=datetime.datetime(2015, 1, 1),
title=title,
voucher_type=voucher_type,
program_uuid=program_uuid,
site=self.site)
request = RequestFactory()
request.site = self.site
request.user = factories.UserFactory()
request.COOKIES = {}
request.GET = {}
self.basket = prepare_basket(request, [coupon])
view = CouponViewSet()
view.request = request
self.response_data = view.create_order_for_invoice(self.basket,
coupon_id=coupon.id,
client=client)
coupon.client = client
return coupon
def test_update_address_book(self):
basket = factories.create_basket(empty=True)
user = factories.UserFactory()
add_product(basket, D('12.00'))
shipping_method = FixedPrice(D('5.00'), D('5.00'))
billing_address = factories.BillingAddressFactory(
line1='1 Boardwalk Place',
line2='Trafalgar Way',
line3='Tower Hamlets',
line4='London')
shipping_address = factories.ShippingAddressFactory(
line1='Knightsbridge', line2='159', line4='London')
shipping_charge = shipping_method.calculate(basket)
order_total = OrderTotalCalculator().calculate(basket, shipping_charge)
order_submission_data = {
'user': user,
'order_number': '12345',
'basket': basket,
'shipping_address': shipping_address,
'shipping_method': shipping_method,
'shipping_charge': shipping_charge,
'billing_address': billing_address,
'order_total': order_total
}
OrderPlacementMixin().place_order(**order_submission_data)
self.assertEqual(
user.addresses.filter(
hash=billing_address.generate_hash()).count(), 1)
self.assertEqual(
user.addresses.filter(
hash=shipping_address.generate_hash()).count(), 1)
user_billing_address = user.addresses.get(
hash=billing_address.generate_hash())
user_shipping_address = user.addresses.get(
hash=shipping_address.generate_hash())
self.assertEqual(user_billing_address.num_orders_as_billing_address, 1)
self.assertEqual(user_shipping_address.num_orders_as_shipping_address,
1)
order_submission_data['order_number'] = '12346'
OrderPlacementMixin().place_order(**order_submission_data)
user_billing_address = user.addresses.get(
hash=billing_address.generate_hash())
user_shipping_address = user.addresses.get(
hash=shipping_address.generate_hash())
self.assertEqual(user_billing_address.num_orders_as_billing_address, 2)
self.assertEqual(user_shipping_address.num_orders_as_shipping_address,
2)
order_submission_data.pop('billing_address', None)
order_submission_data['order_number'] = '123457'
OrderPlacementMixin().place_order(**order_submission_data)
user_billing_address = user.addresses.get(
hash=billing_address.generate_hash())
user_shipping_address = user.addresses.get(
hash=shipping_address.generate_hash())
self.assertEqual(user_billing_address.num_orders_as_billing_address, 2)
self.assertEqual(user_shipping_address.num_orders_as_shipping_address,
3)
shipping_address.line2 = '160'
order_submission_data['billing_address'] = billing_address
order_submission_data['order_number'] = '123458'
OrderPlacementMixin().place_order(**order_submission_data)
user_billing_address = user.addresses.get(
hash=billing_address.generate_hash())
user_shipping_address = user.addresses.get(
hash=shipping_address.generate_hash())
self.assertEqual(user_billing_address.num_orders_as_billing_address, 3)
self.assertEqual(user_shipping_address.num_orders_as_shipping_address,
1)
def setUp(self):
self.applicator = CustomApplicator()
self.basket = factories.create_basket(empty=True)
self.user = factories.UserFactory()
def setUp(self):
self.url = reverse('basket:summary')
self.country = factories.CountryFactory()
self.user = factories.UserFactory()
def test_is_not_satisfied_by_non_match(self):
self.basket.owner = factories.UserFactory(first_name="Alan")
self.assertFalse(self.offer.is_condition_satisfied(self.basket))
def test_is_satisfied_by_match(self):
self.basket.owner = factories.UserFactory(first_name="Barry")
self.assertTrue(self.offer.is_condition_satisfied(self.basket))
def test_create_basket(self):
""" Verify the method creates a new basket. """
user = factories.UserFactory()
basket = Basket.create_basket(self.site, user)
self.assertEqual(basket.site, self.site)
self.assertEqual(basket.owner, user)
def create_coupon(self,
title='Test coupon',
price=100,
client=None,
partner=None,
catalog=None,
code='',
benefit_value=100,
note=None,
max_uses=None,
quantity=5,
catalog_query=None,
course_seat_types=None,
email_domains=None):
"""Helper method for creating a coupon.
Arguments:
title(str): Title of the coupon
price(int): Price of the coupon
partner(Partner): Partner used for creating a catalog
catalog(Catalog): Catalog of courses for which the coupon applies
code(str): Custom coupon code
benefit_value(int): The voucher benefit value
catalog_query(str): Course query string
course_seat_types(str): A string of comma-separated list of seat types
email_domains(str): A comma seperated list of email domains
Returns:
coupon (Coupon)
"""
if partner is None:
partner = PartnerFactory(name='Tester')
if client is None:
client, __ = BusinessClient.objects.get_or_create(
name='Test Client')
if catalog is None and not (catalog_query and course_seat_types):
catalog = Catalog.objects.create(partner=partner)
if code is not '':
quantity = 1
data = {
'partner': partner,
'benefit_type': Benefit.PERCENTAGE,
'benefit_value': benefit_value,
'catalog': catalog,
'end_datetime': datetime.date(2020, 1, 1),
'code': code,
'quantity': quantity,
'start_datetime': datetime.date(2015, 1, 1),
'voucher_type': Voucher.SINGLE_USE,
'categories': [self.category],
'note': note,
'max_uses': max_uses,
'catalog_query': catalog_query,
'course_seat_types': course_seat_types,
'email_domains': email_domains,
}
coupon = CouponViewSet().create_coupon_product(title=title,
price=price,
data=data)
request = RequestFactory()
request.site = self.site
request.user = factories.UserFactory()
request.COOKIES = {}
self.basket = prepare_basket(request, coupon)
self.response_data = CouponViewSet().create_order_for_invoice(
self.basket, coupon_id=coupon.id, client=client)
coupon.client = client
return coupon
def create_user(self, **kwargs):
"""Create a user, with overrideable defaults."""
not_provided = object()
if kwargs.get('username', not_provided) is None:
kwargs.pop('username')
return factories.UserFactory(password=self.password, **kwargs)
def setUp(self):
self.product_class = oscar_factories.ProductClassFactory()
self.user = oscar_factories.UserFactory()
def setUp(self):
super(UsernameReplacementViewTests, self).setUp()
self.service_user = factories.UserFactory(
username=self.SERVICE_USERNAME)
self.url = reverse("api:v2:user_management:username_replacement")
def setUp(self):
super().setUp()
self.basket = factories.create_basket(empty=True)
# Create range and add one product to it.
rng = factories.RangeFactory(name='All products',
includes_all_products=True)
self.product = factories.ProductFactory()
rng.add_product(self.product)
# Create offer #1.
condition1 = factories.ConditionFactory(
range=rng,
type=factories.ConditionFactory._meta.model.COUNT,
value=D('2'),
)
benefit1 = factories.BenefitFactory(
range=rng,
type=factories.BenefitFactory._meta.model.MULTIBUY,
value=None,
)
self.offer1 = factories.ConditionalOfferFactory(
condition=condition1,
benefit=benefit1,
slug='offer-1',
start_datetime=now(),
name='Test offer #1',
priority=1,
)
# Create offer #2.
condition2 = factories.ConditionFactory(
range=rng,
type=factories.ConditionFactory._meta.model.VALUE,
value=D('1.99'),
)
benefit2 = factories.BenefitFactory(
range=rng,
type=factories.BenefitFactory._meta.model.MULTIBUY,
value=None,
)
self.offer2 = factories.ConditionalOfferFactory(
condition=condition2,
benefit=benefit2,
slug='offer-2',
start_datetime=now(),
name='Test offer #2',
)
# Create offer #3.
condition3 = factories.ConditionFactory(
range=rng,
type=factories.ConditionFactory._meta.model.COVERAGE,
value=1,
)
benefit3 = factories.BenefitFactory(
range=rng,
type=factories.BenefitFactory._meta.model.MULTIBUY,
value=None,
)
self.offer3 = factories.ConditionalOfferFactory(
condition=condition3,
benefit=benefit3,
slug='offer-3',
start_datetime=now(),
name='Test offer #3',
)
# Prepare `BasketView` to use `get_upsell_messages` method in tests.
self.view = BasketView()
self.view.request = RequestFactory().get(reverse('basket:summary'))
self.view.request.user = factories.UserFactory()
self.view.args = []
self.view.kwargs = {}
def setUp(self):
super(PopulateInvoiceOrdersCommandTests, self).setUp()
self.order = factories.OrderFactory()
self.basket = factories.BasketFactory()
self.basket.owner = factories.UserFactory()
self.basket.save()
