def test_filter_and_sorting(self, staff_client, program_data, fin_aid_status, sort_param): """ Tests ReviewFinancialAidView correctly applies sort and filter parameters, or uses defaults for those parameters """ FinancialAidFactory.create_batch( 10, tier_program=program_data.tier_programs["0k"], status=factory.Iterator([ ReviewFinancialAidView.default_status, FinancialAidStatus.AUTO_APPROVED ]) ) url = self.review_url(program_data.program.id, status=fin_aid_status, sort_param=sort_param) resp = staff_client.get(url) assert resp.status_code == status.HTTP_200_OK financial_aid_objects = resp.context_data["financial_aid_objects"] # View should filter FinancialAid objects by the provided status or a default status expected_status = fin_aid_status or ReviewFinancialAidView.default_status assert all(fin_aid.status == expected_status for fin_aid in financial_aid_objects) # View should sort by the given parameter, or sort by ascending last name by default should_reverse_sort = sort_param == '-last_name' assert ( list(financial_aid_objects) == sorted(financial_aid_objects, key=lambda f: f.user.last_name, reverse=should_reverse_sort) )
def test_approve_docs(browser, base_test_data, logged_in_staff): """ Test the financial aid review page """ program = base_test_data.program tier_program = program.tier_programs.get(discount_amount=0) FinancialAidFactory.create( user=base_test_data.student_user, tier_program=tier_program, status=FinancialAidStatus.DOCS_SENT, ) browser.get("/financial_aid/review/{}/{}".format(program.id, FinancialAidStatus.DOCS_SENT)) browser.click_when_loaded(By.CLASS_NAME, "mark-docs-as-received") alert = browser.driver.switch_to_alert() alert.accept() browser.wait_until_loaded(By.CLASS_NAME, "alert-success") browser.assert_no_console_errors() def is_now_pending(driver): # pylint: disable=unused-argument """Wait until the change to the financial aid takes effect""" assert FinancialAid.objects.count() == 1 financial_aid = FinancialAid.objects.first() return financial_aid.status == FinancialAidStatus.PENDING_MANUAL_APPROVAL browser.wait().until(is_now_pending)
def test_view_with_search(self, staff_client, program_data): """ Tests that ReviewFinancialAidView returns the expected results with search """ fin_aid_status = FinancialAidStatus.AUTO_APPROVED profiles = ProfileFactory.create_batch( 4, first_name=factory.Iterator(['match_name', 'x', 'y', 'z']), last_name=factory.Iterator(['x', 'y', 'z', 'match_name']), ) FinancialAidFactory.create_batch( 4, tier_program=program_data.tier_programs["0k"], status=fin_aid_status, user=factory.Iterator([p.user for p in profiles]) ) name_query = 'match_name' url = self.review_url(program_data.program.id, status=fin_aid_status, search_param=name_query) resp = staff_client.get(url) assert resp.status_code == status.HTTP_200_OK financial_aid_objects = resp.context_data["financial_aid_objects"] # Two users should match the search term - one for first_name, one for last_name assert len(financial_aid_objects) == 2 assert all( fin_aid.user.profile.first_name == name_query or fin_aid.user.profile.last_name == name_query for fin_aid in financial_aid_objects )
def test_filter_and_sorting(self, staff_client, program_data, fin_aid_status, sort_param): """ Tests ReviewFinancialAidView correctly applies sort and filter parameters, or uses defaults for those parameters """ FinancialAidFactory.create_batch( 10, tier_program=program_data.tier_programs["0k"], status=factory.Iterator([ ReviewFinancialAidView.default_status, FinancialAidStatus.AUTO_APPROVED ]) ) url = self.review_url(program_data.program.id, status=fin_aid_status, sort_param=sort_param) resp = staff_client.get(url) assert resp.status_code == status.HTTP_200_OK financial_aid_objects = resp.context_data["financial_aid_objects"] # View should filter FinancialAid objects by the provided status or a default status expected_status = fin_aid_status or ReviewFinancialAidView.default_status assert all(fin_aid.status == expected_status for fin_aid in financial_aid_objects) # View should sort by the given parameter, or sort by ascending last name by default should_reverse_sort = sort_param == '-last_name' assert ( list(financial_aid_objects) == sorted(financial_aid_objects, key=lambda f: f.user.last_name, reverse=should_reverse_sort) )
def test_view_with_search(self, staff_client, program_data): """ Tests that ReviewFinancialAidView returns the expected results with search """ fin_aid_status = FinancialAidStatus.AUTO_APPROVED profiles = ProfileFactory.create_batch( 4, first_name=factory.Iterator(['match_name', 'x', 'y', 'z']), last_name=factory.Iterator(['x', 'y', 'z', 'match_name']), ) FinancialAidFactory.create_batch( 4, tier_program=program_data.tier_programs["0k"], status=fin_aid_status, user=factory.Iterator([p.user for p in profiles]) ) name_query = 'match_name' url = self.review_url(program_data.program.id, status=fin_aid_status, search_param=name_query) resp = staff_client.get(url) assert resp.status_code == status.HTTP_200_OK financial_aid_objects = resp.context_data["financial_aid_objects"] # Two users should match the search term - one for first_name, one for last_name assert len(financial_aid_objects) == 2 assert all( name_query in (fin_aid.user.profile.first_name, fin_aid.user.profile.last_name) for fin_aid in financial_aid_objects )
def setUpTestData(cls): # replace imported thresholds with fake ones created here CountryIncomeThreshold.objects.all().delete() cls.program, cls.tier_programs = create_program() cls.profile = create_enrolled_profile(cls.program, country="50") cls.staff_user_profile = create_enrolled_profile(cls.program, role=Staff.ROLE_ID) cls.instructor_user_profile = create_enrolled_profile( cls.program, role=Instructor.ROLE_ID) cls.country_income_threshold_0 = CountryIncomeThreshold.objects.create( country_code="0", income_threshold=0, ) CountryIncomeThreshold.objects.create( country_code=cls.profile.country, income_threshold=50000, ) # Create a FinancialAid with a reset status to verify that it is ignored FinancialAidFactory.create( user=cls.profile.user, tier_program=cls.tier_programs['75k'], status=FinancialAidStatus.RESET, )
def test_approve_docs(browser, base_test_data, logged_in_staff): """ Test the financial aid review page """ program = base_test_data.program tier_program = program.tier_programs.get(discount_amount=0) FinancialAidFactory.create( user=base_test_data.student_user, tier_program=tier_program, status=FinancialAidStatus.DOCS_SENT, ) browser.get("/financial_aid/review/{}/{}".format( program.id, FinancialAidStatus.DOCS_SENT)) browser.click_when_loaded(By.CLASS_NAME, "mark-docs-as-received") alert = browser.driver.switch_to_alert() alert.accept() browser.wait_until_loaded(By.CLASS_NAME, "alert-success") browser.assert_no_console_errors() def is_now_pending(driver): # pylint: disable=unused-argument """Wait until the change to the financial aid takes effect""" assert FinancialAid.objects.count() == 1 financial_aid = FinancialAid.objects.first() return financial_aid.status == FinancialAidStatus.PENDING_MANUAL_APPROVAL browser.wait().until(is_now_pending)
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 test_invalid_sorting_and_filter(self, staff_client, program_data, fin_aid_status, sort_param): """ Shouldn't break with invalid sorting or filter parameters """ FinancialAidFactory.create(tier_program=program_data.tier_programs["0k"]) url = self.review_url(program_data.program.id, status=fin_aid_status, sort_param=sort_param) resp = staff_client.get(url) assert resp.status_code == status.HTTP_200_OK
def test_invalid_sorting_and_filter(self, staff_client, program_data, fin_aid_status, sort_param): """ Shouldn't break with invalid sorting or filter parameters """ FinancialAidFactory.create(tier_program=program_data.tier_programs["0k"]) url = self.review_url(program_data.program.id, status=fin_aid_status, sort_param=sort_param) resp = staff_client.get(url) assert resp.status_code == status.HTTP_200_OK
def test_financialaid_object_cannot_be_skipped_if_already_terminal_status(self, financial_aid_status): """ Tests that an existing FinancialAid object that has already reached a terminal status cannot be skipped. """ FinancialAidFactory.create( user=self.profile.user, tier_program=self.tier_programs["25k"], status=financial_aid_status, ) self.make_http_request(self.client.patch, self.skip_url, status.HTTP_400_BAD_REQUEST)
def test_financial_aid_factory_create(self): """ Tests that FinancialAidFactory.create() will create a profile for the user field if a user is not specified """ assert FinancialAid.objects.count() == 0 assert User.objects.count() == 0 assert Profile.objects.count() == 0 FinancialAidFactory.create() assert FinancialAid.objects.count() == 1 assert User.objects.count() == 1 assert Profile.objects.count() == 1
def test_financial_aid_factory_create_with_user(self): """ Tests that FinancialAidFactory.create() will still work normally if provided a User object """ with mute_signals(post_save): user = UserFactory.create() assert FinancialAid.objects.count() == 0 assert User.objects.count() == 1 assert Profile.objects.count() == 0 FinancialAidFactory.create(user=user) assert FinancialAid.objects.count() == 1 assert User.objects.count() == 1 assert Profile.objects.count() == 0
def make_fa_program_enrollment(self, status): """Enroll user in financial aid program""" Program.objects.get(title='Analog Learning').delete() # We need to use Digital Learning here since it has financial aid enabled. Deleting Analog Learning # because it's simpler than adjusting the UI to show the right one program = Program.objects.get(title='Digital Learning') ProgramEnrollment.objects.create(user=self.user, program=program) FinancialAidFactory.create( user=self.user, status=status, tier_program__program=program, tier_program__discount_amount=50, )
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 test_props(self, program_data): """ Fixture that provides test properties for FinancialAidDetailView test cases """ user = create_enrolled_profile(program_data.program).user pending_fa = FinancialAidFactory.create( user=user, tier_program=program_data.tier_programs["25k"], status=FinancialAidStatus.PENDING_DOCS ) docs_sent_url = reverse( "financial_aid", kwargs={"financial_aid_id": pending_fa.id} ) docs_sent_date = now_in_utc().date() docs_sent_request_params = dict( content_type="application/json", data=json.dumps({ "date_documents_sent": docs_sent_date.strftime("%Y-%m-%d") }) ) return SimpleNamespace( user=user, pending_fa=pending_fa, docs_sent_url=docs_sent_url, docs_sent_request_params=docs_sent_request_params, docs_sent_date=docs_sent_date, )
def test_save_and_log(self): """ Tests that FinancialAid.save_and_log() creates an audit record with the correct information. """ with mute_signals(post_save): profile = ProfileFactory.create() acting_user = profile.user financial_aid = FinancialAidFactory.create() original_before_json = serialize_model_object(financial_aid) # Make sure audit object is created assert FinancialAidAudit.objects.count() == 0 financial_aid.status = FinancialAidStatus.AUTO_APPROVED financial_aid.save_and_log(acting_user) assert FinancialAidAudit.objects.count() == 1 # Make sure the before and after data are correct financial_aid.refresh_from_db() original_after_json = serialize_model_object(financial_aid) financial_aid_audit = FinancialAidAudit.objects.first() before_json = financial_aid_audit.data_before after_json = financial_aid_audit.data_after for field, value in before_json.items(): # Data before if isinstance(value, float): # JSON serialization of FloatField is precise, so we need to do almost equal self.assertAlmostEqual(value, original_before_json[field]) else: assert value == original_before_json[field] for field, value in after_json.items(): # Data after if isinstance(value, float): # JSON serialization of FloatField is precise, so we need to do almost equal self.assertAlmostEqual(value, original_after_json[field]) else: assert value == original_after_json[field]
def test_props(self, program_data): """ Fixture that provides test properties for FinancialAidDetailView test cases """ user = create_enrolled_profile(program_data.program).user pending_fa = FinancialAidFactory.create( user=user, tier_program=program_data.tier_programs["25k"], status=FinancialAidStatus.PENDING_DOCS ) docs_sent_url = reverse( "financial_aid", kwargs={"financial_aid_id": pending_fa.id} ) docs_sent_date = now_in_utc().date() docs_sent_request_params = dict( content_type="application/json", data=json.dumps({ "date_documents_sent": docs_sent_date.strftime("%Y-%m-%d") }) ) return SimpleNamespace( user=user, pending_fa=pending_fa, docs_sent_url=docs_sent_url, docs_sent_request_params=docs_sent_request_params, docs_sent_date=docs_sent_date, )
def test_datetime(self): """ Test that a model with a datetime and date field is handled correctly """ financial_aid = FinancialAidFactory.create(justification=None) assert serialize_model_object(financial_aid) == { 'country_of_income': financial_aid.country_of_income, 'country_of_residence': financial_aid.country_of_residence, 'created_on': format_as_iso8601(financial_aid.created_on), 'date_documents_sent': financial_aid.date_documents_sent.isoformat(), 'date_exchange_rate': format_as_iso8601(financial_aid.date_exchange_rate), 'id': financial_aid.id, 'income_usd': financial_aid.income_usd, 'justification': None, 'original_currency': financial_aid.original_currency, 'original_income': financial_aid.original_income, 'status': financial_aid.status, 'tier_program': financial_aid.tier_program.id, 'updated_on': format_as_iso8601(financial_aid.updated_on), 'user': financial_aid.user.id, }
def setUpTestData(cls): super().setUpTestData() cls.financialaid = FinancialAidFactory.create( user=cls.profile.user, tier_program=cls.tier_programs["25k"], status=FinancialAidStatus.PENDING_MANUAL_APPROVAL ) cls.action_url = reverse("financial_aid_action", kwargs={"financial_aid_id": cls.financialaid.id})
def create_purchasable_course_run(): """ Creates a purchasable course run and an associated user """ course_run = CourseRunFactory.create( course__program__live=True, course__program__financial_aid_availability=True, ) price = course_run.course.program.price user = UserFactory.create() FinancialAidFactory.create( tier_program__current=True, tier_program__program=course_run.course.program, tier_program__discount_amount=price/2, user=user, status=FinancialAidStatus.APPROVED, ) ProgramEnrollment.objects.create(user=user, program=course_run.course.program) return course_run, user
def create_purchasable_course_run(): """ Creates a purchasable course run and an associated user """ course_run = CourseRunFactory.create( course__program__live=True, course__program__financial_aid_availability=True, ) price = course_run.course.program.price user = UserFactory.create() FinancialAidFactory.create( tier_program__current=True, tier_program__program=course_run.course.program, tier_program__discount_amount=price/2, user=user, status=FinancialAidStatus.APPROVED, ) ProgramEnrollment.objects.create(user=user, program=course_run.course.program) return course_run, user
def test_financial_aid_with_application_in_reset(self): """ Test that a user that has a FinancialAid record with the reset status will have serialized financial aid information that indicates that they have not applied """ FinancialAidFactory.create(user=self.user, tier_program=self.min_tier_program, date_documents_sent=None, status=FinancialAidStatus.RESET) serialized = FinancialAidDashboardSerializer.serialize( self.user, self.program) assert serialized == { "id": None, "has_user_applied": False, "application_status": None, "min_possible_cost": 250, "max_possible_cost": 1000, "date_documents_sent": None, }
def setUpTestData(cls): with mute_signals(post_save): cls.staff_user_profile = ProfileFactory.create() course_run = CourseRunFactory.create() cls.financial_aid = FinancialAidFactory.create() cls.tier_program = cls.financial_aid.tier_program cls.tier_program.program = course_run.course.program cls.tier_program.save() cls.program_enrollment = ProgramEnrollment.objects.create( user=cls.financial_aid.user, program=cls.tier_program.program)
def test_determine_auto_approval(self, income_usd, country_code, expected): """ Tests determine_auto_approval() assigning the correct auto-approval status. This should return True if income is strictly greater than the threshold (or if the threshold is 0, which is inclusive of 0). """ financial_aid = FinancialAidFactory.create( income_usd=income_usd, country_of_income=country_code, ) tier_program = determine_tier_program(self.program, income_usd) assert determine_auto_approval(financial_aid, tier_program) is expected
def test_determine_auto_approval(self, income_usd, country_code, expected): """ Tests determine_auto_approval() assigning the correct auto-approval status. This should return True if income is strictly greater than the threshold (or if the threshold is 0, which is inclusive of 0). """ financial_aid = FinancialAidFactory.create( income_usd=income_usd, country_of_income=country_code, ) tier_program = determine_tier_program(self.program, income_usd) assert determine_auto_approval(financial_aid, tier_program) is expected
def test_financial_aid_with_application_in_reset(self): """ Test that a user that has a FinancialAid record with the reset status will have serialized financial aid information that indicates that they have not applied """ FinancialAidFactory.create( user=self.user, tier_program=self.min_tier_program, date_documents_sent=None, status=FinancialAidStatus.RESET ) serialized = FinancialAidDashboardSerializer.serialize(self.user, self.program) assert serialized == { "id": None, "has_user_applied": False, "application_status": None, "min_possible_cost": 250, "max_possible_cost": 1000, "date_documents_sent": None, }
def setUpTestData(cls): super().setUpTestData() cls.financial_aid = FinancialAidFactory.create( tier_program=TierProgramFactory.create(program=cls.program)) cls.url = reverse('financial_aid_mail_api', kwargs={'financial_aid_id': cls.financial_aid.id}) cls.request_data = { 'email_subject': 'email subject', 'email_body': 'email body' }
def test_get_course_price_for_learner_with_financial_aid_in_reset(self): """ Tests get_course_price_for_learner() who has financial aid request in status `reset` """ enrollment = ProgramEnrollment.objects.get(program=self.program, user=self.profile.user) FinancialAidFactory.create( user=self.profile.user, tier_program=self.tier_programs['25k'], status=FinancialAidStatus.RESET, ) # Enrolled and has no financial aid course_price = self.program.price expected_response = { "program_id": enrollment.program.id, "price": course_price, "financial_aid_availability": True, "has_financial_aid_request": False } self.assertDictEqual(get_formatted_course_price(enrollment), expected_response)
def setUpTestData(cls): with mute_signals(post_save): cls.staff_user_profile = ProfileFactory.create() course_run = CourseRunFactory.create() cls.financial_aid = FinancialAidFactory.create() cls.tier_program = cls.financial_aid.tier_program cls.tier_program.program = course_run.course.program cls.tier_program.save() cls.program_enrollment = ProgramEnrollment.objects.create( user=cls.financial_aid.user, program=cls.tier_program.program )
def test_financial_aid_model_duplicate_if_reset(self): """ Tests that FinancialAid objects can not be unique per User and Program if the other are in reset status """ financial_aid = FinancialAidFactory.create() # change the first one to any state that is not `reset` will fail to create a new financial aid for status in FinancialAidStatus.ALL_STATUSES: if status == FinancialAidStatus.RESET: continue financial_aid.status = status financial_aid.save() with self.assertRaises(ValidationError): FinancialAidFactory.create( user=financial_aid.user, tier_program=financial_aid.tier_program) # reset status will allow a new financial aid financial_aid.status = FinancialAidStatus.RESET financial_aid.save() FinancialAidFactory.create(user=financial_aid.user, tier_program=financial_aid.tier_program)
def test_get_course_price_for_learner_with_financial_aid_in_reset(self): """ Tests get_course_price_for_learner() who has financial aid request in status `reset` """ enrollment = ProgramEnrollment.objects.get(program=self.program, user=self.profile.user) FinancialAidFactory.create( user=self.profile.user, tier_program=self.tier_programs['25k'], status=FinancialAidStatus.RESET, ) # Enrolled and has no financial aid course_price = self.program.price expected_response = { "program_id": enrollment.program.id, "price": course_price, "financial_aid_availability": True, "has_financial_aid_request": False } self.assertDictEqual( get_formatted_course_price(enrollment), expected_response )
def setUpTestData(cls): super().setUpTestData() cls.financial_aid = FinancialAidFactory.create( tier_program=TierProgramFactory.create(program=cls.program) ) cls.url = reverse( 'financial_aid_mail_api', kwargs={'financial_aid_id': cls.financial_aid.id} ) cls.request_data = { 'email_subject': 'email subject', 'email_body': 'email body' }
def setUpTestData(cls): # replace imported thresholds with fake ones created here CountryIncomeThreshold.objects.all().delete() cls.program, cls.tier_programs = create_program() cls.profile = create_enrolled_profile(cls.program, country="50") cls.staff_user_profile = create_enrolled_profile(cls.program, role=Staff.ROLE_ID) cls.instructor_user_profile = create_enrolled_profile(cls.program, role=Instructor.ROLE_ID) cls.country_income_threshold_0 = CountryIncomeThreshold.objects.create( country_code="0", income_threshold=0, ) CountryIncomeThreshold.objects.create( country_code=cls.profile.country, income_threshold=50000, ) # Create a FinancialAid with a reset status to verify that it is ignored FinancialAidFactory.create( user=cls.profile.user, tier_program=cls.tier_programs['75k'], status=FinancialAidStatus.RESET, )
def test_determine_auto_approval(self): # pylint: disable=no-self-use """ Tests determine_auto_approval() """ # Assumes US threshold is 100000 assert COUNTRY_INCOME_THRESHOLDS["US"] == 100000 financial_aid = FinancialAidFactory.create(income_usd=150000, country_of_income="US") assert determine_auto_approval(financial_aid) is True financial_aid = FinancialAidFactory.create(income_usd=1000, country_of_income="US") assert not determine_auto_approval(financial_aid) financial_aid = FinancialAidFactory.create(income_usd=0, country_of_income="US") assert not determine_auto_approval(financial_aid) # Assumes MX threshold is 50000 assert COUNTRY_INCOME_THRESHOLDS["MX"] == 50000 financial_aid = FinancialAidFactory.create(income_usd=55000, country_of_income="MX") assert determine_auto_approval(financial_aid) is True financial_aid = FinancialAidFactory.create(income_usd=45000, country_of_income="MX") assert not determine_auto_approval(financial_aid) # Assumes IN threshold is 15000 assert COUNTRY_INCOME_THRESHOLDS["IN"] == 15000 financial_aid = FinancialAidFactory.create(income_usd=20000, country_of_income="IN") assert determine_auto_approval(financial_aid) is True financial_aid = FinancialAidFactory.create(income_usd=1000, country_of_income="IN") assert not determine_auto_approval(financial_aid) # Assumes KP threshold is 0 assert COUNTRY_INCOME_THRESHOLDS["KP"] == 0 financial_aid = FinancialAidFactory.create(income_usd=3000, country_of_income="KP") assert determine_auto_approval(financial_aid) is True financial_aid = FinancialAidFactory.create(income_usd=0, country_of_income="KP") assert determine_auto_approval(financial_aid) is True
def test_save_and_log_model(self): """ Tests that the save_model() function on FinancialAidAdmin model creates FinancialAidAudit object """ financial_aid = FinancialAidFactory.create() assert FinancialAidAudit.objects.count() == 0 financial_aid_admin = FinancialAidAdmin(model=financial_aid, admin_site=Mock()) mock_request = Mock(user=self.staff_user_profile.user) financial_aid_admin.save_model(request=mock_request, obj=financial_aid_admin.model, form=Mock(), change=Mock()) assert FinancialAidAudit.objects.count() == 1
def test_save_and_log_model(self): """ Tests that the save_model() function on FinancialAidAdmin model creates FinancialAidAudit object """ financial_aid = FinancialAidFactory.create() assert FinancialAidAudit.objects.count() == 0 financial_aid_admin = FinancialAidAdmin(model=financial_aid, admin_site=Mock()) mock_request = Mock(user=self.staff_user_profile.user) financial_aid_admin.save_model( request=mock_request, obj=financial_aid_admin.model, form=Mock(), change=Mock() ) assert FinancialAidAudit.objects.count() == 1
def test_skipped_financialaid_object_updated(self, financial_aid_status): """ Tests that an existing FinancialAid object is updated to have the status "skipped" """ financial_aid = FinancialAidFactory.create( user=self.profile.user, tier_program=self.tier_programs["75k"], status=financial_aid_status, ) assert FinancialAidAudit.objects.count() == 0 self.make_http_request(self.client.patch, self.skip_url, status.HTTP_200_OK) assert FinancialAid.objects.exclude(status=FinancialAidStatus.RESET).count() == 1 financial_aid.refresh_from_db() assert financial_aid.tier_program == self.tier_programs["75k"] assert financial_aid.status == FinancialAidStatus.SKIPPED # Check logging assert FinancialAidAudit.objects.count() == 1
def test_financial_aid_model_unique(self): """ Tests that FinancialAid objects are unique per User and Program """ financial_aid = FinancialAidFactory.create() # Test creation of FinancialAid that isn't unique_together with "user" and "tier_program__program" # financial aid with same user and different program (new program created by the factory) FinancialAidFactory.create(user=financial_aid.user) # financial aid with same program and different user (new user created by the factory) FinancialAidFactory.create(tier_program=financial_aid.tier_program) # Test updating the original FinancialAid doesn't raise ValidationError financial_aid.income_usd = 100 financial_aid.save() # Test creation should fail for FinancialAid already existing with the same "user" and "tier_program__program" with self.assertRaises(ValidationError): FinancialAidFactory.create(user=financial_aid.user, tier_program=financial_aid.tier_program)
def test_financial_aid_with_documents_sent(self): """ Test that a user that has a FinancialAid record and has sent documents will have serialized financial aid information that indicates the date that documents were sent """ now = now_in_utc() fin_aid = FinancialAidFactory.create( user=self.user, tier_program=self.min_tier_program, date_documents_sent=now, ) serialized = FinancialAidDashboardSerializer.serialize(self.user, self.program) assert serialized == { "id": fin_aid.id, "has_user_applied": True, "application_status": fin_aid.status, "min_possible_cost": 250, "max_possible_cost": 1000, "date_documents_sent": now.date(), }
def test_get_course_price_for_learner_with_financial_aid(self, status): """ Tests get_course_price_for_learner() who has approved financial aid """ enrollment = ProgramEnrollment.objects.get(program=self.program, user=self.profile.user) financial_aid = FinancialAidFactory.create( user=self.profile.user, tier_program=self.tier_programs['25k'], status=status, ) course_price = self.program.price expected_response = { "program_id": enrollment.program.id, "price": course_price - financial_aid.tier_program.discount_amount, "financial_aid_availability": True, "has_financial_aid_request": True } self.assertDictEqual(get_formatted_course_price(enrollment), expected_response)
def test_financial_aid_with_documents_sent(self): """ Test that a user that has a FinancialAid record and has sent documents will have serialized financial aid information that indicates the date that documents were sent """ now = now_in_utc() fin_aid = FinancialAidFactory.create( user=self.user, tier_program=self.min_tier_program, date_documents_sent=now, ) serialized = FinancialAidDashboardSerializer.serialize( self.user, self.program) assert serialized == { "id": fin_aid.id, "has_user_applied": True, "application_status": fin_aid.status, "min_possible_cost": 250, "max_possible_cost": 1000, "date_documents_sent": now.date(), }
def test_get_course_price_for_learner_with_financial_aid(self, status): """ Tests get_course_price_for_learner() who has approved financial aid """ enrollment = ProgramEnrollment.objects.get(program=self.program, user=self.profile.user) financial_aid = FinancialAidFactory.create( user=self.profile.user, tier_program=self.tier_programs['25k'], status=status, ) course_price = self.program.price expected_response = { "program_id": enrollment.program.id, "price": course_price - financial_aid.tier_program.discount_amount, "financial_aid_availability": True, "has_financial_aid_request": True } self.assertDictEqual( get_formatted_course_price(enrollment), expected_response )
def test_datetime(self): """ Test that a model with a datetime and date field is handled correctly """ financial_aid = FinancialAidFactory.create(justification=None) assert serialize_model_object(financial_aid) == { 'country_of_income': financial_aid.country_of_income, 'country_of_residence': financial_aid.country_of_residence, 'created_on': format_as_iso8601(financial_aid.created_on), 'date_documents_sent': financial_aid.date_documents_sent.isoformat(), 'date_exchange_rate': format_as_iso8601(financial_aid.date_exchange_rate), 'id': financial_aid.id, 'income_usd': financial_aid.income_usd, 'justification': None, 'original_currency': financial_aid.original_currency, 'original_income': financial_aid.original_income, 'status': financial_aid.status, 'tier_program': financial_aid.tier_program.id, 'updated_on': format_as_iso8601(financial_aid.updated_on), 'user': financial_aid.user.id, }
def test_to_dict(self): """ assert output of to_dict """ financial_aid = FinancialAidFactory.create() assert financial_aid.to_dict() == serialize_model_object(financial_aid)
def setUpTestData(cls): course_run = CourseRunFactory.create() cls.financial_aid = FinancialAidFactory.create() cls.tier_program = cls.financial_aid.tier_program cls.tier_program.program = course_run.course.program cls.tier_program.save()
def setUpTestData(cls): course_run = CourseRunFactory.create() cls.financial_aid = FinancialAidFactory.create() cls.tier_program = cls.financial_aid.tier_program cls.tier_program.program = course_run.course.program cls.tier_program.save()