Example #1
0
    def setUp(self):
        """
        Fixtures.
        """
        due = datetime.datetime(2010, 5, 12, 2, 42, tzinfo=utc)
        course = CourseFactory.create()
        week1 = ItemFactory.create(due=due, parent=course)
        week2 = ItemFactory.create(due=due, parent=course)
        week3 = ItemFactory.create(due=due, parent=course)

        homework = ItemFactory.create(parent=week1, due=due)

        user1 = UserFactory.create()
        StudentModule(state="{}", student_id=user1.id, course_id=course.id, module_state_key=week1.location).save()
        StudentModule(state="{}", student_id=user1.id, course_id=course.id, module_state_key=week2.location).save()
        StudentModule(state="{}", student_id=user1.id, course_id=course.id, module_state_key=week3.location).save()
        StudentModule(state="{}", student_id=user1.id, course_id=course.id, module_state_key=homework.location).save()

        user2 = UserFactory.create()
        StudentModule(state="{}", student_id=user2.id, course_id=course.id, module_state_key=week1.location).save()
        StudentModule(state="{}", student_id=user2.id, course_id=course.id, module_state_key=homework.location).save()

        user3 = UserFactory.create()
        StudentModule(state="{}", student_id=user3.id, course_id=course.id, module_state_key=week1.location).save()
        StudentModule(state="{}", student_id=user3.id, course_id=course.id, module_state_key=homework.location).save()

        self.course = course
        self.week1 = week1
        self.homework = homework
        self.week2 = week2
        self.user1 = user1
        self.user2 = user2
    def test_expiry_date_range(self):
        """
        Test that the verifications are filtered on the given range. Email is not sent for any verification with
        expiry date out of range
        """
        user = UserFactory.create()
        verification_in_range = self.create_and_submit(user)
        verification_in_range.status = 'approved'
        verification_in_range.expiry_date = now() - timedelta(days=1)
        verification_in_range.save()

        user = UserFactory.create()
        verification = self.create_and_submit(user)
        verification.status = 'approved'
        verification.expiry_date = now() - timedelta(days=5)
        verification.save()

        call_command('send_verification_expiry_email', '--days-range=2')

        # Check that only one email is sent
        self.assertEqual(len(mail.outbox), 1)

        # Verify that the email is not sent to the out of range verification
        expiry_email_date = SoftwareSecurePhotoVerification.objects.get(pk=verification.pk).expiry_email_date
        self.assertIsNone(expiry_email_date)
Example #3
0
 def setUp(self):
     self.course = CourseFactory.create()
     seed_permissions_roles(self.course.id)
     self.student = UserFactory.create()
     self.enrollment = CourseEnrollmentFactory(user=self.student, course_id=self.course.id)
     self.other_user = UserFactory.create(username="******")
     CourseEnrollmentFactory(user=self.other_user, course_id=self.course.id)
    def test_user_details_force_sync_username_conflict(self):
        """
        The user details were attempted to be synced but the incoming username already exists for another account.

        An email should still be sent in this case.
        """
        # Create a user with an email that conflicts with the incoming value.
        UserFactory.create(username='******'.format(self.old_username))

        # Begin the pipeline.
        pipeline.user_details_force_sync(
            auth_entry=pipeline.AUTH_ENTRY_LOGIN,
            strategy=self.strategy,
            details=self.details,
            user=self.user,
        )

        # The username is not changed, but everything else is.
        user = User.objects.get(pk=self.user.pk)
        assert user.email == 'new+{}'.format(self.old_email)
        assert user.username == self.old_username
        assert user.profile.name == 'Grown Up {}'.format(self.old_fullname)
        assert user.profile.country == 'PK'

        # An email should still be sent because the email changed.
        assert len(mail.outbox) == 1
    def test_transfer_students(self):
        student = UserFactory()
        student.set_password(self.PASSWORD)  # pylint: disable=E1101
        student.save()   # pylint: disable=E1101

        # Original Course
        original_course_location = locator.CourseLocator('Org0', 'Course0', 'Run0')
        course = self._create_course(original_course_location)
        # Enroll the student in 'verified'
        CourseEnrollment.enroll(student, course.id, mode="verified")

        # New Course 1
        course_location_one = locator.CourseLocator('Org1', 'Course1', 'Run1')
        new_course_one = self._create_course(course_location_one)

        # New Course 2
        course_location_two = locator.CourseLocator('Org2', 'Course2', 'Run2')
        new_course_two = self._create_course(course_location_two)
        original_key = unicode(course.id)
        new_key_one = unicode(new_course_one.id)
        new_key_two = unicode(new_course_two.id)

        # Run the actual management command
        transfer_students.Command().handle(
            source_course=original_key, dest_course_list=new_key_one + "," + new_key_two
        )

        # Confirm the enrollment mode is verified on the new courses, and enrollment is enabled as appropriate.
        self.assertEquals(('verified', False), CourseEnrollment.enrollment_mode_for_user(student, course.id))
        self.assertEquals(('verified', True), CourseEnrollment.enrollment_mode_for_user(student, new_course_one.id))
        self.assertEquals(('verified', True), CourseEnrollment.enrollment_mode_for_user(student, new_course_two.id))
