def setUp(self): self.url = '/api/places/' # two groups one place self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.group2 = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.place2 = PlaceFactory(group=self.group2)
def test_group_message_title(self): author = UserFactory() group = GroupFactory(members=[author]) conversation = Conversation.objects.get_or_create_for_target(group) message = conversation.messages.create(author=author, content='bla') title = get_message_title(message, 'en') self.assertEqual(title, '{} / {}'.format(group.name, author.display_name))
def test_place_message_title(self): author = UserFactory() place = PlaceFactory() conversation = Conversation.objects.get_or_create_for_target(place) message = conversation.messages.create(author=author, content='bla') title = get_message_title(message, 'en') self.assertEqual(title, '{} / {}'.format(place.name, author.display_name))
def test_leave_group(self): user = UserFactory() GroupMembership.objects.create(group=self.group, user=user) self.client.force_login(user) self.client.post(self.group_url + 'leave/') self.client.force_login(self.member) response = self.get_results(history_url) self.assertEqual(response.data[0]['typus'], 'GROUP_LEAVE')
def test_other_participants_receive_update_on_join(self): user = UserFactory() joining_user = UserFactory() # join a conversation conversation = ConversationFactory(participants=[ user, ]) # login and connect client = self.connect_as(user) conversation.join(joining_user) response = client.messages[0] self.assertEqual(response['topic'], 'conversations:conversation') self.assertEqual(set(response['payload']['participants']), {user.id, joining_user.id})
def setUp(self): self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.activity = ActivityFactory(place=self.place, date=to_range(timezone.now() - relativedelta(days=1))) # No one joined the activity Activity.objects.process_finished_activities()
def test_no_notifications_by_default_in_playground(self): user = UserFactory() group = PlaygroundGroupFactory() membership = group.groupmembership_set.create(user=user) self.assertEqual([], membership.notification_types) conversation = Conversation.objects.get_for_target(group) conversation_participant = ConversationParticipant.objects.get( conversation=conversation, user=user) self.assertTrue(conversation_participant.muted)
def test_no_reply_notification_if_muted(self, notify): author = UserFactory() reply_author = UserFactory() group = GroupFactory(members=[author, reply_author]) conversation = Conversation.objects.get_or_create_for_target(group) message = conversation.messages.create(author=author, content='bla') reply = ConversationMessage.objects.create( author=reply_author, conversation=conversation, thread=message, content='reply' ) participant = ConversationThreadParticipant.objects.get(user=author, thread=reply.thread) participant.muted = True participant.save() PushSubscription.objects.create(user=author, token='', platform=PushSubscriptionPlatform.ANDROID.value) notify.reset_mock() notify_message_push_subscribers(reply) notify.assert_not_called()
def test_create_activity_as_newcomer_fails(self): newcomer = UserFactory() self.group.groupmembership_set.create(user=newcomer) self.client.force_login(user=newcomer) response = self.client.post(self.url, self.activity_data, format='json') self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
def test_patch_as_newcomer_fails(self): newcomer = UserFactory() self.group.groupmembership_set.create(user=newcomer) self.client.force_login(user=newcomer) response = self.client.patch(self.activity_url, {'max_participants': 1}, format='json') self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
def setUp(self): self.now = timezone.now() self.url = '/api/places/' self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.place_url = self.url + str(self.place.id) + '/' self.series = PickupDateSeriesFactory(max_collectors=3, place=self.place)
def setUp(self): self.group = GroupFactory() self.user = UserFactory() self.author = UserFactory() self.group.add_member(self.user) self.group.add_member(self.author) self.token = faker.uuid4() self.content = faker.text() self.conversation = self.group.conversation # add a push subscriber self.subscription = PushSubscription.objects.create( user=self.user, token=self.token, platform=PushSubscriptionPlatform.ANDROID.value, )
def test_list_own_applications(self): [ ApplicationFactory(group=self.group, user=UserFactory()) for _ in range(4) ] self.client.force_login(user=self.applicant) response = self.get_results('/api/applications/?user={}'.format( self.applicant.id)) self.assertEqual(len(response.data), 1)
def test_exclude_unverified_addresses(self): user = UserFactory() # not verified self.group.add_member(user) mail.outbox = [] ConversationMessage.objects.create(author=self.user, conversation=self.conversation, content='asdf') self.assertEqual(len(mail.outbox), 0)
def setUp(self): self.normal_member = UserFactory() self.agreement_manager = UserFactory() self.group = GroupFactory( members=[self.normal_member, self.agreement_manager]) self.agreement = Agreement.objects.create(group=self.group, title=faker.text(), content=faker.text()) membership = GroupMembership.objects.get(group=self.group, user=self.agreement_manager) membership.roles.append(roles.GROUP_AGREEMENT_MANAGER) membership.save() # other group/agreement that neither user is part of self.other_group = GroupFactory() self.other_agreement = Agreement.objects.create(group=self.other_group, title=faker.text(), content=faker.text())
def test_place_statistics_as_average(self): user = UserFactory() self.client.force_login(user=user) group = GroupFactory(members=[user]) place = PlaceFactory(group=group) response = self.client.get('/api/places/{}/statistics/'.format( place.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data, { 'feedback_count': 0, 'feedback_weight': 0, 'activities_done': 0, }) one_day_ago = to_range(timezone.now() - relativedelta(days=1)) users = [UserFactory() for _ in range(9)] activities = [ ActivityFactory( place=place, date=one_day_ago, participants=users, is_done=True, ) for _ in range(3) ] feedback = [ FeedbackFactory(about=choice(activities), given_by=u) for u in users ] # calculate weight from feedback feedback.sort(key=attrgetter('about.id')) weight = float(sum(f.weight for f in feedback)) response = self.client.get('/api/places/{}/statistics/'.format( place.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual( response.data, { 'feedback_count': len(feedback), 'feedback_weight': weight, 'activities_done': len(activities), })
def setUp(self): self.url = '/api/pickup-date-series/' self.series = PickupDateSeriesFactory() self.series_url = '/api/pickup-date-series/{}/'.format(self.series.id) self.non_member = UserFactory() self.series_data = { 'place': self.series.place.id, 'rule': 'FREQ=WEEKLY', 'start_date': timezone.now() }
def setUp(self): self.now = timezone.now() self.url = '/api/places/' self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.place_url = self.url + str(self.place.id) + '/' self.series = ActivitySeriesFactory(max_participants=3, place=self.place)
def test_newcomer_becomes_editor(self): editor = UserFactory() newcomer = UserFactory() group = GroupFactory(members=[editor], newcomers=[newcomer]) two_days_ago = timezone.now() - relativedelta(days=2) GroupMembership.objects.filter(group=group).update( created_at=two_days_ago) mail.outbox = [] membership = GroupMembership.objects.get(user=newcomer, group=group) Trust.objects.create(membership=membership, given_by=editor) self.assertTrue(group.is_editor(newcomer)) self.assertEqual(len(mail.outbox), 1) self.assertIn('You gained editing permissions', mail.outbox[0].subject) self.assertEqual( History.objects.filter( typus=HistoryTypus.MEMBER_BECAME_EDITOR).count(), 1)
def test_pickup_message_title(self): author = UserFactory() group = GroupFactory(members=[author], timezone='Europe/Berlin') place = PlaceFactory(group=group) pickup = PickupDateFactory(place=place, collectors=[author], date=to_range(parse('2018-11-11T20:00:00Z'))) conversation = Conversation.objects.get_or_create_for_target(pickup) message = conversation.messages.create(author=author, content='bla') title = get_message_title(message, 'en') self.assertEqual(title, 'Pickup Sunday 9:00 PM / {}'.format(author.display_name))
def test_only_notifies_active_group_members(self): self.group.add_member(UserFactory()) inactive_user = VerifiedUserFactory() self.group.add_member(inactive_user) self.group.groupmembership_set.filter(user=inactive_user).update(inactive_at=timezone.now()) mail.outbox = [] self.group.conversation.messages.create(author=self.author, content='foo') self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, [self.user.email])
def test_member_becomes_editor(self): user = UserFactory() GroupMembership.objects.create(group=self.group, user=user) url = reverse('group-trust-user', args=(self.group.id, user.id)) self.client.force_login(self.member) self.client.post(url) response = self.get_results(history_url) self.assertEqual(response.data[0]['typus'], 'MEMBER_BECAME_EDITOR')
def test_notifications_on_by_default(self): user = UserFactory() group = GroupFactory(members=[user]) membership = GroupMembership.objects.get(user=user, group=group) self.assertEqual(get_default_notification_types(), membership.notification_types) conversation = Conversation.objects.get_for_target(group) conversation_participant = ConversationParticipant.objects.get( conversation=conversation, user=user) self.assertFalse(conversation_participant.muted)
def setUpTestData(cls): cls.url = '/api/activities/' # activity for group with one member and one place cls.member = UserFactory() cls.second_member = UserFactory() cls.group = GroupFactory(members=[cls.member, cls.second_member]) cls.place = PlaceFactory(group=cls.group) cls.activity_type = ActivityTypeFactory(group=cls.group) cls.archived_activity_type = ActivityTypeFactory(group=cls.group, status='archived') cls.activity = ActivityFactory(activity_type=cls.activity_type, place=cls.place) cls.activity_url = cls.url + str(cls.activity.id) + '/' cls.join_url = cls.activity_url + 'add/' cls.leave_url = cls.activity_url + 'remove/' cls.conversation_url = cls.activity_url + 'conversation/' # not a member of the group cls.user = UserFactory() # another activity for above place cls.activity_data = { 'activity_type': cls.activity_type.id, 'date': to_range(timezone.now() + relativedelta(days=2)).as_list(), 'max_participants': 5, 'place': cls.place.id } # past activity cls.past_activity_data = { 'activity_type': cls.activity_type.id, 'date': to_range(timezone.now() - relativedelta(days=1)).as_list(), 'max_participants': 5, 'place': cls.place.id } cls.past_activity = ActivityFactory( activity_type=cls.activity_type, place=cls.place, date=to_range(timezone.now() - relativedelta(days=1))) cls.past_activity_url = cls.url + str(cls.past_activity.id) + '/' cls.past_join_url = cls.past_activity_url + 'add/' cls.past_leave_url = cls.past_activity_url + 'remove/'
def setUp(self): self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.pickup = PickupDateFactory( place=self.place, date=to_range(timezone.now() - relativedelta(days=1)), is_disabled=True, ) PickupDate.objects.process_finished_pickup_dates()
def test_join_full_activity_fails(self): self.client.force_login(user=self.member) self.activity.max_participants = 1 self.activity.save() u2 = UserFactory() GroupMembership.objects.create(group=self.group, user=u2) self.activity.add_participant(u2) response = self.client.post(self.join_url) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data) self.assertEqual(response.data['detail'], 'Activity is already full.')
def setUp(self): self.user = UserFactory() self.url_user = '******' self.url_change_email = '/api/auth/password/' # Should be url_change_password ? self.url_request_account_deletion = '/api/auth/user/request_delete/' # Mock AnymailMessage to throw error on send self.mail_class = email_utils.AnymailMessage self._original_send = self.mail_class.send self.mail_class.send = MagicMock(side_effect=AnymailAPIError())
def setUp(self): self.user = UserFactory() self.user.photo = 'photo.jpg' self.user.save() self.user2 = UserFactory() self.url = '/api/users/' self.user_data = { 'email': faker.email(), 'password': faker.name(), 'display_name': faker.name(), 'address': faker.address(), 'latitude': faker.latitude(), 'longitude': faker.longitude() } self.group = GroupFactory(members=[self.user, self.user2]) self.another_common_group = GroupFactory(members=[self.user, self.user2]) self.user_in_another_group = UserFactory() self.another_group = GroupFactory(members=[self.user_in_another_group]) mail.outbox = []
def test_create_voting_ends_soon_notifications(self): creator, affected_user, voter = UserFactory(), UserFactory(), UserFactory() group = GroupFactory(members=[creator, affected_user, voter]) issue = IssueFactory(group=group, created_by=creator, affected_user=affected_user) voting = issue.latest_voting() # let's vote with user "voter" vote_for_further_discussion(voting=voting, user=voter) Notification.objects.all().delete() with fast_forward_just_before_voting_expiration(voting): create_voting_ends_soon_notifications() # can call it a second time without duplicating notifications create_voting_ends_soon_notifications() notifications = Notification.objects.filter(type=NotificationType.VOTING_ENDS_SOON.value) # user "voter" is not being notified self.assertEqual( sorted([n.user_id for n in notifications]), sorted([issue.affected_user_id, issue.created_by_id]) )
def test_playground_members_are_always_editors(self): new_member = UserFactory() mail.outbox = [] self.group.add_member(new_member) self.assertTrue(self.group.is_editor(new_member)) # no email should be sent when joining playground self.assertEqual(len(mail.outbox), 0) # no email should be sent when giving trust membership = GroupMembership.objects.get(group=self.group, user=new_member) another_user = UserFactory() self.group.add_member(another_user) mail.outbox = [] Trust.objects.create(membership=membership, given_by=another_user) self.assertEqual(len(mail.outbox), 0)