def test_create_with_lines(self, multiple_lines):
"""
Given an order and order lines that have not been refunded, Refund.create_with_lines
should create a Refund with corresponding RefundLines.
"""
order = self.create_order(user=UserFactory(),
multiple_lines=multiple_lines)
with LogCapture(LOGGER_NAME) as l:
refund = Refund.create_with_lines(order, list(order.lines.all()))
self.assert_refund_creation_logged(l, refund, order)
self.assert_refund_matches_order(refund, order)
def test_remove_dashboard_permission(self):
user = UserFactory(is_staff=False)
permission = PermissionFactory(codename='dashboard_access',
content_type=ContentType.objects.get(
app_label='partner',
model='partner'))
user.user_permissions.add(permission)
partner = PartnerFactory()
partner.users.add(user)
view = views.PartnerUserUnlinkView()
view.unlink_user(user, partner)
assert partner.users.count() == 0
assert Permission.objects.filter(pk=permission.pk).exists()
def test_wishlists_containing_product(self):
p1 = ProductFactory()
p2 = ProductFactory()
user = UserFactory()
wishlist1 = WishListFactory(owner=user)
WishListFactory(owner=user)
wishlist1.add(p1)
containing_one = wishlists_containing_product(Wishlist.objects.all(),
p1)
self.assertEqual(len(containing_one), 1)
self.assertEqual(containing_one[0], wishlist1)
containing_none = wishlists_containing_product(Wishlist.objects.all(),
p2)
self.assertEqual(len(containing_none), 0)
def test_create_with_lines_with_existing_refund(self, refund_status,
refund_created):
"""
Refund.create_with_lines should not create RefundLines for order lines
which have already been refunded.
"""
order = self.create_order(user=UserFactory())
line = order.lines.first()
RefundLineFactory(order_line=line, status=refund_status)
with LogCapture(LOGGER_NAME) as logger:
refund = Refund.create_with_lines(order, [line])
self.assertEqual(isinstance(refund, Refund), refund_created)
if refund_created:
self.assert_refund_creation_logged(logger, refund, order)
def test_generate_coupon_report_for_entitlement(self):
""" Verify the coupon report is generated properly in case of entitlements. """
self.data['coupon'] = self.entitlement_coupon
self.data['catalog'] = self.entitlement_catalog
self.coupon_vouchers = self.entitlement_coupon_vouchers
self.setup_coupons_for_report()
client = UserFactory()
basket = Basket.get_basket(client, self.site)
basket.add_product(self.entitlement_coupon)
vouchers = self.coupon_vouchers.first().vouchers.all()
self.use_voucher('TESTORDER1', vouchers[1], self.user, add_entitlement=True)
self.mock_course_api_response(course=self.course)
try:
generate_coupon_report(self.coupon_vouchers)
except TypeError:
self.fail("Exception:ErrorType raised unexpectedly!")
def _create_order(self, order_number, site):
"""
Creates the order with given order_number and
site also update the order's product's title.
"""
order = create_order(
number="order-{order_number}".format(order_number=order_number),
site=site,
user=UserFactory())
order_line = order.lines.first()
product = order_line.product
product.title = "product-title-{order_number}".format(
order_number=order_number)
product.save()
basket = order.basket
basket.date_created = self._get_date(days=2)
basket.date_submitted = self._get_date(days=1)
basket.save()
def test_cleans_title(self):
product = create_product()
reviewer = UserFactory()
data = {
'title': ' This product is lovely',
'body': 'I really like this cheese',
'score': 0,
'name': 'JR Hartley',
'email': '*****@*****.**'
}
form = forms.ProductReviewForm(product=product,
user=reviewer,
data=data)
assert form.is_valid()
review = form.save()
assert review.title == "This product is lovely"
def test_offer_excl_tax(self):
"The offer should be calculated as if it was declared excluding tax"
with self.settings(OSCAR_OFFERS_INCL_TAX=False):
self.assertEqual(Basket.objects.count(), 0)
admin = UserFactory()
self.client.force_login(admin)
# throw an item in the basket
basket_add_url = reverse("basket:add", args=(2,))
body = {"quantity": 1}
response = self.client.post(basket_add_url, body)
# throw another item in the basket so the offer activates
basket_add_url = reverse("basket:add", args=(3,))
body = {"quantity": 2}
response = self.client.post(basket_add_url, body)
# now go and check if dat offer was handled correctly
request = factory.post(basket_add_url, body)
request.user = admin
request.session = self.client.session
basket = get_user_basket(admin, request)
self.assertEqual(response.status_code, 302)
self.assertEqual(Basket.objects.count(), 1)
# now go and check if the offer was applied correctly
self.assertEqual(
basket.total_excl_tax_excl_discounts - basket.total_excl_tax,
D("10.00"),
"The offer should be a flat 10 pound discount on the total "
"excluding tax",
)
self.assertEqual(
basket.total_discount,
D("10.00"),
"The total discount property should properly reflect the discount"
"applied.",
)
self.check_general_truths(basket)
def handle(self, *args, **options):
orders = options['orders']
sku = options['sku']
try:
stock_record = StockRecord.objects.get(partner_sku=sku)
product = stock_record.product
partner = stock_record.partner
except StockRecord.DoesNotExist:
msg = 'No StockRecord for partner_sku {} exists.'.format(sku)
logger.exception(msg)
raise CommandError(msg)
try:
site = partner.siteconfiguration.site
except SiteConfiguration.DoesNotExist:
msg = 'No Site Configuration exists for partner {}!'.format(
partner.id)
logger.exception(msg)
raise CommandError(msg)
user = UserFactory()
for __ in range(orders):
basket = create_basket(user, product, site)
shipping_method = Free()
shipping_charge = shipping_method.calculate(basket)
total = OrderTotalCalculator().calculate(basket, shipping_charge)
number = OrderNumberGenerator().order_number(basket)
with transaction.atomic():
OrderCreator().place_order(order_number=number,
user=user,
basket=basket,
shipping_address=None,
shipping_method=shipping_method,
shipping_charge=shipping_charge,
billing_address=None,
total=total)
basket.set_as_submitted()
def test_send_product_alert_email_for_user_with_hurry_mode(self):
another_user = UserFactory(email='*****@*****.**')
product = create_product(num_in_stock=1)
ProductAlertFactory(product=product,
user=self.user,
email=self.user.email)
ProductAlertFactory(product=product,
user=another_user,
email=another_user.email)
self.dispatcher.send_product_alert_email_for_user(product)
self.assertEqual(len(mail.outbox), 2) # Separate email for each user
expected_subject = u'{} is back in stock'.format(product.title)
self.assertEqual(expected_subject, mail.outbox[0].subject)
for outboxed_email in mail.outbox:
self.assertEqual(expected_subject, outboxed_email.subject)
self.assertIn('We are happy to inform you that our product',
outboxed_email.body)
self.assertIn(
'Beware that the amount of items in stock is limited.',
outboxed_email.body)
def setUp(self):
super().setUp()
customer = UserFactory()
product1 = create_product(partner_name='Partner 1', price=D(5))
product2 = create_product(partner_name='Partner 2', price=D(10))
create_product(partner_name='Partner 2', price=D(15))
basket1 = create_basket(empty=True)
basket1.add_product(product1)
create_order(basket=basket1, user=customer)
basket2 = create_basket(empty=True)
basket2.add_product(product1)
basket2 = create_basket(empty=True)
basket2.add_product(product2)
for i in range(9):
create_order(basket=basket2, user=customer, number='1000%s' % i)
stockrecord1 = product1.stockrecords.first()
stockrecord2 = product2.stockrecords.first()
self.partner1 = stockrecord1.partner
self.partner2 = stockrecord2.partner
StockAlert.objects.create(stockrecord=stockrecord1, threshold=10)
StockAlert.objects.create(stockrecord=stockrecord2, threshold=5)
def test_handle_post_order_for_seat_purchase(self, __):
"""
Ensure that the single seat purchase order is not linked any business
client when the method `handle_post_order` is invoked.
"""
toggle_switch(ENROLLMENT_CODE_SWITCH, False)
course = CourseFactory(partner=self.partner)
verified_product = course.create_or_update_seat('verified', True, 50)
user = UserFactory()
basket = BasketFactory(owner=user, site=self.site)
basket.add_product(verified_product, quantity=1)
order = create_order(number=1, basket=basket, user=user)
request_data = {'organization': 'Dummy Business Client'}
# Manually add organization attribute on the basket for testing
basket_add_organization_attribute(basket, request_data)
EdxOrderPlacementMixin().handle_post_order(order)
# Now verify that the single seat order is not linked to business
# client by checking that there is no record for BusinessClient.
assert not BusinessClient.objects.all()
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(site=self.site, owner=user, empty=True)
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 test_handle_post_order_for_bulk_purchase(self, __):
"""
Ensure that the bulk purchase order is linked to the provided business
client when the method `handle_post_order` is invoked.
"""
toggle_switch(ENROLLMENT_CODE_SWITCH, True)
course = CourseFactory(partner=self.partner)
course.create_or_update_seat('verified', True, 50, create_enrollment_code=True)
enrollment_code = Product.objects.get(product_class__name=ENROLLMENT_CODE_PRODUCT_CLASS_NAME)
user = UserFactory()
basket = BasketFactory(owner=user, site=self.site)
basket.add_product(enrollment_code, quantity=1)
order = create_order(number=1, basket=basket, user=user)
request_data = {'organization': 'Dummy Business Client'}
# Manually add organization attribute on the basket for testing
basket_add_organization_attribute(basket, request_data)
EdxOrderPlacementMixin().handle_post_order(order)
# Now verify that a new business client has been created in current
# order is now linked with that client through Invoice model.
business_client = BusinessClient.objects.get(name=request_data['organization'])
assert Invoice.objects.get(order=order).business_client == business_client
def setUp(self):
super(OrderAdminTests, self).setUp()
self.user = UserFactory(is_staff=True,
is_superuser=True,
password=self.password)
self.client.login(username=self.user.username, password=self.password)
def setUp(self):
self.customer = UserFactory(username='******',
email='*****@*****.**',
password='******')
super().setUp()
def setUp(self):
self.user = UserFactory()
self.country = models.Country.objects.create(iso_3166_1_a2='GB',
name="UNITED KINGDOM")
def setUp(self):
self.client.force_login(UserFactory())
def test_notify_a_single_user(self):
user = UserFactory()
services.notify_user(user, "Hello you!")
self.assertEqual(1,
Notification.objects.filter(recipient=user).count())
def setUp(self):
self.notification = Notification.objects.create(
recipient=UserFactory(), subject="Hello")
def setUp(self):
self.user = UserFactory()
self.product = create_product()
create_stockrecord(self.product, num_in_stock=1)
def setUp(self):
self.customer = UserFactory(username='******',
email='*****@*****.**',
password='******')
super(TestDetailViewForStaffUser, self).setUp()
def setUp(self):
self.staff = UserFactory(is_staff=True, username='******')
self.commtype = CommunicationEventType.objects.create(
name="Password reset",
category=CommunicationEventType.USER_RELATED)
def setUp(self):
self.user = UserFactory()
self.product = create_product()
create_stockrecord(self.product, num_in_stock=1)
self.dispatcher = AlertsDispatcher()
def setUp(self):
self.user = UserFactory()
self.product = create_product(num_in_stock=0)
def test_non_staff_user_has_empty_menu(self):
menu = get_nodes(UserFactory())
self.assertEqual(menu, [])
def setUp(self):
self.user = UserFactory()
def setUp(self):
user = UserFactory()
product = create_product()
self.wishlist = WishListFactory(owner=user)
self.wishlist.add(product)
def setUp(self):
self.user = UserFactory()
self.product = create_product()
self.dispatcher = AlertsDispatcher()
def setUp(self):
self.user = UserFactory()
self.product = create_product()