Example #6
0
    def setUp(self):
        super(CohortedContentTestCase, self).setUp()

        self.course = CourseFactory.create(
            discussion_topics={
                "cohorted topic": {"id": "cohorted_topic"},
                "non-cohorted topic": {"id": "non_cohorted_topic"},
            },
            cohort_config={
                "cohorted": True,
                "cohorted_discussions": ["cohorted_topic"]
            }
        )
        self.student_cohort = CourseUserGroup.objects.create(
            name="student_cohort",
            course_id=self.course.id,
            group_type=CourseUserGroup.COHORT
        )
        self.moderator_cohort = CourseUserGroup.objects.create(
            name="moderator_cohort",
            course_id=self.course.id,
            group_type=CourseUserGroup.COHORT
        )

        seed_permissions_roles(self.course.id)
        self.student = UserFactory.create()
        self.moderator = UserFactory.create()
        CourseEnrollmentFactory(user=self.student, course_id=self.course.id)
        CourseEnrollmentFactory(user=self.moderator, course_id=self.course.id)
        self.moderator.roles.add(Role.objects.get(name="Moderator", course_id=self.course.id))
        self.student_cohort.users.add(self.student)
        self.moderator_cohort.users.add(self.moderator)
Example #7
0
    def test_enrolled_students_features_keys_cohorted(self):
        course = CourseFactory.create(org="test", course="course1", display_name="run1")
        course.cohort_config = {'cohorted': True, 'auto_cohort': True, 'auto_cohort_groups': ['cohort']}
        self.store.update_item(course, self.instructor.id)
        cohorted_students = [UserFactory.create() for _ in xrange(10)]
        cohort = CohortFactory.create(name='cohort', course_id=course.id, users=cohorted_students)
        cohorted_usernames = [student.username for student in cohorted_students]
        non_cohorted_student = UserFactory.create()
        for student in cohorted_students:
            cohort.users.add(student)
            CourseEnrollment.enroll(student, course.id)
        CourseEnrollment.enroll(non_cohorted_student, course.id)
        instructor = InstructorFactory(course_key=course.id)
        self.client.login(username=instructor.username, password='******')

        query_features = ('username', 'cohort')
        # There should be a constant of 2 SQL queries when calling
        # enrolled_students_features.  The first query comes from the call to
        # User.objects.filter(...), and the second comes from
        # prefetch_related('course_groups').
        with self.assertNumQueries(2):
            userreports = enrolled_students_features(course.id, query_features)
        self.assertEqual(len([r for r in userreports if r['username'] in cohorted_usernames]), len(cohorted_students))
        self.assertEqual(len([r for r in userreports if r['username'] == non_cohorted_student.username]), 1)
        for report in userreports:
            self.assertEqual(set(report.keys()), set(query_features))
            if report['username'] in cohorted_usernames:
                self.assertEqual(report['cohort'], cohort.name)
            else:
                self.assertEqual(report['cohort'], '[unassigned]')
