def setUpTestData(cls):
super().setUpTestData()
cls.username = "******".format(cls.profile.user.username)
cls.staff_username = "******".format(cls.staff_user_profile.user.username)
cls.instructor_username = "******".format(cls.instructor_user_profile.user.username)
cls.profile.user.social_auth.create(
provider=EdxOrgOAuth2.name,
uid=cls.username,
extra_data={"access_token": "fooooootoken"}
)
cls.staff_user_profile.user.social_auth.create(
provider=EdxOrgOAuth2.name,
uid=cls.staff_username,
extra_data={"access_token": "fooooootoken"}
)
cls.course_price_url = reverse("course_price_list", args=[cls.username])
cls.staff_course_price_url = reverse("course_price_list", args=[cls.staff_username])
# create a second program
program, _ = create_program()
ProgramEnrollment.objects.create(
program=program,
user=cls.profile.user,
)
# one just for the staff user
other_program, _ = create_program()
ProgramEnrollment.objects.create(
program=other_program,
user=cls.staff_user_profile.user,
)
def test_authorize_exam_runs(self, authorized,
authorize_for_latest_passed_course_mock):
"""Test authorize_exam_runs()"""
program, _ = create_program()
course = program.course_set.first()
enrollment = ProgramEnrollmentFactory.create(program=program)
current_run = ExamRunFactory.create(course=course,
authorized=authorized)
past_run = ExamRunFactory.create(course=course,
scheduling_future=True,
authorized=authorized)
future_run = ExamRunFactory.create(course=course,
scheduling_past=True,
authorized=authorized)
authorize_exam_runs()
if authorized:
assert authorize_for_latest_passed_course_mock.call_count == 0
else:
assert authorize_for_latest_passed_course_mock.call_count == 2
authorize_for_latest_passed_course_mock.assert_any_call(
enrollment.user, current_run)
authorize_for_latest_passed_course_mock.assert_any_call(
enrollment.user, future_run)
for exam_run in (current_run, future_run):
exam_run.refresh_from_db()
assert exam_run.authorized is True
past_run.refresh_from_db()
assert past_run.authorized is False
def test_financialaid_object_cannot_be_skipped_if_not_enrolled_in_program(self):
"""
Tests that a FinancialAid object cannot be skipped if the user is not enrolled in program
"""
program, _ = create_program()
url = reverse("financial_aid_skip", kwargs={"program_id": program.id})
self.make_http_request(self.client.patch, url, status.HTTP_400_BAD_REQUEST)
def setUpTestData(cls):
cls.program, _ = create_program(past=True)
cls.course_run = cls.program.course_set.first().courserun_set.first()
cls.course = cls.course_run.course
cls.program_enrollment = ProgramEnrollmentFactory.create(program=cls.program)
cls.user = cls.program_enrollment.user
with mute_signals(post_save):
cls.final_grades = sorted([
FinalGradeFactory.create(
user=cls.user,
course_run=cls.course_run,
passed=False,
status=FinalGradeStatus.PENDING
),
FinalGradeFactory.create(
user=cls.user,
course_run__course=cls.course,
passed=True,
status=FinalGradeStatus.COMPLETE
),
FinalGradeFactory.create(
user=cls.user,
course_run__course=cls.course,
passed=True,
status=FinalGradeStatus.COMPLETE
),
], key=lambda final_grade: final_grade.course_run.end_date, reverse=True)
def setUpTestData(cls):
cls.program, _ = create_program(past=True)
cls.course_run = cls.program.course_set.first().courserun_set.first()
cls.course = cls.course_run.course
cls.program_enrollment = ProgramEnrollmentFactory.create(
program=cls.program)
cls.user = cls.program_enrollment.user
with mute_signals(post_save):
cls.final_grades = sorted(
[
FinalGradeFactory.create(user=cls.user,
course_run=cls.course_run,
passed=False,
status=FinalGradeStatus.PENDING),
FinalGradeFactory.create(user=cls.user,
course_run__course=cls.course,
passed=True,
status=FinalGradeStatus.COMPLETE),
FinalGradeFactory.create(user=cls.user,
course_run__course=cls.course,
passed=True,
status=FinalGradeStatus.COMPLETE),
],
key=lambda final_grade: final_grade.course_run.end_date,
reverse=True)
def test_staff_of_different_program(self, client, program_review_url):
"""
Not allowed for staff of different program
"""
new_program, _ = create_program()
new_staff_user = create_enrolled_profile(new_program, role=Staff.ROLE_ID).user
client.force_login(new_staff_user)
assert client.get(program_review_url).status_code == status.HTTP_403_FORBIDDEN
def test_staff_of_different_program(self, client, program_review_url):
"""
Not allowed for staff of different program
"""
new_program, _ = create_program()
new_staff_user = create_enrolled_profile(new_program, role=Staff.ROLE_ID).user
client.force_login(new_staff_user)
assert client.get(program_review_url).status_code == status.HTTP_403_FORBIDDEN
def program_data():
"""
Fixture for program and tier_program test data
"""
program, tier_programs = create_program()
return SimpleNamespace(
program=program,
tier_programs=tier_programs,
)
def test_different_programs_staff(self):
"""Different program's staff should not be allowed to send email for this program"""
program, _ = create_program()
staff_user = create_enrolled_profile(program, Staff.ROLE_ID).user
self.client.force_login(staff_user)
self.make_http_request(self.client.post,
self.url,
status.HTTP_403_FORBIDDEN,
data=self.request_data)
def program_data():
"""
Fixture for program and tier_program test data
"""
program, tier_programs = create_program()
return SimpleNamespace(
program=program,
tier_programs=tier_programs,
)
def test_authorize_enrollment_for_exam_run(self, authorize_for_latest_passed_course_mock):
"""Test authorize_enrollment_for_exam_run()"""
program, _ = create_program()
course = program.course_set.first()
enrollment_1 = ProgramEnrollmentFactory.create(program=program)
enrollment_2 = ProgramEnrollmentFactory.create(program=program)
exam_run = ExamRunFactory.create(course=course)
authorize_enrollment_for_exam_run([enrollment_1.id, enrollment_2.id], exam_run.id)
assert authorize_for_latest_passed_course_mock.call_count == 2
authorize_for_latest_passed_course_mock.assert_any_call(enrollment_1.user, exam_run)
authorize_for_latest_passed_course_mock.assert_any_call(enrollment_2.user, exam_run)
def setUpTestData(cls):
cls.program, _ = create_program(past=True)
cls.course_run = cls.program.course_set.first().courserun_set.first()
cls.program_enrollment = ProgramEnrollmentFactory.create(program=cls.program)
cls.user = cls.program_enrollment.user
create_order(cls.user, cls.course_run)
with mute_signals(post_save):
CachedEnrollmentFactory.create(user=cls.user, course_run=cls.course_run)
cls.final_grade = FinalGradeFactory.create(
user=cls.user,
course_run=cls.course_run,
passed=True,
course_run_paid_on_edx=False,
)
def setUpTestData(cls):
with mute_signals(post_save):
profile = ProfileFactory.create()
cls.program, _ = create_program(past=True)
cls.user = profile.user
cls.course_run = cls.program.course_set.first().courserun_set.first()
with mute_signals(post_save):
CachedEnrollmentFactory.create(user=cls.user, course_run=cls.course_run)
cls.exam_run = ExamRunFactory.create(course=cls.course_run.course)
with mute_signals(post_save):
cls.final_grade = FinalGradeFactory.create(
user=cls.user,
course_run=cls.course_run,
passed=True,
course_run_paid_on_edx=False,
)
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 test_different_programs_staff(self):
"""Different program's staff should not be allowed to send email for this program"""
program, _ = create_program()
staff_user = create_enrolled_profile(program, Staff.ROLE_ID).user
self.client.force_login(staff_user)
self.make_http_request(self.client.post, self.url, status.HTTP_403_FORBIDDEN, data=self.request_data)
def test_not_allowed_staff_of_different_program(self, role):
"""Not allowed for staff or instructors of different program"""
program, _ = create_program()
staff_user = create_enrolled_profile(program, role=role).user
self.client.force_login(staff_user)
self.make_http_request(self.client.patch, self.action_url, status.HTTP_403_FORBIDDEN, data=self.data)
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))