def test_retry_failed_edx_enrollments(mocker, exception_raised):
"""
Tests that retry_failed_edx_enrollments loops through enrollments that failed in edX
and attempts to enroll them again
"""
with freeze_time(now_in_utc() - timedelta(days=1)):
failed_enrollments = CourseRunEnrollmentFactory.create_batch(
3, edx_enrolled=False, user__is_active=True)
CourseRunEnrollmentFactory.create(edx_enrolled=False,
user__is_active=False)
patched_enroll_in_edx = mocker.patch(
"courseware.api.enroll_in_edx_course_runs",
side_effect=[None, exception_raised or None, None],
)
patched_log_exception = mocker.patch("courseware.api.log.exception")
successful_enrollments = retry_failed_edx_enrollments()
assert patched_enroll_in_edx.call_count == len(failed_enrollments)
assert len(successful_enrollments) == (3
if exception_raised is None else 2)
assert patched_log_exception.called == bool(exception_raised)
if exception_raised:
failed_enroll_user, failed_enroll_runs = patched_enroll_in_edx.call_args_list[
1][0]
expected_successful_enrollments = [
e for e in failed_enrollments
if e.user != failed_enroll_user and e.run != failed_enroll_runs[0]
]
assert {e.id
for e in successful_enrollments
} == {e.id
for e in expected_successful_enrollments}
def test_create_run_enrollment_edx_failure(
mocker, keep_failed_enrollments, exception_cls, inner_exception
):
"""Test that create_run_enrollment behaves as expected when the enrollment fails in edX"""
now = now_in_utc()
user = UserFactory()
existing_enrollment = CourseRunEnrollmentFactory(user=user)
non_program_run = CourseRunFactory.create(
course__no_program=True, start_date=(now + timedelta(days=1))
)
expected_enrollment = CourseRunEnrollmentFactory(user=user, run=non_program_run)
patched_edx_enroll = mocker.patch(
"courses.management.utils.enroll_in_edx_course_runs",
side_effect=exception_cls(user, non_program_run, inner_exception),
)
new_enrollment = EnrollmentChangeCommand().create_run_enrollment(
existing_enrollment=existing_enrollment,
to_user=user,
to_run=non_program_run,
keep_failed_enrollments=keep_failed_enrollments,
)
patched_edx_enroll.assert_called_once_with(user, [non_program_run])
if keep_failed_enrollments:
assert new_enrollment == expected_enrollment
else:
assert new_enrollment is None
def test_create_run_enrollments(mocker, user):
"""
create_run_enrollments should call the edX API to create enrollments, create or reactivate local
enrollment records, and notify enrolled users via email
"""
num_runs = 3
order = OrderFactory.create()
company = CompanyFactory.create()
runs = CourseRunFactory.create_batch(num_runs)
# Create an existing deactivate enrollment to test that it gets reactivated
CourseRunEnrollmentFactory.create(
user=user,
run=runs[0],
order=order,
change_status=ENROLL_CHANGE_STATUS_REFUNDED,
active=False,
)
patched_edx_enroll = mocker.patch("courses.api.enroll_in_edx_course_runs")
patched_send_enrollment_email = mocker.patch(
"courses.api.mail_api.send_course_run_enrollment_email")
successful_enrollments, edx_request_success = create_run_enrollments(
user, runs, order=order, company=company)
patched_edx_enroll.assert_called_once_with(user, runs)
assert patched_send_enrollment_email.call_count == num_runs
assert edx_request_success is True
assert len(successful_enrollments) == num_runs
enrollments = CourseRunEnrollment.objects.order_by("run__id").all()
for (run, enrollment) in zip(runs, enrollments):
assert enrollment.change_status is None
assert enrollment.active is True
assert enrollment.edx_enrolled is True
assert enrollment.run == run
patched_send_enrollment_email.assert_any_call(enrollment)
def test_course_available_runs():
"""enrolled runs for a user should not be in the list of available runs"""
user = UserFactory.create()
course = CourseFactory.create()
runs = CourseRunFactory.create_batch(2, course=course, live=True)
runs.sort(key=lambda run: run.start_date)
CourseRunEnrollmentFactory.create(run=runs[0], user=user)
assert course.available_runs(user) == [runs[1]]
assert course.available_runs(UserFactory.create()) == runs
def test_course_view(client, user, home_page, is_enrolled, has_unexpired_run,
has_product, is_anonymous):
"""
Test that the course detail view has the right context and shows the right HTML for the enroll/view button
"""
course = CourseFactory.create(live=True, page__parent=home_page)
if has_unexpired_run:
run = CourseRunFactory.create(course=course, live=True)
else:
run = None
if has_product and has_unexpired_run:
product_id = ProductVersionFactory.create(product=ProductFactory(
content_object=run)).product.id
else:
product_id = None
if is_enrolled and has_unexpired_run:
CourseRunEnrollmentFactory.create(user=user, run=run)
if not is_anonymous:
client.force_login(user)
resp = client.get(course.page.get_url())
assert resp.context["user"] == user if not is_anonymous else AnonymousUser(
)
assert resp.context["product_id"] == product_id
assert resp.context["enrolled"] == (is_enrolled and has_unexpired_run
and not is_anonymous)
# Anynoymous users don't see the enrolled/enroll-now button.
# For logged in users:
# a) product should exist, next courserun should be there, user not enrolled (enroll now button)
# b) user is enrolled (enrolled button)
# NOTE: added `has_unexpired_run` to test for case (b) only because of the way the test is written,
# enrollment isn't actually created unless the course has an unexpired run.
has_button = ((has_product and has_unexpired_run and not is_enrolled) or
(is_enrolled and has_unexpired_run)) and not is_anonymous
url = "" # make linter happy
class_name = ""
if not is_anonymous:
if not is_enrolled and has_product and has_unexpired_run:
url = f'{reverse("checkout-page")}?product={product_id}'
class_name = "enroll-now"
if is_enrolled and has_unexpired_run:
url = reverse("user-dashboard")
class_name = "enrolled"
assert (
f'<a class="enroll-button {class_name}" href="{url}">'.encode("utf-8")
in resp.content) is has_button
assert ("Please Sign In to MITx PRO to enroll in a course".encode("utf-8")
in resp.content) is (is_anonymous and has_product
and has_unexpired_run)
def test_fetch_enrollment(order):
"""Test that method return enrollment and enrolled object, include order while querying if passed"""
user = UserFactory()
run_enrollment = CourseRunEnrollmentFactory(user=user)
program_enrollment = ProgramEnrollmentFactory(user=user)
run_command_options = {"run": run_enrollment.run.courseware_id}
program_command_options = {"program": program_enrollment.program.readable_id}
if order:
run_command_options["order"] = run_enrollment.order
program_command_options["order"] = program_enrollment.order
enrollment_obj, enrolled_obj = EnrollmentChangeCommand.fetch_enrollment(
user=user, command_options=run_command_options
)
assert enrolled_obj == run_enrollment.run
assert enrollment_obj == run_enrollment
enrollment_obj, enrolled_obj = EnrollmentChangeCommand.fetch_enrollment(
user=user, command_options=program_command_options
)
assert enrolled_obj == program_enrollment.program
assert enrollment_obj == program_enrollment
def test_defer_enrollment_validation(mocker, user):
"""
defer_enrollment should raise an exception if the 'from' or 'to' course runs are invalid
"""
courses = CourseFactory.create_batch(2)
enrollments = CourseRunEnrollmentFactory.create_batch(
3,
user=user,
active=factory.Iterator([False, True, True]),
run__course=factory.Iterator([courses[0], courses[0], courses[1]]),
)
unenrollable_run = CourseRunFactory.create(enrollment_end=now_in_utc() -
timedelta(days=1))
patched_create_enrollments = mocker.patch(
"courses.api.create_run_enrollments", return_value=([], False))
mocker.patch("courses.api.deactivate_run_enrollment", return_value=[])
with pytest.raises(ValidationError):
# Deferring to the same course run should raise a validation error
defer_enrollment(user, enrollments[0].run.courseware_id,
enrollments[0].run.courseware_id)
patched_create_enrollments.assert_not_called()
with pytest.raises(ValidationError):
# Deferring to a course run that is outside of its enrollment period should raise a validation error
defer_enrollment(user, enrollments[0].run.courseware_id,
unenrollable_run.courseware_id)
patched_create_enrollments.assert_not_called()
with pytest.raises(ValidationError):
# Deferring from an inactive enrollment should raise a validation error
defer_enrollment(user, enrollments[0].run.courseware_id,
enrollments[1].run.courseware_id)
patched_create_enrollments.assert_not_called()
with pytest.raises(ValidationError):
# Deferring to a course run in a different course should raise a validation error
defer_enrollment(user, enrollments[1].run.courseware_id,
enrollments[2].run.courseware_id)
patched_create_enrollments.assert_not_called()
# The last two cases should not raise an exception if the 'force' flag is set to True
defer_enrollment(
user,
enrollments[0].run.courseware_id,
enrollments[1].run.courseware_id,
force=True,
)
assert patched_create_enrollments.call_count == 1
defer_enrollment(
user,
enrollments[1].run.courseware_id,
enrollments[2].run.courseware_id,
force=True,
)
assert patched_create_enrollments.call_count == 2
def test_unenroll_edx_course_run_failure(mocker, client_exception_raised,
expected_exception):
"""Tests that unenroll_edx_course_run translates exceptions raised by the API client"""
run_enrollment = CourseRunEnrollmentFactory.create(edx_enrolled=True)
mock_client = mocker.MagicMock()
mock_client.enrollments.deactivate_enrollment = mocker.Mock(
side_effect=client_exception_raised)
mocker.patch("courseware.api.get_edx_api_client", return_value=mock_client)
with pytest.raises(expected_exception):
unenroll_edx_course_run(run_enrollment)
def test_send_course_run_enrollment_email_error(mocker):
"""send_course_run_enrollment_email handle and log errors"""
patched_mail_api = mocker.patch("ecommerce.mail_api.api")
patched_log = mocker.patch("ecommerce.mail_api.log")
patched_mail_api.send_message.side_effect = Exception("error")
enrollment = CourseRunEnrollmentFactory.create()
send_course_run_enrollment_email(enrollment)
patched_log.exception.assert_called_once_with(
"Error sending enrollment success email")
def test_retry_failed_enroll_grace_period(mocker):
"""
Tests that retry_failed_edx_enrollments does not attempt to repair any enrollments that were recently created
"""
now = now_in_utc()
with freeze_time(now - timedelta(
minutes=COURSEWARE_REPAIR_GRACE_PERIOD_MINS - 1)):
CourseRunEnrollmentFactory.create(edx_enrolled=False,
user__is_active=True)
with freeze_time(now - timedelta(
minutes=COURSEWARE_REPAIR_GRACE_PERIOD_MINS + 1)):
older_enrollment = CourseRunEnrollmentFactory.create(
edx_enrolled=False, user__is_active=True)
patched_enroll_in_edx = mocker.patch(
"courseware.api.enroll_in_edx_course_runs")
successful_enrollments = retry_failed_edx_enrollments()
assert successful_enrollments == [older_enrollment]
patched_enroll_in_edx.assert_called_once_with(older_enrollment.user,
[older_enrollment.run])
def test_deactivate_and_save():
"""Test that the deactivate_and_save method in enrollment models sets properties and saves"""
course_run_enrollment = CourseRunEnrollmentFactory.create(
active=True, change_status=None)
program_enrollment = ProgramEnrollmentFactory.create(active=True,
change_status=None)
enrollments = [course_run_enrollment, program_enrollment]
for enrollment in enrollments:
enrollment.deactivate_and_save(ENROLL_CHANGE_STATUS_REFUNDED)
enrollment.refresh_from_db()
enrollment.active = False
enrollment.change_status = ENROLL_CHANGE_STATUS_REFUNDED
def test_unenroll_edx_course_run(mocker):
"""Tests that unenroll_edx_course_run makes a call to unenroll in edX via the API client"""
mock_client = mocker.MagicMock()
run_enrollment = CourseRunEnrollmentFactory.create(edx_enrolled=True)
courseware_id = run_enrollment.run.courseware_id
enroll_return_value = mocker.Mock(json={"course_id": courseware_id})
mock_client.enrollments.deactivate_enrollment = mocker.Mock(
return_value=enroll_return_value)
mocker.patch("courseware.api.get_edx_api_client", return_value=mock_client)
deactivated_enrollment = unenroll_edx_course_run(run_enrollment)
mock_client.enrollments.deactivate_enrollment.assert_called_once_with(
courseware_id)
assert deactivated_enrollment == enroll_return_value
def test_get_program_run_enrollments(user):
"""
Test that the get_program_run_enrollments helper method for CourseRunEnrollment returns
the appropriate course run enrollments for a program
"""
programs = ProgramFactory.create_batch(2)
program = programs[0]
course_run_enrollments = CourseRunEnrollmentFactory.create_batch(
2,
user=user,
run__course__program=factory.Iterator([program, program, programs[1]]),
)
expected_run_enrollments = set(course_run_enrollments[0:2])
assert (set(CourseRunEnrollment.get_program_run_enrollments(
user, program)) == expected_run_enrollments)
def test_defer_enrollment(mocker, keep_failed_enrollments):
"""
defer_enrollment should deactivate a user's existing enrollment and create an enrollment in another
course run
"""
course = CourseFactory.create()
course_runs = CourseRunFactory.create_batch(3, course=course)
order = OrderFactory.create()
company = CompanyFactory.create()
existing_enrollment = CourseRunEnrollmentFactory.create(run=course_runs[0],
order=order,
company=company)
target_run = course_runs[1]
mock_new_enrollment = mocker.Mock()
patched_create_enrollments = mocker.patch(
"courses.api.create_run_enrollments",
autospec=True,
return_value=([
mock_new_enrollment if keep_failed_enrollments else None
], True),
)
patched_deactivate_enrollments = mocker.patch(
"courses.api.deactivate_run_enrollment",
autospec=True,
return_value=existing_enrollment if keep_failed_enrollments else None,
)
returned_from_enrollment, returned_to_enrollment = defer_enrollment(
existing_enrollment.user,
existing_enrollment.run.courseware_id,
course_runs[1].courseware_id,
keep_failed_enrollments=keep_failed_enrollments,
)
assert returned_from_enrollment == patched_deactivate_enrollments.return_value
assert returned_to_enrollment == patched_create_enrollments.return_value[
0][0]
patched_create_enrollments.assert_called_once_with(
existing_enrollment.user,
[target_run],
order=order,
company=company,
keep_failed_enrollments=keep_failed_enrollments,
)
patched_deactivate_enrollments.assert_called_once_with(
existing_enrollment,
ENROLL_CHANGE_STATUS_DEFERRED,
keep_failed_enrollments=keep_failed_enrollments,
)
def test_send_course_run_enrollment_email(mocker):
"""send_course_run_enrollment_email should send an email for the given enrollment"""
patched_mail_api = mocker.patch("ecommerce.mail_api.api")
enrollment = CourseRunEnrollmentFactory.create()
send_course_run_enrollment_email(enrollment)
patched_mail_api.context_for_user.assert_called_once_with(
user=enrollment.user, extra_context={"enrollment": enrollment})
patched_mail_api.message_for_recipient.assert_called_once_with(
enrollment.user.email,
patched_mail_api.context_for_user.return_value,
EMAIL_COURSE_RUN_ENROLLMENT,
)
patched_mail_api.send_message.assert_called_once_with(
patched_mail_api.message_for_recipient.return_value)
def test_deactivate_run_enrollment(self, patches):
"""
deactivate_run_enrollment should attempt to unenroll a user in a course run in edX and set the
local enrollment record to inactive
"""
enrollment = CourseRunEnrollmentFactory.create(edx_enrolled=True)
returned_enrollment = deactivate_run_enrollment(
enrollment, change_status=ENROLL_CHANGE_STATUS_REFUNDED)
patches.edx_unenroll.assert_called_once_with(enrollment)
patches.send_unenrollment_email.assert_called_once_with(enrollment)
enrollment.refresh_from_db()
assert enrollment.change_status == ENROLL_CHANGE_STATUS_REFUNDED
assert enrollment.active is False
assert enrollment.edx_enrolled is False
assert returned_enrollment == enrollment
def test_audit(user, is_program, has_company):
"""Test audit table serialization"""
enrollment = (ProgramEnrollmentFactory.create()
if is_program else CourseRunEnrollmentFactory.create())
if has_company:
enrollment.company = CompanyFactory.create()
enrollment.save_and_log(user)
expected = {
"active":
enrollment.active,
"change_status":
enrollment.change_status,
"created_on":
format_as_iso8601(enrollment.created_on),
"company":
enrollment.company.id if has_company else None,
"company_name":
enrollment.company.name if has_company else None,
"email":
enrollment.user.email,
"full_name":
enrollment.user.name,
"id":
enrollment.id,
"order":
enrollment.order.id,
"text_id":
enrollment.program.readable_id
if is_program else enrollment.run.courseware_id,
"updated_on":
format_as_iso8601(enrollment.updated_on),
"user":
enrollment.user.id,
"username":
enrollment.user.username,
}
if not is_program:
expected["edx_enrolled"] = enrollment.edx_enrolled
expected["run"] = enrollment.run.id
else:
expected["program"] = enrollment.program.id
assert (enrollment.get_audit_class().objects.get(
enrollment=enrollment).data_after == expected)
def test_deactivate_run_enrollment_api_fail(self, patches,
keep_failed_enrollments):
"""
If a flag is provided, deactivate_run_enrollment should set local enrollment record to inactive even if the API call fails
"""
enrollment = CourseRunEnrollmentFactory.create(edx_enrolled=True)
patches.edx_unenroll.side_effect = Exception
deactivate_run_enrollment(
enrollment,
change_status=ENROLL_CHANGE_STATUS_REFUNDED,
keep_failed_enrollments=keep_failed_enrollments,
)
patches.edx_unenroll.assert_called_once_with(enrollment)
patches.send_unenrollment_email.assert_not_called()
patches.log_exception.assert_called_once()
enrollment.refresh_from_db()
assert enrollment.active is not keep_failed_enrollments
def test_enrollment_is_ended():
"""Verify that is_ended returns True, if all of course runs in a program/course are ended."""
past_date = now_in_utc() - timedelta(days=1)
past_program = ProgramFactory.create()
past_course = CourseFactory.create()
past_course_runs = CourseRunFactory.create_batch(
3,
end_date=past_date,
course=past_course,
course__program=past_program)
program_enrollment = ProgramEnrollmentFactory.create(program=past_program)
course_enrollment = CourseRunEnrollmentFactory.create(
run=past_course_runs[0])
assert program_enrollment.is_ended
assert course_enrollment.is_ended
def test_serialize_course_run_enrollments(settings, has_company,
receipts_enabled):
"""Test that CourseRunEnrollmentSerializer has correct data"""
settings.ENABLE_ORDER_RECEIPTS = receipts_enabled
course_run_enrollment = CourseRunEnrollmentFactory.create(
has_company_affiliation=has_company)
serialized_data = CourseRunEnrollmentSerializer(course_run_enrollment).data
assert serialized_data == {
"run":
CourseRunDetailSerializer(course_run_enrollment.run).data,
"company": (CompanySerializer(course_run_enrollment.company).data
if has_company else None),
"certificate":
None,
"receipt":
course_run_enrollment.order_id
if course_run_enrollment.order.status == Order.FULFILLED
and receipts_enabled else None,
}
def test_deactivate_program_enrollment(self, user, patches):
"""
deactivate_program_enrollment set the local program enrollment record to inactive as well as all
associated course run enrollments
"""
order = OrderFactory.create()
program_enrollment = ProgramEnrollmentFactory.create(user=user,
order=order)
course = CourseFactory.create(program=program_enrollment.program)
course_run_enrollments = CourseRunEnrollmentFactory.create_batch(
3,
user=user,
run__course=course,
active=True,
order=factory.Iterator([order, order, None]),
)
expected_inactive_run_enrollments = course_run_enrollments[0:2]
expected_ignored_run_enrollment = course_run_enrollments[2]
returned_program_enrollment, returned_run_enrollments = deactivate_program_enrollment(
program_enrollment, change_status=ENROLL_CHANGE_STATUS_REFUNDED)
program_enrollment.refresh_from_db()
assert program_enrollment.change_status == ENROLL_CHANGE_STATUS_REFUNDED
assert program_enrollment.active is False
assert returned_program_enrollment == program_enrollment
assert {e.id
for e in returned_run_enrollments
} == {e.id
for e in expected_inactive_run_enrollments}
assert patches.edx_unenroll.call_count == len(
expected_inactive_run_enrollments)
assert patches.send_unenrollment_email.call_count == len(
expected_inactive_run_enrollments)
for run_enrollment in expected_inactive_run_enrollments:
run_enrollment.refresh_from_db()
assert run_enrollment.change_status == ENROLL_CHANGE_STATUS_REFUNDED
assert run_enrollment.active is False
assert expected_ignored_run_enrollment.active is True
def test_create_run_enrollments_creation_fail(mocker, user):
"""
create_run_enrollments should log a message and send an admin email if there's an error during the
creation of local enrollment records
"""
runs = CourseRunFactory.create_batch(2)
enrollment = CourseRunEnrollmentFactory.build(run=runs[1])
mocker.patch(
"courses.api.CourseRunEnrollment.all_objects.get_or_create",
side_effect=[Exception(), (enrollment, True)],
)
patched_edx_enroll = mocker.patch("courses.api.enroll_in_edx_course_runs")
patched_log_exception = mocker.patch("courses.api.log.exception")
patched_mail_api = mocker.patch("courses.api.mail_api")
successful_enrollments, edx_request_success = create_run_enrollments(
user, runs, order=None, company=None)
patched_edx_enroll.assert_called_once_with(user, runs)
patched_log_exception.assert_called_once()
patched_mail_api.send_course_run_enrollment_email.assert_not_called()
patched_mail_api.send_enrollment_failure_message.assert_called_once()
assert successful_enrollments == [enrollment]
assert edx_request_success is True
def test_serialize_program_enrollments(settings, has_company,
receipts_enabled):
"""Test that ProgramEnrollmentSerializer has correct data"""
settings.ENABLE_ORDER_RECEIPTS = receipts_enabled
program = ProgramFactory.create()
course_run_enrollments = CourseRunEnrollmentFactory.create_batch(
3,
run__course__program=factory.Iterator([program, program, None]),
run__course__position_in_program=factory.Iterator([2, 1, None]),
)
program_enrollment = ProgramEnrollmentFactory.create(
program=program, has_company_affiliation=has_company)
serialized_data = ProgramEnrollmentSerializer(program_enrollment,
context={
"course_run_enrollments":
course_run_enrollments
}).data
assert serialized_data == {
"id":
program_enrollment.id,
"program":
BaseProgramSerializer(program).data,
"company": (CompanySerializer(program_enrollment.company).data
if has_company else None),
# Only enrollments for the given program should be serialized, and they should be
# sorted by position in program.
"course_run_enrollments":
CourseRunEnrollmentSerializer(
[course_run_enrollments[1], course_run_enrollments[0]],
many=True).data,
"certificate":
None,
"receipt":
program_enrollment.order_id
if program_enrollment.order.status == Order.FULFILLED
and receipts_enabled else None,
}
def test_serialize_course(mock_context, is_anonymous, all_runs):
"""Test Course serialization"""
now = datetime.now(tz=pytz.UTC)
if is_anonymous:
mock_context["request"].user = AnonymousUser()
if all_runs:
mock_context["all_runs"] = True
user = mock_context["request"].user
course_run = CourseRunFactory.create(course__no_program=True, live=True)
course = course_run.course
topic = "a course topic"
course.topics.set([CourseTopic.objects.create(name=topic)])
# Create expired, enrollment_ended, future, and enrolled course runs
CourseRunFactory.create(course=course,
end_date=now - timedelta(1),
live=True)
CourseRunFactory.create(course=course,
enrollment_end=now - timedelta(1),
live=True)
CourseRunFactory.create(course=course,
enrollment_start=now + timedelta(1),
live=True)
enrolled_run = CourseRunFactory.create(course=course, live=True)
unexpired_runs = [enrolled_run, course_run]
CourseRunEnrollmentFactory.create(run=enrolled_run,
**({} if is_anonymous else {
"user": user
}))
# create products for all courses so the serializer shows them
for run in CourseRun.objects.all():
ProductVersionFactory.create(product__content_object=run)
data = CourseSerializer(instance=course, context=mock_context).data
if all_runs or is_anonymous:
expected_runs = unexpired_runs
else:
expected_runs = [course_run]
assert_drf_json_equal(
data,
{
"title":
course.title,
"description":
course.page.description,
"readable_id":
course.readable_id,
"id":
course.id,
"courseruns": [
CourseRunSerializer(run).data
for run in sorted(expected_runs,
key=lambda run: run.start_date)
],
"thumbnail_url":
f"http://localhost:8053{course.page.thumbnail_image.file.url}",
"next_run_id":
course.first_unexpired_run.id,
"topics": [{
"name": topic
}],
},
)
def test_get_user_enrollments(user):
"""Test that get_user_enrollments returns an object with a user's program and course enrollments"""
past_date = now_in_utc() - timedelta(days=1)
past_start_dates = [
now_in_utc() - timedelta(days=2),
now_in_utc() - timedelta(days=3),
now_in_utc() - timedelta(days=4),
]
program = ProgramFactory.create()
past_program = ProgramFactory.create()
program_course_runs = CourseRunFactory.create_batch(
3, course__program=program)
past_program_course_runs = CourseRunFactory.create_batch(
3,
start_date=factory.Iterator(past_start_dates),
end_date=past_date,
course__program=past_program,
)
non_program_course_runs = CourseRunFactory.create_batch(
2, course__program=None)
past_non_program_course_runs = CourseRunFactory.create_batch(
2,
start_date=factory.Iterator(past_start_dates),
end_date=past_date,
course__program=None,
)
all_course_runs = (program_course_runs + past_program_course_runs +
non_program_course_runs + past_non_program_course_runs)
course_run_enrollments = CourseRunEnrollmentFactory.create_batch(
len(all_course_runs), run=factory.Iterator(all_course_runs), user=user)
program_enrollment = ProgramEnrollmentFactory.create(program=program,
user=user)
past_program_enrollment = ProgramEnrollmentFactory.create(
program=past_program, user=user)
# Add a non-active enrollment so we can confirm that it isn't returned
CourseRunEnrollmentFactory.create(user=user, active=False)
def key_func(enrollment):
""" Function for sorting runs by start_date"""
return enrollment.run.start_date
user_enrollments = get_user_enrollments(user)
assert list(user_enrollments.programs) == [program_enrollment]
assert list(user_enrollments.past_programs) == [past_program_enrollment]
assert list(user_enrollments.program_runs) == sorted(
[
run_enrollment for run_enrollment in course_run_enrollments
if run_enrollment.run in program_course_runs +
past_program_course_runs
],
key=key_func,
)
assert list(user_enrollments.non_program_runs) == sorted(
[
run_enrollment for run_enrollment in course_run_enrollments
if run_enrollment.run in non_program_course_runs
],
key=key_func,
)
assert list(user_enrollments.past_non_program_runs) == sorted(
[
run_enrollment for run_enrollment in course_run_enrollments
if run_enrollment.run in past_non_program_course_runs
],
key=key_func,
)
