def setUp(self): self.course_key = SlashSeparatedCourseKey('edX', 'toy', '2012_Fall') self.anonymous_user = AnonymousUserFactory() self.student = UserFactory() self.global_staff = UserFactory(is_staff=True) self.course_staff = StaffFactory(course_key=self.course_key) self.course_instructor = InstructorFactory(course_key=self.course_key)
def setUp(self): self.course_id = "edX/open_ended/2012_Fall" self.problem_location = Location([ "i4x", "edX", "open_ended", "combinedopenended", "SampleQuestion" ]) self.self_assessment_task_number = 0 self.open_ended_task_number = 1 self.student_on_initial = UserFactory() self.student_on_accessing = UserFactory() self.student_on_post_assessment = UserFactory() StudentModuleFactory.create(course_id=self.course_id, module_state_key=self.problem_location, student=self.student_on_initial, grade=0, max_grade=1, state=STATE_INITIAL) StudentModuleFactory.create(course_id=self.course_id, module_state_key=self.problem_location, student=self.student_on_accessing, grade=0, max_grade=1, state=STATE_ACCESSING) StudentModuleFactory.create(course_id=self.course_id, module_state_key=self.problem_location, student=self.student_on_post_assessment, grade=0, max_grade=1, state=STATE_POST_ASSESSMENT)
def setUp(self): self.course = Location('i4x://edX/toy/course/2012_Fall') self.anonymous_user = AnonymousUserFactory() self.student = UserFactory() self.global_staff = UserFactory(is_staff=True) self.course_staff = StaffFactory(course=self.course) self.course_instructor = InstructorFactory(course=self.course)
def setUp(self): super(TestCertificatesInstructorApiBulkWhiteListExceptions, self).setUp() self.global_staff = GlobalStaffFactory() self.enrolled_user_1 = UserFactory( username='******', email='*****@*****.**', first_name='Enrolled', last_name='Student' ) self.enrolled_user_2 = UserFactory( username='******', email='*****@*****.**', first_name='Enrolled', last_name='Student' ) self.not_enrolled_student = UserFactory( username='******', email='*****@*****.**', first_name='NotEnrolled', last_name='Student' ) CourseEnrollment.enroll(self.enrolled_user_1, self.course.id) CourseEnrollment.enroll(self.enrolled_user_2, self.course.id) # Global staff can see the certificates section self.client.login(username=self.global_staff.username, password="******")
def setUp(self): super(CertificateExceptionViewInstructorApiTest, self).setUp() self.global_staff = GlobalStaffFactory() self.instructor = InstructorFactory(course_key=self.course.id) self.user = UserFactory() self.user2 = UserFactory() CourseEnrollment.enroll(self.user, self.course.id) CourseEnrollment.enroll(self.user2, self.course.id) self.url = reverse('certificate_exception_view', kwargs={'course_id': unicode(self.course.id)}) certificate_white_list_item = CertificateWhitelistFactory.create( user=self.user2, course_id=self.course.id, ) self.certificate_exception = dict( created="", notes="Test Notes for Test Certificate Exception", user_email='', user_id='', user_name=unicode(self.user.username) ) self.certificate_exception_in_db = dict( id=certificate_white_list_item.id, user_name=certificate_white_list_item.user.username, notes=certificate_white_list_item.notes, user_email=certificate_white_list_item.user.email, user_id=certificate_white_list_item.user.id, ) # Enable certificate generation cache.clear() CertificateGenerationConfiguration.objects.create(enabled=True) self.client.login(username=self.global_staff.username, password='******')
def setUp(self): super(UserRoleTestCase, self).setUp() self.course_key = CourseLocator('edX', 'toy', '2012_Fall') self.anonymous_user = AnonymousUserFactory() self.student = UserFactory() self.global_staff = UserFactory(is_staff=True) self.course_staff = StaffFactory(course_key=self.course_key) self.course_instructor = InstructorFactory(course_key=self.course_key)
def setUp(self): super(RolesTestCase, self).setUp() self.course_key = CourseKey.from_string('edX/toy/2012_Fall') self.course_loc = self.course_key.make_usage_key('course', '2012_Fall') self.anonymous_user = AnonymousUserFactory() self.student = UserFactory() self.global_staff = UserFactory(is_staff=True) self.course_staff = StaffFactory(course_key=self.course_key) self.course_instructor = InstructorFactory(course_key=self.course_key)
def setUp(self): super(AccessTestCase, self).setUp() course_key = SlashSeparatedCourseKey('edX', 'toy', '2012_Fall') self.course = course_key.make_usage_key('course', course_key.run) self.anonymous_user = AnonymousUserFactory() self.student = UserFactory() self.global_staff = UserFactory(is_staff=True) self.course_staff = StaffFactory(course_key=self.course.course_key) self.course_instructor = InstructorFactory(course_key=self.course.course_key)
def setUp(self): super(AccessTestCase, self).setUp() self.course = CourseFactory.create(org='edX', course='toy', run='test_run') self.anonymous_user = AnonymousUserFactory() self.beta_user = BetaTesterFactory(course_key=self.course.id) self.student = UserFactory() self.global_staff = UserFactory(is_staff=True) self.course_staff = StaffFactory(course_key=self.course.id) self.course_instructor = InstructorFactory(course_key=self.course.id) self.staff = GlobalStaffFactory()
def setUp(self): course_key = SlashSeparatedCourseKey('edX', 'toy', '2012_Fall') self.course = course_key.make_usage_key('course', course_key.run) self.anonymous_user = AnonymousUserFactory() self.student = UserFactory() self.global_staff = UserFactory(is_staff=True) # TODO please change the StaffFactory and InstructorFactory parameters ASAP! self.course_staff = StaffFactory(course=self.course.course_key) self.course_instructor = InstructorFactory( course=self.course.course_key)
def build_course(self): """ Build up a course tree with an html control """ self.global_staff = UserFactory(is_staff=True) self.course = CourseFactory.create( org='Elasticsearch', course='ES101', run='test_run', display_name='Elasticsearch test course', ) self.section = ItemFactory.create( parent=self.course, category='chapter', display_name='Test Section', ) self.subsection = ItemFactory.create( parent=self.section, category='sequential', display_name='Test Subsection', ) self.vertical = ItemFactory.create( parent=self.subsection, category='vertical', display_name='Test Unit', ) self.html = ItemFactory.create( parent=self.vertical, category='html', display_name='Test Html control', )
def test_access_student_progress_ccx(self): """ Assert that only a coach can see progress of student. """ ccx_locator = self.make_ccx() student = UserFactory() # Enroll user CourseEnrollment.enroll(student, ccx_locator) # Test for access of a coach request = self.request_factory.get(reverse('about_course', args=[unicode(ccx_locator)])) request.user = self.coach mako_middleware_process_request(request) resp = views.progress(request, course_id=unicode(ccx_locator), student_id=student.id) self.assertEqual(resp.status_code, 200) # Assert access of a student request = self.request_factory.get(reverse('about_course', args=[unicode(ccx_locator)])) request.user = student mako_middleware_process_request(request) with self.assertRaises(Http404) as context: views.progress(request, course_id=unicode(ccx_locator), student_id=self.coach.id) self.assertIsNotNone(context.exception)
def setUp(self): self.course_key = SlashSeparatedCourseKey('edX', 'toy', '2012_Fall') self.location = self.course_key.make_usage_key('chapter', 'Overview') self.toy_course = modulestore().get_course(self.course_key) self.mock_user = UserFactory() self.mock_user.id = 1 self.request_factory = RequestFactory() # Construct a mock module for the modulestore to return self.mock_module = MagicMock() self.mock_module.id = 1 self.dispatch = 'score_update' # Construct a 'standard' xqueue_callback url self.callback_url = reverse('xqueue_callback', kwargs={ 'course_id': self.course_key.to_deprecated_string(), 'userid': str(self.mock_user.id), 'mod_id': self.mock_module.id, 'dispatch': self.dispatch })
def test_group_name_case_sensitive(self): uppercase_course_id = "ORG/COURSE/NAME" lowercase_course_id = uppercase_course_id.lower() uppercase_course_key = SlashSeparatedCourseKey.from_deprecated_string(uppercase_course_id) lowercase_course_key = SlashSeparatedCourseKey.from_deprecated_string(lowercase_course_id) role = "role" lowercase_user = UserFactory() CourseRole(role, lowercase_course_key).add_users(lowercase_user) uppercase_user = UserFactory() CourseRole(role, uppercase_course_key).add_users(uppercase_user) self.assertTrue(CourseRole(role, lowercase_course_key).has_user(lowercase_user)) self.assertFalse(CourseRole(role, uppercase_course_key).has_user(lowercase_user)) self.assertFalse(CourseRole(role, lowercase_course_key).has_user(uppercase_user)) self.assertTrue(CourseRole(role, uppercase_course_key).has_user(uppercase_user))
def test_entrance_exam_gating(self): """ Unit Test: test_entrance_exam_gating """ # This user helps to cover a discovered bug in the milestone fulfillment logic chaos_user = UserFactory() locked_toc = toc_for_course(self.request, self.course, self.entrance_exam.url_name, self.exam_1.url_name, self.field_data_cache) for toc_section in self.expected_locked_toc: self.assertIn(toc_section, locked_toc) # Set up the chaos user # pylint: disable=maybe-no-member,no-member grade_dict = {'value': 1, 'max_value': 1, 'user_id': chaos_user.id} field_data_cache = FieldDataCache.cache_for_descriptor_descendents( self.course.id, chaos_user, self.course, depth=2) # pylint: disable=protected-access module = get_module( chaos_user, self.request, self.problem_1.scope_ids.usage_id, field_data_cache, )._xmodule module.system.publish(self.problem_1, 'grade', grade_dict) # pylint: disable=maybe-no-member,no-member grade_dict = { 'value': 1, 'max_value': 1, 'user_id': self.request.user.id } field_data_cache = FieldDataCache.cache_for_descriptor_descendents( self.course.id, self.request.user, self.course, depth=2) # pylint: disable=protected-access module = get_module( self.request.user, self.request, self.problem_1.scope_ids.usage_id, field_data_cache, )._xmodule module.system.publish(self.problem_1, 'grade', grade_dict) module = get_module( self.request.user, self.request, self.problem_2.scope_ids.usage_id, field_data_cache, )._xmodule # pylint: disable=protected-access module.system.publish(self.problem_2, 'grade', grade_dict) unlocked_toc = toc_for_course(self.request, self.course, self.entrance_exam.url_name, self.exam_1.url_name, self.field_data_cache) for toc_section in self.expected_unlocked_toc: self.assertIn(toc_section, unlocked_toc)
def setUp(self): super(OpenEndedStatsTest, self).setUp() self.user = UserFactory() store = modulestore() course_items = import_from_xml(store, self.user.id, TEST_DATA_DIR, ['open_ended']) # pylint: disable=maybe-no-member self.course = course_items[0] self.course_id = self.course.id self.problem_location = Location("edX", "open_ended", "2012_Fall", "combinedopenended", "SampleQuestion") self.task_number = 1 self.invalid_task_number = 3 self.student_on_initial = UserFactory() self.student_on_accessing = UserFactory() self.student_on_post_assessment = UserFactory() StudentModuleFactory.create( course_id=self.course_id, module_state_key=self.problem_location, student=self.student_on_initial, grade=0, max_grade=1, state=STATE_INITIAL ) StudentModuleFactory.create( course_id=self.course_id, module_state_key=self.problem_location, student=self.student_on_accessing, grade=0, max_grade=1, state=STATE_ACCESSING ) StudentModuleFactory.create( course_id=self.course_id, module_state_key=self.problem_location, student=self.student_on_post_assessment, grade=0, max_grade=1, state=STATE_POST_ASSESSMENT ) self.students = [self.student_on_initial, self.student_on_accessing, self.student_on_post_assessment]
def setUp(self): """ Set up the course and user context """ super(TestEventPublishing, self).setUp() self.mock_user = UserFactory() self.mock_user.id = 1 self.request_factory = RequestFactory()
def test_group_name_case_insensitive(self): uppercase_loc = "i4x://ORG/COURSE/course/NAME" lowercase_loc = uppercase_loc.lower() lowercase_group = "role_org/course/name" uppercase_group = lowercase_group.upper() lowercase_user = UserFactory(groups=lowercase_group) uppercase_user = UserFactory(groups=uppercase_group) self.assertTrue( CourseRole("role", lowercase_loc).has_user(lowercase_user)) self.assertTrue( CourseRole("role", uppercase_loc).has_user(lowercase_user)) self.assertTrue( CourseRole("role", lowercase_loc).has_user(uppercase_user)) self.assertTrue( CourseRole("role", uppercase_loc).has_user(uppercase_user))
def setUp(self): super(CertificatesInstructorApiTest, self).setUp() self.global_staff = GlobalStaffFactory() self.instructor = InstructorFactory(course_key=self.course.id) self.user = UserFactory() CourseEnrollment.enroll(self.user, self.course.id) # Enable certificate generation cache.clear() CertificateGenerationConfiguration.objects.create(enabled=True)
def test_show_enrollment_data_for_prof_ed(self): # Create both "professional" (meaning professional + verification) # and "no-id-professional" (meaning professional without verification) # These should be aggregated for display purposes. users = [UserFactory() for _ in range(2)] CourseEnrollment.enroll(users[0], self.course.id, mode="professional") CourseEnrollment.enroll(users[1], self.course.id, mode="no-id-professional") response = self.client.get(self.url) # Check that the number of professional enrollments is two self.assertContains(response, '<th scope="row">Professional</th><td>2</td>')
def setup_modulestore(self, default_ms, num_finds, num_sends): self.course_key = self.create_toy_course() self.chapter = 'Overview' chapter_url = '%s/%s/%s' % ('/courses', self.course_key, self.chapter) factory = RequestFactory() self.request = factory.get(chapter_url) self.request.user = UserFactory() self.modulestore = self.store._get_modulestore_for_courseid(self.course_key) with check_mongo_calls(self.modulestore, num_finds, num_sends): self.toy_course = self.store.get_course(self.toy_loc, depth=2) self.field_data_cache = FieldDataCache.cache_for_descriptor_descendents( self.toy_loc, self.request.user, self.toy_course, depth=2)
def setUp(self): """ Add a user and a course """ super(TestUsersDefaultRole, self).setUp() # create and log in a staff user. self.user = UserFactory(is_staff=True) self.client = AjaxEnabledTestClient() self.client.login(username=self.user.username, password='******') # create a course via the view handler to create course self.course_key = self.store.make_course_key('Org_1', 'Course_1', 'Run_1') self._create_course_with_given_location(self.course_key)
def setUp(self): """ Add a user and a course """ super(TestUsersDefaultRole, self).setUp() # create and log in a staff user. self.user = UserFactory(is_staff=True) # pylint: disable=no-member self.client = AjaxEnabledTestClient() self.client.login(username=self.user.username, password='******') # create a course via the view handler to create course self.course_location = Location(['i4x', 'Org_1', 'Course_1', 'course', 'Run_1']) self._create_course_with_given_location(self.course_location)
def setUp(self): super(CertificateInvalidationViewTests, self).setUp() self.global_staff = GlobalStaffFactory() self.enrolled_user_1 = UserFactory( username='******', email='*****@*****.**', first_name='Enrolled', last_name='Student', ) self.enrolled_user_2 = UserFactory( username='******', email='*****@*****.**', first_name='Enrolled', last_name='Student', ) self.not_enrolled_student = UserFactory( username='******', email='*****@*****.**', first_name='NotEnrolled', last_name='Student', ) CourseEnrollment.enroll(self.enrolled_user_1, self.course.id) CourseEnrollment.enroll(self.enrolled_user_2, self.course.id) self.generated_certificate = GeneratedCertificateFactory.create( user=self.enrolled_user_1, course_id=self.course.id, status=CertificateStatuses.downloadable, mode='honor', ) self.certificate_invalidation_data = dict( user=self.enrolled_user_1.username, notes=self.notes, ) # Global staff can see the certificates section self.client.login(username=self.global_staff.username, password="******")
def test_rebind_noauth_module_to_user_not_anonymous(self): """ Tests that an exception is thrown when rebind_noauth_module_to_user is run from a module bound to a real user """ module = self.get_module_for_user(self.user) user2 = UserFactory() user2.id = 2 with self.assertRaisesRegexp( render.LmsModuleRenderError, "rebind_noauth_module_to_user can only be called from a module bound to an anonymous user" ): self.assertTrue(module.system.rebind_noauth_module_to_user(module, user2))
def test_rebind_noauth_module_to_user_anonymous(self): """ Tests that get_user_module_for_noauth succeeds when rebind_noauth_module_to_user is run from a module bound to AnonymousUser """ module = self.get_module_for_user(self.anon_user) user2 = UserFactory() user2.id = 2 module.system.rebind_noauth_module_to_user(module, user2) self.assertTrue(module) self.assertEqual(module.system.anonymous_student_id, anonymous_id_for_user(user2, self.course.id)) self.assertEqual(module.scope_ids.user_id, user2.id) self.assertEqual(module.descriptor.scope_ids.user_id, user2.id)
def setUp(self): self.course_id = SlashSeparatedCourseKey("edX", "open_ended", "2012_Fall") self.problem_location = Location("edX", "open_ended", "2012_Fall", "combinedopenended", "SampleQuestion") self.task_number = 1 self.invalid_task_number = 3 self.student_on_initial = UserFactory() self.student_on_accessing = UserFactory() self.student_on_post_assessment = UserFactory() StudentModuleFactory.create( course_id=self.course_id, module_state_key=self.problem_location, student=self.student_on_initial, grade=0, max_grade=1, state=STATE_INITIAL ) StudentModuleFactory.create( course_id=self.course_id, module_state_key=self.problem_location, student=self.student_on_accessing, grade=0, max_grade=1, state=STATE_ACCESSING ) StudentModuleFactory.create( course_id=self.course_id, module_state_key=self.problem_location, student=self.student_on_post_assessment, grade=0, max_grade=1, state=STATE_POST_ASSESSMENT ) self.students = [self.student_on_initial, self.student_on_accessing, self.student_on_post_assessment]
def setUp(self): super(CertificatesInstructorApiTest, self).setUp() self.global_staff = GlobalStaffFactory() self.instructor = InstructorFactory(course_key=self.course.id) self.user = UserFactory() # Enable certificate generation self.certificate_exception_data = [ dict(created="Wednesday, October 28, 2015", notes="Test Notes for Test Certificate Exception", user_email='', user_id='', user_name=unicode(self.user.username)), ] cache.clear() CertificateGenerationConfiguration.objects.create(enabled=True)
def test_access_student_progress_ccx(self): """ Assert that only a coach can see progress of student. """ ccx_locator = self.make_ccx() student = UserFactory() # Enroll user CourseEnrollment.enroll(student, ccx_locator) # Test for access of a coach resp = self.client.get(reverse('student_progress', args=[unicode(ccx_locator), student.id])) self.assertEqual(resp.status_code, 200) # Assert access of a student self.client.login(username=student.username, password='******') resp = self.client.get(reverse('student_progress', args=[unicode(ccx_locator), self.coach.id])) self.assertEqual(resp.status_code, 404)
def setUp(self): self.location = Location('i4x', 'edX', 'toy', 'chapter', 'Overview') self.course_id = 'edX/toy/2012_Fall' self.toy_course = modulestore().get_course(self.course_id) self.mock_user = UserFactory() self.mock_user.id = 1 self.request_factory = RequestFactory() # Construct a mock module for the modulestore to return self.mock_module = MagicMock() self.mock_module.id = 1 self.dispatch = 'score_update' # Construct a 'standard' xqueue_callback url self.callback_url = reverse('xqueue_callback', kwargs=dict(course_id=self.course_id, userid=str(self.mock_user.id), mod_id=self.mock_module.id, dispatch=self.dispatch))