def test_patch_own_profile(self): """ A user PATCHes their own profile """ with mute_signals(post_save): ProfileFactory.create(user=self.user1, filled_out=False, agreed_to_terms_of_service=False) self.client.force_login(self.user1) with mute_signals(post_save): new_profile = ProfileFactory.create(filled_out=False) new_profile.user.social_auth.create( provider=EdxOrgOAuth2.name, uid="{}_edx".format(new_profile.user.username) ) patch_data = ProfileSerializer(new_profile).data del patch_data['image'] resp = self.client.patch(self.url1, content_type="application/json", data=json.dumps(patch_data)) assert resp.status_code == 200 old_profile = Profile.objects.get(user__username=self.user1.username) for key, value in patch_data.items(): field = ProfileSerializer().fields[key] if isinstance(field, (ListSerializer, SerializerMethodField, ReadOnlyField)) or field.read_only is True: # these fields are readonly continue elif isinstance(field, DateField): assert getattr(old_profile, key) == parse(value).date() else: assert getattr(old_profile, key) == value
def test_submission_conversion(capsys, submission_file, settings): # Override the celery settings settings.task_eager_propagates = (True,) settings.task_always_eager = (True,) challenge = ChallengeFactory() test_set = challenge.imageset_set.get(phase=ImageSet.TESTING) with mute_signals(post_save): submission = SubmissionFactory( file__from_path=submission_file, challenge=challenge ) call_command("convertsubmissions", challenge.short_name) _, err = capsys.readouterr() assert err == "" annotation_set = AnnotationSet.objects.all()[0] assert annotation_set.submission == submission assert annotation_set.base == test_set images = annotation_set.images.all() assert len(images) == 1 assert images[0].name == "image10x10x10.mhd" with mute_signals(post_save): submission = SubmissionFactory( file__from_path=Path(__file__).parent.parent / "evaluation_tests" / "resources" / "submission.csv", challenge=challenge, ) call_command("convertsubmissions", challenge.short_name) _, err = capsys.readouterr() assert err == "" annotation_set = AnnotationSet.objects.all()[1] assert annotation_set.submission == submission assert annotation_set.base == test_set labels = annotation_set.labels assert len(labels) == 10 assert labels[0]["class"] == 0
def test_sync_user_profile_save_enabled(mocker, patched_users_api): """Test that sync_user_profile calls the task if enabled on save""" mock_task = mocker.patch('discussions.tasks.sync_discussion_user') with mute_signals(post_save): profile = ProfileFactory.create() profile.save() mock_task.delay.assert_called_once_with(profile.user_id)
def create_enrolled_profile(program, role=None, **profile_kwargs): """ Helper function to create a profile and some related models Args: program (courses.models.Program): A program role (str or None): A role, or no role if None Returns: profiles.models.Profile: A new profile """ with mute_signals(post_save): profile = ProfileFactory.create(**profile_kwargs) ProgramEnrollment.objects.create( user=profile.user, program=program ) if role is not None: Role.objects.create( user=profile.user, program=program, role=role, ) return profile
def setUpTestData(cls): """ Create a profile """ super().setUpTestData() with mute_signals(post_save): cls.profile = ProfileFactory.create()
def test_financial_aid_with_application_with_full_profile(self): """ Test that financialAid request serializer works when profile is filled out. """ with mute_signals(post_save): profile = ProfileFactory.create() ProgramEnrollmentFactory.create(user=profile.user, program=self.program) original_currency = 'USD' original_income = 1000.0 serializer = FinancialAidRequestSerializer( data={ 'program_id': self.program.id, 'tier_program': self.min_tier_program, 'date_documents_sent': None, 'original_currency': original_currency, 'original_income': original_income }, context={ 'request': MagicMock(user=profile.user) } ) serializer.is_valid(raise_exception=True) serializer.save() assert serializer.data == { 'original_currency': original_currency, 'original_income': original_income, 'program_id': self.program.id }
def test_update_exam_authorization_final_grade(self): """ Verify that update_exam_authorization_final_grade is called when a FinalGrade saves """ create_order(self.profile.user, self.course_run) with mute_signals(post_save): # muted because enrollment also trigger signal for profile creation. right now we are just # looking final grades CachedEnrollmentFactory.create(user=self.profile.user, course_run=self.course_run) # There is no ExamProfile or ExamAuthorization before creating the FinalGrade. assert ExamProfile.objects.filter(profile=self.profile).exists() is False assert ExamAuthorization.objects.filter( user=self.profile.user, course=self.course_run.course ).exists() is False FinalGradeFactory.create( user=self.profile.user, course_run=self.course_run, passed=True, ) # assert Exam Authorization and profile created. assert ExamProfile.objects.filter(profile=self.profile).exists() is True assert ExamAuthorization.objects.filter( user=self.profile.user, course=self.course_run.course ).exists() is True
def test_update_exam_authorization_final_grade_when_user_not_paid(self): """ Verify that update_exam_authorization_final_grade is called and log exception when FinalGrade saves user dont match exam authorization criteria """ with mute_signals(post_save): # muting signal for CachedEnrollment. Because CachedEnrollment and FinalGrade both omits # signal, we want to see behaviour of FinalGrade here CachedEnrollmentFactory.create(user=self.profile.user, course_run=self.course_run) assert ExamProfile.objects.filter(profile=self.profile).exists() is False assert ExamAuthorization.objects.filter( user=self.profile.user, course=self.course_run.course ).exists() is False FinalGradeFactory.create( user=self.profile.user, course_run=self.course_run, passed=True, course_run_paid_on_edx=False, ) # assert Exam Authorization and profile not created. assert ExamProfile.objects.filter(profile=self.profile).exists() is False assert ExamAuthorization.objects.filter( user=self.profile.user, course=self.course_run.course ).exists() is False
def test_readonly_resized_images(self, image_key): """ Users should not be able to modify image_small or image_medium directly """ with mute_signals(post_save): profile = ProfileFactory.create(user=self.user1) self.client.force_login(self.user1) # create a dummy image file in memory for upload with make_temp_image_file() as image_file: # save old thumbnail resized_image_file = getattr(profile, image_key).file backup_thumb_bytes = resized_image_file.read() resized_image_file.seek(0) # format patch using multipart upload resp = self.client.patch(self.url1, data={ image_key: image_file }, format='multipart') assert resp.status_code == 200, resp.content.decode('utf-8') profile.refresh_from_db() # resized image should not have changed thumb_bytes = getattr(profile, image_key).file.read() assert thumb_bytes == backup_thumb_bytes
def test_document_needs_update_missing(self): """ If a document doesn't exist on Elasticsearch, document_needs_update should return true """ with mute_signals(post_save): enrollment = ProgramEnrollmentFactory.create() assert document_needs_updating(enrollment) is True
def test_update_discussion_user_no_update(mock_staff_client): """Verify update_discussion_user makes the correct API calls""" with mute_signals(post_save): profile = ProfileFactory.create() discussion_user = DiscussionUser.objects.create(user=profile.user, username='******', last_sync=profile.updated_on) api.update_discussion_user(discussion_user) assert mock_staff_client.users.update.call_count == 0
def test_add_moderators_to_channel(mocker, patched_users_api): """add_moderators_to_channel should add staff or instructors as moderators and subscribers""" channel = ChannelFactory.create() mods = [] for _ in range(3): program = ChannelProgramFactory.create(channel=channel).program with mute_signals(post_save): mods += [ RoleFactory.create( program=program, user=ProfileFactory.create().user ).user for _ in range(5) ] for __ in range(5): # Add some users to the channel to show that being part of the channel is not enough to be added as a mod ProgramEnrollmentFactory.create(program=program) create_stub, _ = patched_users_api create_stub.reset_mock() add_subscriber_stub = mocker.patch('discussions.api.add_subscriber_to_channel', autospec=True) add_moderator_stub = mocker.patch('discussions.api.add_moderator_to_channel', autospec=True) api.add_moderators_to_channel(channel.name) for mod in mods: add_subscriber_stub.assert_any_call(channel.name, mod.discussion_user.username) add_moderator_stub.assert_any_call(channel.name, mod.discussion_user.username) create_stub.assert_any_call(mod.discussion_user) assert add_subscriber_stub.call_count == len(mods) assert add_moderator_stub.call_count == len(mods) assert create_stub.call_count == len(mods)
def test_null_results(settings): # Override the celery settings settings.task_eager_propagates = (True,) settings.task_always_eager = (True,) challenge = ChallengeFactory() with mute_signals(post_save): user1 = UserFactory() queryset = ( ResultFactory( job__submission__challenge=challenge, metrics={"a": 0.6}, job__submission__creator=user1, ), ResultFactory( job__submission__challenge=challenge, metrics={"a": None}, job__submission__creator=user1, ), ) challenge.evaluation_config.score_jsonpath = "a" challenge.evaluation_config.result_display_choice = Config.ALL challenge.evaluation_config.save() expected_ranks = [1, 0] assert_ranks(queryset, expected_ranks)
def test_write_cdd_file(self): """ Tests cdd_writer against a set of profiles """ kwargs = { 'profile__id': 14879, 'profile__romanized_first_name': 'Jane', 'profile__romanized_last_name': 'Smith', 'profile__user__email': '*****@*****.**', 'profile__address': '1 Main St, Room B345', 'profile__city': 'Boston', 'profile__state_or_territory': 'US-MA', 'profile__country': 'US', 'profile__postal_code': '02115', 'profile__phone_number': '+1 617 293-3423', } with mute_signals(post_save): exam_profiles = [ExamProfileFactory.create(**kwargs)] exam_profiles[0].updated_on = FIXED_DATETIME self.cdd_writer.write(self.tsv_file, exam_profiles) assert self.tsv_rows[0] == ( "14879\tJane\tSmith\[email protected]\t" "1 Main St, Room B345\t\t\t" # triple tab is for blank address2 and address3 "Boston\tMA\t02115\tUSA\t" "6172933423\t1\t2016/05/15 15:02:55" )
def test_upload_image_creates_thumbnail(self, image_already_exists, thumb_already_exists): """ An image upload should cause the thumbnail to be updated """ with mute_signals(post_save): profile = ProfileFactory.create(user=self.user1, filled_out=False, agreed_to_terms_of_service=False) if image_already_exists is False: profile.image = None if thumb_already_exists is False: profile.image_small = None profile.image_medium = None profile.save() self.client.force_login(self.user1) patch_data = ProfileSerializer(profile).data del patch_data['image'] del patch_data['image_small'] del patch_data['image_medium'] # create a dummy image file in memory for upload with make_temp_image_file() as image_file: # format patch using multipart upload resp = self.client.patch(self.url1, data={ 'image': image_file }, format='multipart') assert resp.status_code == 200, resp.content.decode('utf-8') profile.refresh_from_db() assert profile.image.height == 500 assert profile.image.width == 500 assert profile.image_small.height == 64 assert profile.image_small.width == 64 assert profile.image_medium.height == 128 assert profile.image_medium.width == 128
def test_write_ead_file(self): """ Tests that write_ead_file outputs correctly """ kwargs = { 'id': 143, 'operation': 'add', 'exam_run__exam_series_code': 'MM-DEDP', 'exam_run__date_first_eligible': date(2016, 5, 15), 'exam_run__date_last_eligible': date(2016, 10, 15), } with mute_signals(post_save): profile = ProfileFactory(id=14879) exam_auths = [ExamAuthorizationFactory.create(user=profile.user, **kwargs)] exam_auths[0].updated_on = FIXED_DATETIME self.ead_writer.write(self.tsv_file, exam_auths) assert self.tsv_rows[0] == ( "add\t143\t" "14879\tMM-DEDP\t\t" "\t2016/05/15\t2016/10/15\t" # accommodation blank intentionally "2016/05/15 15:02:55" )
def test_no_thumbnail_change_if_image_upload(self, image_already_exists, thumb_already_exists): """ A patch without an image upload should not touch the image or the thumbnail """ with mute_signals(post_save): profile = ProfileFactory.create(user=self.user1, filled_out=False, agreed_to_terms_of_service=False) if image_already_exists is False: profile.image = None if thumb_already_exists is False: profile.image_small = None profile.image_medium = None profile.save() self.client.force_login(self.user1) patch_data = ProfileSerializer(profile).data del patch_data['image'] del patch_data['image_small'] del patch_data['image_medium'] resp = self.client.patch(self.url1, content_type="application/json", data=json.dumps(patch_data)) assert resp.status_code == 200 profile.refresh_from_db() assert bool(profile.image) == image_already_exists assert bool(profile.image_small) == thumb_already_exists assert bool(profile.image_medium) == thumb_already_exists
def create_user_for_login(is_staff=True, username=None): """Create a test user that can log into the app""" later = now_in_utc() + timedelta(weeks=5000) with mute_signals(post_save): user = SocialProfileFactory.create( validated=True, user__is_staff=is_staff, image=None, # make these None so the default image is used image_small=None, image_medium=None, **({'user__username': username} if username is not None else {}), user__social_auth__extra_data={ 'access_token': 'fake', 'refresh_token': 'fake', 'updated_at': later.timestamp(), 'expires_in': 3600, } ).user UserCacheRefreshTime.objects.create( user=user, enrollment=later, certificate=later, current_grade=later, ) user.set_password(DEFAULT_PASSWORD) user.save() return user
def test_exam_authorization_when_not_paid(self): """ test exam_authorization when user has passed course but not paid. """ with mute_signals(post_save): self.final_grade.course_run_paid_on_edx = False self.final_grade.save() mmtrack = get_mmtrack(self.user, self.program) assert mmtrack.has_paid(self.course_run.edx_course_key) is False expected_errors_message = MESSAGE_NOT_ELIGIBLE_TEMPLATE.format( user=mmtrack.user.username, course_id=self.course_run.edx_course_key ) # Neither user has exam profile nor authorization. assert ExamProfile.objects.filter(profile=mmtrack.user.profile).exists() is False assert ExamAuthorization.objects.filter( user=mmtrack.user, course=self.course_run.course ).exists() is False with self.assertRaises(ExamAuthorizationException) as eae: authorize_for_exam_run(mmtrack, self.course_run, self.exam_run) assert eae.exception.args[0] == expected_errors_message # Assert user has no exam profile and authorization after exception. assert ExamProfile.objects.filter(profile=mmtrack.user.profile).exists() is False assert ExamAuthorization.objects.filter( user=mmtrack.user, course=self.course_run.course ).exists() is False
def setUpTestData(cls): with mute_signals(post_save): # valid profiles cls.expected_in_progress_profiles = ExamProfileFactory.create_batch(5, status=ExamProfile.PROFILE_PENDING) # invalid profiles cls.expected_invalid_profiles = ExamProfileFactory.create_batch(5, status=ExamProfile.PROFILE_PENDING) cls.all_profiles = cls.expected_in_progress_profiles + cls.expected_invalid_profiles
def test_country_limit(self, browser, base_test_data): """ There should be more than 20 countries in current country and birth country facets """ with open("profiles/data/countries.csv") as f: reader = csv.DictReader(f) country_codes = [row['code'] for row in reader] create_enrolled_user_batch(len(country_codes), program=base_test_data.program, is_staff=False) # Don't update elasticsearch for each profile, do that in bulk after with mute_signals(post_save): for i, profile in enumerate(Profile.objects.all()): code = country_codes[i % len(country_codes)] profile.birth_country = code profile.country = code profile.save() recreate_index() browser.get("/learners") browser.wait_until_loaded(By.CLASS_NAME, 'menu-icon') current_selector = '.filter--country .sk-hierarchical-menu-list__item' country_count = browser.driver.execute_script( "return document.querySelectorAll('{}').length".format(current_selector) ) assert country_count == len(country_codes)
def test_view_delete_automated_poll(self): with mute_signals(post_save): poll_start = now() - timedelta(days=5) poll_user = UserFactory.create(groups=['Review']) poll_group = Group.objects.get(name='Review') bug = BugFactory.create() swag_poll = PollFactory.create(name='swag poll', start=poll_start, end=poll_start + timedelta(days=15), created_by=poll_user, valid_groups=poll_group, bug=bug, automated_poll=True, description='Swag poll description.', slug='swag-poll') with mock.patch('remo.voting.views.messages.success') as faked_message: with self.login(self.admin) as client: response = client.post(reverse('voting_delete_voting', kwargs={'slug': swag_poll.slug}), follow=True) self.assertJinja2TemplateUsed(response, 'list_votings.jinja') ok_(faked_message.called) eq_(faked_message.call_args_list[0][0][1], 'Voting successfully deleted.') ok_(not Poll.objects.filter(id=swag_poll.id).exists()) ok_(not Bug.objects.filter(id=bug.id).exists())
def test_learner_view_needs_paid_learner(self, mock_mailgun_client): """ Test that a learner attempting to email another learner will only succeed if the sender has paid for a course run in a program that the recipient is enrolled in """ mock_mailgun_client.send_individual_email.return_value = Mock( spec=Response, status_code=status.HTTP_200_OK, json=mocked_json() ) with mute_signals(post_save): learner_profile = ProfileFactory.create( user__email='*****@*****.**', email_optin=True, ) learner_user = learner_profile.user ProgramEnrollmentFactory.create(user=learner_user, program=self.program) CachedEnrollment.objects.filter(user=learner_user).delete() self.client.force_login(learner_user) url = reverse(self.url_name, kwargs={'student_id': self.recipient_user.profile.student_id}) resp_post = self.client.post(url, data=self.request_data, format='json') assert resp_post.status_code == status.HTTP_403_FORBIDDEN CachedEnrollmentFactory.create(user=learner_user, course_run__course__program=self.program, verified=True) resp_post = self.client.post(url, data=self.request_data, format='json') assert resp_post.status_code == status.HTTP_200_OK
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 test_post_redirects(self): """Test that POST redirects to same URL""" with mute_signals(post_save): profile = ProfileFactory.create(agreed_to_terms_of_service=True, filled_out=True) self.client.force_login(profile.user) resp = self.client.post("/dashboard/", follow=True) assert resp.redirect_chain == [('http://testserver/dashboard/', 302)]
def setUpTestData(cls): cls.program, _ = create_program(past=True) cls.course_run = cls.program.course_set.first().courserun_set.first() cls.course = cls.course_run.course cls.program_enrollment = ProgramEnrollmentFactory.create(program=cls.program) cls.user = cls.program_enrollment.user with mute_signals(post_save): cls.final_grades = sorted([ FinalGradeFactory.create( user=cls.user, course_run=cls.course_run, passed=False, status=FinalGradeStatus.PENDING ), FinalGradeFactory.create( user=cls.user, course_run__course=cls.course, passed=True, status=FinalGradeStatus.COMPLETE ), FinalGradeFactory.create( user=cls.user, course_run__course=cls.course, passed=True, status=FinalGradeStatus.COMPLETE ), ], key=lambda final_grade: final_grade.course_run.end_date, reverse=True)
def setUpTestData(cls): 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_extend_voting_period_majority(self): bug = BugFactory.create() start = now().replace(microsecond=0) end = datetime.combine(get_date(days=1), datetime.min.time()) user = UserFactory.create(groups=['Admin']) group = Group.objects.get(name='Review') User.objects.filter(groups__name='Review').delete() UserFactory.create_batch(9, groups=['Review']) with mute_signals(post_save): automated_poll = PollFactory.create(name='poll', start=start, end=end, valid_groups=group, created_by=user, automated_poll=True, bug=bug) radio_poll = RadioPollFactory.create(poll=automated_poll, question='Budget Approval') RadioPollChoiceFactory.create(answer='Approved', votes=5, radio_poll=radio_poll) RadioPollChoiceFactory.create(answer='Denied', votes=3, radio_poll=radio_poll) extend_voting_period() poll = Poll.objects.get(pk=automated_poll.id) eq_(poll.end.year, end.year) eq_(poll.end.month, end.month) eq_(poll.end.day, end.day) eq_(poll.end.hour, 0) eq_(poll.end.minute, 0) eq_(poll.end.second, 0) ok_(not poll.is_extended)
def test_update_percolate_memberships(self, source_type, is_member, query_matches, mock_on_commit): """ Tests that existing memberships are updated where appropriate """ with mute_signals(post_save): query = PercolateQueryFactory.create(source_type=source_type) profile = ProfileFactory.create(filled_out=True) program_enrollment = ProgramEnrollmentFactory.create(user=profile.user) membership = PercolateQueryMembershipFactory.create( user=profile.user, query=query, is_member=is_member, needs_update=False ) with patch( 'search.api._search_percolate_queries', return_value=[query.id] if query_matches else [] ) as search_percolate_queries_mock: update_percolate_memberships(profile.user, source_type) search_percolate_queries_mock.assert_called_once_with(program_enrollment) membership.refresh_from_db() assert membership.needs_update is (is_member is not query_matches)
def test_update_exam_authorization_order(self, order_status): """ Verify that update_exam_authorization_final_grade is called when a fulfilled Order saves """ with mute_signals(post_save): # muted because enrollment also trigger signal for profile creation. right now we are just # looking final grades CachedEnrollmentFactory.create(user=self.profile.user, course_run=self.course_run) FinalGradeFactory.create( user=self.profile.user, course_run=self.course_run, passed=True, ) order = OrderFactory.create(user=self.profile.user, fulfilled=False) LineFactory.create(course_key=self.course_run.edx_course_key, order=order) # There is no ExamProfile or ExamAuthorization before creating the FinalGrade. assert ExamProfile.objects.filter(profile=self.profile).exists() is False assert ExamAuthorization.objects.filter( user=self.profile.user, course=self.course_run.course ).exists() is False order.status = order_status order.save() # assert Exam Authorization and profile created. assert ExamProfile.objects.filter(profile=self.profile).exists() is True assert ExamAuthorization.objects.filter( user=self.profile.user, course=self.course_run.course ).exists() is True
def test_calculate_ranks(mocker): challenge = ChallengeFactory() challenge.evaluation_config.score_jsonpath = "a" challenge.evaluation_config.save() with mute_signals(post_save): queryset = ( ResultFactory(challenge=challenge, metrics={"a": 0.1}), ResultFactory(challenge=challenge, metrics={"a": 0.5}), ResultFactory(challenge=challenge, metrics={"a": 1.0}), ResultFactory(challenge=challenge, metrics={"a": 0.7}), ResultFactory(challenge=challenge, metrics={"a": 0.5}), ResultFactory(challenge=challenge, metrics={"a": 1.0}), ) # An alternative implementation could be [4, 3, 1, 2, 3, 1] as there are # only 4 unique values, the current implementation is harsh on poor results expected_ranks = [6, 4, 1, 3, 4, 1] challenge = assert_ranks(challenge, expected_ranks, queryset) # now test reverse order challenge.evaluation_config.score_default_sort = ( challenge.evaluation_config.ASCENDING) challenge.evaluation_config.save() expected_ranks = [1, 2, 5, 4, 2, 5] assert_ranks(challenge, expected_ranks, queryset)
def test_upload_image_creates_thumbnail(self, image_already_exists, thumb_already_exists): """ An image upload should cause the thumbnail to be updated """ with mute_signals(post_save): profile = ProfileFactory.create(user=self.user1, filled_out=False, agreed_to_terms_of_service=False) if image_already_exists is False: profile.image = None if thumb_already_exists is False: profile.image_small = None profile.image_medium = None profile.save() self.client.force_login(self.user1) patch_data = ProfileSerializer(profile).data del patch_data['image'] del patch_data['image_small'] del patch_data['image_medium'] # create a dummy image file in memory for upload with make_temp_image_file() as image_file: # format patch using multipart upload resp = self.client.patch(self.url1, data={'image': image_file}, format='multipart') assert resp.status_code == 200, resp.content.decode('utf-8') profile.refresh_from_db() assert profile.image.height == 500 assert profile.image.width == 500 assert profile.image_small.height == 64 assert profile.image_small.width == 64 assert profile.image_medium.height == 128 assert profile.image_medium.width == 128
def test_get_invoice(authenticated_api_client, settings, issued_invoice): invoice = issued_invoice customer = issued_invoice.customer issued_invoice.generate_pdf() with mute_signals(pre_save): [ TransactionFactory.create( state=state, invoice=issued_invoice, payment_method=PaymentMethodFactory(customer=customer)) for state in Transaction.States.as_list() if state not in [ Transaction.States.Canceled, Transaction.States.Refunded, Transaction.States.Failed ] ] url = reverse('invoice-detail', kwargs={'pk': invoice.pk}) response = authenticated_api_client.get(url, format='json') assert response.status_code == status.HTTP_200_OK, response.data invoice_definition.check_response(invoice, response_data=response.data)
def create_enrolled_profile(program, role=None, **profile_kwargs): """ Helper function to create a profile and some related models Args: program (courses.models.Program): A program role (str or None): A role, or no role if None Returns: profiles.models.Profile: A new profile """ with mute_signals(post_save): profile = ProfileFactory.create(**profile_kwargs) ProgramEnrollment.objects.create(user=profile.user, program=program) if role is not None: Role.objects.create( user=profile.user, program=program, role=role, ) return profile
def test_update_exam_authorization_order(self, order_status): """ Verify that update_exam_authorization_final_grade is called when a fulfilled Order saves """ with mute_signals(post_save): # muted because enrollment also trigger signal for profile creation. right now we are just # looking final grades CachedEnrollmentFactory.create(user=self.profile.user, course_run=self.course_run) FinalGradeFactory.create( user=self.profile.user, course_run=self.course_run, passed=True, ) order = OrderFactory.create(user=self.profile.user, fulfilled=False) LineFactory.create(course_key=self.course_run.edx_course_key, order=order) # There is no ExamProfile or ExamAuthorization before creating the FinalGrade. assert ExamProfile.objects.filter( profile=self.profile).exists() is False assert ExamAuthorization.objects.filter( user=self.profile.user, course=self.course_run.course).exists() is False order.status = order_status order.save() # assert Exam Authorization and profile created. assert ExamProfile.objects.filter( profile=self.profile).exists() is True assert ExamAuthorization.objects.filter( user=self.profile.user, course=self.course_run.course).exists() is True
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) assert resp.json() == ProfileSerializer().to_representation(profile)
def setUpTestData(cls): with mute_signals(post_save): cls.exam_auths = ExamAuthorizationFactory.create_batch( 10, status=ExamAuthorization.STATUS_PENDING)
def create(cls, *args, **kwargs): # pylint: disable=arguments-differ """ Overrides the default .create() method to turn off save signals """ with mute_signals(post_save): return super().create(*args, **kwargs)
def setUpTestData(cls): super().setUpTestData() with mute_signals(post_save): cls.user = ProfileFactory.create().user
def setUpTestData(cls): with mute_signals(post_save): cls.profile = profile = ProfileFactory.create() cls.user = profile.user EducationFactory.create(profile=profile) EmploymentFactory.create(profile=profile) # create a normal program program = ProgramFactory.create() cls.enrollments = cls._generate_cached_enrollments(cls.user, program, num_course_runs=2) certificate_grades_vals = [0.7, 0.8] cls.current_grades_vals = [0.9, 1.0] cls.certificates = [] cls.current_grades = [] for i, enrollment in enumerate(cls.enrollments): cls.certificates.append( CachedCertificateFactory.create( user=cls.user, course_run=enrollment.course_run, data={ "grade": certificate_grades_vals[i], "certificate_type": "verified", "course_id": enrollment.course_run.edx_course_key, "status": "downloadable", })) cls.current_grades.append( CachedCurrentGradeFactory.create( user=cls.user, course_run=enrollment.course_run, data={ "passed": True, "percent": cls.current_grades_vals[i], "course_key": enrollment.course_run.edx_course_key, })) FinalGradeFactory.create( user=cls.user, course_run=enrollment.course_run, grade=certificate_grades_vals[i], passed=True, ) non_fa_cached_edx_data = CachedEdxUserData(cls.user, program=program) non_fa_mmtrack = MMTrack(cls.user, program, non_fa_cached_edx_data) cls.serialized_enrollments = UserProgramSearchSerializer.serialize_enrollments( non_fa_mmtrack) cls.serialized_course_enrollments = UserProgramSearchSerializer.serialize_course_enrollments( non_fa_mmtrack) cls.semester_enrollments = UserProgramSearchSerializer.serialize_course_runs_enrolled( non_fa_mmtrack) cls.program_enrollment = ProgramEnrollment.objects.create( user=cls.user, program=program) # create a financial aid program cls.fa_program, _ = create_program() cls.fa_program_enrollment = ProgramEnrollment.objects.create( user=cls.user, program=cls.fa_program) cls.fa_enrollments = cls._generate_cached_enrollments( cls.user, cls.fa_program, num_course_runs=2) cls.current_grades = [] for i, enrollment in enumerate(cls.fa_enrollments): order = OrderFactory.create(user=cls.user, status='fulfilled') LineFactory.create(order=order, course_key=enrollment.course_run.edx_course_key) cls.current_grades.append( CachedCurrentGradeFactory.create( user=cls.user, course_run=enrollment.course_run, data={ "passed": True, "percent": cls.current_grades_vals[i], "course_key": enrollment.course_run.edx_course_key, })) FinalGradeFactory.create( user=cls.user, course_run=enrollment.course_run, grade=cls.current_grades_vals[i], passed=True, ) fa_cached_edx_data = CachedEdxUserData(cls.user, program=cls.fa_program) fa_mmtrack = MMTrack(cls.user, cls.fa_program, fa_cached_edx_data) cls.fa_serialized_course_enrollments = ( UserProgramSearchSerializer.serialize_course_enrollments( fa_mmtrack)) cls.fa_serialized_enrollments = ( UserProgramSearchSerializer.serialize_enrollments(fa_mmtrack))
def setUp(self): super(IsProfileFilledOutTests, self).setUp() with mute_signals(post_save): self.profile = ProfileFactory.create()
def test_increments(self): """test that a student id increments correctly""" with mute_signals(post_save): profile_one = ProfileFactory() profile_two = ProfileFactory() assert profile_two.student_id > profile_one.student_id
def test_get_invoice(self, mocked_settings): InvoiceFactory.reset_sequence(1) TransactionFactory.reset_sequence(1) customer = CustomerFactory.create() invoice = InvoiceFactory.create(customer=customer, state=Invoice.STATES.ISSUED) invoice.generate_pdf() with mute_signals(pre_save): transactions = [ TransactionFactory.create( state=state, invoice=invoice, payment_method=PaymentMethodFactory(customer=customer)) for state in Transaction.States.as_list() if state not in [ Transaction.States.Canceled, Transaction.States.Refunded, Transaction.States.Failed ] ] expected_transactions = [{ "id": str(transaction.uuid), "url": build_absolute_test_url( reverse('transaction-detail', [transaction.customer.pk, transaction.uuid])), "customer": build_absolute_test_url( reverse('customer-detail', [transaction.customer.id])), "provider": build_absolute_test_url( reverse('provider-detail', [transaction.provider.id])), "amount": "%.2f" % transaction.amount, "currency": "RON", "state": transaction.state, "proforma": build_absolute_test_url( reverse('proforma-detail', [transaction.proforma.id])), "invoice": build_absolute_test_url( reverse('invoice-detail', [transaction.invoice.id])), "can_be_consumed": transaction.can_be_consumed, "payment_processor": transaction.payment_processor, "payment_method": build_absolute_test_url( reverse( 'payment-method-detail', [transaction.customer.pk, transaction.payment_method.pk])), "pay_url": (build_absolute_test_url(reverse('payment', ['token'])) if transaction.state == Transaction.States.Initial else None), } for transaction in transactions] with patch('silver.utils.payments._get_jwt_token') as mocked_token: mocked_token.return_value = 'token' url = reverse('invoice-detail', kwargs={'pk': invoice.pk}) for show_pdf_storage_url, pdf_url in [ (True, build_absolute_test_url(invoice.pdf.url)), (False, build_absolute_test_url(reverse('pdf', args=[invoice.pdf.pk]))) ]: mocked_settings.SILVER_SHOW_PDF_STORAGE_URL = show_pdf_storage_url response = self.client.get(url) self.assertEqual(response.status_code, status.HTTP_200_OK) expected_response = { "id": invoice.pk, "series": "InvoiceSeries", "number": 1, "provider": build_absolute_test_url( reverse('provider-detail', [invoice.provider.pk])), "customer": build_absolute_test_url( reverse('customer-detail', [invoice.customer.pk])), "archived_provider": '{}', "archived_customer": '{}', "due_date": None, "issue_date": invoice.issue_date.strftime('%Y-%m-%d'), "paid_date": None, "cancel_date": None, "sales_tax_name": "VAT", "sales_tax_percent": '1.00', "currency": "RON", "transaction_currency": invoice.transaction_currency, "transaction_xe_rate": ("%.4f" % invoice.transaction_xe_rate if invoice.transaction_xe_rate else None), "transaction_xe_date": invoice.transaction_xe_date, "state": "issued", "proforma": build_absolute_test_url( reverse('proforma-detail', [invoice.related_document.pk])), "invoice_entries": [], "pdf_url": pdf_url, "total": 0 } for field in expected_response: self.assertEqual( expected_response[field], response.data[field], msg=("Expected %s, actual %s for field %s" % (expected_response[field], response.data[field], field))) self.assertEqual(len(response.data["transactions"]), len(expected_transactions)) for actual_transaction in response.data["transactions"]: expected_transaction = [ transaction for transaction in expected_transactions if transaction["id"] == actual_transaction["id"] ] self.assertTrue(expected_transaction) expected_transaction = expected_transaction[0] for field in expected_transaction: self.assertEqual( expected_transaction[field], actual_transaction[field], msg=("Expected %s, actual %s for field %s" % (expected_transaction[field], actual_transaction[field], field)))
def create(cls, *args, **kwargs): """ Overrides the default .create() method to turn off save signals """ with mute_signals(post_save): return super().create(*args, **kwargs)
def create_batch(cls, *args, **kwargs): # pylint: disable=arguments-differ """ Ensure that signals are muted before running the base create_batch method """ with mute_signals(post_save): return super().create_batch(*args, **kwargs)
def test_get_invoice(self): InvoiceFactory.reset_sequence(1) TransactionFactory.reset_sequence(1) customer = CustomerFactory.create() invoice = InvoiceFactory.create(customer=customer, state=Invoice.STATES.ISSUED) with mute_signals(pre_save): transactions = [ TransactionFactory.create( state=state, invoice=invoice, payment_method=PaymentMethodFactory(customer=customer)) for state in Transaction.States.as_list() if state not in [ Transaction.States.Canceled, Transaction.States.Refunded, Transaction.States.Failed ] ] expected_transactions = [{ "id": str(transaction.uuid), "url": "http://testserver/customers/%s/transactions/%s/" % (invoice.customer.pk, transaction.uuid), "customer": "http://testserver/customers/%s/" % invoice.customer.pk, "provider": "http://testserver/providers/%s/" % invoice.provider.pk, "amount": "%s.00" % str(transaction.amount), "currency": "USD", "state": transaction.state, "proforma": "http://testserver/proformas/%s/" % transaction.proforma.pk, "invoice": "http://testserver/invoices/%s/" % transaction.invoice.pk, "can_be_consumed": transaction.can_be_consumed, "payment_processor": transaction.payment_processor, "payment_method": "http://testserver/customers/%s/payment_methods/%s/" % (invoice.customer.pk, transaction.payment_method.pk), "pay_url": "http://testserver/pay/token/" if transaction.state == Transaction.States.Initial else None, } for transaction in transactions] with patch('silver.utils.payments._get_jwt_token') as mocked_token: mocked_token.return_value = 'token' url = reverse('invoice-detail', kwargs={'pk': invoice.pk}) response = self.client.get(url) self.assertEqual(response.status_code, status.HTTP_200_OK) expected_response = { "id": invoice.pk, "series": "InvoiceSeries", "number": 1, "provider": "http://testserver/providers/%s/" % invoice.provider.pk, "customer": "http://testserver/customers/%s/" % invoice.customer.pk, "archived_provider": '{}', "archived_customer": '{}', "due_date": None, "issue_date": str(invoice.issue_date), "paid_date": None, "cancel_date": None, "sales_tax_name": "VAT", "sales_tax_percent": '1.00', "currency": "RON", "transaction_currency": invoice.transaction_currency, "transaction_xe_rate": ("%.4f" % invoice.transaction_xe_rate if invoice.transaction_xe_rate else None), "transaction_xe_date": invoice.transaction_xe_date, "state": "issued", "proforma": "http://testserver/proformas/%s/" % invoice.proforma.pk, "invoice_entries": [], "pdf_url": invoice.pdf.url, "total": 0 } for field in expected_response: self.assertEqual(expected_response[field], response.data[field], msg=("Expected %s, actual %s for field %s" % (expected_response[field], response.data[field], field))) self.assertEqual(len(response.data["transactions"]), len(expected_transactions)) for actual_transaction in response.data["transactions"]: expected_transaction = [ transaction for transaction in expected_transactions if transaction["id"] == actual_transaction["id"] ] self.assertTrue(expected_transaction) expected_transaction = expected_transaction[0] self.assertEqual(expected_transaction[field], actual_transaction[field], msg=("Expected %s, actual %s for field %s" % (expected_response[field], response.data[field], field)))
def test_calculate_ranks(settings): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) challenge = ChallengeFactory() with mute_signals(post_save): queryset = ( # Warning: Do not change this values without updating the # expected_ranks below. ResultFactory( job__submission__challenge=challenge, metrics={ "a": 0.0, "b": 0.0 }, ), ResultFactory( job__submission__challenge=challenge, metrics={ "a": 0.5, "b": 0.2 }, ), ResultFactory( job__submission__challenge=challenge, metrics={ "a": 1.0, "b": 0.3 }, ), ResultFactory( job__submission__challenge=challenge, metrics={ "a": 0.7, "b": 0.4 }, ), ResultFactory( job__submission__challenge=challenge, metrics={ "a": 0.5, "b": 0.5 }, ), # Following two are invalid if relative ranking is used ResultFactory(job__submission__challenge=challenge, metrics={"a": 1.0}), ResultFactory(job__submission__challenge=challenge, metrics={"b": 0.3}), # Add a valid, but unpublished result ResultFactory( job__submission__challenge=challenge, metrics={ "a": 0.1, "b": 0.1 }, ), ) # Unpublish the result queryset[-1].published = False queryset[-1].save() expected = { Config.DESCENDING: { Config.ABSOLUTE: { Config.DESCENDING: { "ranks": [6, 4, 1, 3, 4, 1, 0, 0], "rank_scores": [6, 4, 1, 3, 4, 1, 0, 0], }, Config.ASCENDING: { "ranks": [6, 4, 1, 3, 4, 1, 0, 0], "rank_scores": [6, 4, 1, 3, 4, 1, 0, 0], }, }, Config.MEDIAN: { Config.DESCENDING: { "ranks": [5, 4, 1, 1, 1, 0, 0, 0], "rank_scores": [5, 3.5, 2, 2, 2, 0, 0, 0], }, Config.ASCENDING: { "ranks": [3, 2, 1, 3, 5, 0, 0, 0], "rank_scores": [3, 2.5, 2, 3, 4, 0, 0, 0], }, }, Config.MEAN: { Config.DESCENDING: { "ranks": [5, 4, 1, 1, 1, 0, 0, 0], "rank_scores": [5, 3.5, 2, 2, 2, 0, 0, 0], }, Config.ASCENDING: { "ranks": [3, 2, 1, 3, 5, 0, 0, 0], "rank_scores": [3, 2.5, 2, 3, 4, 0, 0, 0], }, }, }, Config.ASCENDING: { Config.ABSOLUTE: { Config.DESCENDING: { "ranks": [1, 2, 5, 4, 2, 5, 0, 0], "rank_scores": [1, 2, 5, 4, 2, 5, 0, 0], }, Config.ASCENDING: { "ranks": [1, 2, 5, 4, 2, 5, 0, 0], "rank_scores": [1, 2, 5, 4, 2, 5, 0, 0], }, }, Config.MEDIAN: { Config.DESCENDING: { "ranks": [2, 2, 5, 2, 1, 0, 0, 0], "rank_scores": [3, 3, 4, 3, 1.5, 0, 0, 0], }, Config.ASCENDING: { "ranks": [1, 2, 4, 4, 3, 0, 0, 0], "rank_scores": [1, 2, 4, 4, 3.5, 0, 0, 0], }, }, Config.MEAN: { Config.DESCENDING: { "ranks": [2, 2, 5, 2, 1, 0, 0, 0], "rank_scores": [3, 3, 4, 3, 1.5, 0, 0, 0], }, Config.ASCENDING: { "ranks": [1, 2, 4, 4, 3, 0, 0, 0], "rank_scores": [1, 2, 4, 4, 3.5, 0, 0, 0], }, }, }, } for score_method in (Config.ABSOLUTE, Config.MEDIAN, Config.MEAN): for a_order in (Config.DESCENDING, Config.ASCENDING): for b_order in (Config.DESCENDING, Config.ASCENDING): challenge.evaluation_config.score_jsonpath = "a" challenge.evaluation_config.scoring_method_choice = ( score_method) challenge.evaluation_config.score_default_sort = a_order challenge.evaluation_config.extra_results_columns = [{ "path": "b", "title": "b", "order": b_order }] challenge.evaluation_config.save() assert_ranks( queryset, expected[a_order][score_method][b_order]["ranks"], expected[a_order][score_method][b_order]["rank_scores"], )
def test_results_display(settings): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) challenge = ChallengeFactory() with mute_signals(post_save): user1 = UserFactory() user2 = UserFactory() queryset = ( ResultFactory( job__submission__challenge=challenge, metrics={"b": 0.3}, # Invalid result job__submission__creator=user1, ), ResultFactory( job__submission__challenge=challenge, metrics={"a": 0.6}, job__submission__creator=user1, ), ResultFactory( job__submission__challenge=challenge, metrics={"a": 0.4}, job__submission__creator=user1, ), ResultFactory( job__submission__challenge=challenge, metrics={"a": 0.2}, job__submission__creator=user1, ), ResultFactory( job__submission__challenge=challenge, metrics={"a": 0.1}, job__submission__creator=user2, ), ResultFactory( job__submission__challenge=challenge, metrics={"a": 0.5}, job__submission__creator=user2, ), ResultFactory( job__submission__challenge=challenge, metrics={"a": 0.3}, job__submission__creator=user2, ), ) challenge.evaluation_config.score_jsonpath = "a" challenge.evaluation_config.result_display_choice = Config.ALL challenge.evaluation_config.save() expected_ranks = [0, 1, 3, 5, 6, 2, 4] assert_ranks(queryset, expected_ranks) challenge.evaluation_config.result_display_choice = Config.MOST_RECENT challenge.evaluation_config.save() expected_ranks = [0, 0, 0, 2, 0, 0, 1] assert_ranks(queryset, expected_ranks) challenge.evaluation_config.result_display_choice = Config.BEST challenge.evaluation_config.save() expected_ranks = [0, 1, 0, 0, 0, 2, 0] assert_ranks(queryset, expected_ranks) # now test reverse order challenge.evaluation_config.score_default_sort = ( challenge.evaluation_config.ASCENDING) challenge.evaluation_config.save() expected_ranks = [0, 0, 0, 2, 1, 0, 0] assert_ranks(queryset, expected_ranks) challenge.evaluation_config.result_display_choice = Config.MOST_RECENT challenge.evaluation_config.save() expected_ranks = [0, 0, 0, 1, 0, 0, 2] assert_ranks(queryset, expected_ranks)
def create_batch(cls, *args, **kwargs): """ Ensure that signals are muted before running the base create_batch method """ with mute_signals(post_save): return super().create_batch(*args, **kwargs)
def test_country_subdivision(self, state, expected_result): """Test country_subdivision against a range of values""" with mute_signals(post_save): profile = ProfileFactory(state_or_territory=state) assert profile.country_subdivision == expected_result
def test_should_pretty_print(self): """test pretty printing property method""" with mute_signals(post_save): profile = ProfileFactory() assert profile.pretty_printed_student_id == "MMM{0:06}".format( profile.student_id)
from django.core.exceptions import ValidationError from django.db.models.signals import post_save from django.test.testcases import TestCase from factory.django import mute_signals from tests.factories import SubmissionFactory MutedFactory = mute_signals(post_save)(SubmissionFactory) class SubmissionCreateTest(TestCase): def test_create_valid_submission(self): submission = MutedFactory( image='alpine:latest' ) def test_create_invalid_image_submission(self): with self.assertRaises(ValidationError): submission = MutedFactory( image='blsfsdfd:3' )
def setUpTestData(cls): with mute_signals(post_save): cls.user_profile = ProfileFactory.create() cls.user = cls.user_profile.user
def test_serialize_pkcs12_cas_nopassphrase(self): root_key = Key().create_key("ed25519", None) subject = DistinguishedNameFactory(countryName="NL", stateOrProvinceName="Noord Holland", organizationName="Repleo") root_certificate = CertificateFactory( dn=subject, name="test_server_root_certificate", expires_at=arrow.get(timezone.now()).shift(days=+30).date()) with mute_signals(signals.post_save): root_certificate.save() root_certhandler = Certificate() root_certhandler.create_certificate(root_certificate, root_key.serialize()) keystore = KeyStore(certificate=root_certificate) keystore.crt = root_certhandler.serialize() keystore.key = root_key.serialize() keystore.save() int_key = Key().create_key("rsa", 2048) subject = DistinguishedNameFactory( countryName=root_certificate.dn.countryName, stateOrProvinceName=root_certificate.dn.stateOrProvinceName, organizationName=root_certificate.dn.organizationName, ) int_certificate = CertificateFactory( expires_at=arrow.get(timezone.now()).shift(days=+5).date(), name="test_server_intermediate_certificate", type=CertificateTypes.INTERMEDIATE, parent=root_certificate, dn=subject, crl_distribution_url="https://example.com/crl/cert.crl.pem", ocsp_distribution_host="https://example.com/ocsp/", ) with mute_signals(signals.post_save): int_certificate.save() int_certhandler = Certificate() int_certhandler.create_certificate(int_certificate, int_key.serialize()) keystore = KeyStore(certificate=int_certificate) keystore.crt = int_certhandler.serialize() keystore.key = int_key.serialize() keystore.save() pkcs12 = int_key.serialize_pkcs12("test_pkcs12_cas", int_certhandler.certificate, cas=[root_certhandler.certificate]) pkcs12_obj = load_pkcs12(pkcs12, None) self.assertEqual(pkcs12_obj.key.key_size, 2048) self.assertEqual(pkcs12_obj.cert.friendly_name.decode("utf-8"), "test_pkcs12_cas") self.assertEqual(pkcs12_obj.cert.certificate.serial_number, int_certhandler.certificate.serial_number) self.assertEqual( pkcs12_obj.additional_certs[0].certificate.serial_number, root_certhandler.certificate.serial_number)
def test_index_program_enrolled_users(self, mock_on_commit): """ Test that index_program_enrolled_users indexes an iterable of program-enrolled users """ num_enrollments = 10 chunk_size = 4 with mute_signals(post_save): program_enrollments = [ ProgramEnrollmentFactory.create() for _ in range(num_enrollments) ] for enrollment in program_enrollments: ProfileFactory.create(user=enrollment.user) private = [ serialize_program_enrolled_user(enrollment) for enrollment in program_enrollments ] private_dicts = { serialized['id']: serialized for serialized in private } public = [ serialize_public_enrolled_user(serialized) for serialized in private ] public_dicts = {serialized['id']: serialized for serialized in public} with patch('search.indexing_api._index_chunk', autospec=True, return_value=0) as index_chunk, patch( 'search.indexing_api.serialize_program_enrolled_user', autospec=True, side_effect=lambda x: private_dicts[x.id] ) as serialize_mock, patch( 'search.indexing_api.serialize_public_enrolled_user', autospec=True, side_effect=lambda x: public_dicts[x[ 'id']]) as serialize_public_mock: index_program_enrolled_users(program_enrollments, chunk_size=chunk_size) assert index_chunk.call_count == 6 # 10 enrollments divided in chunks of 4, times the number of types (2) public_index = make_alias_name(PUBLIC_ENROLLMENT_INDEX_TYPE, is_reindexing=False) private_index = make_alias_name(PRIVATE_ENROLLMENT_INDEX_TYPE, is_reindexing=False) for offset in range(0, num_enrollments, chunk_size): # each enrollment should get yielded twice to account for each doctype index_chunk.assert_any_call( public[offset:offset + 4], # ordered dicts FTW index=public_index) index_chunk.assert_any_call(private[offset:offset + 4], index=private_index) assert serialize_mock.call_count == len(program_enrollments) assert serialize_public_mock.call_count == len(program_enrollments) for enrollment in program_enrollments: serialize_mock.assert_any_call(enrollment) serialize_public_mock.assert_any_call( private_dicts[enrollment.id])
def setUp(self): super().setUp() with mute_signals(post_save): self.profile = ProfileFactory.create()
def test_profile_state(self, country, state, expected): """Test that profile_state returns expected values""" with mute_signals(post_save): profile = ExamProfileFactory(profile__country=country, profile__state_or_territory=state) assert CDDWriter.profile_state(profile) == expected
def test_on_save(self): """test that a student id is set on save""" with mute_signals(post_save): profile = ProfileFactory() assert profile.student_id is not None assert profile.student_id == profile.id
def setUpTestData(cls): super().setUpTestData() with mute_signals(post_save): cls.profile2 = ProfileFactory.create() cls.url = reverse("financialaid_api")