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)