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'])
