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_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_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_filter_courses_based_on_org(self):
"""
Test course are filtered properly on current site organization.
"""
edx_org_1 = OrganizationFactory()
edx_org_2 = OrganizationFactory()
courses_of_org_1 = CourseFactory.create_batch(2,
org=edx_org_1.short_name)
CourseFactory.create(org=edx_org_2.short_name)
assert len(modulestore().get_courses()) == 3
EdlySubOrganizationFactory(edx_organization=edx_org_1,
lms_site=self.request.site,
studio_site=self.request.site)
create_user_link_with_edly_sub_organization(self.request,
self.request.user)
response = cookies_api.set_logged_in_edly_cookies(
self.request, HttpResponse(), self.user,
cookie_settings(self.request))
self._copy_cookies_to_request(response, self.request)
filtered_courses = filter_courses_based_on_org(self.request,
courses_of_org_1)
assert len(filtered_courses) == 2
edx_orgs_of_filterd_courses = [
course.org for course in filtered_courses
]
for org in edx_orgs_of_filterd_courses:
assert org == edx_org_1.short_name
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_list(self):
course_runs = CourseFactory.create_batch(3)
response = self.client.get(self.list_url)
assert response.status_code == 200
# Order matters for the assertion
course_runs = sorted(course_runs, key=lambda course_run: str(course_run.id))
actual = sorted(response.data['results'], key=lambda course_run: course_run['id'])
assert actual == CourseRunSerializer(course_runs, many=True, context=self.get_serializer_context()).data
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_arguments_batching(self, start, count, expected_tabs_modified):
courses = CourseFactory.create_batch(4)
for course in courses:
course.tabs = [
tab for tab in course.tabs
if tab.type in ('course_info', 'courseware')
]
course = self.update_course(course, ModuleStoreEnum.UserID.test)
assert len(course.tabs) == 2
BackfillCourseTabsConfig.objects.create(enabled=True,
start_index=start,
count=count)
call_command('backfill_course_tabs')
for i, course in enumerate(courses):
course = self.store.get_course(course.id)
assert len(course.tabs) == (7 if expected_tabs_modified[i] else
2), f'Wrong tabs for course index {i}'