Example #8
0
 def setUp(self):
     """Create a user with a team to test signals."""
     super(TeamSignalsTest, self).setUp("teams.utils.tracker")
     self.user = UserFactory.create(username="******")
     self.moderator = UserFactory.create(username="******")
     self.team = CourseTeamFactory(discussion_topic_id=self.DISCUSSION_TOPIC_ID)
     self.team_membership = CourseTeamMembershipFactory(user=self.user, team=self.team)
    def test_resolve_course_enrollments(self):
        """
        Test that the CourseEnrollmentsScopeResolver actually returns all enrollments
        """

        test_user_1 = UserFactory.create(password='******')
        CourseEnrollmentFactory(user=test_user_1, course_id=self.course.id)
        test_user_2 = UserFactory.create(password='******')
        CourseEnrollmentFactory(user=test_user_2, course_id=self.course.id)
        test_user_3 = UserFactory.create(password='******')
        enrollment = CourseEnrollmentFactory(user=test_user_3, course_id=self.course.id)

        # unenroll #3

        enrollment.is_active = False
        enrollment.save()

        resolver = CourseEnrollmentsScopeResolver()

        user_ids = resolver.resolve('course_enrollments', {'course_id': self.course.id}, None)

        # should have first two, but the third should not be present

        self.assertTrue(test_user_1.id in user_ids)
        self.assertTrue(test_user_2.id in user_ids)

        self.assertFalse(test_user_3.id in user_ids)
Example #10
0
    def setUp(self):
        super(TestBlockListGetForm, self).setUp()

        self.student = UserFactory.create()
        self.student2 = UserFactory.create()
        self.staff = UserFactory.create(is_staff=True)

        CourseEnrollmentFactory.create(user=self.student, course_id=self.course.id)
        CourseEnrollmentFactory.create(user=self.student2, course_id=self.course.id)

        usage_key = self.course.location
        self.initial = {'requesting_user': self.student}
        self.form_data = QueryDict(
            urlencode({
                'username': self.student.username,
                'usage_key': unicode(usage_key),
            }),
            mutable=True,
        )
        self.cleaned_data = {
            'all_blocks': None,
            'block_counts': set(),
            'depth': 0,
            'nav_depth': None,
            'return_type': 'dict',
            'requested_fields': {'display_name', 'type'},
            'student_view_data': set(),
            'usage_key': usage_key,
            'username': self.student.username,
            'user': self.student,
        }
Example #11
0
def setup_students_and_grades(context):
    """
    Create students and set their grades.
    :param context:  class reference
    """
    if context.course:
        context.student = student = UserFactory.create()
        CourseEnrollmentFactory.create(user=student, course_id=context.course.id)

        context.student2 = student2 = UserFactory.create()
        CourseEnrollmentFactory.create(user=student2, course_id=context.course.id)

        # create grades for self.student as if they'd submitted the ccx
        for chapter in context.course.get_children():
            for i, section in enumerate(chapter.get_children()):
                for j, problem in enumerate(section.get_children()):
                    # if not problem.visible_to_staff_only:
                    StudentModuleFactory.create(
                        grade=1 if i < j else 0,
                        max_grade=1,
                        student=context.student,
                        course_id=context.course.id,
                        module_state_key=problem.location
                    )

                    StudentModuleFactory.create(
                        grade=1 if i > j else 0,
                        max_grade=1,
                        student=context.student2,
                        course_id=context.course.id,
                        module_state_key=problem.location
                    )
Example #12
0
    def setUp(self):
        super(UserStandingTest, self).setUp()
        # create users
        self.bad_user = UserFactory.create(username="******")
        self.good_user = UserFactory.create(username="******")
        self.non_staff = UserFactory.create(username="******")
        self.admin = UserFactory.create(username="******", is_staff=True)

        # create clients
        self.bad_user_client = Client()
        self.good_user_client = Client()
        self.non_staff_client = Client()
        self.admin_client = Client()

        for user, client in [
            (self.bad_user, self.bad_user_client),
            (self.good_user, self.good_user_client),
            (self.non_staff, self.non_staff_client),
            (self.admin, self.admin_client),
        ]:
            client.login(username=user.username, password="******")

        UserStandingFactory.create(
            user=self.bad_user, account_status=UserStanding.ACCOUNT_DISABLED, changed_by=self.admin
        )

        # set stock url to test disabled accounts' access to site
        self.some_url = "/"
Example #13
0
 def setUp(self):
     """ Create a course and user, then log in. """
     super(EnrollmentTest, self).setUp()
     self.course = CourseFactory.create()
     self.user = UserFactory.create(username=self.USERNAME, email=self.EMAIL, password=self.PASSWORD)
     self.other_user = UserFactory.create()
     self.client.login(username=self.USERNAME, password=self.PASSWORD)
