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_pickup_active_within(self): PickupDateFactory(place=self.place, date=to_range(timezone.now() - timedelta(days=2)), collectors=[self.user]) PickupDateFactory( place=self.place, date=to_range(timezone.now() - timedelta(days=9)), collectors=[self.other_user] ) memberships = self.group.groupmembership_set.pickup_active_within(days=7) self.assertEqual(memberships.count(), 1)
def test_leave_group(self): place = PlaceFactory(group=self.group) pickupdate = PickupDateFactory(place=place, collectors=[self.member, self.user], date=to_range(timezone.now() + relativedelta(weeks=1))) past_pickupdate = PickupDateFactory( place=place, collectors=[ self.member, ], date=to_range(timezone.now() - relativedelta(weeks=1))) unrelated_pickupdate = PickupDateFactory( date=to_range(timezone.now() + relativedelta(weeks=1)), collectors=[ self.member, ], ) GroupMembership.objects.create(group=unrelated_pickupdate.place.group, user=self.member) self.client.force_login(user=self.member) response = self.client.post('/api/groups/{}/leave/'.format( self.group.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertFalse(pickupdate.collectors.get_queryset().filter( id=self.member.id).exists()) self.assertTrue(past_pickupdate.collectors.get_queryset().filter( id=self.member.id).exists()) self.assertTrue(unrelated_pickupdate.collectors.get_queryset().filter( id=self.member.id).exists())
class TestHistoryAPIWithDonePickup(APITestCase, ExtractPaginationMixin): 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))) self.pickup.add_collector(self.member) PickupDate.objects.process_finished_pickup_dates() def test_pickup_done(self): self.client.force_login(self.member) response = self.get_results(history_url) self.assertEqual(response.data[0]['typus'], 'PICKUP_DONE') self.assertLess(parse(response.data[0]['date']), timezone.now() - relativedelta(hours=22)) def test_filter_pickup_done(self): self.client.force_login(self.member) response = self.get_results(history_url, {'typus': 'PICKUP_DONE'}) self.assertEqual(response.data[0]['typus'], 'PICKUP_DONE') response = self.get_results( history_url, {'typus': 'GROUP_JOIN'}) # unrelated event should give no result self.assertEqual(len(response.data), 0)
class TestProcessFinishedPickupDates(TestCase): def setUp(self): self.pickup = PickupDateFactory( date=to_range(timezone.now() - relativedelta(weeks=1), minutes=30)) def test_process_finished_pickup_dates(self): PickupDate.objects.process_finished_pickup_dates() self.assertEqual(PickupDate.objects.count(), 1) self.assertEqual(History.objects.count(), 1) def test_do_not_process_disabled_pickups(self): self.pickup.is_disabled = True self.pickup.save() PickupDate.objects.process_finished_pickup_dates() self.assertFalse(self.pickup.is_done) self.assertEqual(History.objects.count(), 0) def test_disables_past_pickups_of_inactive_places(self): place = self.pickup.place place.status = PlaceStatus.ARCHIVED.value place.save() PickupDate.objects.process_finished_pickup_dates() self.assertEqual(History.objects.count(), 0) self.assertEqual(PickupDate.objects.count(), 1) self.assertTrue(PickupDate.objects.first().is_disabled) # do not process pickup again if places gets active place.status = PlaceStatus.ACTIVE.value place.save() PickupDate.objects.process_finished_pickup_dates() self.assertEqual(History.objects.count(), 0)
class TestHistoryAPIPickupForInactivePlace(APITestCase, ExtractPaginationMixin): def setUp(self): self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group, status='archived') self.pickup = PickupDateFactory(place=self.place, date=to_range(timezone.now() - relativedelta(days=1))) self.pickup.add_collector(self.member) PickupDateFactory(place=self.place, date=to_range(timezone.now() - relativedelta(days=1), minutes=30)) PickupDate.objects.process_finished_pickup_dates() def test_no_pickup_done_for_inactive_place(self): self.client.force_login(self.member) response = self.get_results(history_url, {'typus': 'PICKUP_DONE'}) self.assertEqual(len(response.data), 0) def test_no_pickup_missed_for_inactive_place(self): self.client.force_login(self.member) response = self.get_results(history_url, {'typus': 'PICKUP_MISSED'}) self.assertEqual(len(response.data), 0)
def make_activity_in_group(self, group): place = PlaceFactory(group=group) new_users = [VerifiedUserFactory() for _ in range(self.new_user_count)] user = new_users[0] a_few_days_ago = timezone.now() - relativedelta(days=4) with freeze_time(a_few_days_ago, tick=True): [group.add_member(u) for u in new_users] # a couple of messages [ group.conversation.messages.create(author=user, content='hello') for _ in range(self.message_count) ] # missed pickups [ PickupDateFactory(place=place) for _ in range(self.pickups_missed_count) ] # fullfilled pickups pickups = [ PickupDateFactory(place=place, max_collectors=1, collectors=[user]) for _ in range(self.pickups_done_count) ] # pickup feedback [ FeedbackFactory(about=pickup, given_by=user) for pickup in pickups[:self.feedback_count] ]
def setUp(self): self.user = VerifiedUserFactory() self.group = GroupFactory(members=[self.user]) self.place = PlaceFactory(group=self.group) self.pickup = PickupDateFactory(place=self.place, collectors=[self.user]) self.conversation = self.pickup.conversation
def test_create_pickup_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)) pickup1 = PickupDateFactory(place=place, date=in_one_hour, collectors=users) in_two_hours = to_range(timezone.now() + relativedelta(hours=1)) PickupDateFactory(place=place, date=in_two_hours, collectors=users) Notification.objects.all().delete() create_pickup_upcoming_notifications.call_local() notifications = Notification.objects.filter( type=NotificationType.PICKUP_UPCOMING.value) self.assertEqual(notifications.count(), 6) self.assertEqual(set(n.user.id for n in notifications), set(user.id for user in users)) pickup1_user1_collector = PickupDateCollector.objects.get( user=users[0], pickupdate=pickup1) pickup1_user1_notification = next( n for n in notifications if n.context['pickup_collector'] == pickup1_user1_collector.id) self.assertEqual( pickup1_user1_notification.context, { 'group': group.id, 'place': place.id, 'pickup': pickup1.id, 'pickup_collector': pickup1_user1_collector.id, }) self.assertEqual(pickup1_user1_notification.expires_at, pickup1.date.start)
class FinishedPickupReceiverTest(WSTestCase): 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_receive_history_and_notification(self): self.pickup.date = to_range(timezone.now() - relativedelta(days=1)) self.pickup.save() self.client = self.connect_as(self.member) PickupDate.objects.process_finished_pickup_dates() history_response = next(m for m in self.client.messages if m['topic'] == 'history:history') self.assertEqual(history_response['payload']['typus'], 'PICKUP_DONE') history_response = next(m for m in self.client.messages if m['topic'] == 'notifications:notification') self.assertEqual(history_response['payload']['type'], 'feedback_possible') self.assertEqual(len(self.client.messages), 2, self.client.messages)
def setUp(self): self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.pickup = PickupDateFactory(place=self.place) self.pickup_url = '/api/pickup-dates/{}/'.format(self.pickup.id) self.series = PickupDateSeriesFactory(place=self.place) self.series_url = '/api/pickup-date-series/{}/'.format(self.series.id)
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))) self.pickup.add_collector(self.member) PickupDate.objects.process_finished_pickup_dates()
def setUp(self): self.url = '/api/pickup-dates/' # pickup date for group with one member and one place self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.active_place = PlaceFactory(group=self.group, status='active') self.inactive_place = PlaceFactory(group=self.group, status='created') PickupDateFactory(place=self.active_place) PickupDateFactory(place=self.inactive_place)
class TestPickupConversations(TestCase): def setUp(self): self.user = VerifiedUserFactory() self.group = GroupFactory(members=[self.user]) self.place = PlaceFactory(group=self.group) self.pickup = PickupDateFactory(place=self.place, collectors=[self.user]) self.conversation = self.pickup.conversation def test_send_email_notifications(self): users = [VerifiedUserFactory() for _ in range(2)] [self.pickup.add_collector(u) for u in users] mail.outbox = [] with execute_scheduled_tasks_immediately(): ConversationMessage.objects.create(author=self.user, conversation=self.conversation, content='asdf') actual_recipients = sorted(m.to[0] for m in mail.outbox) expected_recipients = sorted(u.email for u in users) self.assertEqual(actual_recipients, expected_recipients) self.assertEqual(len(mail.outbox), 2)
def test_deletes_pickup_upcoming_notification(self): user = UserFactory() group = GroupFactory(members=[user]) place = PlaceFactory(group=group) in_one_hour = to_range(timezone.now() + relativedelta(hours=1)) pickup = PickupDateFactory(place=place, date=in_one_hour, collectors=[user]) Notification.objects.all().delete() create_pickup_upcoming_notifications.call_local() pickup.remove_collector(user) notifications = Notification.objects.filter( type=NotificationType.PICKUP_UPCOMING.value) self.assertEqual(notifications.count(), 0)
def test_unsubscribe_from_pickup_conversation(self): pickup = PickupDateFactory(place=self.place, collectors=[self.user]) participant = pickup.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_list_conversations_with_related_data_efficiently(self): user = UserFactory() group = GroupFactory(members=[user]) place = PlaceFactory(group=group) pickup = PickupDateFactory(place=place) application = ApplicationFactory(user=UserFactory(), group=group) issue = IssueFactory(group=group) conversations = [ t.conversation for t in (group, pickup, application, issue) ] [c.sync_users([user]) for c in conversations] [c.messages.create(content='hey', author=user) for c in conversations] ConversationMeta.objects.get_or_create(user=user) self.client.force_login(user=user) with self.assertNumQueries(13): response = self.client.get('/api/conversations/', {'group': group.id}, format='json') results = response.data['results'] self.assertEqual(len(results['conversations']), len(conversations)) self.assertEqual(results['pickups'][0]['id'], pickup.id) self.assertEqual(results['applications'][0]['id'], application.id) self.assertEqual(results['issues'][0]['id'], issue.id)
def setUp(self): self.first_member = UserFactory() self.second_member = UserFactory() self.group = GroupFactory( members=[self.first_member, self.second_member]) self.place = PlaceFactory(group=self.group) self.pickup = PickupDateFactory(place=self.place, collectors=[self.first_member])
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_group_summary_data(self): a_couple_of_weeks_ago = timezone.now() - relativedelta(weeks=3) a_few_days_ago = timezone.now() - relativedelta(days=4) place = PlaceFactory(group=self.group) old_user = VerifiedUserFactory(mail_verified=True) user = VerifiedUserFactory(mail_verified=True) # should not be included in summary email with freeze_time(a_couple_of_weeks_ago, tick=True): self.group.add_member(old_user) self.group.conversation.messages.create(author=old_user, content='old message') PickupDateFactory(place=place) PickupDateFactory(place=place, max_collectors=1, collectors=[old_user]) # should be included in summary email with freeze_time(a_few_days_ago, tick=True): self.group.add_member(user) # a couple of messages self.group.conversation.messages.create(author=user, content='hello') self.group.conversation.messages.create(author=user, content='whats up') # a missed pickup PickupDateFactory(place=place) # a fulfilled pickup PickupDateFactory(place=place, max_collectors=1, collectors=[user]) from_date, to_date = karrot.groups.emails.calculate_group_summary_dates( self.group) data = karrot.groups.emails.prepare_group_summary_data( self.group, from_date, to_date) self.assertEqual(data['pickups_done_count'], 1) self.assertEqual(data['pickups_missed_count'], 1) self.assertEqual(len(data['new_users']), 1) self.assertEqual(len(data['messages']), 2)
class PickupDateReceiverTests(WSTestCase): 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) def test_receive_pickup_changes(self): self.client = self.connect_as(self.member) # change property date = to_range( faker.future_datetime(end_date='+30d', tzinfo=timezone.utc)) self.pickup.date = date self.pickup.save() response = self.client.messages_by_topic.get('pickups:pickupdate')[0] self.assertEqual(parse(response['payload']['date'][0]), date.start) # join self.client = self.connect_as(self.member) self.pickup.add_collector(self.member) response = self.client.messages_by_topic.get('pickups:pickupdate')[0] self.assertEqual(response['payload']['collectors'], [self.member.id]) response = self.client.messages_by_topic.get( 'conversations:conversation')[0] self.assertEqual(response['payload']['participants'], [self.member.id]) # leave self.client = self.connect_as(self.member) self.pickup.remove_collector(self.member) response = self.client.messages_by_topic.get('pickups:pickupdate')[0] self.assertEqual(response['payload']['collectors'], []) self.assertIn('conversations:leave', self.client.messages_by_topic.keys()) def test_receive_pickup_delete(self): self.client = self.connect_as(self.member) pickup_id = self.pickup.id self.pickup.delete() response = self.client.messages_by_topic.get( 'pickups:pickupdate_deleted')[0] self.assertEqual(response['payload']['id'], pickup_id) self.assertEqual(len(self.client.messages), 1)
def setUp(self): self.type = VerificationCode.ACCOUNT_DELETE self.user = UserFactory() self.user2 = UserFactory() self.group = GroupFactory(members=[self.user, self.user2]) self.place = PlaceFactory(group=self.group) self.pickupdate = PickupDateFactory( place=self.place, date=to_range(timezone.now() + relativedelta(days=1)), collectors=[self.user], ) self.past_pickupdate = PickupDateFactory( place=self.place, date=to_range(timezone.now() - relativedelta(days=1)), collectors=[self.user], ) self.url_user = '******' self.url_delete = '/api/auth/user/?code={:s}' self.url_request_delete = '/api/auth/user/request_delete/' mail.outbox = []
def setUp(self): self.url = '/api/pickup-dates/' # pickup date for group with one member and one place self.member = UserFactory() self.group = GroupFactory(members=[self.member]) self.place = PlaceFactory(group=self.group) self.pickup = PickupDateFactory(place=self.place) # and another place + group + pick-update self.group2 = GroupFactory(members=[self.member]) self.place2 = PlaceFactory(group=self.group2) self.pickup2 = PickupDateFactory(place=self.place2) # a pickup date series self.series = PickupDateSeriesFactory(place=self.place) # another pickup date series self.series2 = PickupDateSeriesFactory(place=self.place)
def test_tags_for_pickup_conversation(self): group = GroupFactory() place = PlaceFactory(group=group) pickup = PickupDateFactory(place=place) tags = conversation_tags(pickup.conversation) self.assertEqual( tags, { 'type': 'pickup', 'group': str(group.id), 'group_status': group.status, })
def test_creates_no_pickup_upcoming_notification_when_in_past(self): user = UserFactory() group = GroupFactory(members=[user]) place = PlaceFactory(group=group) one_hour_ago = to_range(timezone.now() - relativedelta(hours=1)) PickupDateFactory(place=place, date=one_hour_ago, collectors=[user]) Notification.objects.all().delete() create_pickup_upcoming_notifications.call_local() notifications = Notification.objects.filter( type=NotificationType.PICKUP_UPCOMING.value) self.assertEqual(notifications.count(), 0)
def test_creates_pickup_disabled_notification_and_deletes_pickup_upcoming_notification( self): user1, user2 = UserFactory(), UserFactory() group = GroupFactory(members=[user1, user2]) place = PlaceFactory(group=group) in_one_hour = to_range(timezone.now() + relativedelta(hours=1)) pickup = PickupDateFactory(place=place, date=in_one_hour, collectors=[user1, user2]) Notification.objects.all().delete() create_pickup_upcoming_notifications.call_local() pickup.last_changed_by = user2 pickup.is_disabled = True pickup.save() pickup_upcoming_notifications = Notification.objects.filter( type=NotificationType.PICKUP_UPCOMING.value) self.assertEqual(pickup_upcoming_notifications.count(), 0) pickup_disabled_notifications = Notification.objects.filter( type=NotificationType.PICKUP_DISABLED.value) self.assertEqual(pickup_disabled_notifications.count(), 1) self.assertEqual(pickup_disabled_notifications[0].user, user1) context = pickup_disabled_notifications[0].context self.assertEqual(context['group'], group.id) self.assertEqual(context['pickup'], pickup.id) self.assertEqual(context['place'], place.id)
class FinishedPickupReceiverTest(WSTestCase): 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_receive_history_and_notification(self): self.pickup.date = to_range(timezone.now() - relativedelta(days=1)) self.pickup.save() Notification.objects.all().delete() client = self.connect_as(self.member) PickupDate.objects.process_finished_pickup_dates() messages_by_topic = client.messages_by_topic response = messages_by_topic['history:history'][0] self.assertEqual(response['payload']['typus'], 'PICKUP_DONE') response = messages_by_topic['notifications:notification'][0] self.assertEqual(response['payload']['type'], 'feedback_possible') status_messages = messages_by_topic['status'] self.assertEqual(len(status_messages), 2) self.assertEqual(status_messages[0]['payload'], {'unseen_notification_count': 1}) self.assertEqual( status_messages[1]['payload'], {'groups': { self.group.id: { 'feedback_possible_count': 1 } }}) self.assertEqual(len(client.messages), 4, client.messages)
def setUp(self): self.url = '/api/feedback/' # create a group with a user and two places self.collector = UserFactory() self.collector2 = UserFactory() self.group = GroupFactory(members=[self.collector, self.collector2]) self.group2 = GroupFactory(members=[self.collector, self.collector2]) self.place = PlaceFactory(group=self.group) self.place2 = PlaceFactory(group=self.group) self.pickup = PickupDateFactory(place=self.place, date=to_range(timezone.now() - relativedelta(days=1))) self.pickup2 = PickupDateFactory(place=self.place2, date=to_range(timezone.now() - relativedelta(days=1))) # create a feedback data self.feedback_get = { 'given_by': self.collector, 'about': self.pickup, 'weight': 1, 'comment': 'asfjk' } self.feedback_get2 = { 'given_by': self.collector2, 'about': self.pickup2, 'weight': 2, 'comment': 'bsfjk' } # create 2 instances of feedback self.feedback = Feedback.objects.create(**self.feedback_get) self.feedback2 = Feedback.objects.create(**self.feedback_get2) # transforms the user into a collector self.pickup.add_collector(self.collector) self.pickup2.add_collector(self.collector) self.pickup2.add_collector(self.collector2)
def setUp(self): self.url = '/api/pickup-dates/' self.oneWeekAgo = to_range(timezone.now() - relativedelta(weeks=1)) self.tooLongAgo = to_range( timezone.now() - relativedelta(days=settings.FEEDBACK_POSSIBLE_DAYS + 1), minutes=30) self.member = UserFactory() self.member2 = UserFactory() self.group = GroupFactory(members=[self.member, self.member2]) self.place = PlaceFactory(group=self.group) # not member (anymore) self.group2 = GroupFactory(members=[]) self.place2 = PlaceFactory(group=self.group2) self.pickupFeedbackPossible = PickupDateFactory(place=self.place, collectors=[ self.member, ], date=self.oneWeekAgo) # now the issues where no feedback can be given self.pickupUpcoming = PickupDateFactory(place=self.place, collectors=[ self.member, ]) self.pickupNotCollector = PickupDateFactory(place=self.place, date=self.oneWeekAgo) self.pickupTooLongAgo = PickupDateFactory(place=self.place, date=self.tooLongAgo) self.pickupFeedbackAlreadyGiven = PickupDateFactory( place=self.place, collectors=[ self.member, ], date=self.oneWeekAgo) self.feedback = FeedbackFactory(about=self.pickupFeedbackAlreadyGiven, given_by=self.member) self.pickupCollectorLeftGroup = PickupDateFactory(place=self.place2, collectors=[ self.member, ], date=self.oneWeekAgo) self.pickupDoneByAnotherUser = PickupDateFactory(place=self.place, collectors=[ self.member2, ], date=self.oneWeekAgo) PickupDateModel.objects.process_finished_pickup_dates()
def test_can_access_messages_if_not_participant(self): user = UserFactory() author = UserFactory() group = GroupFactory(members=[user, author]) pickup = PickupDateFactory(place=PlaceFactory(group=group)) conversation = pickup.conversation conversation.messages.create(author=author, content='asdf') self.client.force_login(user=user) response = self.client.get('/api/messages/?conversation={}'.format( conversation.id)) self.assertEqual(response.status_code, status.HTTP_200_OK, response.data) self.assertEqual(len(response.data['results']), 1, response.data['results'])