def test_delete_education(self): """ Test that we delete Educations which aren't specified in the PATCH """ with mute_signals(post_save): education1 = EducationFactory.create() EducationFactory.create(profile=education1.profile) # has a different profile education3 = EducationFactory.create() assert education1.profile.education.count() == 2 education_object1 = EducationSerializer().to_representation(education1) serializer = ProfileSerializer(instance=education1.profile, data={ 'education': [education_object1], 'work_history': [] }) serializer.is_valid(raise_exception=True) serializer.save() assert education1.profile.education.count() == 1 assert education1.profile.education.first() == education1 # Other profile is unaffected assert education3.profile.education.count() == 1
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_education_add(self, index_type, mock_on_commit): """ Test that Education is indexed after being added """ program_enrollment = ProgramEnrollmentFactory.create() assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT EducationFactory.create(profile=program_enrollment.user.profile) assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_education_add(self): """ Test that Education is indexed after being added """ program_enrollment = ProgramEnrollmentFactory.create() assert es.search()['total'] == 1 EducationFactory.create(profile=program_enrollment.user.profile) assert_search(es.search(), [program_enrollment])
def test_education_add(self, index_type, mock_on_commit): """ Test that Education is indexed after being added """ program_enrollment = ProgramEnrollmentFactory.create() assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT EducationFactory.create(profile=program_enrollment.user.profile) assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
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_not_analyzed(self): """ At the moment no string fields in the mapping should be 'analyzed' since there's no field supporting full text search. """ program_enrollment = ProgramEnrollmentFactory.create() EducationFactory.create(profile=program_enrollment.user.profile) EmploymentFactory.create(profile=program_enrollment.user.profile) mapping = es.get_mappings() nodes = list(traverse_mapping(mapping)) for node in nodes: if node.get('type') == 'string': assert node['index'] == 'not_analyzed'
def setUpTestData(cls): """ Create a profile and social auth """ with mute_signals(post_save): cls.profile = ProfileFactory.create( filled_out=True, agreed_to_terms_of_service=True, ) EmploymentFactory.create(profile=cls.profile) EducationFactory.create(profile=cls.profile) cls.profile.user.social_auth.create(provider=EdxOrgOAuth2.name, uid="{}_edx".format( cls.profile.user.username))
def setUpTestData(cls): """ Create a profile and social auth """ with mute_signals(post_save): cls.profile = ProfileFactory.create( filled_out=True, agreed_to_terms_of_service=True, ) EmploymentFactory.create(profile=cls.profile) EducationFactory.create(profile=cls.profile) cls.profile.user.social_auth.create( provider=EdxOrgOAuth2.name, uid="{}_edx".format(cls.profile.user.username) )
def test_update_education_different_profile(self): """ Make sure we can't edit an education for a different profile """ with mute_signals(post_save): education1 = EducationFactory.create() education2 = EducationFactory.create() education_object = EducationSerializer(education1).data education_object['id'] = education2.id serializer = ProfileSerializer(instance=education1.profile, data={ 'education': [education_object], 'work_history': [] }) serializer.is_valid(raise_exception=True) with self.assertRaises(ValidationError) as ex: serializer.save() assert ex.exception.detail == ["Education {} does not exist".format(education2.id)]
def test_analyzed(self, mock_on_commit): """ Most string fields in the mapping should be 'analyzed' since we don't want to tokenize strings arbitrarily when filtering on fields. """ program_enrollment = ProgramEnrollmentFactory.create() EducationFactory.create(profile=program_enrollment.user.profile) EmploymentFactory.create(profile=program_enrollment.user.profile) for index_type in ALL_INDEX_TYPES: mapping = es.get_mappings(index_type) nodes = list(traverse_mapping(mapping, "")) for key, node in nodes: if key == "folded": assert node['analyzer'] == "folding" elif node.get('type') == 'string': assert node['index'] == 'not_analyzed'
def test_analyzed(self, mock_on_commit): """ Most string fields in the mapping should be 'analyzed' since we don't want to tokenize strings arbitrarily when filtering on fields. """ program_enrollment = ProgramEnrollmentFactory.create() EducationFactory.create(profile=program_enrollment.user.profile) EmploymentFactory.create(profile=program_enrollment.user.profile) for index_type in ALL_INDEX_TYPES: mapping = es.get_mappings(index_type) nodes = list(traverse_mapping(mapping, "")) for key, node in nodes: if key == "folded": assert node['analyzer'] == "folding" elif node.get('type') == 'string': assert node['index'] == 'not_analyzed'
def setUpTestData(cls): with mute_signals(post_save): profile = ProfileFactory.create() EducationFactory.create(profile=profile) EmploymentFactory.create(profile=profile) program = ProgramFactory.create() cls.enrollments = cls._generate_cached_enrollments(profile.user, program, num_course_runs=2) certificate_grades = [0.7, 0.8] cls.certificates = [] for i, enrollment in enumerate(cls.enrollments): cls.certificates.append( CachedCertificateFactory.create( user=profile.user, course_run=enrollment.course_run, data={'grade': certificate_grades[i]} ) ) cls.program_enrollment = ProgramEnrollment.objects.create(user=profile.user, program=program)
def test_education_delete(self, index_type, mock_on_commit): """ Test that Education is removed from index after being deleted """ program_enrollment = ProgramEnrollmentFactory.create() education = EducationFactory.create(profile=program_enrollment.user.profile) assert_search(es.search(index_type), [program_enrollment], index_type=index_type) education.delete() assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
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_education_delete(self): """ Test that Education is removed from index after being deleted """ program_enrollment = ProgramEnrollmentFactory.create() education = EducationFactory.create( profile=program_enrollment.user.profile) assert_search(es.search(), [program_enrollment]) education.delete() assert_search(es.search(), [program_enrollment])
def test_education_update(self, index_type, mock_on_commit): """ Test that Education is reindexed after being updated """ program_enrollment = ProgramEnrollmentFactory.create() assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT education = EducationFactory.create(profile=program_enrollment.user.profile) education.school_city = 'city' education.save() assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_upload_image(self): """ An image upload should not delete education or work history entries """ with mute_signals(post_save): profile = ProfileFactory.create(user=self.user1) EducationFactory.create(profile=profile) EmploymentFactory.create(profile=profile) self.client.force_login(self.user1) # create a dummy image file in memory for upload with make_temp_image_file(width=50, height=50) 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') assert profile.education.count() == 1 assert profile.work_history.count() == 1
def test_upload_image(self): """ An image upload should not delete education or work history entries """ with mute_signals(post_save): profile = ProfileFactory.create(user=self.user1) EducationFactory.create(profile=profile) EmploymentFactory.create(profile=profile) self.client.force_login(self.user1) # create a dummy image file in memory for upload with make_temp_image_file(width=50, height=50) 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') assert profile.education.count() == 1 assert profile.work_history.count() == 1
def test_folded(self, mock_on_commit): """ Check that we have a folded type for first_name, last_name, and preferred_name """ program_enrollment = ProgramEnrollmentFactory.create() EducationFactory.create(profile=program_enrollment.user.profile) EmploymentFactory.create(profile=program_enrollment.user.profile) for index_type in ALL_INDEX_TYPES: mapping = es.get_mappings(index_type) properties = mapping[GLOBAL_DOC_TYPE]['properties'] if index_type == PUBLIC_ENROLLMENT_INDEX_TYPE: # Make sure we aren't exposing people's email addresses assert 'email' not in properties else: assert properties['email']['fields']['folded']['analyzer'] == 'folding' profile_properties = properties['profile']['properties'] for key in 'first_name', 'last_name', 'preferred_name', 'full_name', 'username': assert profile_properties[key]['fields']['folded']['analyzer'] == 'folding'
def test_education_update(self): """ Test that Education is reindexed after being updated """ program_enrollment = ProgramEnrollmentFactory.create() assert es.search()['total'] == 1 education = EducationFactory.create( profile=program_enrollment.user.profile) education.school_city = 'city' education.save() assert_search(es.search(), [program_enrollment])
def test_update_education_different_profile(self): """ Make sure we can't edit an education for a different profile """ with mute_signals(post_save): education1 = EducationFactory.create() education2 = EducationFactory.create() education_object = EducationSerializer().to_representation(education1) education_object['id'] = education2.id serializer = ProfileSerializer(instance=education1.profile, data={ 'education': [education_object], 'work_history': [] }) serializer.is_valid(raise_exception=True) with self.assertRaises(ValidationError) as ex: serializer.save() assert ex.exception.detail == [ "Education {} does not exist".format(education2.id) ]
def test_education_update(self, index_type, mock_on_commit): """ Test that Education is reindexed after being updated """ program_enrollment = ProgramEnrollmentFactory.create() assert es.search(index_type)['total'] == DOC_TYPES_PER_ENROLLMENT education = EducationFactory.create( profile=program_enrollment.user.profile) education.school_city = 'city' education.save() assert_search(es.search(index_type), [program_enrollment], index_type=index_type)
def test_folded(self, mock_on_commit): """ Check that we have a folded type for first_name, last_name, and preferred_name """ program_enrollment = ProgramEnrollmentFactory.create() EducationFactory.create(profile=program_enrollment.user.profile) EmploymentFactory.create(profile=program_enrollment.user.profile) for index_type in ALL_INDEX_TYPES: mapping = es.get_mappings(index_type) properties = mapping[GLOBAL_DOC_TYPE]['properties'] if index_type == PUBLIC_ENROLLMENT_INDEX_TYPE: # Make sure we aren't exposing people's email addresses assert 'email' not in properties else: assert properties['email']['fields']['folded'][ 'analyzer'] == 'folding' profile_properties = properties['profile']['properties'] for key in 'first_name', 'last_name', 'preferred_name', 'full_name', 'username': assert profile_properties[key]['fields']['folded'][ 'analyzer'] == 'folding'
def test_delete_education(self): """ Test that we delete Educations which aren't specified in the PATCH """ with mute_signals(post_save): education1 = EducationFactory.create() EducationFactory.create(profile=education1.profile) # has a different profile education3 = EducationFactory.create() assert education1.profile.education.count() == 2 education_object1 = EducationSerializer(education1).data serializer = ProfileSerializer(instance=education1.profile, data={ 'education': [education_object1], 'work_history': [] }) serializer.is_valid(raise_exception=True) serializer.save() assert education1.profile.education.count() == 1 assert education1.profile.education.first() == education1 # Other profile is unaffected assert education3.profile.education.count() == 1
def test_update_education(self): """ Test that we handle updating an Education correctly """ with mute_signals(post_save): education = EducationFactory.create() education_data = EducationSerializer(education).data education_data['degree_name'] = BACHELORS serializer = ProfileSerializer(instance=education.profile, data={ 'education': [education_data], 'work_history': [] }) serializer.is_valid(raise_exception=True) serializer.save() assert education.profile.education.count() == 1 education = education.profile.education.first() assert EducationSerializer(education).data == education_data
def test_update_education(self): """ Test that we handle updating an Education correctly """ with mute_signals(post_save): education = EducationFactory.create() education_data = EducationSerializer(education).data education_data['degree_name'] = BACHELORS serializer = ProfileSerializer(instance=education.profile, data={ 'education': [education_data], 'work_history': [] }) serializer.is_valid(raise_exception=True) serializer.save() assert education.profile.education.count() == 1 education = education.profile.education.first() assert EducationSerializer(education).data == education_data
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 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))