def test_has_passing_certificate_fa(self): """ Assert that has_passing_certificate is true if user has a cert even if has_paid is false for FA programs """ mmtrack = MMTrack( user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data ) key = self.crun_fa.edx_course_key assert mmtrack.has_passing_certificate(key) is False assert mmtrack.has_paid(key) is False cert_json = { "username": "******", "course_id": self.crun_fa.edx_course_key, "certificate_type": "verified", "status": "downloadable", "is_passing": True, "download_url": "http://www.example.com/demo.pdf", "grade": "0.98" } cached_edx_user_data = MagicMock( spec=CachedEdxUserData, enrollments=CachedEnrollment.deserialize_edx_data(self.enrollments_json), certificates=CachedCertificate.deserialize_edx_data(self.certificates_json + [cert_json]), current_grades=CachedCurrentGrade.deserialize_edx_data(self.current_grades_json), ) mmtrack = MMTrack( user=self.user, program=self.program_financial_aid, edx_user_data=cached_edx_user_data ) assert mmtrack.has_passing_certificate(key) is True assert mmtrack.has_paid(key) is False
def test_is_enrolled(self): """ Tests for is_enrolled method """ mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) for course_id in [ "course-v1:edX+DemoX+Demo_Course", "course-v1:MITx+8.MechCX+2014_T1" ]: assert mmtrack.is_enrolled(course_id) is True with patch('edx_api.enrollments.models.Enrollments.is_enrolled_in', return_value=False): assert mmtrack.is_enrolled(course_id) is False # for financial aid program there is no difference mmtrack_fa = MMTrack(user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) assert mmtrack_fa.is_enrolled("course-v1:odl+FOO101+CR-FALL15") is True with patch('edx_api.enrollments.models.Enrollments.is_enrolled_in', return_value=False): assert mmtrack.is_enrolled( "course-v1:odl+FOO101+CR-FALL15") is False
def test_has_paid_fa_with_course_run_paid_on_mm(self): """ Test for has_paid is True for FA programs when the course has been paid on MicroMasters """ mmtrack = MMTrack(user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) key = self.crun_fa.edx_course_key assert mmtrack.has_paid(key) is False self.pay_for_fa_course(key) mmtrack = MMTrack(user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) assert mmtrack.has_paid(key) is True
def test_has_paid_fa_no_final_grade(self): """ Assert that has_paid works for FA programs in case there is no final grade """ mmtrack = MMTrack(user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) key = self.crun_fa.edx_course_key assert mmtrack.has_paid(key) is False self.pay_for_fa_course(key) mmtrack = MMTrack(user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) assert mmtrack.has_paid(key) is True
def test_get_exam_card_status_for_edx_exams(self, profile_status, expected_status, make_exam_run, make_profile, make_auth): """ test get_exam_card_status """ now = now_in_utc() exam_run = None if make_exam_run: exam_run = ExamRunFactory.create( course=self.course, date_first_eligible=now - timedelta(weeks=1), date_last_eligible=now + timedelta(weeks=1), ) if make_profile: ExamProfileFactory.create( profile=self.user.profile, status=profile_status, ) if make_auth: ExamAuthorizationFactory.create( user=self.user, status=ExamAuthorization.STATUS_SUCCESS, exam_run=exam_run, ) mmtrack = MMTrack( user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data ) assert mmtrack.get_exam_card_status() == expected_status
def test_count_courses_mixed_fa(self): """ Test count_courses_passed with mixed course-exam configuration """ mmtrack = MMTrack( user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data ) # this is course with exam run and the user has CombinedFinalGrade for it course_with_exam_1 = CourseFactory.create(program=self.program_financial_aid) ExamRunFactory.create(course=course_with_exam_1, date_grades_available=now_in_utc()-timedelta(weeks=1)) CombinedFinalGrade.objects.create(user=self.user, course=course_with_exam_1, grade=0.7) # create course with exam run the user did not pass ExamRunFactory.create( course__program=self.program_financial_aid, date_grades_available=now_in_utc() - timedelta(weeks=1) ) # another course with no exam FinalGradeFactory.create( user=self.user, course_run=self.crun_fa, passed=True ) assert mmtrack.count_courses_passed() == 2
def test_fa_paid(self, order_status): """ Test that for financial aid, mmtrack.paid_course_ids only apply to the user with a matching Order """ key = "course-v1:odl+FOO101+CR-FALL15" self.pay_for_fa_course(key, status=order_status) mmtrack_paid = MMTrack(user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) assert mmtrack_paid.paid_course_fa == {self.crun_fa.course.id: True} mmtrack = MMTrack(user=UserFactory.create(), program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) assert mmtrack.paid_course_fa == {self.crun_fa.course.id: False}
def test_has_passing_certificate(self, certificate_type, is_passing, expected_result): """ Test for has_passing_certificate method with different type of certificates """ course_key = self.crun_fa.edx_course_key cert_json = { "username": "******", "course_id": course_key, "certificate_type": certificate_type, "is_passing": is_passing, "status": "downloadable", "download_url": "http://www.example.com/demo.pdf", "grade": "0.98" } cached_edx_user_data = MagicMock( spec=CachedEdxUserData, enrollments=CachedEnrollment.deserialize_edx_data(self.enrollments_json), certificates=CachedCertificate.deserialize_edx_data(self.certificates_json + [cert_json]), current_grades=CachedCurrentGrade.deserialize_edx_data(self.current_grades_json), ) mmtrack = MMTrack( user=self.user, program=self.program_financial_aid, edx_user_data=cached_edx_user_data ) assert mmtrack.has_passing_certificate(course_key) is expected_result
def test_count_passing_courses_for_keys(self): """ Assert that count_courses_passed works in case of normal program. """ mmtrack = MMTrack( user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data ) assert mmtrack.count_passing_courses_for_keys(mmtrack.edx_course_keys) == 0 for crun_index in [0, 1]: course_run = self.cruns[crun_index] FinalGradeFactory.create( user=self.user, course_run=course_run, passed=True ) assert mmtrack.count_passing_courses_for_keys(mmtrack.edx_course_keys) == 1 # now create a grade for another course final_grade = FinalGradeFactory.create( user=self.user, course_run__course__program=self.program, passed=True ) mmtrack.edx_course_keys.add(final_grade.course_run.edx_course_key) assert mmtrack.count_passing_courses_for_keys(mmtrack.edx_course_keys) == 2
def test_get_program_letter_url(self): """ Test get_program_letter_url """ mmtrack = MMTrack( user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data ) assert mmtrack.get_program_letter_url() == "" letter = MicromastersProgramCommendation.objects.create( user=self.user, program=self.program_financial_aid ) assert mmtrack.get_program_letter_url() == "" signatory = ProgramLetterSignatoryFactory.create(program_page__program=letter.program) assert mmtrack.get_program_letter_url() == "" program_page = signatory.program_page program_page.program_letter_text = "<p> Some example test </p>" program_page.save() assert mmtrack.get_program_letter_url() == "" program_page.program_letter_logo = ImageFactory() program_page.save() assert mmtrack.get_program_letter_url() == reverse('program_letter', args=[letter.uuid])
def test_get_best_proctored_exam_grade(self): """ Test get_best_proctorate_exam_grade to return a passed exam with the highest score """ mmtrack = MMTrack( user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data ) finaid_course = self.crun_fa.course last_week = now_in_utc() - timedelta(weeks=1) ProctoredExamGradeFactory.create(user=self.user, course=finaid_course, passed=False, percentage_grade=0.6) assert mmtrack.get_best_proctored_exam_grade(finaid_course) is None best_exam = ProctoredExamGradeFactory.create( user=self.user, course=finaid_course, passed=True, percentage_grade=0.9, exam_run__date_grades_available=last_week ) assert mmtrack.get_best_proctored_exam_grade(finaid_course) == best_exam ProctoredExamGradeFactory.create( user=self.user, course=finaid_course, passed=True, percentage_grade=0.8, exam_run__date_grades_available=last_week ) assert mmtrack.get_best_proctored_exam_grade(finaid_course) == best_exam
def test_count_courses_passed_normal(self): """ Assert that count_courses_passed works in case of normal program. """ mmtrack = MMTrack( user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data ) assert mmtrack.count_courses_passed() == 0 course_run = self.cruns[0] FinalGradeFactory.create( user=self.user, course_run=course_run, passed=True ) assert mmtrack.count_courses_passed() == 1 course = CourseFactory.create(program=self.program) final_grade = FinalGradeFactory.create( user=self.user, course_run__course=course, passed=True ) mmtrack.edx_course_keys.add(final_grade.course_run.edx_course_key) assert mmtrack.count_courses_passed() == 2
def has_object_permission(self, request, view, obj): """ Returns True if the user has permission to send a message to a course team. Args: request (Request): DRF request object view (View): DRF view object obj (Course): Course object Returns: boolean """ user = request.user program = obj.program # Make sure the user has an enrollment in the course's program if not ProgramEnrollment.objects.filter(user=user, program=program).exists(): return False # Make sure the user has paid for any course run for the given course edx_user_data = CachedEdxUserData(user) mmtrack = MMTrack(user, program, edx_user_data) course_run_keys = obj.courserun_set.values_list('edx_course_key', flat=True) return any([ mmtrack.has_paid(course_run_key) for course_run_key in course_run_keys ])
def test_get_final_grade_none(self): """ Test for get_final_grade returns None if there is no associated FinalGrade """ mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) assert mmtrack.get_final_grade('random-course-id') is None
def test_has_paid_final_grade_none(self): """ Test that has_paid_final_grade returns False when a FinalGrade doesn't exist """ mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) assert mmtrack.has_paid_final_grade('random-course-id') is False
def test_get_final_grade_percent_none(self): """ Test that get_final_grade_percent returns a None when there is no final grade """ mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) assert mmtrack.get_final_grade_percent('random-course-id') is None
def test_has_passed_course_no_grade(self): """ Test that has_passed_course returns False when no FinalGrade exists """ mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) assert mmtrack.has_passed_course('random-course-id') is False
def test_has_paid_not_fa_no_final_grade(self): """ Assert that has_paid works for non-FA programs in case there is no final grade """ mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) key = "course-v1:edX+DemoX+Demo_Course" assert mmtrack.has_paid(key) is True
def test_is_enrolled_mmtrack_fa(self): """ Tests for the is_enrolled_mmtrack method in case financial aid is available """ course_id = "course-v1:odl+FOO101+CR-FALL15" # before paying mmtrack = MMTrack(user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) assert mmtrack.is_enrolled_mmtrack(course_id) is False # after paying self.pay_for_fa_course(course_id) mmtrack = MMTrack(user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) assert mmtrack.is_enrolled_mmtrack(course_id) is True
def test_get_required_final_grade_raises(self): """ Test for get_required_final_grade raises an exception if there is no associated FinalGrade """ mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) with self.assertRaises(FinalGrade.DoesNotExist): mmtrack.get_required_final_grade('random-course-id')
def test_has_paid_for_entire_course(self): """ Tests that the .has_paid method returns true if any of the course runs in the course have been paid for """ self.pay_for_fa_course(self.crun_fa.edx_course_key) mmtrack = MMTrack(user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) assert mmtrack.has_paid(self.crun_fa2.edx_course_key) is True
def test_has_passed_course(self, final_grade_passed): """ Test that has_passed_course returns True when a passed FinalGrade exists """ final_grade = FinalGradeFactory.create(user=self.user, course_run=self.cruns[0], passed=final_grade_passed) mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) assert mmtrack.has_passed_course( final_grade.course_run.edx_course_key) is final_grade_passed
def test_has_final_grade(self): """ Test that has_final_grade returns True when a FinalGrade exists """ final_grade = FinalGradeFactory.create(user=self.user, course_run=self.cruns[0]) mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) assert mmtrack.has_final_grade( final_grade.course_run.edx_course_key) is True assert mmtrack.has_final_grade('random-course-id') is False
def test_has_paid_final_grade(self, has_paid): """ Test that has_paid_final_grade returns True when the associated FinalGrade is paid """ final_grade = FinalGradeFactory.create(user=self.user, course_run=self.cruns[0], course_run_paid_on_edx=has_paid) mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) assert mmtrack.has_paid_final_grade( final_grade.course_run.edx_course_key) is has_paid
def test_get_required_final_grade(self): """ Test that get_required_final_grade returns the FinalGrade associated with a user's course run """ final_grade = FinalGradeFactory.create( user=self.user, course_run=self.cruns[0], ) mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) assert mmtrack.get_required_final_grade( final_grade.course_run.edx_course_key) == final_grade
def test_is_enrolled_mmtrack_normal(self): """ Tests for the is_enrolled_mmtrack method in case financial aid is not available """ mmtrack = MMTrack( user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data ) # this is a verified enrollment from edx assert mmtrack.is_enrolled_mmtrack("course-v1:edX+DemoX+Demo_Course") is True # this is a audit enrollment from edx assert mmtrack.is_enrolled_mmtrack("course-v1:MITx+8.MechCX+2014_T1") is False
def test_is_course_in_program(self): """ Test the _is_course_in_program method """ # pylint: disable=protected-access mmtrack = MMTrack( user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data ) for course_id in ["course-v1:edX+DemoX+Demo_Course", "course-v1:MITx+8.MechCX+2014_T1"]: assert mmtrack._is_course_in_program(course_id) is True assert mmtrack._is_course_in_program("course-v1:odl+FOO101+CR-FALL15") is False
def test_get_final_grade_percent(self): """ Test that get_final_grade_percent returns a final grade in percent form """ final_grade = FinalGradeFactory.create(user=self.user, course_run=self.cruns[0], grade=0.57) mmtrack = MMTrack(user=self.user, program=self.program, edx_user_data=self.cached_edx_user_data) # calling round here because we do not want to add it in `get_final_grade` and let the frontend handle it assert round( mmtrack.get_final_grade_percent( final_grade.course_run.edx_course_key)) == 57.0
def test_count_courses_passed_fa(self): """ Assert that count_courses_passed works in case of fa program. """ mmtrack = MMTrack(user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data) with patch('courses.models.Course.has_exam', new_callable=PropertyMock, return_value=True): assert mmtrack.count_courses_passed() == 0 CombinedFinalGrade.objects.create(user=self.user, course=self.crun_fa.course, grade=0.6) assert mmtrack.count_courses_passed() == 1
def test_get_overall_final_grade_for_course(self): """ Test for get_overall_final_grade_for_course to return CombinedFinalGrade for course """ mmtrack = MMTrack( user=self.user, program=self.program_financial_aid, edx_user_data=self.cached_edx_user_data ) finaid_course = self.crun_fa.course assert mmtrack.get_overall_final_grade_for_course(finaid_course) == "" FinalGradeFactory.create(user=self.user, course_run=self.crun_fa, passed=True, grade=0.8) assert mmtrack.get_overall_final_grade_for_course(finaid_course) == "80" ExamRunFactory.create(course=finaid_course) CombinedFinalGrade.objects.create(user=self.user, course=finaid_course, grade="74") assert mmtrack.get_overall_final_grade_for_course(finaid_course) == "74"