Example #14
0
    def test_enrollment_email_on(self):
        """
        Do email on enroll test
        """

        course = self.course

        #Create activated, but not enrolled, user
        UserFactory.create(username="******", email="*****@*****.**")

        url = reverse('instructor_dashboard', kwargs={'course_id': course.id})
        response = self.client.post(url, {'action': 'Enroll multiple students', 'multiple_students': '[email protected], [email protected], [email protected]', 'auto_enroll': 'on', 'email_students': 'on'})

        #Check the page output
        self.assertContains(response, '<td>[email protected]</td>')
        self.assertContains(response, '<td>[email protected]</td>')
        self.assertContains(response, '<td>[email protected]</td>')
        self.assertContains(response, '<td>added, email sent</td>')
        self.assertContains(response, '<td>user does not exist, enrollment allowed, pending with auto enrollment on, email sent</td>')

        #Check the outbox
        self.assertEqual(len(mail.outbox), 3)
        self.assertEqual(mail.outbox[0].subject, 'You have been enrolled in MITx/999/Robot_Super_Course')

        self.assertEqual(mail.outbox[1].subject, 'You have been invited to register for MITx/999/Robot_Super_Course')
        self.assertEqual(mail.outbox[1].body, "Dear student,\n\nYou have been invited to join MITx/999/Robot_Super_Course at edx.org by a member of the course staff.\n\n" +
                                              "To finish your registration, please visit https://edx.org/register and fill out the registration form.\n" +
                                              "Once you have registered and activated your account, you will see MITx/999/Robot_Super_Course listed on your dashboard.\n\n" +
                                              "----\nThis email was automatically sent from edx.org to [email protected]")
Example #15
0
 def test_duplicate_email(self):
     """
     Assert the expected error message from the email validation method for an email address
     that is already in use by another account.
     """
     UserFactory.create(email=self.new_email)
     self.assertEqual(self.do_email_validation(self.new_email), 'An account with this e-mail already exists.')
Example #16
0
 def setUp(self):
     super(ExternalAuthShibTest, self).setUp()
     self.course = CourseFactory.create(
         org='Stanford',
         number='456',
         display_name='NO SHIB',
         user_id=self.user.id,
     )
     self.shib_course = CourseFactory.create(
         org='Stanford',
         number='123',
         display_name='Shib Only',
         enrollment_domain='shib:https://idp.stanford.edu/',
         user_id=self.user.id,
     )
     self.user_w_map = UserFactory.create(email='*****@*****.**')
     self.extauth = ExternalAuthMap(external_id='*****@*****.**',
                                    external_email='*****@*****.**',
                                    external_domain='shib:https://idp.stanford.edu/',
                                    external_credentials="",
                                    user=self.user_w_map)
     self.user_w_map.save()
     self.extauth.save()
     self.user_wo_map = UserFactory.create(email='*****@*****.**')
     self.user_wo_map.save()
Example #17
0
    def setUp(self):
        super(RefundTests, self).setUp()

        self.course = CourseFactory.create(
            org='testorg', number='run1', display_name='refundable course'
        )
        self.course_id = self.course.location.course_key
        self.client = Client()
        self.admin = UserFactory.create(
            username='******',
            email='*****@*****.**',
            password='******'
        )
        SupportStaffRole().add_users(self.admin)
        self.client.login(username=self.admin.username, password='******')

        self.student = UserFactory.create(
            username='******',
            email='*****@*****.**'
        )
        self.course_mode = CourseMode.objects.get_or_create(
            course_id=self.course_id,
            mode_slug='verified',
            min_price=1
        )[0]

        self.order = None
        self.form_pars = {'course_id': str(self.course_id), 'user': self.student.email}
Example #18
0
    def setUp(self):
        """ Create users for use in the tests """
        super(TpaAPITestCase, self).setUp()

        google = self.configure_google_provider(enabled=True)
        self.configure_facebook_provider(enabled=True)
        self.configure_linkedin_provider(enabled=False)
        self.enable_saml()
        testshib = self.configure_saml_provider(name='TestShib', enabled=True, idp_slug=IDP_SLUG_TESTSHIB)

        # Create several users and link each user to Google and TestShib
        for username in LINKED_USERS:
            make_superuser = (username == ADMIN_USERNAME)
            make_staff = (username == STAFF_USERNAME) or make_superuser
            user = UserFactory.create(
                username=username,
                password=PASSWORD,
                is_staff=make_staff,
                is_superuser=make_superuser
            )
            UserSocialAuth.objects.create(
                user=user,
                provider=google.backend_name,
                uid='{}@gmail.com'.format(username),
            )
            UserSocialAuth.objects.create(
                user=user,
                provider=testshib.backend_name,
                uid='{}:remote_{}'.format(testshib.idp_slug, username),
            )
        # Create another user not linked to any providers:
        UserFactory.create(username=CARL_USERNAME, password=PASSWORD)
