def test_organizations_courses_search_by_mobile_available(self):
organization = self.setup_test_organization()
courses = CourseFactory.create_batch(2)
mobile_course = CourseFactory.create(mobile_available=True)
courses.append(mobile_course)
users = UserFactory.create_batch(3)
for course in courses:
CourseOverview.get_from_id(course.id)
for i, user in enumerate(users):
CourseEnrollmentFactory.create(user=user, course_id=courses[i].id)
user.organizations.add(organization['id'])
# fetch all courses for organization
courses_uri = '{}{}/courses/'.format(self.base_organizations_uri,
organization['id'])
response = self.do_get(courses_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 3)
# fetch mobile available courses for organization
response = self.do_get("{}?mobile_available=false".format(courses_uri))
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
self.assertEqual(response.data[0]['mobile_available'], False)
self.assertEqual(response.data[1]['mobile_available'], False)
# fetch mobile available courses for organization
response = self.do_get("{}?mobile_available=true".format(courses_uri))
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['mobile_available'], True)
def test_organizations_list_number_of_participants(self):
"""
Test number_of_participants field in organization list
"""
number_of_participants = 5
users = UserFactory.create_batch(number_of_participants)
courses = CourseFactory.create_batch(2)
org = self.setup_test_organization()
# get org list without any users/participants
response = self.do_get(self.base_organizations_uri)
self.assertEqual(response.data['results'][0]['number_of_participants'],
0)
for user in users:
user.organizations.add(org['id'])
response = self.do_get(self.base_organizations_uri)
self.assertEqual(response.data['results'][0]['number_of_participants'],
number_of_participants)
# enroll users in both course to test distinct count
for user in users:
CourseEnrollmentFactory.create(user=user, course_id=courses[0].id)
CourseEnrollmentFactory.create(user=user, course_id=courses[1].id)
response = self.do_get(self.base_organizations_uri)
self.assertEqual(response.data['results'][0]['number_of_participants'],
number_of_participants)
def test_organizations_courses_get(self):
organization = self.setup_test_organization()
courses = CourseFactory.create_batch(2)
users = UserFactory.create_batch(2)
for course in courses:
CourseOverview.get_from_id(course.id)
for i, user in enumerate(users):
user.organizations.add(organization['id'])
CourseEnrollmentFactory.create(user=users[0],
course_id=courses[i].id)
test_uri = '{}{}/'.format(self.base_organizations_uri,
organization['id'])
courses_uri = '{}courses/'.format(test_uri)
response = self.do_get(courses_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
self.assertEqual(response.data[0]['id'], unicode(courses[0].id))
self.assertEqual(len(response.data[0]['enrolled_users']), 1)
self.assertEqual(response.data[1]['id'], unicode(courses[1].id))
self.assertEqual(len(response.data[1]['enrolled_users']), 1)
# test course uniqueness if multiple organization users are enrolled in same course
CourseEnrollmentFactory.create(user=users[1], course_id=courses[0].id)
response = self.do_get(courses_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
self.assertEqual(response.data[0]['id'], unicode(courses[0].id))
self.assertEqual(len(response.data[0]['enrolled_users']), 2)
self.assertEqual(response.data[1]['id'], unicode(courses[1].id))
self.assertEqual(len(response.data[1]['enrolled_users']), 1)
def test_organizations_groups_users_delete(self):
organization = self.setup_test_organization()
organization_two = self.setup_test_organization()
groups = GroupFactory.create_batch(2)
users = UserFactory.create_batch(5)
groups[0].organizations.add(organization['id'])
groups[0].organizations.add(organization_two['id'])
for user in users:
OrganizationGroupUser.objects.create(
organization_id=organization['id'], group=groups[0], user=user)
OrganizationGroupUser.objects.create(
organization_id=organization_two['id'],
group=groups[0],
user=user)
# test for invalid user id
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization['id'],
groups[1].id)
data = {'users': '1,qwerty'}
response = self.do_delete(test_uri, data)
self.assertEqual(response.status_code, 400)
# group does not belong to organization
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization['id'],
groups[1].id)
data = {'users': ','.join([str(user.id) for user in users])}
response = self.do_delete(test_uri, data)
self.assertEqual(response.status_code, 404)
expected_response = "Group {} does not belong to organization {}".format(
groups[1].id, organization['id'])
self.assertEqual(response.data['detail'], expected_response)
# group belong to organization but users does not exit
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization['id'],
groups[0].id)
data = {'users': '1234,9912,9800'}
response = self.do_delete(test_uri, data)
self.assertEqual(response.status_code, 204)
# organization group user relationship exists for users
data = {'users': ','.join([str(user.id) for user in users])}
response = self.do_delete(test_uri, data)
self.assertEqual(response.status_code, 200)
user_ids = ', '.join([str(user.id) for user in users])
expected_response = "user id(s) {} removed from organization {}'s group {}".format(
user_ids, organization['id'], groups[0].id)
self.assertEqual(response.data['detail'], expected_response)
response = self.do_get(test_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
# test users were not removed from organization_two group relation
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization_two['id'],
groups[0].id)
response = self.do_get(test_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), len(users))
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)
self.assertEqual(
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)
self.assertEqual(QuerySet.delete.invocations, initial_count)
self.assertEqual(
AccessToken.objects.filter(refresh_token__isnull=True,
expires__lt=now).count(), 0)
finally:
QuerySet.delete = original_delete
def test_page_size_parameter(self, page_size):
user_size = 60
with patch(
'lms.djangoapps.grades.course_grade_factory.CourseGradeFactory.read'
) as mock_grade:
users = UserFactory.create_batch(user_size)
mocked_course_grades = []
for user in users:
self._create_user_enrollments(user)
mocked_course_grades.append(self.mock_course_grade(user, passed=True, letter_grade='A', percent=0.85))
mock_grade.side_effect = mocked_course_grades
with override_waffle_flag(self.waffle_flag, active=True):
self.login_staff()
query = ''
if page_size:
query = '?page_size={}'.format(page_size)
resp = self.client.get(
self.get_url(course_key=self.course.id) + query
)
self.assertEqual(status.HTTP_200_OK, resp.status_code)
actual_data = dict(resp.data)
expected_page_size = page_size or CourseEnrollmentPagination.page_size
if expected_page_size > user_size:
expected_page_size = user_size
self.assertEqual(len(actual_data['results']), expected_page_size)
def test_organizations_groups_users_get(self):
organization = self.setup_test_organization()
organization_two = self.setup_test_organization()
group = GroupFactory.create()
users = UserFactory.create_batch(5)
group.organizations.add(organization['id'])
group.organizations.add(organization_two['id'])
for user in users:
OrganizationGroupUser.objects.create(
organization_id=organization['id'], group=group, user=user)
# test when organization group have no users
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization['id'], 1234)
response = self.do_get(test_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
# test when organization group have users
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization['id'], group.id)
response = self.do_get(test_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), len(users))
for i, user in enumerate(response.data):
self.assertEqual(user['id'], users[i].id)
# test organization_two group users
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization_two['id'],
group.id)
response = self.do_get(test_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
def test_organizations_list_get(self):
courses = CourseFactory.create_batch(5)
users = UserFactory.create_batch(5)
organizations = []
for i in xrange(30):
data = {
'name': 'Test Organization {}'.format(i),
'display_name': 'Test Name {}'.format(i),
'contact_name': 'Test Contact {}'.format(i),
'contact_email': 'test{}@test.com'.format(i),
'contact_phone': '12313{}'.format(i),
}
organizations.append(self.setup_test_organization(org_data=data))
for i, user in enumerate(users):
user.organizations.add(organizations[0]['id'])
CourseEnrollmentFactory.create(user=user, course_id=courses[i].id)
# to test if number_of_courses has distinct course count
CourseEnrollmentFactory.create(user=users[0], course_id=courses[1].id)
test_uri = '{}'.format(self.base_organizations_uri)
response = self.do_get(test_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['count'], len(organizations))
self.assertEqual(len(response.data['results']), 20)
self.assertEqual(response.data['num_pages'], 2)
for i, organization in enumerate(response.data['results']):
uri = '{}{}{}/'.format(self.test_server_prefix,
self.base_organizations_uri,
organizations[i]['id'])
self.assertEqual(organization['url'], uri)
self.assertEqual(organization['id'], organizations[i]['id'])
self.assertEqual(organization['name'], organizations[i]['name'])
self.assertEqual(organization['display_name'],
organizations[i]['display_name'])
self.assertEqual(organization['contact_name'],
organizations[i]['contact_name'])
self.assertEqual(organization['contact_email'],
organizations[i]['contact_email'])
self.assertEqual(organization['contact_phone'],
organizations[i]['contact_phone'])
self.assertEqual(organization['logo_url'],
self.test_organization_logo_url)
number_of_courses = 0 if i else 5
self.assertEqual(organization['number_of_courses'],
number_of_courses)
self.assertIsNotNone(organization['created'])
self.assertIsNotNone(organization['modified'])
# fetch organization data with page outside range
response = self.do_get('{}?page=5'.format(test_uri))
self.assertEqual(response.status_code, 404)
# test with page_size 0, should not paginate and return all results
response = self.do_get('{}?page_size=0'.format(test_uri))
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), len(organizations))
def test_organizations_groups_users_post(self):
organization = self.setup_test_organization()
organization_two = self.setup_test_organization()
groups = GroupFactory.create_batch(2)
users = UserFactory.create_batch(5)
groups[0].organizations.add(organization['id'])
groups[0].organizations.add(organization_two['id'])
# test for invalid user id
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization['id'],
groups[1].id)
data = {'users': '1,qwerty'}
response = self.do_delete(test_uri, data)
self.assertEqual(response.status_code, 400)
# group does not belong to organization
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization['id'],
groups[1].id)
data = {'users': ','.join([str(user.id) for user in users])}
response = self.do_post(test_uri, data)
self.assertEqual(response.status_code, 404)
expected_response = "Group {} does not belong to organization {}".format(
groups[1].id, organization['id'])
self.assertEqual(response.data['detail'], expected_response)
# group belong to organization but users does not exit
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization['id'],
groups[0].id)
data = {'users': '1234,9912,9800'}
response = self.do_post(test_uri, data)
self.assertEqual(response.status_code, 204)
response = self.do_get(test_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
# group belong to organization and users exist
data = {'users': ','.join([str(user.id) for user in users])}
response = self.do_post(test_uri, data)
self.assertEqual(response.status_code, 201)
user_ids = ', '.join([str(user.id) for user in users])
expected_response = "user id(s) {} added to organization {}'s group {}".format(
user_ids, organization['id'], groups[0].id)
self.assertEqual(response.data['detail'], expected_response)
response = self.do_get(test_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), len(users))
for i, user in enumerate(response.data):
self.assertEqual(user['id'], users[i].id)
# test users were not added to organization_two group relation
test_uri = '{}{}/groups/{}/users'.format(self.base_organizations_uri,
organization_two['id'],
groups[0].id)
response = self.do_get(test_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
def setUp(self):
self.user = "******"
self.course_id = CourseLocator.from_string("org/num/run")
self.debug = False
self.noop = False
self.file_prefix = ""
self.exclude = None
self.mail = "*****@*****.**"
self.students = UserFactory.create_batch(3)
def setUp(self):
self.user = "******"
self.course_id = CourseLocator.from_string("org/num/run")
self.debug = False
self.noop = False
self.file_prefix = ""
self.exclude = None
self.mail = "*****@*****.**"
self.students = UserFactory.create_batch(3)
def test_handle_assessment_file(self):
users = UserFactory.create_batch(2)
file = self.create_csv([users[0], '5', u"Well done."],
[users[1], '1', u"Very bad."])
self.gea_xblock.usernames[users[0].username] = users[0]
self.gea_xblock.usernames[users[1].username] = users[1]
self.gea_xblock.handle_assessment_file(file)
results = self.edx_grade_students(users)
self.assertEqual(results.next()[1]['percent'], 0.5)
self.assertEqual(results.next()[1]['percent'], 0.1)
def test_register_all_students(self):
users = UserFactory.create_batch(size=10)
for user in users:
self.assertFalse(self.is_enrolled(self.course.id, user))
call_command('register_all_students',
course=self.get_course_id(self.course))
for user in users:
self.assertTrue(self.is_enrolled(self.course.id, user))
def test_unregister_students(self):
users = UserFactory.create_batch(size=20)
self.enroll_students(self.course, *users)
for user in users:
self.assertTrue(CourseEnrollment.is_enrolled(user, self.course.id))
input_file = self.create_input_file(*[user.email for user in users])
self.unregister_student(input_file)
for user in users:
self.assertFalse(CourseEnrollment.is_enrolled(user, self.course.id))
def test_unregister_students(self):
users = UserFactory.create_batch(size=20)
self.enroll_students(self.course, *users)
for user in users:
self.assertTrue(CourseEnrollment.is_enrolled(user, self.course.id))
input_file = self.create_input_file(*[user.email for user in users])
self.unregister_student(input_file)
for user in users:
self.assertFalse(CourseEnrollment.is_enrolled(
user, self.course.id))
def setUp(self):
start_date = datetime.datetime(2000, 1, 1, tzinfo=UTC())
end_date = datetime.datetime(2010, 12, 31, tzinfo=UTC())
#self.course = CourseFactory.create(
# org='org', number='num', run='run', display_name='test_course',
# start=start_date, end=end_date)
for i in xrange(1, 10):
random = i * randint(1, 100)
try:
self.course = CourseFactory.create(
org='org_' + str(random), number='num', run="run", display_name='test_course',
start=start_date, end=end_date)
break
except DuplicateCourseError:
print "wow"
UserFactory.reset_sequence()
self.students = UserFactory.create_batch(3)
for student in self.students:
CourseEnrollmentFactory.create(
user=student, course_id=self.course.id)
self.course.save()
self.prog_name = "create_certs"
self.args_create = ["create", self.course.id.to_deprecated_string()]
self.args_delete = ["delete", self.course.id.to_deprecated_string()]
self.args_report = ["report", self.course.id.to_deprecated_string()]
self.args_publish = ["publish", self.course.id.to_deprecated_string()]
self.kwargs = {
"noop": False, "username": False,
"debug": False, "prefix": "", "exclude": None}
patcher0 = patch('pdfgen.views.logging')
self.log_mock = patcher0.start()
self.addCleanup(patcher0.stop)
patcher1 = patch('pdfgen.views.S3Connection')
self.s3conn_mock = patcher1.start()
self.addCleanup(patcher1.stop)
patcher2 = patch('pdfgen.views.Key')
self.s3key_mock = patcher2.start()
self.addCleanup(patcher2.stop)
self.s3key_mock().generate_url.return_value = "http://example.com"
self.pdf_path = settings.PDFGEN_BASE_PDF_DIR + "/" + self.kwargs['prefix'] + "-".join(
self.course.id.to_deprecated_string().split('/')) + ".pdf"
self.base_pdf = canvas.Canvas(self.pdf_path, pagesize=landscape(A4))
self.base_pdf.showPage()
self.base_pdf.save()
def test_organizations_courses_get_enrolled_users(self):
organization = self.setup_test_organization()
courses = CourseFactory.create_batch(2)
users = UserFactory.create_batch(5)
for course in courses:
CourseOverview.get_from_id(course.id)
for i, user in enumerate(users):
CourseEnrollmentFactory.create(user=user,
course_id=courses[i % 2].id)
if i < 3:
user.organizations.add(organization['id'])
# test with all users enrolled but only 3 in organization
test_uri = '{}{}/'.format(self.base_organizations_uri,
organization['id'])
courses_uri = '{}courses/'.format(test_uri)
response = self.do_get(courses_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
self.assertEqual(response.data[0]['id'], unicode(courses[0].id))
self.assertEqual(len(response.data[0]['enrolled_users']), 2)
self.assertEqual(response.data[0]['enrolled_users'][0], users[0].id)
self.assertEqual(response.data[0]['enrolled_users'][1], users[2].id)
self.assertEqual(response.data[1]['id'], unicode(courses[1].id))
self.assertEqual(len(response.data[1]['enrolled_users']), 1)
self.assertEqual(response.data[1]['enrolled_users'][0], users[1].id)
# now add remaining 2 users to organization
for user in users[3:]:
user.organizations.add(organization['id'])
response = self.do_get(courses_uri)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
self.assertEqual(response.data[0]['id'], unicode(courses[0].id))
self.assertEqual(len(response.data[0]['enrolled_users']), 3)
self.assertEqual(response.data[0]['enrolled_users'][0], users[0].id)
self.assertEqual(response.data[0]['enrolled_users'][1], users[2].id)
self.assertEqual(response.data[0]['enrolled_users'][2], users[4].id)
self.assertEqual(response.data[1]['id'], unicode(courses[1].id))
self.assertEqual(len(response.data[1]['enrolled_users']), 2)
self.assertEqual(response.data[1]['enrolled_users'][0], users[1].id)
self.assertEqual(response.data[1]['enrolled_users'][1], users[3].id)
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)
self.assertEqual(
AccessToken.objects.filter(refresh_token__isnull=True, expires__lt=now).count(),
initial_count
)
QuerySet.delete = counter(QuerySet.delete)
call_command('edx_clear_expired_tokens', batch_size=1, sleep_time=0)
self.assertEqual(QuerySet.delete.invocations, initial_count)
self.assertEqual(AccessToken.objects.filter(refresh_token__isnull=True, expires__lt=now).count(), 0)
def setUp(self):
super(BulkChangeEnrollmentTests, self).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(BulkChangeEnrollmentTests, self).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(BulkChangeEnrollmentTests, self).setUp()
self.course = CourseFactory.create()
self.users = UserFactory.create_batch(5)
def setUp(self):
super(TestGenerateExternalIds, self).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()
self.course = CourseFactory.create()
self.users = UserFactory.create_batch(5)
