def test_creates_new_applicant_notification(self): member = UserFactory() group = GroupFactory(members=[member]) self.assertEqual( Notification.objects.filter( user=member, type=NotificationType.NEW_APPLICANT.value).count(), 0) user = UserFactory() ApplicationFactory(user=user, group=group) self.assertEqual( Notification.objects.filter( user=member, type=NotificationType.NEW_APPLICANT.value).count(), 1)
def test_creates_application_declined_notification(self): member = UserFactory() group = GroupFactory(members=[member]) user = UserFactory() application = ApplicationFactory(user=user, group=group) application.decline(member) self.assertEqual( Notification.objects.filter( user=user, type=NotificationType.APPLICATION_DECLINED.value).count(), 1) self.assertEqual( Notification.objects.filter( type=NotificationType.NEW_APPLICANT.value).count(), 0)
def test_creates_new_member_notification(self): member1 = UserFactory() member2 = UserFactory() group = GroupFactory(members=[member1, member2]) Notification.objects.all().delete() user = UserFactory() group.add_member(user, added_by=member1) notifications = Notification.objects.filter( type=NotificationType.NEW_MEMBER.value) # member1 doesn't get a notification, as they added the user self.assertEqual(notifications.count(), 1, notifications) self.assertEqual(notifications[0].user, member2) self.assertEqual(notifications[0].context['user'], user.id)
def test_sync_users(self): user1 = UserFactory() user2 = UserFactory() user3 = UserFactory() user4 = UserFactory() users = [user1, user2, user3] conversation = ConversationFactory() conversation.join(user1) # should not be added again conversation.join(user4) # should be removed conversation.sync_users(users) self.assertEqual(conversation.participants.count(), 3) self.assertIn(user1, conversation.participants.all()) self.assertIn(user2, conversation.participants.all()) self.assertIn(user3, conversation.participants.all()) self.assertNotIn(user4, conversation.participants.all())
def setUp(self): self.user = UserFactory() self.member = UserFactory() self.group = GroupFactory(members=[self.member], is_open=True) self.group_with_password = GroupFactory(password='******', is_open=True) self.join_password_url = '/api/groups/{}/join/'.format(self.group_with_password.id) self.url = '/api/groups/' self.group_data = { 'name': faker.name(), 'description': faker.text(), 'address': faker.address(), 'latitude': faker.latitude(), 'longitude': faker.longitude(), 'timezone': 'Europe/Berlin' }
def test_removes_new_application_notification_when_decided(self): member = UserFactory() group = GroupFactory(members=[member]) users = [UserFactory() for _ in range(3)] applications = [ ApplicationFactory(user=user, group=group) for user in users ] applications[0].withdraw() applications[1].accept(member) applications[2].decline(member) self.assertEqual( Notification.objects.filter( type=NotificationType.NEW_APPLICANT.value).count(), 0)
def setUp(self): self.member = UserFactory() self.non_editor_member = UserFactory() self.non_member = UserFactory() self.group = GroupFactory( members=[self.member, self.non_editor_member]) self.place = PlaceFactory(group=self.group) self.activity_types = [ ActivityTypeFactory(group=self.group) for _ in range(3) ] self.activity_type = self.activity_types[0] # remove all roles GroupMembership.objects.filter( group=self.group, user=self.non_editor_member).update(roles=[])
def setUp(self): self.user = UserFactory() self.member = UserFactory() self.group = GroupFactory(members=[self.member, UserFactory()], is_open=True) self.url = '/api/groups/' self.group_data = { 'name': faker.name(), 'description': faker.text(), 'address': faker.address(), 'latitude': faker.latitude(), 'longitude': faker.longitude(), 'timezone': 'Europe/Berlin' }
def test_no_message_notification_if_muted(self, notify): author = UserFactory() user = UserFactory() group = GroupFactory(members=[author, user]) conversation = Conversation.objects.get_or_create_for_target(group) message = conversation.messages.create(author=author, content='bla') participant = ConversationParticipant.objects.get(user=user, conversation=conversation) participant.muted = True participant.save() PushSubscription.objects.create(user=user, token='', platform=PushSubscriptionPlatform.ANDROID.value) notify.reset_mock() notify_message_push_subscribers(message) notify.assert_not_called()
def test_adds_participant_marks_existing_messages_as_read(self): existing_member = UserFactory() group = GroupFactory(members=[existing_member]) group.conversation.messages.create(author=existing_member, content='foo') second_message = group.conversation.messages.create( author=existing_member, content='bar') new_member = UserFactory() GroupMembership.objects.create(group=group, user=new_member) new_participant = ConversationParticipant.objects.get( user=new_member, conversation=group.conversation) self.assertTrue(new_participant.seen_up_to == second_message)
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 = 0 for _, fs in groupby(feedback, key=attrgetter('about.id')): len_list = [f.weight for f in fs] weight += float(sum(len_list)) / len(len_list) weight = round(weight) 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 test_receive_reaction_deletion(self): self.maxDiff = None author, user, reaction_user = [UserFactory() for _ in range(3)] conversation = ConversationFactory( participants=[author, user, reaction_user]) message = ConversationMessage.objects.create( conversation=conversation, content='yay', author=author, ) reaction = ConversationMessageReaction.objects.create( message=message, user=reaction_user, name='carrot', ) # login and connect client = self.connect_as(user) reaction.delete() # check if conversation update was received response = client.messages[0] parse_dates(response) self.assertEqual(response, make_conversation_message_broadcast(message))
def test_receive_group_join(self): member_client = self.connect_as(self.member) joining_client = self.connect_as(self.user) nonmember_client = self.connect_as(UserFactory()) self.group.add_member(self.user) response = member_client.messages_by_topic.get( 'groups:group_detail')[0] self.assertIn(self.user.id, response['payload']['members']) self.assertIn(self.user.id, response['payload']['memberships'].keys()) response = member_client.messages_by_topic.get( 'groups:group_preview')[0] self.assertIn(self.user.id, response['payload']['members']) self.assertNotIn('memberships', response['payload']) response = joining_client.messages_by_topic.get( 'groups:group_detail')[0] self.assertIn(self.user.id, response['payload']['members']) response = joining_client.messages_by_topic.get( 'groups:group_preview')[0] self.assertIn(self.user.id, response['payload']['members']) self.assertNotIn('groups:group_detail', nonmember_client.messages_by_topic.keys()) response = nonmember_client.messages_by_topic.get( 'groups:group_preview')[0] self.assertIn(self.user.id, response['payload']['members']) self.assertNotIn('memberships', response['payload'])
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 test_thread_marked_as_seen(self): author, op_author = [UserFactory() for _ in range(2)] conversation = ConversationFactory(participants=[author, op_author]) thread = ConversationMessage.objects.create(conversation=conversation, content='yay', author=op_author) reply = ConversationMessage.objects.create( conversation=conversation, thread=thread, content='really yay?', author=author, ) participant = thread.participants.get(user=op_author) client = self.connect_as(op_author) participant.seen_up_to = reply participant.save() messages = client.messages_by_topic self.assertEqual(len(messages['status']), 1, messages['status']) self.assertEqual( messages['status'][0]['payload'], { 'unseen_thread_count': 0, 'unseen_conversation_count': 0, 'has_unread_conversations_or_threads': False, 'groups': {}, 'places': {}, })
def setUp(self): super().setUp() self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.activity = ActivityFactory(place=self.place, participants=[self.member])
def test_unsubscribe_from_applications(self): application = ApplicationFactory(group=self.group, user=UserFactory()) participant = application.conversation.conversationparticipant_set.filter( user=self.user) self.assertFalse(participant.get().muted) unsubscribe_from_all_conversations_in_group(self.user, self.group) self.assertTrue(participant.get().muted)
def test_clicked(self, write_points): user = UserFactory() group = GroupFactory(members=[user]) two_hours_ago = timezone.now() - relativedelta(hours=2) notification = Notification.objects.create( created_at=two_hours_ago, user=user, type=NotificationType.USER_BECAME_EDITOR.value, context={'group': group.id}, ) write_points.reset_mock() notification.clicked = True notification.save() write_points.assert_called_with([{ 'measurement': 'karrot.events', 'tags': { 'group': str(group.id), 'group_status': group.status, 'notification_type': NotificationType.USER_BECAME_EDITOR.value, }, 'fields': { 'notification_clicked': 1, 'notification_clicked_seconds': 60 * 60 * 2, }, }])
def test_reply_notification(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' ) subscriptions = [ PushSubscription.objects.create(user=author, token='', platform=PushSubscriptionPlatform.ANDROID.value) ] notify.reset_mock() notify_message_push_subscribers(reply) notify.assert_called_once_with(reply, subscriptions, 'en')
def test_delete_as_newcomer_fails(self): newcomer = UserFactory() self.series.place.group.groupmembership_set.create(user=newcomer) self.client.force_login(user=newcomer) response = self.client.delete(self.series_url) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
def setUp(self): self.now = timezone.now() self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.series = PickupDateSeriesFactory(max_collectors=3, place=self.place)
def setUpTestData(cls): cls.user = VerifiedUserFactory() cls.other_user = VerifiedUserFactory() cls.non_verified_user = UserFactory() cls.group = GroupFactory( members=[cls.user, cls.other_user, cls.non_verified_user]) cls.place = PlaceFactory( group=cls.group, subscribers=[cls.user, cls.other_user, cls.non_verified_user]) cls.declined_place = PlaceFactory(group=cls.group, status=PlaceStatus.DECLINED.value) # unsubscribe other_user from notifications GroupMembership.objects.filter( group=cls.group, user=cls.other_user).update(notification_types=[]) # add some random inactive users, to make sure we don't send to them inactive_users = [ VerifiedUserFactory(language='en') for _ in list(range(randint(2, 5))) ] for user in inactive_users: membership = cls.group.add_member(user) membership.inactive_at = timezone.now() membership.save()
def setUp(self): self.maxDiff = None self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.activity_type = ActivityTypeFactory(group=self.group) self.archived_activity_type = ActivityTypeFactory(group=self.group, status='archived')
def setUp(self): super().setUp() self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.pickup = PickupDateFactory(place=self.place, collectors=[self.member])
def test_leave(self): user = UserFactory() conversation = ConversationFactory(participants=[user]) self.assertIn(user, conversation.participants.all()) conversation.leave(user) self.assertNotIn(user, conversation.participants.all())
def create_group_with_members(self, member_count): self.members = [UserFactory() for _ in range(member_count)] self.group = GroupFactory(members=self.members) # trust threshold calculation ignores recently joined users, so we need to create users before that two_days_ago = timezone.now() - relativedelta(days=2) GroupMembership.objects.filter(group=self.group).update( created_at=two_days_ago)
def setUp(self): self.active_user = UserFactory() self.inactive_user = UserFactory() self.group = GroupFactory( members=[self.active_user, self.inactive_user]) self.active_membership = GroupMembership.objects.get( group=self.group, user=self.active_user) set_lastseen_at(self.group, self.inactive_user, days=99999) set_inactive_at(self.group, self.inactive_user, days=99999) self.inactive_membership = set_removal_notification_at( self.group, self.inactive_user, days=settings. NUMBER_OF_DAYS_AFTER_REMOVAL_NOTIFICATION_WE_ACTUALLY_REMOVE_THEM) mail.outbox = []
def test_ignores_recently_joined_users(self): self.create_group_with_members(1) [self.group.add_member(UserFactory()) for _ in range(5)] self.assertEqual( self.group.trust_threshold_for_newcomer(), 1, )
def test_create_activity_upcoming_notifications(self): users = [UserFactory() for _ in range(3)] group = GroupFactory(members=users) place = PlaceFactory(group=group) in_one_hour = to_range(timezone.now() + relativedelta(hours=1)) activity1 = ActivityFactory(place=place, date=in_one_hour, participants=users) in_two_hours = to_range(timezone.now() + relativedelta(hours=1)) ActivityFactory(place=place, date=in_two_hours, participants=users) Notification.objects.all().delete() create_activity_upcoming_notifications.call_local() notifications = Notification.objects.filter(type=NotificationType.ACTIVITY_UPCOMING.value) self.assertEqual(notifications.count(), 6) self.assertEqual(set(n.user.id for n in notifications), set(user.id for user in users)) activity1_user1_participant = ActivityParticipant.objects.get(user=users[0], activity=activity1) activity1_user1_notification = next( n for n in notifications if n.context['activity_participant'] == activity1_user1_participant.id ) self.assertEqual( activity1_user1_notification.context, { 'group': group.id, 'place': place.id, 'activity': activity1.id, 'activity_participant': activity1_user1_participant.id, } ) self.assertEqual(activity1_user1_notification.expires_at, activity1.date.start)
def test_do_not_send_notification_again(self): editor = UserFactory() editor2 = UserFactory() group = GroupFactory(members=[editor, editor2]) 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=editor, group=group) Trust.objects.create(membership=membership, given_by=editor2) self.assertEqual(len(mail.outbox), 0) self.assertEqual( History.objects.filter( typus=HistoryTypus.MEMBER_BECAME_EDITOR).count(), 0)