def test_email_settings_unfulfilled_entitlement(self, mock_email_feature,
mock_course_overview):
"""
Assert that the Email Settings action is not shown when the entitlement is not fulfilled.
"""
mock_email_feature.return_value = True
mock_course_overview.return_value = CourseOverviewFactory(
start=self.TOMORROW)
CourseEntitlementFactory(user=self.user)
response = self.client.get(self.path)
self.assertEqual(
pq(response.content)(self.EMAIL_SETTINGS_ELEMENT_ID).length, 0)
def setUp(self): # pylint: disable=arguments-differ
super().setUp()
self.course = CourseOverviewFactory()
self.user = UserFactory.create(username="******",
first_name="Student",
last_name="Person",
email="*****@*****.**",
is_active=True)
self.first_cohort = CohortFactory(course_id=self.course.id,
name="FirstCohort")
self.second_cohort = CohortFactory(course_id=self.course.id,
name="SecondCohort")
def setUp(self):
super().setUp()
freezer = freeze_time(datetime(2013, 10, 3, 8, 24, 55, tzinfo=pytz.utc))
self.addCleanup(freezer.stop)
freezer.start()
self.course = CourseOverviewFactory()
self.user = UserFactory()
self.request = RequestFactory().request()
self.request.site = SiteFactory()
self.request.user = self.user
def test_email_settings_fulfilled_entitlement(self, mock_email_feature,
mock_course_overview):
"""
Assert that the Email Settings action is shown when the user has a fulfilled entitlement.
"""
mock_email_feature.return_value = True
mock_course_overview.return_value = CourseOverviewFactory(
start=self.TOMORROW, self_paced=True, enrollment_end=self.TOMORROW)
course_enrollment = CourseEnrollmentFactory(user=self.user)
CourseEntitlementFactory(user=self.user,
enrollment_course_run=course_enrollment)
response = self.client.get(self.path)
self.assertEqual(
pq(response.content)(self.EMAIL_SETTINGS_ELEMENT_ID).length, 1)
def test_get_language_name_from_codes(language_codes, language_names):
"""
Tests if the correct language names are being returned, with their respective course_ids
"""
language_codes_with_course_ids = []
expected_output = []
for language_code, language_name in zip(language_codes, language_names):
course = CourseOverviewFactory(language=language_code)
language_codes_with_course_ids.append((course.id, language_code))
expected_output.append((course.id, language_name))
assert get_language_names_from_codes(
language_codes_with_course_ids) == expected_output
def test_multilingual_group_with_single_course(mock_module_store,
course_inline_formset,
course_group_data):
"""
Test formset is valid for a single multilingual course.
"""
mock_module_store.get_course.return_value = mock.Mock()
course = CourseOverviewFactory()
course_group_data['multilingual_courses-0-course'] = course.id
formset = course_inline_formset(course_group_data,
prefix='multilingual_courses')
assert formset.is_valid()
def test_external_course_updates(self, bucket):
"""Confirm that we exclude enrollments in the external course updates experiment"""
user = UserFactory()
overview1 = CourseOverviewFactory(
has_highlights=False
) # set has_highlights just to avoid a modulestore lookup
overview2 = CourseOverviewFactory(has_highlights=False)
# We need to enroll with a request, because our specific experiment code expects it
self.addCleanup(crum.set_current_request, None)
request = RequestFactory()
request.user = user
crum.set_current_request(request)
enrollment1 = CourseEnrollment.enroll(user, overview1.id)
with override_experiment_waffle_flag(_EXTERNAL_COURSE_UPDATES_FLAG,
bucket=bucket):
enrollment2 = CourseEnrollment.enroll(user, overview2.id)
# OK, at this point, we'd expect course1 to be returned, but course2's enrollment to be excluded by the
# experiment. Note that the experiment waffle is currently inactive, but they should still be excluded because
# they were bucketed at enrollment time.
bin_num = BinnedSchedulesBaseResolver.bin_num_for_user_id(user.id)
resolver = BinnedSchedulesBaseResolver(None, self.site,
datetime.datetime.now(pytz.UTC),
0, bin_num)
resolver.schedule_date_field = 'created'
schedules = resolver.get_schedules_with_target_date_by_bin_and_orgs()
if bucket == 1:
assert len(schedules) == 1
assert schedules[0].enrollment == enrollment1
else:
assert len(schedules) == 2
assert {s.enrollment
for s in schedules} == {enrollment1, enrollment2}
def setUp(self):
"""
Set up test data
"""
super(ProgramCourseEnrollmentModelTests, self).setUp()
RequestCache.clear_all_namespaces()
self.user = UserFactory.create()
self.program_uuid = uuid4()
self.program_enrollment = ProgramEnrollment.objects.create(
user=self.user,
external_user_key='abc',
program_uuid=self.program_uuid,
curriculum_uuid=uuid4(),
status='enrolled')
self.course_key = CourseKey.from_string(generate_course_run_key())
CourseOverviewFactory(id=self.course_key)
def setUpClass(cls):
super(SocialAuthEnrollmentCompletionSignalTest, cls).setUpClass()
cls.external_id = '0000'
cls.provider_slug = 'uox'
cls.course_keys = [
CourseKey.from_string('course-v1:edX+DemoX+Test_Course'),
CourseKey.from_string('course-v1:edX+DemoX+Another_Test_Course'),
]
cls.organization = OrganizationFactory.create(short_name='UoX')
cls.user = UserFactory.create()
for course_key in cls.course_keys:
CourseOverviewFactory(id=course_key)
cls.provider_config = SAMLProviderConfigFactory.create(
organization=cls.organization, slug=cls.provider_slug)
def setUp(self):
"""
Set up test data
"""
super(ProgramCourseEnrollmentModelTests, self).setUp()
RequestCache.clear_all_namespaces()
self.user = UserFactory(username="******")
self.program_uuid = UUID("88888888-4444-2222-1111-000000000000")
self.curriculum_uuid = UUID("77777777-4444-2222-1111-000000000000")
self.program_enrollment = ProgramEnrollmentFactory(
user=self.user,
external_user_key='abc',
program_uuid=self.program_uuid,
curriculum_uuid=self.curriculum_uuid,
status='enrolled')
self.course_key = CourseKey.from_string("course-v1:blah+blah+blah")
CourseOverviewFactory(id=self.course_key)
def test_fulfilled_expired_entitlement(self, mock_course_key,
mock_course_overview,
mock_course_runs,
mock_get_programs):
"""
When a learner has a fulfilled entitlement that is expired, their course dashboard should have:
- exactly one course item, meaning it:
- has an entitlement card
- Message that the learner can no longer change sessions
- a related programs message
"""
mocked_course_overview = CourseOverviewFactory(
start=self.TOMORROW, self_paced=True, enrollment_end=self.TOMORROW)
mock_course_overview.return_value = mocked_course_overview
mock_course_key.return_value = mocked_course_overview.id
course_enrollment = CourseEnrollmentFactory(
user=self.user,
course_id=unicode(mocked_course_overview.id),
created=self.THREE_YEARS_AGO)
mock_course_runs.return_value = [{
'key':
str(mocked_course_overview.id),
'enrollment_end':
str(mocked_course_overview.enrollment_end),
'pacing_type':
'self_paced',
'type':
'verified',
'status':
'published'
}]
entitlement = CourseEntitlementFactory(
user=self.user,
enrollment_course_run=course_enrollment,
created=self.THREE_YEARS_AGO)
program = ProgramFactory()
program['courses'][0]['course_runs'] = [{
'key':
unicode(mocked_course_overview.id)
}]
program['courses'][0]['uuid'] = entitlement.course_uuid
mock_get_programs.return_value = [program]
response = self.client.get(self.path)
self.assertEqual(response.content.count('<li class="course-item">'), 1)
self.assertIn('You can no longer change sessions.', response.content)
self.assertIn('Related Programs:', response.content)
def test_email_settings_fulfilled_entitlement(self, mock_email_feature, mock_get_course_runs):
"""
Assert that the Email Settings action is shown when the user has a fulfilled entitlement.
"""
mock_email_feature.return_value = True
course_overview = CourseOverviewFactory(
start=self.TOMORROW, self_paced=True, enrollment_end=self.TOMORROW
)
course_enrollment = CourseEnrollmentFactory(user=self.user, course_id=course_overview.id)
entitlement = CourseEntitlementFactory(user=self.user, enrollment_course_run=course_enrollment)
course_runs = [{
'key': six.text_type(course_overview.id),
'uuid': entitlement.course_uuid
}]
mock_get_course_runs.return_value = course_runs
response = self.client.get(self.path)
self.assertEqual(pq(response.content)(self.EMAIL_SETTINGS_ELEMENT_ID).length, 1)
def test_send_after_course_end(self, mock_schedule_send):
user1 = UserFactory.create(id=tasks.RECURRING_NUDGE_NUM_BINS)
schedule = ScheduleFactory.create(
start=datetime.datetime(2017, 8, 3, 20, 34, 30, tzinfo=pytz.UTC),
enrollment__user=user1,
)
schedule.enrollment.course = CourseOverviewFactory()
schedule.enrollment.course.end = datetime.datetime.now(pytz.UTC) - datetime.timedelta(days=1)
test_datetime = datetime.datetime(2017, 8, 3, 20, tzinfo=pytz.UTC)
test_datetime_str = serialize(test_datetime)
tasks.recurring_nudge_schedule_bin.apply_async(
self.site_config.site.id, target_day_str=test_datetime_str, day_offset=-3, bin_num=0,
org_list=[schedule.enrollment.course.org],
)
self.assertFalse(mock_schedule_send.apply_async.called)
def test_fulfilled_entitlement(self, mock_course_key, mock_course_overview,
mock_course_runs, mock_get_programs):
"""
When a learner has a fulfilled entitlement, their course dashboard should have:
- exactly one course item, meaning it:
- has an entitlement card
- does NOT have a course card referencing the selected session
- an unhidden Change or Leave Session button
- a related programs message
"""
mocked_course_overview = CourseOverviewFactory(
start=self.TOMORROW, self_paced=True, enrollment_end=self.TOMORROW)
mock_course_overview.return_value = mocked_course_overview
mock_course_key.return_value = mocked_course_overview.id
course_enrollment = CourseEnrollmentFactory(
user=self.user, course_id=unicode(mocked_course_overview.id))
mock_course_runs.return_value = [{
'key':
str(mocked_course_overview.id),
'enrollment_end':
str(mocked_course_overview.enrollment_end),
'pacing_type':
'self_paced',
'type':
'verified',
'status':
'published'
}]
entitlement = CourseEntitlementFactory(
user=self.user, enrollment_course_run=course_enrollment)
program = ProgramFactory()
program['courses'][0]['course_runs'] = [{
'key':
unicode(mocked_course_overview.id)
}]
program['courses'][0]['uuid'] = entitlement.course_uuid
mock_get_programs.return_value = [program]
response = self.client.get(self.path)
self.assertEqual(response.content.count('<li class="course-item">'), 1)
self.assertIn('<button class="change-session btn-link "',
response.content)
self.assertIn('Related Programs:', response.content)
def test_unfulfilled_expired_entitlement(self, mock_course_overview,
mock_course_runs):
"""
When a learner has an unfulfilled, expired entitlement, a card should NOT appear on the dashboard.
This use case represents either an entitlement that the user waited too long to fulfill, or an entitlement
for which they received a refund.
"""
CourseEntitlementFactory(user=self.user,
created=self.THREE_YEARS_AGO,
expired_at=datetime.datetime.now())
mock_course_overview.return_value = CourseOverviewFactory(
start=self.TOMORROW)
mock_course_runs.return_value = [{
'key': 'course-v1:FAKE+FA1-MA1.X+3T2017',
'enrollment_end': str(self.TOMORROW),
'pacing_type': 'instructor_paced',
'type': 'verified'
}]
response = self.client.get(self.path)
self.assertEqual(response.content.count('<li class="course-item">'), 0)
def setUp(self):
super().setUp()
freezer = freeze_time(datetime(2013, 10, 3, 8, 24, 55, tzinfo=pytz.utc))
self.addCleanup(freezer.stop)
freezer.start()
self.course = CourseOverviewFactory()
self.user = UserFactory()
self.request = RequestFactory().request()
self.request.site = SiteFactory()
self.request.user = self.user
self.site_config = SiteConfigurationFactory.create(
site_values={'course_org_filter': self.course.org}
)
self.user_calendar_sync_config = UserCalendarSyncConfigFactory.create(
user=self.user,
course_key=self.course.id,
)
def test_unfulfilled_expired_entitlement(self, mock_course_overview,
mock_course_runs):
"""
When a learner has an unfulfilled, expired entitlement, their course dashboard should have:
- a hidden 'View Course' button
- a message saying that they can no longer select a session
"""
CourseEntitlementFactory(user=self.user, created=self.THREE_YEARS_AGO)
mock_course_overview.return_value = CourseOverviewFactory(
start=self.TOMORROW)
mock_course_runs.return_value = [{
'key': 'course-v1:FAKE+FA1-MA1.X+3T2017',
'enrollment_end': self.TOMORROW,
'pacing_type': 'instructor_paced',
'type': 'verified'
}]
response = self.client.get(self.path)
self.assertIn('class="enter-course hidden"', response.content)
self.assertIn('You can no longer select a session', response.content)
self.assertNotIn(
'<div class="course-entitlement-selection-container ">',
response.content)
def setUpClass(cls):
"""
Set up test data
"""
super().setUpClass()
catalog_org = CatalogOrganizationFactory.create(
key=cls.organization_key)
cls.program = ProgramFactory.create(
uuid=cls.program_uuid, authoring_organizations=[catalog_org])
organization = OrganizationFactory.create(
short_name=cls.organization_key)
SAMLProviderConfigFactory.create(organization=organization)
catalog_course_id_str = 'course-v1:edX+ToyX'
course_run_id_str = f'{catalog_course_id_str}+Toy_Course'
cls.course_id = CourseKey.from_string(course_run_id_str)
CourseOverviewFactory(id=cls.course_id)
course_run = CourseRunFactory(key=course_run_id_str)
cls.course = CourseFactory(key=catalog_course_id_str,
course_runs=[course_run])
cls.student_1 = UserFactory(username='******')
cls.student_2 = UserFactory(username='******')
def test_get_extra_course_about_context(
mock_get_lang_names, mock_get_pre_requisite_courses_not_completed,
mock_testing_env, request):
"""
Test if the context is being returned correctly by the get_extra_course_about_context function
"""
user = UserFactory()
request.user = user
course = CourseOverviewFactory(self_paced=True,
effort=EFFORT,
language='en')
CourseEnrollmentFactory(user=user, course=course)
MultilingualCourseFactory(course=course)
course_languages_with_ids = [(course.id, 'English')]
mock_get_lang_names.return_value = course_languages_with_ids
mock_get_pre_requisite_courses_not_completed.return_value = None
mock_testing_env.return_value = False
enroll_popup_message = (
f'Warning: If you wish to change the language of this course, your progress in the following '
f'course(s) will be erased.<br>{course.display_name_with_default}')
expected_context = {
'course_languages': course_languages_with_ids,
'course_requirements': None,
'total_enrollments': 1,
'self_paced': True,
'effort': EFFORT,
'is_course_passed': False,
'has_certificate': None,
'has_user_enrolled_in_course_group_courses': True,
'has_generated_cert_for_any_course_group_course': False,
'enroll_popup_message': enroll_popup_message,
'cannot_enroll_message': ''
}
assert get_extra_course_about_context(request, course) == expected_context
def test_get_course_info_for_application_review(courses, user_with_profile):
"""
Tests that `get_course_info_for_application_review` returns expected data for application review.
"""
course1 = courses['test_course1']
course2 = courses['test_course2']
course3 = CourseOverviewFactory()
CourseEnrollmentFactory(user=user_with_profile, course=course2)
PersistentCourseGradeFactory(
user_id=user_with_profile.id, course_id=course2.id, percent_grade=1.0, letter_grade='A'
)
CourseEnrollmentFactory(user=user_with_profile, course=course3)
actual_courses_info = get_course_info_for_application_review([course1, course2, course3], user_with_profile)
expected_courses_info = {
course1.display_name: NOT_STARTED,
course2.display_name: '100%',
course3.display_name: IN_PROGRESS,
}
assert actual_courses_info == expected_courses_info
def test_unfulfilled_entitlement(self, mock_course_overview,
mock_course_runs):
"""
When a learner has an unfulfilled entitlement, their course dashboard should have:
- a hidden 'View Course' button
- the text 'In order to view the course you must select a session:'
- an unhidden course-entitlement-selection-container
"""
CourseEntitlementFactory(user=self.user)
mock_course_overview.return_value = CourseOverviewFactory(
start=self.TOMORROW)
mock_course_runs.return_value = [{
'key': 'course-v1:FAKE+FA1-MA1.X+3T2017',
'enrollment_end': self.TOMORROW,
'pacing_type': 'instructor_paced',
'type': 'verified'
}]
response = self.client.get(self.path)
self.assertIn('class="enter-course hidden"', response.content)
self.assertIn('You must select a session to access the course.',
response.content)
self.assertIn('<div class="course-entitlement-selection-container ">',
response.content)
def setUp(self):
super().setUp()
self.user = UserFactory()
self.course = CourseOverviewFactory()
self.course_key = self.course.id
def setUpClass(cls):
super().setUpClass()
cls.course = CourseOverviewFactory(start=now())
def test_end_to_end(self):
"""
Test the happy path of the backfill command without any mocking.
"""
# org_A: already existing, with courses and a library.
org_a = add_organization({"short_name": "org_A", "name": "Org A"})
course_a1_key = CourseOverviewFactory(org="org_A", run="1").id
CourseOverviewFactory(org="org_A", run="2")
LibraryFactory(org="org_A")
# Write linkage for org_a->course_a1.
# (Linkage for org_a->course_a2 is purposefully left out here;
# it should be created by the backfill).
add_organization_course(org_a, course_a1_key)
# org_B: already existing, but has no content.
add_organization({"short_name": "org_B", "name": "Org B"})
# org_C: has a couple courses; should be created.
CourseOverviewFactory(org="org_C", run="1")
CourseOverviewFactory(org="org_C", run="2")
# org_D: has both a course and a library; should be created.
CourseOverviewFactory(org="org_D", run="1")
LibraryFactory(org="org_D")
# org_E: just has a library; should be created.
LibraryFactory(org="org_E")
# Confirm starting condition:
# Only orgs are org_A and org_B, and only linkage is org_a->course_a1.
assert set(org["short_name"]
for org in get_organizations()) == {"org_A", "org_B"}
assert len(
get_organization_courses(
get_organization_by_short_name('org_A'))) == 1
assert len(
get_organization_courses(
get_organization_by_short_name('org_B'))) == 0
# Run the backfill.
call_command("backfill_orgs_and_org_courses", "--apply")
# Confirm ending condition:
# All five orgs present. Each org a has expected number of org-course linkages.
assert set(org["short_name"] for org in get_organizations()) == {
"org_A", "org_B", "org_C", "org_D", "org_E"
}
assert len(
get_organization_courses(
get_organization_by_short_name('org_A'))) == 2
assert len(
get_organization_courses(
get_organization_by_short_name('org_B'))) == 0
assert len(
get_organization_courses(
get_organization_by_short_name('org_C'))) == 2
assert len(
get_organization_courses(
get_organization_by_short_name('org_D'))) == 1
assert len(
get_organization_courses(
get_organization_by_short_name('org_E'))) == 0
def setUpClass(cls):
super(cls, ExpireWaitingEnrollmentsTest).setUpClass()
cls.timed_course_key = CourseKey.from_string('course-v1:edX+TestExpire+Timed')
cls.fresh_course_key = CourseKey.from_string('course-v1:edX+TestExpire+Fresh')
CourseOverviewFactory(id=cls.timed_course_key)
CourseOverviewFactory(id=cls.fresh_course_key)
def setUp(self):
""" Setup components used by each test."""
super(SendCalendarSyncEmailTestCase, self).setUp()
self.user = UserFactory()
self.course_overview = CourseOverviewFactory()
self.msg = compose_calendar_sync_email(self.user, self.course_overview)
def test_end_to_end(self, run_type):
"""
Test the happy path of the backfill command without any mocking.
"""
# org_A: already existing, with courses and a library.
org_a = add_organization({"short_name": "org_A", "name": "Org A"})
course_a1_key = CourseOverviewFactory(org="org_A", run="1").id
CourseOverviewFactory(org="org_A", run="2")
LibraryFactory(org="org_A")
# Write linkage for org_a->course_a1.
# (Linkage for org_a->course_a2 is purposefully left out here;
# it should be created by the backfill).
add_organization_course(org_a, course_a1_key)
# org_B: already existing, but has no content.
add_organization({"short_name": "org_B", "name": "Org B"})
# org_C: has a few courses; should be created.
CourseOverviewFactory(org="org_C", run="1")
CourseOverviewFactory(org="org_C", run="2")
# Include an Old Mongo Modulestore -style deprecated course key.
# This can be safely removed when Old Mongo Modulestore support is
# removed.
CourseOverviewFactory(
id=CourseLocator.from_string("org_C/toy/3"),
org="org_C",
run="3",
)
# org_D: has both a course and a library; should be created.
CourseOverviewFactory(org="org_D", run="1")
LibraryFactory(org="org_D")
# org_E: just has a library; should be created.
LibraryFactory(org="org_E")
# Confirm starting condition:
# Only orgs are org_A and org_B, and only linkage is org_a->course_a1.
assert set(
org["short_name"] for org in get_organizations()
) == {
"org_A", "org_B"
}
assert len(get_organization_courses(get_organization_by_short_name('org_A'))) == 1
assert len(get_organization_courses(get_organization_by_short_name('org_B'))) == 0
# Run the backfill.
call_command("backfill_orgs_and_org_courses", run_type)
if run_type == "--dry":
# Confirm ending conditions are the same as the starting conditions.
assert set(
org["short_name"] for org in get_organizations()
) == {
"org_A", "org_B"
}
assert len(get_organization_courses(get_organization_by_short_name('org_A'))) == 1
assert len(get_organization_courses(get_organization_by_short_name('org_B'))) == 0
else:
# Confirm ending condition:
# All five orgs present. Each org a has expected number of org-course linkages.
assert set(
org["short_name"] for org in get_organizations()
) == {
"org_A", "org_B", "org_C", "org_D", "org_E"
}
assert len(get_organization_courses(get_organization_by_short_name('org_A'))) == 2
assert len(get_organization_courses(get_organization_by_short_name('org_B'))) == 0
assert len(get_organization_courses(get_organization_by_short_name('org_C'))) == 3
assert len(get_organization_courses(get_organization_by_short_name('org_D'))) == 1
assert len(get_organization_courses(get_organization_by_short_name('org_E'))) == 0
def setUpTestData(cls):
super(ProgramEnrollmentReadingTests, cls).setUpTestData()
cls.user_0 = UserFactory(username=cls.username_0) # No enrollments
cls.user_1 = UserFactory(username=cls.username_1)
cls.user_2 = UserFactory(username=cls.username_2)
cls.user_3 = UserFactory(username=cls.username_3)
cls.user_4 = UserFactory(username=cls.username_4)
CourseOverviewFactory(id=cls.course_key_p)
CourseOverviewFactory(id=cls.course_key_q)
CourseOverviewFactory(id=cls.course_key_r)
enrollment_test_data = [ # ID
(cls.user_1, None, cls.program_uuid_x, cls.curriculum_uuid_a, PEStatuses.ENROLLED), # 1
(cls.user_2, None, cls.program_uuid_x, cls.curriculum_uuid_a, PEStatuses.PENDING), # 2
(cls.user_3, cls.ext_3, cls.program_uuid_x, cls.curriculum_uuid_b, PEStatuses.ENROLLED), # 3
(cls.user_4, cls.ext_4, cls.program_uuid_x, cls.curriculum_uuid_b, PEStatuses.PENDING), # 4
(None, cls.ext_5, cls.program_uuid_x, cls.curriculum_uuid_b, PEStatuses.SUSPENDED), # 5
(None, cls.ext_6, cls.program_uuid_y, cls.curriculum_uuid_c, PEStatuses.CANCELED), # 6
(cls.user_3, cls.ext_3, cls.program_uuid_y, cls.curriculum_uuid_c, PEStatuses.CANCELED), # 7
(None, cls.ext_4, cls.program_uuid_y, cls.curriculum_uuid_c, PEStatuses.ENROLLED), # 8
(cls.user_1, None, cls.program_uuid_x, cls.curriculum_uuid_b, PEStatuses.SUSPENDED), # 9
(cls.user_2, None, cls.program_uuid_y, cls.curriculum_uuid_c, PEStatuses.ENDED), # 10
]
for user, external_user_key, program_uuid, curriculum_uuid, status in enrollment_test_data:
ProgramEnrollmentFactory(
user=user,
external_user_key=external_user_key,
program_uuid=program_uuid,
curriculum_uuid=curriculum_uuid,
status=status,
)
course_enrollment_test_data = [ # ID
(1, cls.course_key_p, PCEStatuses.ACTIVE), # 1
(1, cls.course_key_q, PCEStatuses.ACTIVE), # 2
(9, cls.course_key_r, PCEStatuses.ACTIVE), # 3
(2, cls.course_key_p, PCEStatuses.INACTIVE), # 4
(3, cls.course_key_p, PCEStatuses.ACTIVE), # 5
(5, cls.course_key_p, PCEStatuses.INACTIVE), # 6
(8, cls.course_key_p, PCEStatuses.ACTIVE), # 7
(8, cls.course_key_q, PCEStatuses.INACTIVE), # 8
(2, cls.course_key_r, PCEStatuses.INACTIVE), # 9
(6, cls.course_key_r, PCEStatuses.INACTIVE), # 10
(8, cls.course_key_r, PCEStatuses.ACTIVE), # 11
(7, cls.course_key_q, PCEStatuses.ACTIVE), # 12
]
for program_enrollment_id, course_key, status in course_enrollment_test_data:
program_enrollment = ProgramEnrollment.objects.get(id=program_enrollment_id)
course_enrollment = (
CourseEnrollmentFactory(
course_id=course_key,
user=program_enrollment.user,
mode=CourseMode.MASTERS,
)
if program_enrollment.user
else None
)
ProgramCourseEnrollmentFactory(
program_enrollment=program_enrollment,
course_enrollment=course_enrollment,
course_key=course_key,
status=status,
)
def setUpClass(cls):
super(CourseEnrollmentAdminFormTest, cls).setUpClass()
cls.course = CourseOverviewFactory(start=now())
def expired_course_overview(current_time):
return CourseOverviewFactory(
language='en',
start_date=current_time - timedelta(days=2),
end_date=current_time - timedelta(days=1),
)
