def test_filter_reviews_by_status(self):
url = reverse('dashboard:reviews-list')
user1 = UserFactory()
user2 = UserFactory()
review1 = ProductReviewFactory(user=user1, status=1)
review2 = ProductReviewFactory(user=user2, status=0)
review3 = ProductReviewFactory(user=user2, status=2)
response = self.get(url, params={'status': 0})
self.assertEqual(len(response.context['review_list']), 1)
self.assertEqual(response.context['review_list'][0], review2)
response = self.get(url, params={'status': 1})
self.assertEqual(len(response.context['review_list']), 1)
self.assertEqual(response.context['review_list'][0], review1)
response = self.get(url, params={'status': 2})
self.assertEqual(len(response.context['review_list']), 1)
self.assertEqual(response.context['review_list'][0], review3)
response = self.get(url, params={'status': 3})
reviews = response.context['review_list']
self.assertTrue(review1 in reviews)
class TestASuccessfulTransfer(TestCase):
def setUp(self):
self.user = UserFactory(username="******")
source = AccountFactory(primary_user=None, credit_limit=None)
destination = AccountFactory()
self.transfer = Transfer.objects.create(source,
destination,
D('10.00'),
user=self.user)
def test_creates_2_transactions(self):
self.assertEqual(2, self.transfer.transactions.all().count())
def test_records_the_transferred_amount(self):
self.assertEqual(D('10.00'), self.transfer.amount)
def test_updates_source_balance(self):
self.assertEqual(-D('10.00'), self.transfer.source.balance)
def test_updates_destination_balance(self):
self.assertEqual(D('10.00'), self.transfer.destination.balance)
def test_cannot_be_deleted(self):
with self.assertRaises(RuntimeError):
self.transfer.delete()
def test_records_static_user_information_in_case_user_is_deleted(self):
self.assertEqual('barry', self.transfer.authorisor_username)
self.user.delete()
transfer = Transfer.objects.get(id=self.transfer.id)
self.assertEqual('barry', transfer.authorisor_username)
class TestASuccessfulTransfer(TestCase):
def setUp(self):
self.user = UserFactory(username="******")
source = AccountFactory(primary_user=None, credit_limit=None)
destination = AccountFactory()
self.transfer = Transfer.objects.create(source, destination,
D('10.00'), user=self.user)
def test_creates_2_transactions(self):
self.assertEqual(2, self.transfer.transactions.all().count())
def test_records_the_transferred_amount(self):
self.assertEqual(D('10.00'), self.transfer.amount)
def test_updates_source_balance(self):
self.assertEqual(-D('10.00'), self.transfer.source.balance)
def test_updates_destination_balance(self):
self.assertEqual(D('10.00'), self.transfer.destination.balance)
def test_cannot_be_deleted(self):
with self.assertRaises(RuntimeError):
self.transfer.delete()
def test_records_static_user_information_in_case_user_is_deleted(self):
self.assertEqual('barry', self.transfer.authorisor_username)
self.user.delete()
transfer = Transfer.objects.get(id=self.transfer.id)
self.assertEqual('barry', transfer.authorisor_username)
def setUp(self):
self.user = UserFactory(username="******")
source = AccountFactory(primary_user=None, credit_limit=None)
destination = AccountFactory()
self.transfer = Transfer.objects.create(source,
destination,
D('10.00'),
user=self.user)
def setUp(self):
self.product = create_product()
self.user = UserFactory()
self.voter = UserFactory()
self.review = self.product.reviews.create(title='This is nice',
score=3,
body="This is the body",
user=self.user)
def test_can_only_be_authorised_by_primary_user_when_set(self):
primary = UserFactory()
other = UserFactory()
self.account.primary_user = primary
self.account.save()
self.assertTrue(self.account.can_be_authorised_by(primary))
self.assertFalse(self.account.can_be_authorised_by(other))
def test_is_not_deleted_when_the_authorisor_is_deleted(self):
user = UserFactory()
source = AccountFactory(credit_limit=None, primary_user=user, start_date=None, end_date=None)
destination = AccountFactory(start_date=None, end_date=None)
txn = Transfer.objects.create(source, destination,
D('20.00'), user=user)
self.assertEqual(2, txn.transactions.all().count())
user.delete()
self.assertEqual(2, txn.transactions.all().count())
def test_can_only_be_authorised_by_secondary_users_when_set(self):
self.account.save()
users = [UserFactory(), UserFactory()]
other = UserFactory()
for user in users:
self.account.secondary_users.add(user)
for user in users:
self.assertTrue(self.account.can_be_authorised_by(user))
self.assertFalse(self.account.can_be_authorised_by(other))
def test_user_email_unicode_collision(self):
# Regression test for CVE-2019-19844, which Oscar's PasswordResetForm
# was vulnerable to because it had overridden the save() method.
UserFactory(username='******', email='*****@*****.**')
UserFactory(username='******', email='mı[email protected]')
form = PasswordResetForm({'email': 'mı[email protected]'})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, ['mı[email protected]'])
def test_is_available_to_different_users(self):
users, order = [UserFactory(), UserFactory()], OrderFactory()
for user in users:
is_voucher_available_to_user, __ = self.voucher.is_available_to_user(
user=user)
self.assertTrue(is_voucher_available_to_user)
self.voucher.record_usage(order, user)
is_voucher_available_to_user, __ = self.voucher.is_available_to_user(
user=user)
self.assertFalse(is_voucher_available_to_user)
def test_invoice_document_is_not_accessible_via_url(self):
invoice = self._test_invoice_is_created()
another_user = UserFactory(username='******')
staff_user = UserFactory(is_staff=True)
superuser = UserFactory(is_superuser=True)
# Invoice document is not accessible via url for any user
for user in [self.user, another_user, staff_user, superuser]:
with self.assertRaisesMessage(ValueError, 'This file is not accessible via a URL.'):
self.app.get(invoice.document.url, user=user)
def setUp(self):
super().setUp()
for i in range(1, 25):
UserFactory(is_active=True)
for i in range(1, 25):
UserFactory(is_active=False)
user_queryset = User.objects.all()
self.active_users_ids = user_queryset.filter(
is_active=True).values_list('id', flat=True)
self.inactive_users_ids = user_queryset.filter(
is_active=False).values_list('id', flat=True)
def test_generate_coupon_report(self):
""" Verify the coupon report is generated properly. """
self.setup_coupons_for_report()
client = UserFactory()
basket = Basket.get_basket(client, self.site)
basket.add_product(self.coupon)
vouchers = self.coupon_vouchers.first().vouchers.all()
self.use_voucher('TESTORDER1', vouchers[1], self.user)
user2 = UserFactory()
self.use_voucher('TESTORDER2', vouchers[2], self.user)
self.use_voucher('TESTORDER3', vouchers[2], user2)
self.mock_course_api_response(course=self.course)
field_names, rows = generate_coupon_report(self.coupon_vouchers)
self.assertEqual(field_names, [
'Code',
'Coupon Name',
'Maximum Coupon Usage',
'Redemption Count',
'Coupon Type',
'URL',
'Course ID',
'Organization',
'Client',
'Category',
'Note',
'Price',
'Invoiced Amount',
'Discount Percentage',
'Discount Amount',
'Status',
'Order Number',
'Redeemed By Username',
'Create Date',
'Coupon Start Date',
'Coupon Expiry Date',
'Email Domains',
])
voucher = Voucher.objects.get(name=rows[0]['Coupon Name'])
self.assert_report_first_row(rows.pop(0), self.coupon, voucher)
for row in rows:
voucher = Voucher.objects.get(code=row['Code'])
self.assert_report_row(row, voucher)
self.assertNotIn('Catalog Query', field_names)
self.assertNotIn('Course Seat Types', field_names)
self.assertNotIn('Redeemed For Course ID', field_names)
def setUp(self):
UserFactory(username='******',
email='*****@*****.**',
first_name='Lars',
last_name='van der Berg')
UserFactory(username='******',
email='*****@*****.**',
first_name='Owen',
last_name='Davies')
UserFactory(username='******',
email='*****@*****.**',
first_name='Rob Alan',
last_name='Lewis')
super().setUp()
def test_zero_dollar_refund(self, mock_revoke_line):
"""
Given an order and order lines which total $0 and are not refunded, Refund.create_with_lines
should create and approve a Refund with corresponding RefundLines.
"""
httpretty.register_uri(httpretty.POST,
get_lms_enrollment_api_url(),
status=200,
body='{}',
content_type='application/json')
order = self.create_order(user=UserFactory(), free=True)
# Verify that the order totals $0.
self.assertEqual(order.total_excl_tax, 0)
with mock.patch.object(Refund, '_notify_purchaser') as mock_notify:
refund = Refund.create_with_lines(order, list(order.lines.all()))
# Verify that refund lines are not revoked.
self.assertFalse(mock_revoke_line.called)
# Verify that the refund has been successfully approved.
self.assertEqual(refund.status, REFUND.COMPLETE)
self.assertEqual(set([line.status for line in refund.lines.all()]),
{REFUND_LINE.COMPLETE})
# Verify no notification is sent to the purchaser
self.assertFalse(mock_notify.called)
def test_notify_a_set_of_users(self):
users = [UserFactory() for i in range(3)]
services.notify_users(User.objects.all(), "Hello everybody!")
for user in users:
self.assertEqual(
1,
Notification.objects.filter(recipient=user).count())
def test_notify_purchaser_course_entielement(self, mock_task):
""" Verify the notification is scheduled if the site has notifications enabled
and the refund is for a course entitlement.
"""
site_configuration = self.site.siteconfiguration
site_configuration.send_refund_notifications = True
user = UserFactory()
course_entitlement = create_or_update_course_entitlement(
'verified', 100, self.partner, '111-222-333-444',
'Course Entitlement')
basket = create_basket(site=self.site, owner=user, empty=True)
basket.add_product(course_entitlement, 1)
order = create_order(number=1, 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, 100)
mock_task.assert_called_once_with(user.email,
refund.id,
amount,
course_entitlement.title,
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):
self.user = UserFactory()
self.source = AccountFactory(credit_limit=None, primary_user=None)
self.destination = AccountFactory()
self.transfer = facade.transfer(
self.source, self.destination, D('100'),
user=self.user, description="Give money to customer")
def test_is_available_to_same_user_multiple_times(self):
user, order = UserFactory(), OrderFactory()
for i in range(10):
self.voucher.record_usage(order, user)
is_voucher_available_to_user, __ = self.voucher.is_available_to_user(
user=user)
self.assertTrue(is_voucher_available_to_user)
class AuthBackendTestCase(TestCase):
def setUp(self):
self.user = UserFactory(email='*****@*****.**', is_staff=True)
self.user.set_password('letmein')
self.user.save()
self.backend = EmailBackend()
@unittest.skipUnless(django.VERSION < (1, 11), "for Django <1.11 only")
def test_authentication_method_signature_pre_django_1_11(self):
auth_result = self.backend.authenticate('*****@*****.**', 'letmein')
self.assertEqual(auth_result, self.user)
@unittest.skipUnless(django.VERSION >= (1, 11), "for Django >=1.11 only")
def test_authentication_method_signature_post_django_1_11(self):
auth_result = self.backend.authenticate(None, '*****@*****.**', 'letmein')
self.assertEqual(auth_result, self.user)
def test_num_orders(self):
voucherset = VoucherSetFactory()
assert voucherset.num_orders == 0
user, order = UserFactory(), OrderFactory()
voucher = voucherset.vouchers.first()
voucher.record_usage(order, user)
assert voucherset.num_orders == 1
def setUp(self):
super().setUp()
self.user = UserFactory()
LegalEntityAddressFactory(
legal_entity=LegalEntityFactory(),
country=CountryFactory(),
)
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 test_account_exception_raised_for_runtime_error(self):
user = UserFactory()
source = AccountFactory(credit_limit=None)
destination = AccountFactory()
with mock.patch('oscar_accounts.abstract_models.PostingManager._wrap') as mock_method:
mock_method.side_effect = RuntimeError()
with self.assertRaises(exceptions.AccountException):
facade.transfer(source, destination, D('100'), user)
def setUp(self):
super(TestInvoice, self).setUp()
self.user = UserFactory()
self.order = create_order(number='000042', user=self.user)
LegalEntityAddressFactory(
legal_entity=LegalEntityFactory(),
country=CountryFactory(),
)
def test_create_voucher_with_multi_use_per_customer_usage(self):
""" Verify voucher is created with `MULTI_USE_PER_CUSTOMER` usage type. """
voucher_data = dict(self.data, usage=Voucher.MULTI_USE_PER_CUSTOMER)
voucher = Voucher.objects.create(**voucher_data)
user = UserFactory()
self.assertEqual(voucher.usage, Voucher.MULTI_USE_PER_CUSTOMER)
is_available, message = voucher.is_available_to_user(user)
self.assertTrue(is_available)
self.assertEqual(message, '')
def test_notify_a_single_user(self):
user = UserFactory()
subj = "Hello you!"
body = "This is the notification body."
Dispatcher().notify_user(user, subj, body=body)
user_notification = Notification.objects.get(recipient=user)
assert user_notification.subject == subj
assert user_notification.body == body
def test_bulk_editing_review_status(self):
user1 = UserFactory()
user2 = UserFactory()
ProductReviewFactory(pk=1, user=user1, status=0)
ProductReviewFactory(pk=2, user=user2, status=0)
ProductReviewFactory(pk=3, user=user2, status=0)
assert (ProductReview.objects.count() == 3)
list_page = self.get(reverse('dashboard:reviews-list'))
form = list_page.forms[1]
form['selected_review'] = [3, 2]
form.submit('update')
self.assertEqual(ProductReview.objects.get(pk=1).status, 0)
self.assertEqual(ProductReview.objects.get(pk=2).status, 1)
self.assertEqual(ProductReview.objects.get(pk=3).status, 1)
def test_notify_a_single_user(self):
user = UserFactory()
subj = "Hello you!"
body = "This is the notification body."
services.notify_user(user, subj, body=body)
user_notification = Notification.objects.get(recipient=user)
self.assertEqual(user_notification.subject, subj)
self.assertEqual(user_notification.body, body)
def test_filter_reviews_by_keyword(self):
url = reverse('dashboard:reviews-list')
user1 = UserFactory()
user2 = UserFactory()
review1 = ProductReviewFactory(user=user1, title='Sexy Review')
review2 = ProductReviewFactory(
user=user2, title='Anry Review', body='argh')
ProductReviewFactory(user=user2, title='Lovely Thing')
response = self.get(url, params={'keyword': 'argh'})
self.assertEqual(len(response.context['review_list']), 1)
self.assertEqual(response.context['review_list'][0], review2)
response = self.get(url, params={'keyword': 'review'})
self.assertQuerysetContains(response.context['review_list'],
[review1, review2])
class AuthBackendTestCase(TestCase):
def setUp(self):
self.user = UserFactory(email='*****@*****.**', is_staff=True)
self.user.set_password('letmein')
self.user.save()
self.backend = EmailBackend()
def test_authentication_method_signature_post_django_1_11(self):
auth_result = self.backend.authenticate(None, '*****@*****.**', 'letmein')
self.assertEqual(auth_result, self.user)
def test_inactive_users_cannot_authenticate(self):
self.user.is_active = False
self.user.save()
auth_result = self.backend.authenticate(None, '*****@*****.**', 'letmein')
self.assertIsNone(auth_result)
def setUp(self):
self.user = UserFactory(email='*****@*****.**', is_staff=True)
self.user.set_password('letmein')
self.user.save()
self.backend = EmailBackend()
def setUp(self):
self.user = UserFactory(username="******")
source = AccountFactory(primary_user=None, credit_limit=None)
destination = AccountFactory()
self.transfer = Transfer.objects.create(source, destination,
D('10.00'), user=self.user)