def setUp(self):
""" Test case setup """
self.global_admin = AdminFactory()
self.instructor = User.objects.create_user('testinstructor', '*****@*****.**', 'foo')
self.staff = User.objects.create_user('teststaff', '*****@*****.**', 'foo')
self.location = Location('i4x', 'mitX', '101', 'course', 'test')
self.locator = CourseLocator(url='edx://mitX.101.test')
def _load_mktg_about(self, language=None, org=None):
"""Retrieve the marketing about button (iframed into the marketing site)
and return the HTTP response.
Keyword Args:
language (string): If provided, send this in the 'Accept-Language' HTTP header.
org (string): If provided, send the string as a GET parameter.
Returns:
Response
"""
# Log in as an administrator to guarantee that we can access the button
admin = AdminFactory()
self.client.login(username=admin.username, password='******')
# If provided, set the language header
headers = {}
if language is not None:
headers['HTTP_ACCEPT_LANGUAGE'] = language
url = reverse('mktg_about_course',
kwargs={'course_id': unicode(self.course_key)})
if org:
return self.client.get(url, {'org': org}, **headers)
else:
return self.client.get(url, **headers)
def _verify_cohort_settings_response(self, expected_response):
""" Verify that the response was successful and matches the expected JSON payload. """
request = RequestFactory().get("dummy_url")
request.user = AdminFactory()
response = cohorting_settings(request, unicode(self.course.id))
self.assertEqual(200, response.status_code)
self.assertEqual(expected_response, json.loads(response.content))
def test_enrollment_list_permissions(self):
"""
Test that the correct list of enrollments is returned, depending on the permissions of the
requesting user.
"""
# Create another course, and enroll self.user in both courses.
other_course = CourseFactory.create(emit_signals=True)
for course in self.course, other_course:
CourseModeFactory.create(
course_id=unicode(course.id),
mode_slug=CourseMode.DEFAULT_MODE_SLUG,
mode_display_name=CourseMode.DEFAULT_MODE_SLUG,
)
self.assert_enrollment_status(
course_id=unicode(course.id),
max_mongo_calls=0,
)
# Verify the user himself can see both of his enrollments.
self._assert_enrollments_visible_in_list([self.course, other_course])
# Verify that self.other_user can't see any of the enrollments.
self.client.login(username=self.OTHER_USERNAME, password=self.PASSWORD)
self._assert_enrollments_visible_in_list([])
# Create a staff user for self.course (but nor for other_course) and log her in.
staff_user = UserFactory.create(username='******', email='*****@*****.**', password=self.PASSWORD)
CourseStaffRole(self.course.id).add_users(staff_user)
self.client.login(username='******', password=self.PASSWORD)
# Verify that she can see only the enrollment in the course she has staff privileges for.
self._assert_enrollments_visible_in_list([self.course])
# Create a global staff user, and verify she can see all enrollments.
AdminFactory(username='******', email='*****@*****.**', password=self.PASSWORD)
self.client.login(username='******', password=self.PASSWORD)
self._assert_enrollments_visible_in_list([self.course, other_course])
# Verify the server can see all enrollments.
self.client.logout()
self._assert_enrollments_visible_in_list([self.course, other_course], use_server_key=True)
def test_submission_history_xss(self):
# log into a staff account
admin = AdminFactory()
self.client.login(username=admin.username, password='******')
# try it with an existing user and a malicious location
url = reverse('submission_history',
kwargs={
'course_id': self.course_key.to_deprecated_string(),
'student_username': '******',
'location': '<script>alert("hello");</script>'
})
response = self.client.get(url)
self.assertFalse('<script>' in response.content)
# try it with a malicious user and a non-existent location
url = reverse('submission_history',
kwargs={
'course_id': self.course_key.to_deprecated_string(),
'student_username':
'******',
'location': 'dummy'
})
response = self.client.get(url)
self.assertFalse('<script>' in response.content)
def test_course_mktg_register(self):
admin = AdminFactory()
self.client.login(username=admin.username, password='******')
url = reverse('mktg_about_course', kwargs={'course_id': self.course_id})
response = self.client.get(url)
self.assertIn('Register for', response.content)
self.assertNotIn('and choose your student track', response.content)
def setUp(self):
super(CourseIdListViewTestCase, self).setUp()
self.course = self.create_course()
self.url = reverse('course-id-list')
self.staff_user = self.create_user(username='******', is_staff=True)
self.honor_user = self.create_user(username='******', is_staff=False)
self.global_admin = AdminFactory()
def test_closed_course_admin(self):
"""
Users marked as Admin should be able to submit grade events to a closed course
"""
self.user = AdminFactory()
self._create_course(start=datetime(2010, 1, 1, tzinfo=UTC()),
end=datetime(2011, 1, 1, tzinfo=UTC()))
module = self.get_module_for_user(self.user, self.course, self.problem)
grade_dict = {'value': 0.75, 'max_value': 1, 'user_id': self.user.id}
module.system.publish(module, 'grade', grade_dict)
with self.assertRaises(StudentGradebook.DoesNotExist):
gradebook = StudentGradebook.objects.get(user=self.user,
course_id=self.course.id)
module = self.get_module_for_user(self.user, self.course,
self.problem2)
grade_dict = {'value': 0.95, 'max_value': 1, 'user_id': self.user.id}
module.system.publish(module, 'grade', grade_dict)
with self.assertRaises(StudentGradebook.DoesNotExist):
gradebook = StudentGradebook.objects.get(user=self.user,
course_id=self.course.id)
gradebook = StudentGradebook.objects.all()
self.assertEqual(len(gradebook), 0)
history = StudentGradebookHistory.objects.all()
self.assertEqual(len(history), 0)
def setUp(self):
""" Test case setup """
super(CourseGroupTest, self).setUp()
self.global_admin = AdminFactory()
self.creator = User.objects.create_user('testcreator', '*****@*****.**', 'foo')
self.staff = User.objects.create_user('teststaff', '*****@*****.**', 'foo')
self.course_key = SlashSeparatedCourseKey('mitX', '101', 'test')
def setUp(self):
""" Test case setup """
super(EnrollmentAttributeOverrideViewTest, self).setUp()
self.client = Client()
user = AdminFactory()
self.view_url = reverse('admin:enterprise_override_attributes')
self.client.login(username=user.username, password=TEST_PASSWORD)
self.users = []
for _ in range(3):
self.users.append(UserFactory())
self.course = CourseRunFactory()
self.course_id = self.course.get('key')
self.csv_data = [
[self.users[0].id, self.course_id, 'OP_4321'],
[self.users[1].id, self.course_id, 'OP_8765'],
[self.users[2].id, self.course_id, 'OP_2109'],
]
self.csv_data_for_existing_attributes = [
[self.users[0].id, self.course_id, 'OP_1234'],
[self.users[1].id, self.course_id, 'OP_5678'],
[self.users[2].id, self.course_id, 'OP_9012'],
]
for user in self.users:
CourseEnrollmentFactory(
course_id=self.course_id,
user=user
)
def setUp(self):
super(TestAccountDeactivation, self).setUp()
self.superuser = SuperuserFactory()
self.staff_user = AdminFactory()
self.test_user = UserFactory()
self.url = reverse('accounts_deactivation',
kwargs={'username': self.test_user.username})
def setUp(self):
super(CourseListViewTestCaseMultipleCourses, self).setUp()
self.course = self.create_course(mobile_available=False)
self.url = reverse('course-list')
self.staff_user = self.create_user(username='******', is_staff=True)
self.honor_user = self.create_user(username='******', is_staff=False)
self.global_admin = AdminFactory()
def setUp(self):
super(BookmarksTestsBase, self).setUp()
self.admin = AdminFactory()
self.user = UserFactory.create(password=self.TEST_PASSWORD)
self.other_user = UserFactory.create(password=self.TEST_PASSWORD)
self.setup_data(self.STORE_TYPE)
def setUp(self):
super(TestMaintenanceIndex, self).setUp()
self.user = AdminFactory()
login_success = self.client.login(username=self.user.username,
password='******')
self.assertTrue(login_success)
self.view_url = reverse('maintenance:maintenance_index')
def add_course_author(user, course):
"""
Add the user to the instructor group of the course
so they will have the permissions to see it in studio
"""
global_admin = AdminFactory()
for role in (CourseStaffRole, CourseInstructorRole):
auth.add_users(global_admin, role(course.id), user)
def test_post_permissions_staff(self):
""" Verify staff users can create requests for any user. """
admin = AdminFactory(password=self.password)
self.client.logout()
self.client.login(username=admin.username, password=self.password)
response = self.post_credit_request(self.user.username,
self.eligibility.course.course_key)
self.assertEqual(response.status_code, 200)
def setUp(self):
""" Test case setup """
super(RolesTest, self).setUp()
self.global_admin = AdminFactory()
self.instructor = User.objects.create_user('testinstructor', '*****@*****.**', 'foo')
self.staff = User.objects.create_user('teststaff', '*****@*****.**', 'foo')
self.course_key = CourseLocator('mitX', '101', 'test')
def setUp(self):
""" Test case setup """
super(CourseGroupTest, self).setUp()
self.global_admin = AdminFactory()
self.creator = User.objects.create_user('testcreator', '*****@*****.**', 'foo')
self.staff = User.objects.create_user('teststaff', '*****@*****.**', 'foo')
self.assistant = User.objects.create_user('testassistant', '*****@*****.**', 'foo')
self.course_key = CourseLocator('mitX', '101', 'test')
def setUp(self):
"""
Set up test variables
"""
super(CCXCourseGroupTest, self).setUp()
self.global_admin = AdminFactory()
self.staff = User.objects.create_user('teststaff', '*****@*****.**', 'foo')
self.ccx_course_key = CCXLocator.from_string('ccx-v1:edX+DemoX+Demo_Course+ccx@1')
add_users(self.global_admin, CourseStaffRole(self.ccx_course_key), self.staff)
def setup_user(self, admin=False, enroll=False, login=False):
"""
Helper method to create the user.
"""
self.user = AdminFactory() if admin else UserFactory()
if enroll:
CourseEnrollmentFactory(user=self.user, course_id=self.course.id)
if login:
self.login()
def setup_user(self, admin=False, enroll=False, login=False):
"""
Helper method to create the user.
"""
self.user = AdminFactory() if admin else UserFactory() # pylint: disable=attribute-defined-outside-init
if enroll:
CourseEnrollmentFactory(user=self.user, course_id=self.course.id)
if login:
self.login()
def test_disabled_feature(self):
"""
Test that behavior is normal when this feature is not turned on
"""
user = UserFactory()
staff = AdminFactory()
# if feature is disabled user can keep reusing same password
self.assertTrue(PasswordHistory.is_allowable_password_reuse(user, "test"))
self.assertTrue(PasswordHistory.is_allowable_password_reuse(staff, "test"))
self.assertFalse(PasswordHistory.should_user_reset_password_now(user))
self.assertFalse(PasswordHistory.should_user_reset_password_now(staff))
def test_submission_history_accepts_valid_ids(self):
# log into a staff account
admin = AdminFactory()
self.client.login(username=admin.username, password='******')
url = reverse('submission_history', kwargs={
'course_id': self.course_key.to_deprecated_string(),
'student_username': '******',
'location': self.component.location.to_deprecated_string(),
})
response = self.client.get(url)
# Tests that we do not get an "Invalid x" response when passing correct arguments to view
self.assertFalse('Invalid' in response.content)
def test_course_mktg_register_multiple_modes(self):
admin = AdminFactory()
CourseMode.objects.get_or_create(mode_slug='honor',
mode_display_name='Honor Code Certificate',
course_id=self.course_id)
CourseMode.objects.get_or_create(mode_slug='verified',
mode_display_name='Verified Certificate',
course_id=self.course_id)
self.client.login(username=admin.username, password='******')
url = reverse('mktg_about_course', kwargs={'course_id': self.course_id})
response = self.client.get(url)
self.assertIn('Register for', response.content)
self.assertIn('and choose your student track', response.content)
# clean up course modes
CourseMode.objects.all().delete()
def _user_factory_with_history(self, is_staff=False, set_initial_history=True):
"""
Helper method to generate either an Admin or a User
"""
if is_staff:
user = AdminFactory()
else:
user = UserFactory()
user.date_joined = timezone.now()
if set_initial_history:
history = PasswordHistory()
history.create(user)
return user
def create_other_user(_step, name, has_extra_perms, role_name):
email = name + '@edx.org'
user = create_studio_user(uname=name, password="******", email=email)
if has_extra_perms:
if role_name == "is_staff":
GlobalStaff().add_users(user)
else:
if role_name == "admin":
# admins get staff privileges, as well
roles = (CourseStaffRole, CourseInstructorRole)
else:
roles = (CourseStaffRole,)
course_key = world.scenario_dict["COURSE"].id
global_admin = AdminFactory()
for role in roles:
auth.add_users(global_admin, role(course_key), user)
def test_save_completion_admin_not_started(self):
"""
Save a CourseModuleCompletion with the feature flag on a course that has not yet started
but Admins should be able to write
"""
self._create_course(start=datetime(3000, 1, 1, tzinfo=UTC()))
self.user = AdminFactory()
module = self.get_module_for_user(self.user, self.course, self.problem4)
module.system.publish(module, 'progress', {})
completion_fetch = CourseModuleCompletion.objects.get(
user=self.user.id,
course_id=self.course.id,
content_id=self.problem4.location
)
self.assertIsNotNone(completion_fetch)
def test_save_completion_admin_ended(self, store):
"""
Save a CourseModuleCompletion with the feature flag on a course that has not yet started
but Admins should be able to write
"""
self._create_course(store=store, end=datetime(1999, 1, 1, tzinfo=UTC()))
self.user = AdminFactory()
module = self.get_module_for_user(self.user, self.course, self.problem4)
module.system.publish(module, 'progress', {})
with self.assertRaises(CourseModuleCompletion.DoesNotExist):
CourseModuleCompletion.objects.get(
user=self.user.id,
course_id=self.course.id,
content_id=self.problem4.location
)
def create_user_for_course(self, course, user_type=CourseUserType.ENROLLED):
"""
Create a test user for a course.
"""
if user_type is CourseUserType.ANONYMOUS:
return AnonymousUser()
is_enrolled = user_type is CourseUserType.ENROLLED
is_unenrolled_staff = user_type is CourseUserType.UNENROLLED_STAFF
# Set up the test user
if is_unenrolled_staff:
user = StaffFactory(course_key=course.id, password=self.TEST_PASSWORD)
elif user_type is CourseUserType.GLOBAL_STAFF:
user = AdminFactory(password=self.TEST_PASSWORD)
else:
user = UserFactory(password=self.TEST_PASSWORD)
self.client.login(username=user.username, password=self.TEST_PASSWORD)
if is_enrolled:
CourseEnrollment.enroll(user, course.id)
return user
def setUp(self):
super(CourseRunViewSetTests, self).setUp()
self.client = APIClient()
user = AdminFactory()
self.client.login(username=user.username, password=TEST_PASSWORD)
