def test_create_pickup_upcoming_notifications(self):
users = [UserFactory() for _ in range(3)]
group = GroupFactory(members=users)
store = StoreFactory(group=group)
in_one_hour = timezone.now() + relativedelta(hours=1)
pickup1 = PickupDateFactory(store=store, date=in_one_hour, collectors=users)
in_two_hours = timezone.now() + relativedelta(hours=1)
PickupDateFactory(store=store, 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,
'store': store.id,
'pickup': pickup1.id,
'pickup_collector': pickup1_user1_collector.id,
}
)
self.assertEqual(pickup1_user1_notification.expires_at, pickup1.date)
def test_leave_group(self):
store = StoreFactory(group=self.group)
pickupdate = PickupDateFactory(store=store,
collectors=[self.member, self.user],
date=timezone.now() +
relativedelta(weeks=1))
past_pickupdate = PickupDateFactory(store=store,
collectors=[
self.member,
],
date=timezone.now() -
relativedelta(weeks=1))
unrelated_pickupdate = PickupDateFactory(
date=timezone.now() + relativedelta(weeks=1),
collectors=[
self.member,
],
)
GroupMembership.objects.create(group=unrelated_pickupdate.store.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())
def make_activity_in_group(self, group):
store = StoreFactory(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(store=store)
for _ in range(self.pickups_missed_count)
]
# fullfilled pickups
pickups = [
PickupDateFactory(store=store,
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.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store,
collectors=[self.user])
self.conversation = self.pickup.conversation
def setUp(self):
self.url = '/api/feedback/'
# create a group with a user and two stores
self.collector = UserFactory()
self.collector2 = UserFactory()
self.group = GroupFactory(members=[
self.collector,
self.collector2,
])
self.group2 = GroupFactory(members=[
self.collector,
self.collector2,
])
self.store = StoreFactory(group=self.group)
self.store2 = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store, date=timezone.now() - relativedelta(days=1))
self.pickup2 = PickupDateFactory(store=self.store2, date=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.collectors.add(self.collector, )
self.pickup2.collectors.add(self.collector, self.collector2)
class FinishedPickupReceiverTest(ChannelTestCase):
def setUp(self):
self.client = WSClient()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store,
collectors=[self.member])
def test_receive_feedback_possible_and_history(self):
self.pickup.date = timezone.now() - relativedelta(days=1)
self.pickup.save()
self.client.force_login(self.member)
self.client.send_and_consume('websocket.connect', path='/')
call_command('process_finished_pickup_dates')
response = self.client.receive(json=True)
self.assertEqual(response['topic'], 'history:history')
self.assertEqual(response['payload']['typus'], 'PICKUP_DONE')
response = self.client.receive(json=True)
self.assertEqual(response['topic'], 'pickups:feedback_possible')
self.assertEqual(response['payload']['id'], self.pickup.id)
self.assertIsNone(self.client.receive(json=True))
def setUp(self):
self.url = '/api/pickup-dates/'
# pickup date for group with one member and one store
self.member = UserFactory()
self.group = GroupFactory(members=[
self.member,
])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store)
# and another store + group + pick-update
self.group2 = GroupFactory(members=[
self.member,
])
self.store2 = StoreFactory(group=self.group2)
self.pickup2 = PickupDateFactory(store=self.store2)
# a pickup date series
self.series = PickupDateSeriesFactory(store=self.store)
self.series.update_pickup_dates()
# another pickup date series
self.series2 = PickupDateSeriesFactory(store=self.store)
self.series2.update_pickup_dates()
def setUp(self):
self.client = WSClient()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store,
collectors=[self.member])
class TestHistoryAPIWithDonePickup(APITestCase, ExtractPaginationMixin):
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store,
date=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=timezone.now() - relativedelta(weeks=1))
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.feedback_possible)
self.assertEqual(History.objects.count(), 0)
def test_disables_past_pickups_of_inactive_stores(self):
store = self.pickup.store
store.status = StoreStatus.ARCHIVED.value
store.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 stores gets active
store.status = StoreStatus.ACTIVE.value
store.save()
PickupDate.objects.process_finished_pickup_dates()
self.assertEqual(History.objects.count(), 0)
def setUp(self):
self.url = '/api/pickup-dates/'
# pickup date for group with one member and one store
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store)
self.pickup_url = self.url + str(self.pickup.id) + '/'
self.join_url = self.pickup_url + 'add/'
self.leave_url = self.pickup_url + 'remove/'
self.conversation_url = self.pickup_url + 'conversation/'
# not a member of the group
self.user = UserFactory()
# another pickup date for above store
self.pickup_data = {
'date': timezone.now() + relativedelta(days=2),
'max_collectors': 5,
'store': self.store.id
}
# past pickup date
self.past_pickup_data = {
'date': timezone.now() - relativedelta(days=1),
'max_collectors': 5,
'store': self.store.id
}
self.past_pickup = PickupDateFactory(store=self.store, date=timezone.now() - relativedelta(days=1))
self.past_pickup_url = self.url + str(self.past_pickup.id) + '/'
self.past_join_url = self.past_pickup_url + 'add/'
self.past_leave_url = self.past_pickup_url + 'remove/'
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store, date=timezone.now() - relativedelta(days=1))
self.pickup.add_collector(self.member)
PickupDate.objects.process_finished_pickup_dates()
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[self.member, ],
slack_webhook='https://hooks.slack.com/services/some_webhook')
self.store = StoreFactory(group=self.group, name="Elke's")
self.pickup_upcoming = PickupDateFactory(store=self.store, date=timezone.now() + relativedelta(hours=1))
self.pickup_future = PickupDateFactory(store=self.store, date=timezone.now() + relativedelta(hours=12))
self.pickup_past = PickupDateFactory(store=self.store, date=timezone.now() - relativedelta(days=1))
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store)
self.pickup_url = '/api/pickup-dates/{}/'.format(self.pickup.id)
self.series = PickupDateSeriesFactory(store=self.store)
self.series_url = '/api/pickup-date-series/{}/'.format(self.series.id)
class PickupDateReceiverTests(ChannelTestCase):
def setUp(self):
self.client = WSClient()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store)
def test_receive_pickup_changes(self):
self.client.force_login(self.member)
self.client.send_and_consume('websocket.connect', path='/')
# change property
date = faker.future_datetime(end_date='+30d', tzinfo=timezone.utc)
self.pickup.date = date
self.pickup.save()
response = self.client.receive(json=True)
self.assertEqual(response['topic'], 'pickups:pickupdate')
self.assertEqual(parse(response['payload']['date']), date)
# join
self.pickup.collectors.add(self.member)
response = self.client.receive(json=True)
self.assertEqual(response['topic'], 'pickups:pickupdate')
self.assertEqual(response['payload']['collector_ids'], [self.member.id])
response = self.client.receive(json=True)
self.assertEqual(response['topic'], 'conversations:conversation')
self.assertEqual(response['payload']['participants'], [self.member.id])
# leave
self.pickup.collectors.remove(self.member)
response = self.client.receive(json=True)
self.assertEqual(response['topic'], 'pickups:pickupdate')
self.assertEqual(response['payload']['collector_ids'], [])
response = self.client.receive(json=True)
self.assertEqual(response['topic'], 'conversations:leave')
self.assertIsNone(self.client.receive(json=True))
def test_receive_pickup_delete(self):
self.client.force_login(self.member)
self.client.send_and_consume('websocket.connect', path='/')
self.pickup.deleted = True
self.pickup.save()
response = self.client.receive(json=True)
self.assertEqual(response['topic'], 'pickups:pickupdate_deleted')
self.assertEqual(response['payload']['id'], self.pickup.id)
self.assertIsNone(self.client.receive(json=True))
class PickupDateReceiverTests(WSTestCase):
def setUp(self):
super().setUp()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store)
def test_receive_pickup_changes(self):
self.client = self.connect_as(self.member)
# change property
date = faker.future_datetime(end_date='+30d', tzinfo=timezone.utc)
self.pickup.date = date
self.pickup.save()
response = self.client.messages[0]
self.assertEqual(response['topic'], 'pickups:pickupdate')
self.assertEqual(parse(response['payload']['date']), date)
# join
self.pickup.collectors.add(self.member)
response = self.client.messages[1]
self.assertEqual(response['topic'], 'pickups:pickupdate')
self.assertEqual(response['payload']['collector_ids'], [self.member.id])
response = self.client.messages[2]
self.assertEqual(response['topic'], 'conversations:conversation')
self.assertEqual(response['payload']['participants'], [self.member.id])
# leave
self.pickup.collectors.remove(self.member)
response = self.client.messages[3]
self.assertEqual(response['topic'], 'pickups:pickupdate')
self.assertEqual(response['payload']['collector_ids'], [])
response = self.client.messages[4]
self.assertEqual(response['topic'], 'conversations:leave')
self.assertEqual(len(self.client.messages), 5)
def test_receive_pickup_delete(self):
self.client = self.connect_as(self.member)
self.pickup.deleted = True
self.pickup.save()
response = self.client.messages[0]
self.assertEqual(response['topic'], 'pickups:pickupdate_deleted')
self.assertEqual(response['payload']['id'], self.pickup.id)
self.assertEqual(len(self.client.messages), 1)
def setUp(self):
self.url = '/api/pickup-dates/'
# pickup date for group with one member and one store
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.active_store = StoreFactory(group=self.group, status='active')
self.inactive_store = StoreFactory(group=self.group, status='created')
PickupDateFactory(store=self.active_store)
PickupDateFactory(store=self.inactive_store)
def test_deletes_pickup_upcoming_notification(self):
user = UserFactory()
group = GroupFactory(members=[user])
store = StoreFactory(group=group)
in_one_hour = timezone.now() + relativedelta(hours=1)
pickup = PickupDateFactory(store=store, 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_collects_stats(self, write_points):
a_few_days_ago = timezone.now() - relativedelta(days=4)
store = StoreFactory(group=self.group)
message_count = 10
pickups_missed_count = 5
feedback_count = 4
new_user_count = 3
pickups_done_count = 8
new_users = [VerifiedUserFactory() for _ in range(new_user_count)]
user = new_users[0]
with freeze_time(a_few_days_ago, tick=True):
[self.group.add_member(u) for u in new_users]
# a couple of messages
[self.group.conversation.messages.create(author=user, content='hello') for _ in range(message_count)]
# missed pickups
[PickupDateFactory(store=store) for _ in range(pickups_missed_count)]
# fullfilled pickups
pickups = [
PickupDateFactory(store=store, max_collectors=1, collectors=[user])
for _ in range(pickups_done_count)
]
# pickup feedback
[FeedbackFactory(about=pickup, given_by=user) for pickup in pickups[:feedback_count]]
write_points.reset_mock()
send_summary_emails()
write_points.assert_called_with([{
'measurement': 'karrot.email.group_summary',
'tags': {
'group': str(self.group.id)
},
'fields': {
'value': 1,
'new_user_count': new_user_count,
'email_recipient_count': new_user_count,
'feedback_count': feedback_count,
'pickups_missed_count': pickups_missed_count,
'message_count': message_count,
'pickups_done_count': pickups_done_count,
},
}])
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[
self.member,
])
self.store = StoreFactory(group=self.group, status='archived')
self.pickup = PickupDateFactory(store=self.store,
date=timezone.now() -
relativedelta(days=1))
self.pickup.collectors.add(self.member)
PickupDateFactory(store=self.store,
date=timezone.now() - relativedelta(days=1))
call_command('process_finished_pickup_dates')
def setUp(self):
self.user = UserFactory()
self.user2 = UserFactory()
self.group = GroupFactory(members=[self.user, self.user2])
self.store = StoreFactory(group=self.group)
self.pickupdate = PickupDateFactory(
store=self.store,
date=timezone.now() + relativedelta(days=1),
collectors=[self.user, ])
self.past_pickupdate = PickupDateFactory(
store=self.store,
date=timezone.now() - relativedelta(days=1),
collectors=[self.user, ]
)
self.url = '/api/auth/user/'
def setUp(self):
self.first_member = UserFactory()
self.second_member = UserFactory()
self.group = GroupFactory(
members=[self.first_member, self.second_member])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store,
collectors=[self.first_member])
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)
store = StoreFactory(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(store=store)
PickupDateFactory(store=store,
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(store=store)
# a fulfilled pickup
PickupDateFactory(store=store, max_collectors=1, collectors=[user])
from_date, to_date = foodsaving.groups.emails.calculate_group_summary_dates(
self.group)
data = foodsaving.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)
def test_tags_for_pickup_conversation(self):
group = GroupFactory()
store = StoreFactory(group=group)
pickup = PickupDateFactory(store=store)
tags = conversation_tags(pickup.conversation)
self.assertEqual(
tags, {
'type': 'pickup',
'group': str(group.id),
'group_status': group.status,
})
def setUp(self):
self.type = VerificationCode.ACCOUNT_DELETE
self.user = UserFactory()
self.user2 = UserFactory()
self.group = GroupFactory(members=[self.user, self.user2])
self.store = StoreFactory(group=self.group)
self.pickupdate = PickupDateFactory(
store=self.store,
date=timezone.now() + relativedelta(days=1),
collectors=[self.user],
)
self.past_pickupdate = PickupDateFactory(
store=self.store,
date=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 test_creates_no_pickup_upcoming_notification_when_too_far_in_future(self):
user = UserFactory()
group = GroupFactory(members=[user])
store = StoreFactory(group=group)
in_one_day = timezone.now() + relativedelta(days=1)
PickupDateFactory(store=store, date=in_one_day, 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)
class TestHistoryAPIPickupForInactiveStore(APITestCase, ExtractPaginationMixin):
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group, status='archived')
self.pickup = PickupDateFactory(store=self.store, date=timezone.now() - relativedelta(days=1))
self.pickup.add_collector(self.member)
PickupDateFactory(store=self.store, date=timezone.now() - relativedelta(days=1))
PickupDate.objects.process_finished_pickup_dates()
def test_no_pickup_done_for_inactive_store(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_store(self):
self.client.force_login(self.member)
response = self.get_results(history_url, {'typus': 'PICKUP_MISSED'})
self.assertEqual(len(response.data), 0)
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[
self.member,
])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store,
date=timezone.now() -
relativedelta(days=1))
# No one joined the pickup
call_command('process_finished_pickup_dates')
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[
self.member,
])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store,
date=timezone.now() -
relativedelta(days=1))
self.pickup_url = '/api/pickup-dates/{}/'.format(self.pickup.id)
self.pickup.collectors.add(self.member)
call_command('process_finished_pickup_dates')
def test_pickup_message_title(self):
author = UserFactory()
group = GroupFactory(members=[author], timezone='Europe/Berlin')
store = StoreFactory(group=group)
pickup = PickupDateFactory(store=store,
collectors=[author],
date=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))