def test_program_enrolled_user_serializer(self): # pylint: disable=no-self-use """ Asserts the output of the serializer for program-enrolled users (ProgramEnrollments) """ with mute_signals(post_save): profile = ProfileFactory.create() EducationFactory.create(profile=profile) EmploymentFactory.create(profile=profile) program = ProgramFactory.create() course = CourseFactory.create(program=program) course_runs = [ CourseRunFactory.create(course=course) for _ in range(2) ] for course_run in course_runs: CachedCertificateFactory.create(user=profile.user, course_run=course_run) CachedEnrollmentFactory.create(user=profile.user, course_run=course_run) program_enrollment = ProgramEnrollment.objects.create( user=profile.user, program=program) assert serialize_program_enrolled_user(program_enrollment) == { '_id': program_enrollment.id, 'id': program_enrollment.id, 'user_id': profile.user.id, 'email': profile.user.email, 'profile': ProfileSerializer().to_representation(profile), 'program': UserProgramSerializer.serialize(program_enrollment) }
def test_get_cached_edx_data(self): """ Test for get_cached_edx_data """ with self.assertRaises(ValueError): CachedEdxDataApi.get_cached_edx_data(self.user, 'footype') self.assert_cache_in_db() for run in self.all_runs: CachedEnrollmentFactory.create(user=self.user, course_run=run) CachedCertificateFactory.create(user=self.user, course_run=run) CachedCurrentGradeFactory.create(user=self.user, course_run=run) self.assert_cache_in_db(self.all_course_run_ids, self.all_course_run_ids, self.all_course_run_ids)
def setUpTestData(cls): with mute_signals(post_save): cls.profile = ProfileFactory.create() EducationFactory.create(profile=cls.profile) EmploymentFactory.create(profile=cls.profile) EmploymentFactory.create(profile=cls.profile, end_date=None) program = ProgramFactory.create() course = CourseFactory.create(program=program) course_runs = [CourseRunFactory.create(course=course) for _ in range(2)] for course_run in course_runs: CachedCertificateFactory.create(user=cls.profile.user, course_run=course_run) CachedEnrollmentFactory.create(user=cls.profile.user, course_run=course_run) cls.program_enrollment = ProgramEnrollment.objects.create(user=cls.profile.user, program=program)
def setUpTestData(cls): cls.user = UserFactory.create() # Create Programs, Courses, CourseRuns... cls.p1_course_run_keys = ['p1_course_run'] cls.p2_course_run_keys = ['p2_course_run_1', 'p2_course_run_2'] cls.p1_course_run = CourseRunFactory.create( edx_course_key=cls.p1_course_run_keys[0]) p2 = FullProgramFactory.create() first_course = p2.course_set.first() extra_course = CourseFactory.create(program=p2) cls.p2_course_run_1 = CourseRunFactory.create( course=first_course, edx_course_key=cls.p2_course_run_keys[0]) cls.p2_course_run_2 = CourseRunFactory.create( course=extra_course, edx_course_key=cls.p2_course_run_keys[1]) all_course_runs = [ cls.p1_course_run, cls.p2_course_run_1, cls.p2_course_run_2 ] # Create cached edX data cls.enrollments = [ CachedEnrollmentFactory.create(user=cls.user, course_run=course_run) for course_run in all_course_runs ] cls.certificates = [ CachedCertificateFactory.create(user=cls.user, course_run=course_run) for course_run in all_course_runs ] cls.current_grades = [ CachedCurrentGradeFactory.create(user=cls.user, course_run=course_run) for course_run in all_course_runs ]
def test_update_cached_certificates(self, mocked_index): """Test for update_cached_certificates.""" assert self.verified_certificates_ids.issubset(self.certificates_ids) self.assert_cache_in_db() assert UserCacheRefreshTime.objects.filter( user=self.user).exists() is False CachedEdxDataApi.update_cached_certificates(self.user, self.edx_client) self.assert_cache_in_db( certificate_keys=self.verified_certificates_ids) cache_time = UserCacheRefreshTime.objects.get(user=self.user) now = now_in_utc() assert cache_time.certificate <= now assert mocked_index.delay.called is True mocked_index.reset_mock() # add another cached element for another course that will be removed by the refresh cached_cert = CachedCertificateFactory.create(user=self.user) self.assert_cache_in_db( certificate_keys=list(self.verified_certificates_ids) + [cached_cert.course_run.edx_course_key]) CachedEdxDataApi.update_cached_certificates(self.user, self.edx_client) self.assert_cache_in_db( certificate_keys=self.verified_certificates_ids) cache_time.refresh_from_db() assert cache_time.certificate >= now mocked_index.delay.assert_called_once_with([self.user.id], check_if_changed=True)
def setUpTestData(cls): cls.user = SocialUserFactory.create() cls.run_fa = CourseRunFactory.create( freeze_grade_date=now_in_utc() - timedelta(days=1), course__program__financial_aid_availability=True, ) cls.run_fa_with_cert = CourseRunFactory.create( freeze_grade_date=None, course__program=cls.run_fa.course.program, ) cls.run_no_fa = CourseRunFactory.create( freeze_grade_date=now_in_utc() + timedelta(days=1), course__program__financial_aid_availability=False, ) cls.run_no_fa_with_cert = CourseRunFactory.create( course__program=cls.run_no_fa.course.program, ) all_course_runs = ( cls.run_fa, cls.run_fa_with_cert, cls.run_no_fa, cls.run_no_fa_with_cert, ) for run in all_course_runs: if run.course.program.financial_aid_availability: FinancialAidFactory.create( user=cls.user, tier_program=TierProgramFactory.create( program=run.course.program, income_threshold=0, current=True), status=FinancialAidStatus.RESET, ) cls.enrollments = { course_run.edx_course_key: CachedEnrollmentFactory.create(user=cls.user, course_run=course_run) for course_run in all_course_runs } cls.current_grades = { course_run.edx_course_key: CachedCurrentGradeFactory.create(user=cls.user, course_run=course_run) for course_run in all_course_runs } cls.certificates = { course_run.edx_course_key: CachedCertificateFactory.create(user=cls.user, course_run=course_run) for course_run in (cls.run_fa_with_cert, cls.run_no_fa_with_cert) } cls.user_edx_data = CachedEdxUserData(cls.user)
def setUpTestData(cls): with mute_signals(post_save): cls.profile = ProfileFactory.create() EducationFactory.create(profile=cls.profile) EmploymentFactory.create(profile=cls.profile) EmploymentFactory.create(profile=cls.profile, end_date=None) program = ProgramFactory.create() course = CourseFactory.create(program=program) course_runs = [ CourseRunFactory.create(course=course) for _ in range(2) ] for course_run in course_runs: CachedCertificateFactory.create(user=cls.profile.user, course_run=course_run) CachedEnrollmentFactory.create(user=cls.profile.user, course_run=course_run) cls.program_enrollment = ProgramEnrollment.objects.create( user=cls.profile.user, program=program)
def setUpTestData(cls): with mute_signals(post_save): cls.profile = ProfileFactory.create() cls.program, _ = create_program(past=True) cls.course_run = cls.program.course_set.first().courserun_set.first() CachedCurrentGradeFactory.create( user=cls.profile.user, course_run=cls.course_run, data={ "passed": True, "percent": 0.9, "course_key": cls.course_run.edx_course_key, "username": cls.profile.user.username } ) CachedCertificateFactory.create(user=cls.profile.user, course_run=cls.course_run) cls.exam_run = ExamRunFactory.create( course=cls.course_run.course, date_first_schedulable=now_in_utc() - timedelta(days=1), )
def setUpTestData(cls): with mute_signals(post_save): cls.profile = ProfileFactory.create() cls.program, _ = create_program(past=True) cls.course_run = cls.program.course_set.first().courserun_set.first() CachedCurrentGradeFactory.create(user=cls.profile.user, course_run=cls.course_run, data={ "passed": True, "percent": 0.9, "course_key": cls.course_run.edx_course_key, "username": cls.profile.user.username }) CachedCertificateFactory.create(user=cls.profile.user, course_run=cls.course_run) cls.exam_run = ExamRunFactory.create( course=cls.course_run.course, date_first_schedulable=now_in_utc() - timedelta(days=1), )
def setUpTestData(cls): cls.user = SocialUserFactory.create() cls.run_fa = CourseRunFactory.create( freeze_grade_date=now_in_utc()-timedelta(days=1), course__program__financial_aid_availability=True, ) cls.run_fa_with_cert = CourseRunFactory.create( freeze_grade_date=None, course__program=cls.run_fa.course.program, ) cls.run_no_fa = CourseRunFactory.create( freeze_grade_date=now_in_utc()+timedelta(days=1), course__program__financial_aid_availability=False, ) cls.run_no_fa_with_cert = CourseRunFactory.create( course__program=cls.run_no_fa.course.program, ) all_course_runs = (cls.run_fa, cls.run_fa_with_cert, cls.run_no_fa, cls.run_no_fa_with_cert, ) for run in all_course_runs: if run.course.program.financial_aid_availability: FinancialAidFactory.create( user=cls.user, tier_program=TierProgramFactory.create( program=run.course.program, income_threshold=0, current=True ), status=FinancialAidStatus.RESET, ) cls.enrollments = { course_run.edx_course_key: CachedEnrollmentFactory.create( user=cls.user, course_run=course_run) for course_run in all_course_runs } cls.current_grades = { course_run.edx_course_key: CachedCurrentGradeFactory.create( user=cls.user, course_run=course_run) for course_run in all_course_runs } cls.certificates = { course_run.edx_course_key: CachedCertificateFactory.create( user=cls.user, course_run=course_run) for course_run in (cls.run_fa_with_cert, cls.run_no_fa_with_cert) } cls.user_edx_data = CachedEdxUserData(cls.user)
def setUpTestData(cls): with mute_signals(post_save): profile = ProfileFactory.create() EducationFactory.create(profile=profile) EmploymentFactory.create(profile=profile) program = ProgramFactory.create() cls.enrollments = cls._generate_cached_enrollments(profile.user, program, num_course_runs=2) certificate_grades = [0.7, 0.8] cls.certificates = [] for i, enrollment in enumerate(cls.enrollments): cls.certificates.append( CachedCertificateFactory.create( user=profile.user, course_run=enrollment.course_run, data={'grade': certificate_grades[i]} ) ) cls.program_enrollment = ProgramEnrollment.objects.create(user=profile.user, program=program)
def setUpTestData(cls): cls.user = UserFactory.create() # Create Programs, Courses, CourseRuns... cls.p1_course_run_keys = ['p1_course_run'] cls.p2_course_run_keys = ['p2_course_run_1', 'p2_course_run_2'] cls.p1_course_run = CourseRunFactory.create(edx_course_key=cls.p1_course_run_keys[0]) p2 = FullProgramFactory.create() first_course = p2.course_set.first() extra_course = CourseFactory.create(program=p2) cls.p2_course_run_1 = CourseRunFactory.create(course=first_course, edx_course_key=cls.p2_course_run_keys[0]) cls.p2_course_run_2 = CourseRunFactory.create(course=extra_course, edx_course_key=cls.p2_course_run_keys[1]) all_course_runs = [cls.p1_course_run, cls.p2_course_run_1, cls.p2_course_run_2] # Create cached edX data cls.enrollments = [ CachedEnrollmentFactory.create(user=cls.user, course_run=course_run) for course_run in all_course_runs ] cls.certificates = [ CachedCertificateFactory.create(user=cls.user, course_run=course_run) for course_run in all_course_runs ] cls.current_grades = [ CachedCurrentGradeFactory.create(user=cls.user, course_run=course_run) for course_run in all_course_runs ]
def test_update_cached_certificates(self, mocked_index): """Test for update_cached_certificates.""" assert self.verified_certificates_ids.issubset(self.certificates_ids) self.assert_cache_in_db() assert UserCacheRefreshTime.objects.filter(user=self.user).exists() is False CachedEdxDataApi.update_cached_certificates(self.user, self.edx_client) self.assert_cache_in_db(certificate_keys=self.verified_certificates_ids) cache_time = UserCacheRefreshTime.objects.get(user=self.user) now = now_in_utc() assert cache_time.certificate <= now assert mocked_index.delay.called is True mocked_index.reset_mock() # add another cached element for another course that will be removed by the refresh cached_cert = CachedCertificateFactory.create(user=self.user) self.assert_cache_in_db( certificate_keys=list(self.verified_certificates_ids) + [cached_cert.course_run.edx_course_key]) CachedEdxDataApi.update_cached_certificates(self.user, self.edx_client) self.assert_cache_in_db(certificate_keys=self.verified_certificates_ids) cache_time.refresh_from_db() assert cache_time.certificate >= now mocked_index.delay.assert_called_once_with([self.user.id], check_if_changed=True)
def setUpTestData(cls): with mute_signals(post_save): cls.profile = profile = ProfileFactory.create() cls.user = profile.user EducationFactory.create(profile=profile) EmploymentFactory.create(profile=profile) # create a normal program program = ProgramFactory.create() cls.enrollments = cls._generate_cached_enrollments(cls.user, program, num_course_runs=2) certificate_grades_vals = [0.7, 0.8] cls.current_grades_vals = [0.9, 1.0] cls.certificates = [] cls.current_grades = [] for i, enrollment in enumerate(cls.enrollments): cls.certificates.append( CachedCertificateFactory.create( user=cls.user, course_run=enrollment.course_run, data={ "grade": certificate_grades_vals[i], "certificate_type": "verified", "course_id": enrollment.course_run.edx_course_key, "status": "downloadable", } ) ) cls.current_grades.append( CachedCurrentGradeFactory.create( user=cls.user, course_run=enrollment.course_run, data={ "passed": True, "percent": cls.current_grades_vals[i], "course_key": enrollment.course_run.edx_course_key, } ) ) FinalGradeFactory.create( user=cls.user, course_run=enrollment.course_run, grade=certificate_grades_vals[i], passed=True, ) non_fa_cached_edx_data = CachedEdxUserData(cls.user, program=program) non_fa_mmtrack = MMTrack(cls.user, program, non_fa_cached_edx_data) cls.serialized_enrollments = UserProgramSearchSerializer.serialize_enrollments(non_fa_mmtrack) cls.serialized_course_enrollments = UserProgramSearchSerializer.serialize_course_enrollments(non_fa_mmtrack) cls.semester_enrollments = UserProgramSearchSerializer.serialize_course_runs_enrolled(non_fa_mmtrack) cls.program_enrollment = ProgramEnrollment.objects.create(user=cls.user, program=program) # create a financial aid program cls.fa_program, _ = create_program() cls.fa_program_enrollment = ProgramEnrollment.objects.create(user=cls.user, program=cls.fa_program) cls.fa_enrollments = cls._generate_cached_enrollments(cls.user, cls.fa_program, num_course_runs=2) cls.current_grades = [] for i, enrollment in enumerate(cls.fa_enrollments): order = OrderFactory.create(user=cls.user, status='fulfilled') LineFactory.create(order=order, course_key=enrollment.course_run.edx_course_key) cls.current_grades.append( CachedCurrentGradeFactory.create( user=cls.user, course_run=enrollment.course_run, data={ "passed": True, "percent": cls.current_grades_vals[i], "course_key": enrollment.course_run.edx_course_key, } ) ) FinalGradeFactory.create( user=cls.user, course_run=enrollment.course_run, grade=cls.current_grades_vals[i], passed=True, ) fa_cached_edx_data = CachedEdxUserData(cls.user, program=cls.fa_program) fa_mmtrack = MMTrack(cls.user, cls.fa_program, fa_cached_edx_data) cls.fa_serialized_course_enrollments = ( UserProgramSearchSerializer.serialize_course_enrollments(fa_mmtrack) ) cls.fa_serialized_enrollments = ( UserProgramSearchSerializer.serialize_enrollments(fa_mmtrack) )
def setUpTestData(cls): with mute_signals(post_save): cls.profile = profile = ProfileFactory.create() cls.user = profile.user EducationFactory.create(profile=profile) EmploymentFactory.create(profile=profile) # create a normal program program = ProgramFactory.create() cls.enrollments = cls._generate_cached_enrollments(cls.user, program, num_course_runs=2) certificate_grades_vals = [0.7, 0.8] cls.current_grades_vals = [0.9, 1.0] cls.certificates = [] cls.current_grades = [] for i, enrollment in enumerate(cls.enrollments): cls.certificates.append( CachedCertificateFactory.create( user=cls.user, course_run=enrollment.course_run, data={ "grade": certificate_grades_vals[i], "certificate_type": "verified", "course_id": enrollment.course_run.edx_course_key, "status": "downloadable", })) cls.current_grades.append( CachedCurrentGradeFactory.create( user=cls.user, course_run=enrollment.course_run, data={ "passed": True, "percent": cls.current_grades_vals[i], "course_key": enrollment.course_run.edx_course_key, })) FinalGradeFactory.create( user=cls.user, course_run=enrollment.course_run, grade=certificate_grades_vals[i], passed=True, ) non_fa_cached_edx_data = CachedEdxUserData(cls.user, program=program) non_fa_mmtrack = MMTrack(cls.user, program, non_fa_cached_edx_data) cls.serialized_enrollments = UserProgramSearchSerializer.serialize_enrollments( non_fa_mmtrack) cls.serialized_course_enrollments = UserProgramSearchSerializer.serialize_course_enrollments( non_fa_mmtrack) cls.semester_enrollments = UserProgramSearchSerializer.serialize_course_runs_enrolled( non_fa_mmtrack) cls.program_enrollment = ProgramEnrollment.objects.create( user=cls.user, program=program) # create a financial aid program cls.fa_program, _ = create_program() cls.fa_program_enrollment = ProgramEnrollment.objects.create( user=cls.user, program=cls.fa_program) cls.fa_enrollments = cls._generate_cached_enrollments( cls.user, cls.fa_program, num_course_runs=2) cls.current_grades = [] for i, enrollment in enumerate(cls.fa_enrollments): order = OrderFactory.create(user=cls.user, status='fulfilled') LineFactory.create(order=order, course_key=enrollment.course_run.edx_course_key) cls.current_grades.append( CachedCurrentGradeFactory.create( user=cls.user, course_run=enrollment.course_run, data={ "passed": True, "percent": cls.current_grades_vals[i], "course_key": enrollment.course_run.edx_course_key, })) FinalGradeFactory.create( user=cls.user, course_run=enrollment.course_run, grade=cls.current_grades_vals[i], passed=True, ) fa_cached_edx_data = CachedEdxUserData(cls.user, program=cls.fa_program) fa_mmtrack = MMTrack(cls.user, cls.fa_program, fa_cached_edx_data) cls.fa_serialized_course_enrollments = ( UserProgramSearchSerializer.serialize_course_enrollments( fa_mmtrack)) cls.fa_serialized_enrollments = ( UserProgramSearchSerializer.serialize_enrollments(fa_mmtrack))