def test_roles_can_see_profile(self, role_to_set): """ Staff and Instructors can see private profile of user with same program """ # Create a private profile new_user = SocialProfileFactory.create( verified_micromaster_user=False, account_privacy=Profile.PRIVATE, ).user program = ProgramFactory.create() ProgramEnrollment.objects.create( program=program, user=new_user, ) # Make self.unverified_user a staff of that program role = Role.objects.create( user=self.user, program=program, role=role_to_set, ) request = Mock(user=self.user) view = Mock(kwargs={'user': self.get_social_auth_uid(new_user)}) assert self.perm.has_permission(request, view) is True # Change role.program and assert that user no longer has permission to see private profile role.program = ProgramFactory.create() role.save() with self.assertRaises(Http404): self.perm.has_permission(request, view)
def setUpTestData(cls): super(APITests, cls).setUpTestData() # create an user cls.user = UserFactory.create() # create the programs cls.program1 = ProgramFactory.create(live=True) cls.program2 = ProgramFactory.create(live=True)
def test_doesnt_list_unlive_programs(self): """Not-live programs should NOT show up""" ProgramFactory.create(live=False) resp = self.client.get(reverse('program-list')) assert len(resp.json()) == 0
def setUpTestData(cls): super(SearchTests, cls).setUpTestData() # create some students with mute_signals(post_save): cls.students = [(ProfileFactory.create(filled_out=True)).user for _ in range(30)] # create the programs cls.program1 = ProgramFactory.create(live=True) cls.program2 = ProgramFactory.create(live=True) cls.program3 = ProgramFactory.create(live=True) # enroll the users in the programs for num, student in enumerate(cls.students): if num % 3 == 0: program = cls.program1 elif num % 3 == 1: program = cls.program2 else: program = cls.program3 ProgramEnrollmentFactory.create( user=student, program=program ) # create an user with a role for one program cls.staff = UserFactory.create() Role.objects.create( user=cls.staff, program=cls.program1, role=Staff.ROLE_ID ) # search URL cls.search_url = reverse('search_api', kwargs={'elastic_url': ''})
def test_program_liveness(self): """Verify only 'live' program visible on homepage""" program_live_true = ProgramFactory.create(live=True) program_live_false = ProgramFactory.create(live=False) response = self.client.get('/') self.assertContains(response, program_live_true.title, status_code=200) self.assertNotContains(response, program_live_false.title, status_code=200)
def test_program_order(self): """ Assert that programs are output in id order """ for i in range(10): ProgramFactory.create(live=True, title="Program {}".format(i + 1)) response = self.client.get("/") content = response.content.decode('utf-8') indexes = [content.find("Program {}".format(i + 1)) for i in range(10)] assert indexes == sorted(indexes)
def setUpTestData(cls): super(ProgramEnrollmentTests, cls).setUpTestData() cls.user1 = UserFactory.create() cls.user2 = UserFactory.create() cls.program1 = ProgramFactory.create(live=True) cls.program2 = ProgramFactory.create(live=True) cls.program3 = ProgramFactory.create(live=True) cls.url = reverse('user_program_enrollments')
def setUpTestData(cls): super().setUpTestData() # create an user cls.user = UserFactory.create() cls.cached_edx_user_data = MagicMock( spec=CachedEdxUserData, enrollments=CachedEnrollment.deserialize_edx_data(cls.enrollments_json), certificates=CachedCertificate.deserialize_edx_data(cls.certificates_json), current_grades=CachedCurrentGrade.deserialize_edx_data(cls.current_grades_json), ) # create the programs cls.program = ProgramFactory.create(live=True, financial_aid_availability=False, price=1000) cls.program_financial_aid = ProgramFactory.create(live=True, financial_aid_availability=True, price=1000) # create course runs for the normal program cls.course = CourseFactory.create(program=cls.program) expected_course_keys = [ "course-v1:edX+DemoX+Demo_Course", "course-v1:MITx+8.MechCX+2014_T1", '', None, 'course-v1:odl+FOO102+CR-FALL16' ] cls.cruns = [] for course_key in expected_course_keys: course_run = CourseRunFactory.create( course=cls.course, edx_course_key=course_key ) if course_key: cls.cruns.append(course_run) # and the program with financial aid finaid_course = CourseFactory.create(program=cls.program_financial_aid) cls.now = now_in_utc() cls.end_date = cls.now - timedelta(weeks=45) cls.crun_fa = CourseRunFactory.create( course=finaid_course, start_date=cls.now-timedelta(weeks=52), end_date=cls.end_date, enrollment_start=cls.now-timedelta(weeks=62), enrollment_end=cls.now-timedelta(weeks=53), edx_course_key="course-v1:odl+FOO101+CR-FALL15" ) cls.crun_fa2 = CourseRunFactory.create( course=finaid_course ) CourseRunFactory.create( course=finaid_course, edx_course_key=None )
def test_unseed_db(self): """Test that unseed_db deletes seed data""" for i in range(2): ProgramFactory.create(description='{} test program {}'.format(FAKE_PROGRAM_DESC_PREFIX, i)) UserFactory.create(username='******'.format(FAKE_USER_USERNAME_PREFIX, i)) fake_program_qset = Program.objects.filter(description__startswith=FAKE_PROGRAM_DESC_PREFIX) fake_user_qset = User.objects.filter(username__startswith=FAKE_USER_USERNAME_PREFIX) assert fake_program_qset.count() == 2 assert fake_user_qset.count() == 2 unseed_db() assert fake_program_qset.count() == 0 assert fake_user_qset.count() == 0
def test_program_page(self): """Verify that ProgramPage is passed in the context if and only if it's available""" program_with_page = ProgramFactory.create(live=True) program_page = ProgramPage(program=program_with_page, title="Test Program") homepage = HomePage.objects.first() homepage.add_child(instance=program_page) program_page.save_revision().publish() program_without_page = ProgramFactory.create(live=True) response = self.client.get('/') assert response.context['programs'] == [ (program_with_page, program_page), (program_without_page, None), ]
def test_program_liveness(self): """Verify only 'live' program visible on homepage""" program_live_true = ProgramFactory.create(live=True) program_live_false = ProgramFactory.create(live=False) response = self.client.get('/') self.assertContains( response, program_live_true.description, status_code=200 ) self.assertNotContains( response, program_live_false.description, status_code=200 )
def test_staff_sees_entire_profile(self): """ Staff should be able to see the entire profile despite the account privacy """ with mute_signals(post_save): profile = ProfileFactory.create(user=self.user2, account_privacy=Profile.PRIVATE) ProfileFactory.create(user=self.user1, verified_micromaster_user=False) program = ProgramFactory.create() ProgramEnrollment.objects.create( program=program, user=profile.user, ) Role.objects.create( program=program, role=Staff.ROLE_ID, user=self.user1, ) self.client.force_login(self.user1) resp = self.client.get(self.url2) profile_data = ProfileSerializer(profile).data assert resp.json() == format_image_expectation(profile_data)
def setUp(self): super(TestProgramPage, self).setUp() homepage = HomePage.objects.first() program = ProgramFactory.create(title="Test Program Title", live=True) self.program_page = ProgramPage(program=program, title="Test Program") homepage.add_child(instance=self.program_page) self.program_page.save_revision().publish()
def test_roles_setting(self): """ Assert SETTINGS when a user has roles assigned to them """ profile = self.create_and_login_user() Role.objects.create( program=ProgramFactory.create(), user=profile.user, role=Role.DEFAULT_ROLE, ) resp = self.client.get(DASHBOARD_URL) js_settings = json.loads(resp.context['js_settings_json']) assert js_settings['roles'] == [{ 'program': role.program.id, 'role': role.role, 'permissions': [ key for key, value in available_perm_status(profile.user).items() if value is True ], } for role in profile.user.role_set.all()]
def setUpTestData(cls): super().setUpTestData() with mute_signals(post_save): cls.user = ProfileFactory.create().user cls.program = ProgramFactory.create() cls.course = CourseFactory.create(program=cls.program)
def base_test_data(): """ Fixture for test data that should be available to any test case in the suite """ # Create a live program with valid prices and financial aid program = ProgramFactory.create( live=True, financial_aid_availability=True, price=1000, ) CourseRunFactory.create(course__program=program) TierProgramFactory.create_properly_configured_batch(2, program=program) # Create users staff_user, student_user = (create_user_for_login(is_staff=True), create_user_for_login(is_staff=False)) ProgramEnrollment.objects.create(program=program, user=staff_user) ProgramEnrollment.objects.create(program=program, user=student_user) Role.objects.create( role=Staff.ROLE_ID, user=staff_user, program=program, ) return SimpleNamespace( staff_user=staff_user, student_user=student_user, program=program )
def test_switch_program(self, browser, base_test_data, logged_in_staff): """ Switching programs should show a different set of users """ existing_program_user_count = settings.ELASTICSEARCH_DEFAULT_PAGE_SIZE create_enrolled_user_batch(existing_program_user_count, program=base_test_data.program, is_staff=False) new_program = ProgramFactory.create(live=True) new_program_user_count = settings.ELASTICSEARCH_DEFAULT_PAGE_SIZE - 1 create_enrolled_user_batch(new_program_user_count, program=new_program, is_staff=False) ProgramEnrollment.objects.create(program=new_program, user=logged_in_staff) Role.objects.create( role=Staff.ROLE_ID, user=logged_in_staff, program=new_program, ) # Load the learners page for the existing program browser.get("/learners") browser.wait_until_element_count(By.CLASS_NAME, 'learner-result', existing_program_user_count) # Switch programs and check that the correct number of users are returned switcher = browser.driver.find_element_by_css_selector('.micromasters-header .Select-input') switcher.send_keys(Keys.DOWN) switcher.send_keys(Keys.ENTER) browser.wait_until_element_count(By.CLASS_NAME, 'learner-result', new_program_user_count) # Refresh browser and verify the count is the same browser.get("/learners") browser.wait_until_element_count(By.CLASS_NAME, 'learner-result', new_program_user_count)
def test_serialize_basket_product_version_program(mock_context): """Test ProductVersion serialization for a Program""" program = ProgramFactory.create() courses = CourseFactory.create_batch(3, program=program) product_version = ProductVersionFactory.create( product=ProductFactory(content_object=program) ) data = FullProductVersionSerializer( instance=product_version, context=mock_context ).data assert data == { "id": product_version.id, "description": product_version.description, "content_title": product_version.product.content_object.title, "price": str(round_half_up(product_version.price)), "type": product_version.product.content_type.model, "courses": [ CourseSerializer(instance=course, context=mock_context).data for course in courses ], "thumbnail_url": program.catalog_image_url, "object_id": product_version.product.object_id, "product_id": product_version.product.id, "readable_id": get_readable_id(product_version.product.content_object), "run_tag": None, "created_on": product_version.created_on.strftime(datetime_millis_format), "start_date": product_version.product.content_object.next_run_date.isoformat() if product_version.product.content_object.next_run_date else None, }
def test_program_enrolled_user_serializer(self): # pylint: disable=no-self-use """ Asserts the output of the serializer for program-enrolled users (ProgramEnrollments) """ with mute_signals(post_save): profile = ProfileFactory.create() EducationFactory.create(profile=profile) EmploymentFactory.create(profile=profile) program = ProgramFactory.create() course = CourseFactory.create(program=program) course_runs = [ CourseRunFactory.create(course=course) for _ in range(2) ] for course_run in course_runs: CachedCertificateFactory.create(user=profile.user, course_run=course_run) CachedEnrollmentFactory.create(user=profile.user, course_run=course_run) program_enrollment = ProgramEnrollment.objects.create( user=profile.user, program=program) assert serialize_program_enrolled_user(program_enrollment) == { '_id': program_enrollment.id, 'id': program_enrollment.id, 'user_id': profile.user.id, 'email': profile.user.email, 'profile': ProfileSerializer().to_representation(profile), 'program': UserProgramSerializer.serialize(program_enrollment) }
def test_create_program_enrollments(user): """ create_program_enrollments should create or reactivate local enrollment records """ num_programs = 2 order = OrderFactory.create() company = CompanyFactory.create() programs = ProgramFactory.create_batch(num_programs) # Create an existing deactivate enrollment to test that it gets reactivated ProgramEnrollmentFactory.create( user=user, program=programs[0], order=order, change_status=ENROLL_CHANGE_STATUS_REFUNDED, active=False, ) successful_enrollments = create_program_enrollments(user, programs, order=order, company=company) assert len(successful_enrollments) == num_programs enrollments = ProgramEnrollment.objects.order_by("program__id").all() assert len(enrollments) == len(programs) for (program, enrollment) in zip(programs, enrollments): assert enrollment.change_status is None assert enrollment.active is True assert enrollment.program == program
def test_program_first_unexpired_run(): """ Test that the first unexpired run of a program is returned """ program = ProgramFactory() course = CourseFactory.create(program=program) now = now_in_utc() end_date = now + timedelta(days=100) enr_end_date = now + timedelta(days=100) first_run = CourseRunFactory.create( start_date=now, course=course, end_date=end_date, enrollment_end=enr_end_date, live=True, ) # create another course and course run in program another_course = CourseFactory.create(program=program) second_run = CourseRunFactory.create( start_date=now + timedelta(days=50), course=another_course, end_date=end_date, enrollment_end=enr_end_date, ) assert first_run.start_date < second_run.start_date assert program.first_unexpired_run == first_run
def test_index_context_logged_in_staff(self, role): """ Assert context values when logged in as staff for a program """ program = ProgramFactory.create(live=True) with mute_signals(post_save): profile = ProfileFactory.create() Role.objects.create( role=role, program=program, user=profile.user, ) self.client.force_login(profile.user) ga_tracking_id = FuzzyText().fuzz() with self.settings(GA_TRACKING_ID=ga_tracking_id, ): response = self.client.get('/') assert response.context['authenticated'] is True assert response.context['username'] is None assert response.context['title'] == HomePage.objects.first().title assert response.context['is_public'] is True assert response.context['has_zendesk_widget'] is True assert response.context['is_staff'] is True assert response.context['programs'] == [ (program, None), ] self.assertContains(response, 'Share this page') js_settings = json.loads(response.context['js_settings_json']) assert js_settings['gaTrackingID'] == ga_tracking_id
def setUpTestData(cls): super().setUpTestData() with mute_signals(post_save): staff_profile = ProfileFactory.create(user__email='*****@*****.**') recipient_profile = ProfileFactory.create( user__email='*****@*****.**', email_optin=True, ) cls.staff_user = staff_profile.user cls.recipient_user = recipient_profile.user cls.program = ProgramFactory.create(financial_aid_availability=False) ProgramEnrollmentFactory.create( user=cls.recipient_user, program=cls.program ) Role.objects.create( user=cls.staff_user, program=cls.program, role=Staff.ROLE_ID ) cls.url_name = 'learner_mail_api' cls.request_data = { 'email_subject': 'email subject', 'email_body': 'email body' }
def setUpTestData(cls): with mute_signals(post_save): cls.profile = ProfileFactory.create() cls.program = ProgramFactory.create(financial_aid_availability=True) cls.tiers = { "0k": TierProgramFactory.create(program=cls.program, income_threshold=0, current=True), "15k": TierProgramFactory.create(program=cls.program, income_threshold=15000, current=True), "50k": TierProgramFactory.create(program=cls.program, income_threshold=50000, current=True), "100k": TierProgramFactory.create(program=cls.program, income_threshold=100000, current=True), "150k_not_current": TierProgramFactory.create(program=cls.program, income_threshold=150000, current=False) } cls.program_enrollment = ProgramEnrollment.objects.create( user=cls.profile.user, program=cls.program)
def test_unseed_db(self): """Test that unseed_db deletes seed data""" for i in range(2): ProgramFactory.create(description='{} test program {}'.format( FAKE_PROGRAM_DESC_PREFIX, i)) UserFactory.create(username='******'.format( FAKE_USER_USERNAME_PREFIX, i)) fake_program_qset = Program.objects.filter( description__startswith=FAKE_PROGRAM_DESC_PREFIX) fake_user_qset = User.objects.filter( username__startswith=FAKE_USER_USERNAME_PREFIX) assert fake_program_qset.count() == 2 assert fake_user_qset.count() == 2 unseed_db() assert fake_program_qset.count() == 0 assert fake_user_qset.count() == 0
def test_program_certificate_start_end_dates(user): """ Test that the ProgramCertificate start_end_dates property works properly """ now = now_in_utc() start_date = now + timedelta(days=1) end_date = now + timedelta(days=100) program = ProgramFactory.create() early_course_run = CourseRunFactory.create(course__program=program, start_date=start_date, end_date=end_date) later_course_run = CourseRunFactory.create( course__program=program, start_date=start_date + timedelta(days=1), end_date=end_date + timedelta(days=1), ) # Need the course run certificates to be there in order for the start_end_dates # to return valid values CourseRunCertificateFactory.create(course_run=early_course_run, user=user) CourseRunCertificateFactory.create(course_run=later_course_run, user=user) certificate = ProgramCertificateFactory.create(program=program, user=user) program_start_date, program_end_date = certificate.start_end_dates assert program_start_date == early_course_run.start_date assert program_end_date == later_course_run.end_date
def setUpTestData(cls): """Create a program and user to test with""" super().setUpTestData() cls.program = ProgramFactory.create() cls.user = UserFactory.create() cls.context = {"request": Mock(user=cls.user)}
def setUpTestData(cls): with mute_signals(post_save): profile = ProfileFactory.create() cls.user = profile.user cls.program = ProgramFactory.create() cls.program_enrollment = ProgramEnrollment.objects.create( user=cls.user, program=cls.program)
def base_test_data(): """ Fixture for test data that should be available to any test case in the suite """ # Create a live program with valid prices and financial aid program = ProgramFactory.create( live=True, financial_aid_availability=True, price=1000, ) CourseRunFactory.create(course__program=program) TierProgramFactory.create_properly_configured_batch(2, program=program) # Create users staff_user, student_user = (create_user_for_login(is_staff=True), create_user_for_login(is_staff=False)) ProgramEnrollment.objects.create(program=program, user=staff_user) ProgramEnrollment.objects.create(program=program, user=student_user) Role.objects.create( role=Staff.ROLE_ID, user=staff_user, program=program, ) return SimpleNamespace(staff_user=staff_user, student_user=student_user, program=program)
def test_course_tier_mandatory(self): """ Test that an attempt to serialize financial aid information will raise an exception if no tiers are created. """ new_program = ProgramFactory.create(live=True, financial_aid_availability=True, price=1000) with self.assertRaises(ImproperlyConfigured): FinancialAidDashboardSerializer.serialize(self.user, new_program)
def programs(): """Fixture for a set of Programs in the database""" programs = ProgramFactory.create_batch(3) for program in programs: ProductVersionFactory.create(product=ProductFactory( content_object=program)) return programs
def test_index_context_logged_in_staff(self, role): """ Assert context values when logged in as staff for a program """ program = ProgramFactory.create(live=True) with mute_signals(post_save): profile = ProfileFactory.create() Role.objects.create( role=role, program=program, user=profile.user, ) self.client.force_login(profile.user) ga_tracking_id = FuzzyText().fuzz() with self.settings( GA_TRACKING_ID=ga_tracking_id, ): response = self.client.get('/') assert response.context['authenticated'] is True assert response.context['username'] is None assert response.context['title'] == HomePage.objects.first().title assert response.context['is_public'] is True assert response.context['has_zendesk_widget'] is True assert response.context['is_staff'] is True assert response.context['programs'] == [ (program, None), ] self.assertContains(response, 'Share this page') js_settings = json.loads(response.context['js_settings_json']) assert js_settings['gaTrackingID'] == ga_tracking_id
def test_catalog_program_serializer(has_page, has_thumbnail): """Tests that the catalog serializer returns a correct data structure""" page = ProgramPageFactory.create( has_thumbnail=has_thumbnail) if has_page else None program = page.program if page else ProgramFactory.create() courses = CourseFactory.create_batch(3, program=program) for course in courses: CourseRunFactory.create_batch(2, course=course) faculty_name = "faculty" if has_page: ProgramFaculty.objects.create( program_page=page, name=faculty_name, ) serialized = CatalogProgramSerializer(program).data # coerce OrderedDict objects to dict serialized = { **serialized, "courses": [{ **course, "course_runs": [dict(run) for run in course["course_runs"]] } for course in serialized["courses"]] } assert serialized == { "id": program.id, "title": program.title, "programpage_url": page.get_full_url() if has_page else None, "thumbnail_url": (page.thumbnail_image.get_rendition('fill-300x186').url if has_page and has_thumbnail else None), "courses": [{ "id": course.id, "edx_key": course.edx_key, "position_in_program": course.position_in_program, "course_runs": [{ "id": course_run.id, "edx_course_key": course_run.edx_course_key, } for course_run in course.courserun_set.all()] } for course in courses], 'topics': [{ 'name': topic.name } for topic in program.topics.iterator()], "instructors": [{ "name": faculty_name }] if has_page else [], "start_date": courses[0].first_unexpired_run().start_date, "enrollment_start": courses[0].first_unexpired_run().enrollment_start, "end_date": courses[-1].courserun_set.last().end_date, "total_price": str(program.price * program.num_required_courses), }
def test_program_page(): """ page property should return an associated Wagtail page if one exists """ program = ProgramFactory.create(page=None) assert program.page is None page = ProgramPageFactory.create(program=program) assert program.page == page
def test_create_program_not_live(self): """Test in case the program is not live""" program = ProgramFactory.create(live=False) self.assert_program_enrollments_count() resp = self.client.post(self.url, {'program_id': program.pk}, format='json') self.assert_program_enrollments_count() assert resp.status_code == status.HTTP_404_NOT_FOUND
def test_determine_tier_program_improper_setup(self): """ Tests that determine_tier_program() raises ImproperlyConfigured if no $0-discount TierProgram has been created and income supplied is too low. """ program = ProgramFactory.create() with self.assertRaises(ImproperlyConfigured): determine_tier_program(program, 0)
def setUpTestData(cls): super(ProgramLearnersTests, cls).setUpTestData() cls.program = ProgramFactory.create(live=True) cls.url = reverse('learners_in_program', kwargs={"program_id": cls.program.id}) cls.user = create_learner_with_image(privacy=Profile.PUBLIC)
def test_deserialize_course_data(self): """Test that course data is correctly deserialized""" new_program = ProgramFactory.create() new_course = deserialize_course_data(new_program, self.COURSE_DATA) new_course_runs = new_course.courserun_set.all() assert new_course.title == 'Digital Learning 100' assert len(new_course_runs) == 1 assert new_course_runs[0].title == 'Digital Learning 100 - January 2016'
def test_lists_live_programs(self): """Live programs should show up""" prog = ProgramFactory.create(live=True) resp = self.client.get(reverse('program-list')) assert len(resp.json()) == 1 assert prog.title == resp.json()[0]['title']
def setUpTestData(cls): """Create a program and user to test with""" super().setUpTestData() cls.program = ProgramFactory.create() cls.user = UserFactory.create() cls.context = { "request": Mock(user=cls.user) }
def setUpTestData(cls): cls.staff_user = UserFactory.create() cls.program = ProgramFactory.create() Role.objects.create( user=cls.staff_user, program=cls.program, role=Staff.ROLE_ID, ) cls.url = reverse('automatic_email_api-list')
def setUpTestData(cls): with mute_signals(post_save): cls.profile = profile = ProfileFactory.create() cls.user = profile.user # Create non-FA program data cls.non_fa_program = ProgramFactory.create() _, course_runs = cls.generate_course_with_runs( cls.non_fa_program, course_params=dict(title='Non FA Course 1') ) cls.non_fa_enrollments = [cls.verified_enroll(cls.user, course_runs[0])] cls.non_fa_program_enrollment = ProgramEnrollment.objects.create(user=cls.user, program=cls.non_fa_program) # Create FA program data cls.fa_program = ProgramFactory.create(financial_aid_availability=False) _, course_runs = cls.generate_course_with_runs( cls.fa_program, course_params=dict(title='FA Course 1') ) cls.fa_enrollments = [cls.verified_enroll(cls.user, course_runs[0])] cls.fa_program_enrollment = ProgramEnrollment.objects.create(user=cls.user, program=cls.fa_program)
def setUpTestData(cls): super(DashboardTest, cls).setUpTestData() # create a user cls.user = SocialUserFactory.create() UserCacheRefreshTimeFactory(user=cls.user, unexpired=True) # create the programs cls.program_1 = ProgramFactory.create(live=True) cls.program_2 = ProgramFactory.create(live=True) cls.program_not_enrolled = ProgramFactory.create(live=True) cls.program_no_live = ProgramFactory.create(live=False) # enroll the user in some courses for program in [cls.program_1, cls.program_2, cls.program_no_live]: ProgramEnrollment.objects.create( user=cls.user, program=program ) # url for the dashboard cls.url = reverse('dashboard_api', args=[cls.user.social_auth.first().uid])
def setUpTestData(cls): cls.search_result_mail_url = reverse('search_result_mail_api') cls.program = ProgramFactory.create(live=True) # create a user with a role for one program with mute_signals(post_save): staff_profile = ProfileFactory.create() cls.staff = staff_profile.user Role.objects.create( user=cls.staff, program=cls.program, role=Staff.ROLE_ID )
def setUpTestData(cls): with mute_signals(post_save): cls.profile = ProfileFactory.create() EducationFactory.create(profile=cls.profile) EmploymentFactory.create(profile=cls.profile) EmploymentFactory.create(profile=cls.profile, end_date=None) program = ProgramFactory.create() course = CourseFactory.create(program=program) course_runs = [CourseRunFactory.create(course=course) for _ in range(2)] for course_run in course_runs: CachedCertificateFactory.create(user=cls.profile.user, course_run=course_run) CachedEnrollmentFactory.create(user=cls.profile.user, course_run=course_run) cls.program_enrollment = ProgramEnrollment.objects.create(user=cls.profile.user, program=program)
def test_login_redirect_learners(self): """ Staff or instructors should be directed to /learners """ for role in [Staff.ROLE_ID, Instructor.ROLE_ID]: user = UserFactory.create() Role.objects.create(user=user, role=role, program=ProgramFactory.create()) mock_strategy = mock.Mock() mock_strategy.session.load.return_value = {} mock_strategy.session.get.return_value = {} backend = edxorg.EdxOrgOAuth2(strategy=mock_strategy) pipeline_api.update_profile_from_edx(backend, user, {}, False, **{'edx_profile': self.mocked_edx_profile}) mock_strategy.session_set.assert_called_with('next', '/learners')
def create(cls, **kwargs): """ Overrides default ProgramEnrollment object creation for the factory. """ user = kwargs.get('user', UserFactory.create()) program = kwargs.get('program', ProgramFactory.create()) course = CourseFactory.create(program=program) course_run = CourseRunFactory.create(course=course) CachedEnrollmentFactory.create(user=user, course_run=course_run) CachedCertificateFactory.create(user=user, course_run=course_run) CachedCurrentGradeFactory.create(user=user, course_run=course_run) program_enrollment = ProgramEnrollment.objects.create(user=user, program=program) return program_enrollment
def test_program_link(self): """Verify that program links are present in home page if ProgramPage is set""" program = ProgramFactory.create(live=True) program_page = ProgramPage(program=program, title="Test Program") homepage = HomePage.objects.first() homepage.add_child(instance=program_page) program_page.save_revision().publish() response = self.client.get('/') self.assertContains( response, program_page.url, status_code=200 )
def test_course_finder_success(self): """Tests that CourseFinder will return a desired course""" program = ProgramFactory.create(title='program1') course = CourseFactory.create(title='Course Lvl 100', program=program) CourseFactory.create(title='Course Lvl 200', program=program) CourseFactory.create(title='Course Lvl 300', program=program) CourseFactory.create(title='Other Course 100', program__title='program2') found_courses = [ CourseFinder.find(course_title='Course Lvl 100'), CourseFinder.find(course_title='Lvl 100'), CourseFinder.find(program_title='program1', course_level='100') ] assert all([course == found_course for found_course in found_courses])
def setUpTestData(cls): super().setUpTestData() cls.user = UserFactory.create() cls.program = ProgramFactory.create(live=True, financial_aid_availability=True, price=1000) cls.min_tier_program = TierProgramFactory.create( program=cls.program, discount_amount=750, current=True ) cls.max_tier_program = TierProgramFactory.create( program=cls.program, discount_amount=0, current=True )
def test_other_programs_not_serialized(self): """ Tests that the serialization for a ProgramEnrollment doesn't yield enrollment data for a different program """ program_enrollment_to_test = self.non_fa_program_enrollment # We want to test serialization for a new course in the enrolled program and a different program programs_to_test = [program_enrollment_to_test.program, ProgramFactory.create()] for program in programs_to_test: course, course_runs = self.generate_course_with_runs(program) self.verified_enroll(self.user, course_run=course_runs[0]) serialized_program_user = UserProgramSearchSerializer.serialize(program_enrollment_to_test) # If the new course's program is the same one we just serialized, we expect the course to be serialized. course_is_expected_serialized = program == program_enrollment_to_test.program course_is_serialized = self.is_course_serialized(serialized_program_user['courses'], course) assert course_is_serialized == course_is_expected_serialized
def test_can_view_if_verified_mm_user(self): """ Verified MM users are allowed to view public_to_mm profile. """ new_user = SocialProfileFactory.create(account_privacy=Profile.PUBLIC_TO_MM).user verified_user = SocialProfileFactory.create(verified_micromaster_user=True).user program = ProgramFactory.create() for user in [new_user, verified_user]: ProgramEnrollment.objects.create( program=program, user=user, ) request = Mock(user=verified_user) view = Mock(kwargs={'user': self.get_social_auth_uid(new_user)}) assert self.perm.has_permission(request, view) is True
def test_has_paid_for_any_in_program(self): """ Assert that has_paid_for_any_in_program returns True if any CourseRun associated with a Program has been paid for. """ new_program = ProgramFactory.create() new_course_runs = CourseRunFactory.create_batch(2, course__program=new_program) mmtrack = MMTrack( user=self.user, program=new_program, edx_user_data=self.cached_edx_user_data ) assert mmtrack.has_paid_for_any_in_program() is False fg = FinalGradeFactory.create(user=self.user, course_run=new_course_runs[0], course_run_paid_on_edx=True) assert mmtrack.has_paid_for_any_in_program() is True fg.delete() FinalGradeFactory.create(user=self.user, course_run=new_course_runs[1], course_run_paid_on_edx=True) assert mmtrack.has_paid_for_any_in_program() is True