Example #19
0
    def test_site_config(self, this_org_list, other_org_list, expected_message_count, mock_ace):
        filtered_org = 'filtered_org'
        unfiltered_org = 'unfiltered_org'
        this_config = SiteConfigurationFactory.create(values={'course_org_filter': this_org_list})
        other_config = SiteConfigurationFactory.create(values={'course_org_filter': other_org_list})

        for config in (this_config, other_config):
            ScheduleConfigFactory.create(site=config.site)

        user1 = UserFactory.create(id=self.task.num_bins)
        user2 = UserFactory.create(id=self.task.num_bins * 2)
        current_day, offset, target_day, upgrade_deadline = self._get_dates()

        self._schedule_factory(
            enrollment__course__org=filtered_org,
            enrollment__user=user1,
        )
        self._schedule_factory(
            enrollment__course__org=unfiltered_org,
            enrollment__user=user1,
        )
        self._schedule_factory(
            enrollment__course__org=unfiltered_org,
            enrollment__user=user2,
        )

        with patch.object(self.task, 'async_send_task') as mock_schedule_send:
            self.task().apply(kwargs=dict(
                site_id=this_config.site.id, target_day_str=serialize(target_day), day_offset=offset, bin_num=0
            ))

        self.assertEqual(mock_schedule_send.apply_async.call_count, expected_message_count)
        self.assertFalse(mock_ace.send.called)
Example #20
0
    def setUp(self):
        super(TeamAPITestCase, self).setUp()
        self.topics_count = 4
        self.users = {
            "student_unenrolled": UserFactory.create(password=self.test_password),
            "student_enrolled": UserFactory.create(password=self.test_password),
            "student_enrolled_not_on_team": UserFactory.create(password=self.test_password),
            # This student is enrolled in both test courses and is a member of a team in each course, but is not on the
            # same team as student_enrolled.
            "student_enrolled_both_courses_other_team": UserFactory.create(password=self.test_password),
            "staff": AdminFactory.create(password=self.test_password),
            "course_staff": StaffFactory.create(course_key=self.test_course_1.id, password=self.test_password),
        }
        # 'solar team' is intentionally lower case to test case insensitivity in name ordering
        self.test_team_1 = CourseTeamFactory.create(
            name=u"sólar team", course_id=self.test_course_1.id, topic_id="topic_0"
        )
        self.test_team_2 = CourseTeamFactory.create(name="Wind Team", course_id=self.test_course_1.id)
        self.test_team_3 = CourseTeamFactory.create(name="Nuclear Team", course_id=self.test_course_1.id)
        self.test_team_4 = CourseTeamFactory.create(name="Coal Team", course_id=self.test_course_1.id, is_active=False)
        self.test_team_5 = CourseTeamFactory.create(name="Another Team", course_id=self.test_course_2.id)

        for user, course in [
            ("student_enrolled", self.test_course_1),
            ("student_enrolled_not_on_team", self.test_course_1),
            ("student_enrolled_both_courses_other_team", self.test_course_1),
            ("student_enrolled_both_courses_other_team", self.test_course_2),
        ]:
            CourseEnrollment.enroll(self.users[user], course.id, check_access=True)

        self.test_team_1.add_user(self.users["student_enrolled"])
        self.test_team_3.add_user(self.users["student_enrolled_both_courses_other_team"])
        self.test_team_5.add_user(self.users["student_enrolled_both_courses_other_team"])
Example #21
0
 def setUp(self):
     super(DiscussionTabTestCase, self).setUp()
     self.course = CourseFactory.create()
     self.enrolled_user = UserFactory.create()
     self.staff_user = AdminFactory.create()
     CourseEnrollmentFactory.create(user=self.enrolled_user, course_id=self.course.id)
     self.unenrolled_user = UserFactory.create()
