def test_clear_expired_tokens(self):
settings.OAUTH2_PROVIDER['REFRESH_TOKEN_EXPIRE_SECONDS'] = 3600
initial_count = 5
now = timezone.now()
expires = now - timedelta(days=1)
users = UserFactory.create_batch(initial_count)
for user in users:
application = factories.ApplicationFactory(user=user)
factories.AccessTokenFactory(user=user,
application=application,
expires=expires)
assert AccessToken.objects.filter(
refresh_token__isnull=True,
expires__lt=now).count() == initial_count
original_delete = QuerySet.delete
QuerySet.delete = counter(QuerySet.delete)
try:
call_command('edx_clear_expired_tokens',
batch_size=1,
sleep_time=0)
assert not QuerySet.delete.invocations != initial_count # pylint: disable=no-member
assert AccessToken.objects.filter(refresh_token__isnull=True,
expires__lt=now).count() == 0
finally:
QuerySet.delete = original_delete
def user_fixture(request):
"""
Create test users
Returns:
list: A list of User objects as specified
"""
users = UserFactory.create_batch(request.param)
return users
def test_get_user_emails_of_invited_cohort(cohort, business_line):
"""
Tests that `get_user_emails_of_invited_cohort` returns expected emails for a given cohort.
"""
users = UserFactory.create_batch(5)
if cohort == 'business_line':
cohort = business_line.title
for user in users:
UserApplicationFactory(business_line=business_line, user=user)
actual_user_emails = Webinar.get_user_emails_of_invited_cohort(cohort)
expected_user_emails = [user.email for user in users]
assert sorted(expected_user_emails) == sorted(actual_user_emails)
def create_admin_accounts(count, account_type, is_active, is_staff=True):
"""
Creates admin accounts using the provided args.
Args:
count (int): Number of accounts
account_type (str): Account type
is_active (bool): Is account active
is_staff (bool): Is staff account
"""
business_line = BusinessLineFactory()
adg_admin_group = GroupFactory(name=ADG_ADMIN_GROUP_NAME)
users = UserFactory.create_batch(count,
is_active=is_active,
is_staff=is_staff)
user_group = adg_admin_group if account_type == ADG_ADMIN else business_line.group
for user in users:
user.groups.add(user_group)
return business_line, adg_admin_group, users, user_group
def test_get_enrollments_and_completions_count(course_group_with_courses,
number_of_users):
"""
Test that the total number of enrollments and completions in all the
courses of a course group are returned.
"""
users = UserFactory.create_batch(number_of_users)
courses = course_group_with_courses.multilingual_courses.open_multilingual_courses(
)
for idx, user in enumerate(users):
course_index = idx % 2
CourseEnrollmentFactory(user=user, course=courses[course_index].course)
PersistentCourseGradeFactory(user_id=user.id,
course_id=courses[course_index].course.id,
letter_grade='A',
percent_grade=80,
passed_timestamp=now())
enrollments, completions = course_group_with_courses.get_enrollments_and_completions_count(
)
assert enrollments == completions == number_of_users
def test_expiration_date_updated_multiple_records(self):
"""
Test that `expiration_date` is properly updated with multiple records fits the selection
criteria
"""
users = UserFactory.create_batch(10)
for user in users:
verification = self.create_and_submit(user)
verification.status = 'approved'
verification.expiry_date = now() + timedelta(days=3)
verification.expiration_date = '2021-11-12T16:33:15.691Z'
verification.save()
call_command('update_expiration_date', batch_size=3, sleep_time=1)
updated_verifications = SoftwareSecurePhotoVerification.objects.filter(
user__in=users)
for updated_verification in updated_verifications:
expected_date = updated_verification.created_at + timedelta(
days=settings.VERIFY_STUDENT["DAYS_GOOD_FOR"])
# Check that the `expiration_date` is updated
assert updated_verification.expiration_date == expected_date
# Check that the `expiry_date` is set to NULL
assert updated_verification.expiry_date is None
def setUp(self):
super(TestGenerateExternalIds, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
self.users = UserFactory.create_batch(10)
self.user_id_list = [user.id for user in self.users]
self.external_id_admin = ExternalIdAdmin(ExternalId, AdminSite())
def setUp(self):
super().setUp()
self.org = 'testX'
self.course = CourseFactory.create(org=self.org)
self.users = UserFactory.create_batch(5)
CourseOverview.load_from_module_store(self.course.id)
def setUp(self):
super().setUp()
self.users = UserFactory.create_batch(10)
self.user_id_list = [user.id for user in self.users]
self.external_id_admin = ExternalIdAdmin(ExternalId, AdminSite())
def setUp(self):
super(BulkChangeEnrollmentTests, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
self.org = 'testX'
self.course = CourseFactory.create(org=self.org)
self.users = UserFactory.create_batch(5)
CourseOverview.load_from_module_store(self.course.id)
