def setUp(self): self.from_profile = ProfileFactory.create() self.to_profile = ProfileFactory.create() self.other_profile = ProfileFactory.create() self.from_profile.friends.add(self.to_profile) self.from_profile.friends.add(self.other_profile) self.proposal = PairProposal.objects.create( from_profile=self.from_profile, to_profile=self.to_profile)
def test_delete(self): profile = ProfileFactory() profile.partner_staff_member = profile.user.pk profile.save() models.delete_partner_relationship(None, profile.user) profile_updated = models.UserProfile.objects.get(pk=profile.pk) self.assertIsNone(profile_updated.partner_staff_member) user = models.User.objects.get(pk=profile.user.pk) self.assertFalse(user.is_active)
def test_has_proposed_to_friend(self): profile = ProfileFactory.create(state=self.swing_state.name) friend = ProfileFactory.create(state=self.safe_state.name) profile.friends.add(friend) ctx = ProfileContext(profile) self.assertFalse(ctx.has_proposed_to_friend(friend)) PairProposal.objects.create( from_profile=profile, to_profile=friend) ctx = ProfileContext(profile) self.assertTrue(ctx.has_proposed_to_friend(friend))
def test_random(self): profile = ProfileFactory.create(allow_random=True) rando = ProfileFactory.create(allow_random=True) form = PairProposalForm(profile, data={'to_profile': rando.id}) self.assertTrue(form.is_valid()) form.save() self.proposal = profile.proposals_made.get() form = RejectPairProposalForm(data=self._data(), instance=self.proposal) self.assertTrue(form.is_valid()) form.save()
def test_valid(self): profile = ProfileFactory.create() friend = ProfileFactory.create() profile.friends.add(friend) form = PairProposalForm(profile, data={'to_profile': friend.id}) self.assertEqual(len(PairProposal.objects.all()), 0) self.assertTrue(form.is_valid()) form.save() self.assertEqual(len(PairProposal.objects.all()), 1) proposal = PairProposal.objects.get() self.assertEqual(proposal.from_profile, profile) self.assertEqual(proposal.to_profile, friend)
def test_no_paired_friends(self): profile = ProfileFactory.create() friend = ProfileFactory.create() profile.friends.add(friend) paired_friend = ProfileFactory.create() paired_friend.paired_with = ProfileFactory.create() profile.friends.add(paired_friend) form = PairProposalForm(profile, data={'to_profile': friend.id}) self.assertEqual(form.fields['from_profile'].queryset.get(), profile) self.assertEqual(set(form.fields['to_profile'].queryset), set(Profile.objects.filter(id=friend.id))) self.assertTrue(form.is_valid())
def test_querydict(self): ProfileFactory.create() profile = ProfileFactory.create() friends = [ProfileFactory.create() for x in range(2)] profile.friends.add(*friends) form = PairProposalForm( profile, data=QueryDict('from_profile=%s&to_profile=%s' % (profile.id, friends[0].id))) self.assertEqual(form.fields['from_profile'].queryset.get(), profile) self.assertEqual(set(form.fields['to_profile'].queryset.all()), set(friends))
def test_friends_queryset(self): ProfileFactory.create() profile = ProfileFactory.create() friends = [ProfileFactory.create() for x in range(2)] profile.friends.add(*friends) form = PairProposalForm(profile, data={'to_profile': friends[0].id}) self.assertEqual(form.fields['from_profile'].queryset.get(), profile) self.assertEqual( set(form.fields['to_profile'].queryset), set( Profile.objects.filter( id__in=[friend.id for friend in friends]))) self.assertTrue(form.is_valid())
def test_birth_date_validation(self): profile = ProfileFactory() assert profile.full_clean() is None profile.birth_date = timezone.now().date() + timezone.timedelta(days=2) with pytest.raises(ValidationError): profile.full_clean() profile.birth_date = timezone.datetime(199, 1, 1).date() with pytest.raises(ValidationError): profile.full_clean()
def test_custom_update_user_is_staff_no_group(self): profile = ProfileFactory() self.assertFalse(profile.user.is_staff) res = models.UserProfile.custom_update_user(profile.user, {}, None) self.assertTrue(res) profile_updated = models.UserProfile.objects.get(pk=profile.pk) self.assertTrue(profile_updated.user.is_staff)
def test_existing_profile(self, mock_request): # This flow shouldn't happen, but in case it does, just merge the # profiles self.assertEqual(len(Profile.objects.all()), 0) request = self.request.get(reverse(confirm_signup)) request.user = UserFactory() ProfileFactory.create(fb_id=request.user.social_auth.get().uid) self.assertEqual(len(Profile.objects.all()), 2) request.session = self.session response = confirm_signup(request) # And a new profile will be created from the response, but the existing # profile got deleted, so the total number hasn't changed self.assertEqual(len(Profile.objects.all()), 2) self.assertEqual(response.status_code, HTTP_REDIRECT) self.assertTrue(response.has_header('Location')) self.assertEqual(response.get('Location'), reverse('users:profile'))
def test_create_application_raises_exception_if_apartment_data_does_not_exist( ): data = create_validated_application_data(ProfileFactory(), ApplicationType.HASO) data["apartments"] = [{"priority": 1, "identifier": "this-does-not-exist"}] with pytest.raises(InvalidElasticDataError): create_application(data)
def test_name_methods(self): profile = ProfileFactory() user = profile.user assert profile.first_name == user.first_name assert profile.last_name == user.last_name assert profile.full_name == user.get_full_name()
def test_to_representation(self): profile = ProfileFactory() data = ProfileSerializer(profile).data assert data["username"] == profile.user.username assert data["last_name"] == profile.user.last_name assert data["first_name"] == profile.user.first_name assert data["description"] == profile.description
def test_application_post(api_client): profile = ProfileFactory() api_client.credentials(HTTP_AUTHORIZATION=f"Bearer {_create_token(profile)}") data = create_application_data(profile) response = api_client.post( reverse("application_form:application-list"), data, format="json" ) assert response.status_code == 201 assert response.data == {"application_uuid": data["application_uuid"]}
def test_application_post_writes_audit_log_if_not_authenticated(api_client, caplog): data = create_application_data(ProfileFactory()) api_client.post(reverse("application_form:application-list"), data, format="json") audit_event = get_audit_log_event(caplog) assert audit_event is not None, "no audit log entry was written" assert audit_event["actor"] == {"role": "ANONYMOUS", "profile_id": None} assert audit_event["operation"] == "CREATE" assert audit_event["target"] == {"id": None, "type": "Application"} assert audit_event["status"] == "FORBIDDEN"
def test_random(self): profile = ProfileFactory.create(allow_random=True) friend = ProfileFactory.create() profile.friends.add(friend) # Add a friend and make sure it's there self.assertEqual(friend, profile.all_unpaired_friends.get()) rando = ProfileFactory.create(allow_random=True) # The rando also accepts random friends, so it should show up as an # unpaired friend self.assertEqual(set([friend, rando]), set(profile.all_unpaired_friends)) form = PairProposalForm(profile, data={'to_profile': rando.id}) self.assertEqual(len(PairProposal.objects.all()), 0) self.assertTrue(form.is_valid()) form.save() self.assertEqual(len(PairProposal.objects.all()), 1) proposal = PairProposal.objects.get() self.assertEqual(proposal.from_profile, profile) self.assertEqual(proposal.to_profile, rando)
def test_invalid_proposal_id(self): """Giving a proposal for a different user gives an error""" new_profile = ProfileFactory.create() other_proposal = PairProposal.objects.create( from_profile=self.other_profile, to_profile=new_profile) request = self.request.post(reverse('users:confirm_swap', args=[other_proposal.ref_id]), data={}) request.user = self.to_profile.user response = confirm_swap(request, other_proposal.ref_id) self.assertContains(response, 'Invalid swap proposal')
def test_friends_of_friends(self): profile = ProfileFactory.create() # Start with no friends self.assertQuerysetEqual(profile.friends.all(), profile.all_unpaired_friends) friend = ProfileFactory.create() profile.friends.add(friend) # Add a friend and make sure it's there self.assertEqual(friend, profile.all_unpaired_friends.get()) foaf = ProfileFactory.create() # After creating another profile, it isn't yet a friend self.assertEqual(friend, profile.all_unpaired_friends.get()) friend.friends.add(foaf) # But after adding it as a friend of my friend, I can see it self.assertEqual(set([friend, foaf]), set(profile.all_unpaired_friends)) # But won't see friends-of-friends-of-friends foaf.friends.add(ProfileFactory.create()) self.assertEqual(set([friend, foaf]), set(profile.all_unpaired_friends))
def test_save_update_name_user_and_profile_unlinked(self): fb_id = 1234 user = UserFactory.create(profile=None, social_auth__uid=fb_id) profile = ProfileFactory.create(fb_id=fb_id) data = self._data() form = LandingPageForm(data=data) self.assertTrue(form.is_valid()) form.save(user) user = get_user_model().objects.get(id=user.id) self.assertNotEqual(user.get_full_name(), user.profile.fb_name) self.assertEqual(user.profile, profile)
def test_save_model_supervisor(self): """If supervisor provided, then set supervisor""" mock_form = Mock() mock_form.data = {"supervisor": self.superuser.pk} obj = ProfileFactory() self.assertIsNone(obj.supervisor) self.admin.save_model( self.request, obj, mock_form, None) profile_updated = UserProfile.objects.get(pk=obj.pk) self.assertEqual(profile_updated.supervisor, self.superuser)
def test_save_model_oic(self): """If OIC provided, then set OIC""" mock_form = Mock() mock_form.data = {"oic": self.superuser.pk} obj = ProfileFactory() self.assertIsNone(obj.oic) self.admin.save_model( self.request, obj, mock_form, None) profile_updated = UserProfile.objects.get(pk=obj.pk) self.assertEqual(profile_updated.oic, self.superuser)
def test_username_uniqueness_validation(self): user = UserFactory() profile = ProfileFactory(user=user) new_user_data = UserFactory() data = {"username": new_user_data.username} serializer = ProfileSerializer(instance=profile, data=data, partial=True) assert not serializer.is_valid() assert "username" in serializer.errors
def setUp(self): super(_TestSafeStateFriendsOfFriendsMatchBase, self).setUp() candidate = CANDIDATE_CLINTON self.state_safe = StateFactory.create( safe_for=candidate, safe_rank=1 ) self.user = UserFactory.create( profile__state=self.state_safe.name, profile__preferred_candidate=candidate) tipping_point_rank = 1 self.foaf_expected_matches = [] # Create friends that haven't specified a vote choice just for links for i in range(2): friend_profile = ProfileFactory.create(state='') self.user.profile.friends.add(friend_profile) # And create friends of these friends in swing states for i in range(2): state = StateFactory.create( tipping_point_rank=tipping_point_rank) foaf = UserFactory.create( profile__state=state.name, profile__preferred_candidate=CANDIDATE_STEIN) tipping_point_rank += 1 friend_profile.friends.add(foaf.profile) self.foaf_expected_matches.append(foaf.profile) # And make another foaf that's friends with both of my friends state = StateFactory.create( tipping_point_rank=tipping_point_rank) self.foafoaf = UserFactory.create( profile__state=state.name, profile__preferred_candidate=CANDIDATE_JOHNSON) for friend in self.user.profile.friends.all(): friend.friends.add(self.foafoaf.profile) self.foaf_expected_matches.append(self.foafoaf.profile) tipping_point_rank += 1 self.direct_expected_matches = [] # Create friends in swing states for i in range(2): state = StateFactory.create( tipping_point_rank=tipping_point_rank) friend = UserFactory.create( profile__state=state.name, profile__preferred_candidate=CANDIDATE_JOHNSON) tipping_point_rank += 1 self.user.profile.friends.add(friend.profile) self.direct_expected_matches.append(friend.profile) # Direct friends are always preferred, so prepend them to expected self.expected_matches = ( self.direct_expected_matches + self.foaf_expected_matches)
def setUp(self): super(TestConfirmSwapView, self).setUp() self.request = RequestFactory() from_state = StateFactory.create(tipping_point_rank=1) self.from_profile = UserFactory.create( profile__state=from_state.name).profile to_state = StateFactory.create(safe_rank=1) self.to_profile = UserFactory.create( profile__state=to_state.name).profile self.other_profile = ProfileFactory.create() self.from_profile.friends.add(self.to_profile) self.from_profile.friends.add(self.other_profile) self.proposal = PairProposal.objects.create( from_profile=self.from_profile, to_profile=self.to_profile)
def test_application_post_writes_audit_log(api_client, caplog): profile = ProfileFactory() api_client.credentials(HTTP_AUTHORIZATION=f"Bearer {_create_token(profile)}") data = create_application_data(profile) api_client.post(reverse("application_form:application-list"), data, format="json") audit_event = get_audit_log_event(caplog) assert audit_event is not None, "no audit log entry was written" assert audit_event["actor"] == {"role": "USER", "profile_id": str(profile.pk)} assert audit_event["operation"] == "CREATE" assert audit_event["target"] == { "id": data["application_uuid"], "type": "Application", } assert audit_event["status"] == "SUCCESS"
def test_partial_update(self): user = UserFactory() profile = ProfileFactory(user=user) new_profile_data = ProfileFactory.build() new_user_data = UserFactory.build() data = { "description": new_profile_data.description, "last_name": new_user_data.last_name, } serializer = ProfileSerializer(instance=profile, data=data, partial=True) assert serializer.is_valid(), serializer.errors serializer.save() user.refresh_from_db() assert user.last_name == data["last_name"] profile.refresh_from_db() assert profile.description == data["description"]
def test_clean_duplicate_email(self): """Duplicate email not allowed if user associated as staff member""" profile = ProfileFactory( partner_staff_member=10, ) self.data["email"] = profile.user.email form = forms.PartnerStaffMemberForm(self.data) self.assertFalse(form.is_valid()) self.assertIn( "This user already exists under a different partnership: {}".format( profile.user.email ), form.errors["__all__"] )
def test_profile_reason_emoji(self): reason = u"💩" reasonb64 = base64.b64encode(reason.encode('utf-8')) profile = ProfileFactory.create() profile.reason = reason profile.clean() profile.save() self.assertEqual(profile.reason, reasonb64) self.assertEqual(profile.reason_decoded, reason) profile = Profile.objects.get(id=profile.id) profile.clean() profile.save() self.assertEqual(profile.reason, reasonb64) self.assertEqual(profile.reason_decoded, reason)
def test_update(self): user = UserFactory() profile = ProfileFactory(user=user) new_profile_data = ProfileFactory.build() new_user_data = UserFactory.build() data = { "birth_date": new_profile_data.birth_date, "description": new_profile_data.description, "first_name": new_user_data.first_name, "last_name": new_user_data.last_name, "username": new_user_data.username, } serializer = ProfileSerializer(instance=profile, data=data) assert serializer.is_valid(), serializer.errors profile = serializer.save() assert profile.description == data["description"] assert profile.birth_date == data["birth_date"] assert profile.user.last_name == data["last_name"] assert profile.user.first_name == data["first_name"] assert profile.user.username == data["username"]