Example #22
0
    def setUp(self):
        """ Create a course and user, then log in. """
        super(EnrollmentTest, self).setUp()

        self.rate_limit_config = RateLimitConfiguration.current()
        self.rate_limit_config.enabled = False
        self.rate_limit_config.save()

        throttle = EnrollmentUserThrottle()
        self.rate_limit, __ = throttle.parse_rate(throttle.rate)

        # Pass emit_signals when creating the course so it would be cached
        # as a CourseOverview.
        self.course = CourseFactory.create(emit_signals=True)

        self.user = UserFactory.create(
            username=self.USERNAME,
            email=self.EMAIL,
            password=self.PASSWORD,
        )
        self.other_user = UserFactory.create(
            username=self.OTHER_USERNAME,
            email=self.OTHER_EMAIL,
            password=self.PASSWORD,
        )
        self.client.login(username=self.USERNAME, password=self.PASSWORD)
Example #23
0
    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)
Example #24
0
 def create_mock_user(self, is_staff=True, is_enrolled=True):
     """
     Creates a mock user with the specified properties.
     """
     user = UserFactory(is_staff=is_staff)
     user.is_enrolled = is_enrolled
     return user
Example #25
0
    def setUp(self):
        super(CertificatesRestApiTest, self).setUp()

        self.student = UserFactory.create(password=USER_PASSWORD)
        self.student_no_cert = UserFactory.create(password=USER_PASSWORD)
        self.staff_user = UserFactory.create(password=USER_PASSWORD, is_staff=True)

        GeneratedCertificateFactory.create(
            user=self.student,
            course_id=self.course.id,
            status=CertificateStatuses.downloadable,
            mode='verified',
            download_url='www.google.com',
            grade="0.88"
        )

        self.namespaced_url = 'certificates_api:v0:certificates:detail'

        # create a configuration for django-oauth-toolkit (DOT)
        dot_app_user = UserFactory.create(password=USER_PASSWORD)
        dot_app = dot_models.Application.objects.create(
            name='test app',
            user=dot_app_user,
            client_type='confidential',
            authorization_grant_type='authorization-code',
            redirect_uris='http://localhost:8079/complete/edxorg/'
        )
        self.dot_access_token = dot_models.AccessToken.objects.create(
            user=self.student,
            application=dot_app,
            expires=datetime.utcnow() + timedelta(weeks=1),
            scope='read write',
            token='16MGyP3OaQYHmpT1lK7Q6MMNAZsjwF'
        )
Example #26
0
 def setUpTestData(cls):
     UserFactory.create(
         username='******',
         email='*****@*****.**',
         password='******',
     )
     super(TestEnterpriseApi, cls).setUpTestData()
Example #27
0
    def test_course_bulk_notification_tests(self):
        # create new users and enroll them in the course.
        startup.startup_notification_subsystem()

        test_user_1 = UserFactory.create(password='******')
        CourseEnrollmentFactory(user=test_user_1, course_id=self.course.id)
        test_user_2 = UserFactory.create(password='******')
        CourseEnrollmentFactory(user=test_user_2, course_id=self.course.id)

        notification_type = get_notification_type(u'open-edx.studio.announcements.new-announcement')
        course = modulestore().get_course(self.course.id, depth=0)
        notification_msg = NotificationMessage(
            msg_type=notification_type,
            namespace=unicode(self.course.id),
            payload={
                '_schema_version': '1',
                'course_name': course.display_name,

            }
        )
        # Send the notification_msg to the Celery task
        publish_course_notifications_task.delay(self.course.id, notification_msg)

        # now the enrolled users should get notification about the
        # course update where they are enrolled as student.
        self.assertTrue(get_notifications_count_for_user(test_user_1.id), 1)
        self.assertTrue(get_notifications_count_for_user(test_user_2.id), 1)
    def setUp(self):
        # create users
        self.bad_user = UserFactory.create(username="******")
        self.good_user = UserFactory.create(username="******")
        self.non_staff = UserFactory.create(username="******")
        self.admin = UserFactory.create(username="******", is_staff=True)

        # create clients
        self.bad_user_client = Client()
        self.good_user_client = Client()
        self.non_staff_client = Client()
        self.admin_client = Client()

        for user, client in [
            (self.bad_user, self.bad_user_client),
            (self.good_user, self.good_user_client),
            (self.non_staff, self.non_staff_client),
            (self.admin, self.admin_client),
        ]:
            client.login(username=user.username, password="******")

        UserStandingFactory.create(
            user=self.bad_user, account_status=UserStanding.ACCOUNT_DISABLED, changed_by=self.admin
        )

        # set different stock urls for lms and cms
        # to test disabled accounts' access to site
        try:
            self.some_url = reverse("dashboard")
        except NoReverseMatch:
            self.some_url = "/course"
    def setUp(self):
        """Set up data for the test case"""
        super(SubmitFeedbackTest, self).setUp()
        self._request_factory = RequestFactory()
        self._anon_user = AnonymousUser()
        self._auth_user = UserFactory.create(
            email="*****@*****.**",
            username="******",
            profile__name="Test User"
        )
        self._anon_fields = {
            "email": "*****@*****.**",
            "name": "Test User",
            "subject": "a subject",
            "details": "some details",
            "issue_type": "test_issue"
        }
        # This does not contain issue_type nor course_id to ensure that they are optional
        self._auth_fields = {"subject": "a subject", "details": "some details"}

        # Create a service user, because the track selection page depends on it
        UserFactory.create(
            username='******',
            email="*****@*****.**",
            password="******",
        )
