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), )