Example #30
0
    def setUp(self):
        """
        Fixtures.
        """
        super(TestDataDumps, self).setUp()

        due = datetime.datetime(2010, 5, 12, 2, 42, tzinfo=UTC)
        course = CourseFactory.create()
        week1 = ItemFactory.create(due=due, parent=course)
        week2 = ItemFactory.create(due=due, parent=course)

        homework = ItemFactory.create(
            parent=week1,
            due=due
        )

        user1 = UserFactory.create()
        user2 = UserFactory.create()
        self.course = course
        self.week1 = week1
        self.homework = homework
        self.week2 = week2
        self.user1 = user1
        self.user2 = user2
        signals.extract_dates(None, course.id)
Example #31
0
 def setUp(self):
     self.user = UserFactory(username="******", email="*****@*****.**")
     self.user.profile.name = "Test Tester"
     self.anon_user = AnonymousUserFactory()
Example #32
0
 def test_allow_twice(self):
     user = UserFactory.create()
     update_forum_role(self.course.id, user, FORUM_ROLE_MODERATOR, 'allow')
     self.assertIn(user, self.mod_role.users.all())
     update_forum_role(self.course.id, user, FORUM_ROLE_MODERATOR, 'allow')
     self.assertIn(user, self.mod_role.users.all())
Example #33
0
 def test_revoke_badrolename(self):
     user = UserFactory()
     revoke_access(self.course, user, 'robot-not-a-level')
Example #34
0
 def setUp(self):
     super(ComputeGradesForCourseTest, self).setUp()
     self.users = [UserFactory.create() for _ in xrange(12)]
     self.set_up_course()
     for user in self.users:
         CourseEnrollment.enroll(user, self.course.id)
Example #35
0
 def setUp(self):
     super(RecalculateSubsectionGradeTest, self).setUp()
     self.user = UserFactory()
     PersistentGradesEnabledFlag.objects.create(
         enabled_for_all_courses=True, enabled=True)
 def setUpTestData(cls):
     """Set up and enroll our fake user in the course."""
     cls.user = UserFactory(password=TEST_PASSWORD)
     CourseEnrollment.enroll(cls.user, cls.course.id)
    def setUp(self):
        super(InstructorTaskTestCase, self).setUp()

        self.student = UserFactory.create(username="******", email="*****@*****.**")
        self.instructor = UserFactory.create(username="******", email="*****@*****.**")
        self.problem_url = InstructorTaskTestCase.problem_location("test_urlname")
 def setUp(self):
     super(ClientCredentialsTest, self).setUp()
     self.user = UserFactory()
Example #39
0
 def setUp(self):
     self.user = UserFactory.create(username='******')
     self.assertEqual(self.user.id, 1)   # check our assumption hard-coded in the key functions above.
     self.field_data_cache = FieldDataCache([mock_descriptor()], course_id, self.user)
     self.kvs = DjangoKeyValueStore(self.field_data_cache)
Example #40
0
 def setUp(self):
     super(TestApplicability, self).setUp()
     self.user = UserFactory.create()
     self.course = CourseFactory.create(run='test', display_name='test')
     CourseModeFactory.create(course_id=self.course.id,
                              mode_slug='verified')
 def setUpTestData(cls):
     """Set up and enroll our fake user in the course."""
     super(CourseHomePageTestCase, cls).setUpTestData()
     cls.staff_user = StaffFactory(course_key=cls.course.id, password=TEST_PASSWORD)
     cls.user = UserFactory(password=TEST_PASSWORD)
     CourseEnrollment.enroll(cls.user, cls.course.id)
Example #42
0
 def setUp(self):
     self.user = UserFactory.create(username='******')
     self.field_data_cache = FieldDataCache([mock_descriptor([mock_field(Scope.user_state, 'a_field')])], course_id, self.user)
     self.kvs = DjangoKeyValueStore(self.field_data_cache)
Example #43
0
 def test_get_course_func_with_access(self, course_access_func_name, num_mongo_calls):
     course_access_func = self.COURSE_ACCESS_FUNCS[course_access_func_name]
     user = UserFactory.create()
     course = CourseFactory.create(emit_signals=True)
     with check_mongo_calls(num_mongo_calls):
         course_access_func(user, 'load', course.id)
Example #44
0
 def test_success_no_enrollment(self):
     """
     Basic success path for users who have no enrollments, should simply not error
     """
     user = UserFactory()
     _listen_for_lms_retire(sender=self.__class__, user=user)
Example #45
0
 def setUp(self):
     super(_BaseTestCase, self).setUp()
     self.override_waffle_switch(True)
     self.user = UserFactory.create()
Example #46
0
    def setUp(self):
        super(UserCartContextProcessorUnitTest, self).setUp()

        self.user = UserFactory.create()
        self.request = Mock()
 def setUp(self):
     super(TestAccountAPITransactions, self).setUp()
     self.client = APIClient()
     self.user = UserFactory.create(password=TEST_PASSWORD)
     self.url = reverse("accounts_api",
                        kwargs={'username': self.user.username})
Example #48
0
 def setUp(self):
     super(EnrollmentTrackTestCase, self).setUp()
     self.audit_user = UserFactory.create(username='******')
     self.verified_enrollment = CourseEnrollment.enroll(self.user, self.course_key, mode='verified')
     self.audit_enrollment = CourseEnrollment.enroll(self.audit_user, self.course_key, mode='audit')
Example #49
0
 def test_nonexistent_request(self):
     """Test that users who have not requested API access do not get it."""
     other_user = UserFactory()
     self.assertFalse(ApiAccessRequest.has_api_access(other_user))
 def setUp(self):
     super(UsernameReplacementViewTests, self).setUp()
     self.service_user = UserFactory(username=self.SERVICE_USERNAME)
     self.url = reverse("username_replacement")
Example #51
0
 def setUp(self):
     super(TestGetCourseRunDetails, self).setUp()
     self.catalog_integration = self.create_catalog_integration(cache_ttl=1)
     self.user = UserFactory(username=self.catalog_integration.service_username)
Example #52
0
 def setUp(self):
     super(ApiRequestViewTest, self).setUp()
     self.url = reverse('api-request')
     password = '******'
     self.user = UserFactory(password=password)
     self.client.login(username=self.user.username, password=password)
Example #53
0
 def setUp(self):
     super(CreateFakeCertTest, self).setUp()
     self.user = UserFactory.create(username=self.USERNAME)
Example #54
0
 def setUp(self):
     super(ApiAccessRequestTests, self).setUp()
     self.user = UserFactory()
     self.request = ApiAccessRequestFactory(user=self.user)
Example #55
0
 def test_retire_user_do_not_exist(self):
     user2 = UserFactory()
     retire_result = self.request.retire_user(user2)
     self.assertFalse(retire_result)
Example #56
0
 def setUp(self):
     self.course_overview = CourseOverviewFactory.create()
     self.user = UserFactory.create()
     super(TestCourseDurationLimitConfig, self).setUp()
Example #57
0
 def setUp(self):
     super(UserMixin, self).setUp()
     self.user = UserFactory()
Example #58
0
 def _create_user(self, username, user_email):
     user = UserFactory.build(username=username, email=user_email)
     user.set_password(self.password)
     user.save()
     return user
Example #59
0
 def setUp(self):
     super(ThreadViewSetListTest, self).setUp()
     self.author = UserFactory.create()
     self.url = reverse("thread-list")
Example #60
0
 def setUp(self):
     self.user = UserFactory.create()