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())
def test_matches_first_when_distance_is_equal(self):
now = timezone.now()
# shift pickups
every_minute = [now + relativedelta(minutes=n) for n in range(1, 5)]
pickups = [
PickupDate(date=to_range(d +
relativedelta(seconds=30), minutes=30))
for d in every_minute
]
self.assertIteratorEqual(
match_pickups_with_dates(pickups, every_minute),
zip(pickups, every_minute),
)
# shift dates
pickups = [
PickupDate(date=to_range(d, minutes=30)) for d in every_minute
]
every_minute = [n + relativedelta(seconds=30) for n in every_minute]
self.assertIteratorEqual(
match_pickups_with_dates(pickups, every_minute),
zip(pickups, every_minute),
)
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)
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 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 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_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 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 setUpBeforeMigration(self, apps):
User = apps.get_model('users', 'User')
Group = apps.get_model('groups', 'Group')
Place = apps.get_model('places', 'Place')
Conversation = apps.get_model('conversations', 'Conversation')
PickupDate = apps.get_model('pickups', 'PickupDate')
Application = apps.get_model('applications', 'Application')
ContentType = apps.get_model('contenttypes', 'ContentType')
self.group = Group.objects.create(name='hello')
target_type = ContentType.objects.get(app_label='groups',
model='group')
self.group_conversation = Conversation.objects.create(
target_type=target_type, target_id=self.group.id)
self.none_conversation = Conversation.objects.create()
self.private_conversation = Conversation.objects.create(
is_private=True)
place = Place.objects.create(group=self.group)
pickup = PickupDate.objects.create(place=place,
date=to_range(timezone.now()))
target_type = ContentType.objects.get(app_label='pickups',
model='pickupdate')
self.pickup_conversation = Conversation.objects.create(
target_type=target_type, target_id=pickup.id)
user = User.objects.create(email=faker.email())
application = Application.objects.create(user=user, group=self.group)
target_type = ContentType.objects.get(app_label='applications',
model='application')
self.application_conversation = Conversation.objects.create(
target_type=target_type, target_id=application.id)
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)
def create_empty_pickup(self, delta, place=None):
if place is None:
place = self.place
return PickupDate.objects.create(
place=place,
date=to_range(timezone.localtime() + delta),
max_collectors=1,
)
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)))
# No one joined the pickup
PickupDate.objects.process_finished_pickup_dates()
def test_matches_identical_pickups(self):
now = timezone.now()
every_day = [now + relativedelta(days=n) for n in range(1, 5)]
pickups = [PickupDate(date=to_range(d, minutes=30)) for d in every_day]
self.assertIteratorEqual(
match_pickups_with_dates(pickups, every_day),
zip(pickups, every_day),
)
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 create_user_pickup(self, delta, place=None, **kwargs):
if place is None:
place = self.place
pickup = PickupDate.objects.create(
place=place,
date=to_range(timezone.localtime() + delta),
**kwargs,
)
pickup.add_collector(self.user)
pickup.save()
return pickup
def create_not_full_pickup(self, delta, place=None):
if place is None:
place = self.place
pickup = PickupDate.objects.create(
place=place,
date=to_range(timezone.localtime() + delta),
max_collectors=2,
)
pickup.add_collector(self.other_user)
pickup.save()
return pickup
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 test_create_pickup(self):
self.client.force_login(self.member)
self.client.post(
'/api/pickup-dates/', {
'date':
to_range(timezone.now() + relativedelta(days=1)).as_list(),
'place': self.place.id
},
format='json')
response = self.get_results(history_url)
self.assertEqual(response.data[0]['typus'], 'PICKUP_CREATE')
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 create_done_pickup(place, user_id):
pickup = PickupDate.objects.create(
date=to_range(faker.date_time_between(start_date='-9d',
end_date='-1d',
tzinfo=pytz.utc),
minutes=30),
place_id=place,
max_collectors=10,
)
pickup.add_collector(User.objects.get(pk=user_id))
print('created done pickup: ', pickup)
return pickup
def test_matches_shifted_pickups_within_few_seconds(self):
now = timezone.now()
every_day = [now + relativedelta(days=n) for n in range(1, 5)]
pickups = [
PickupDate(date=to_range(d +
relativedelta(seconds=20), minutes=30))
for d in every_day
]
self.assertIteratorEqual(
match_pickups_with_dates(pickups, every_day),
zip(pickups, every_day),
)
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 setUpTestData(cls):
cls.url = '/api/pickup-dates/'
# pickup date 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.pickup = PickupDateFactory(place=cls.place)
cls.pickup_url = cls.url + str(cls.pickup.id) + '/'
cls.join_url = cls.pickup_url + 'add/'
cls.leave_url = cls.pickup_url + 'remove/'
cls.conversation_url = cls.pickup_url + 'conversation/'
# not a member of the group
cls.user = UserFactory()
# another pickup date for above place
cls.pickup_data = {
'date': to_range(timezone.now() + relativedelta(days=2)).as_list(),
'max_collectors': 5,
'place': cls.place.id
}
# past pickup date
cls.past_pickup_data = {
'date': to_range(timezone.now() - relativedelta(days=1)).as_list(),
'max_collectors': 5,
'place': cls.place.id
}
cls.past_pickup = PickupDateFactory(
place=cls.place,
date=to_range(timezone.now() - relativedelta(days=1)))
cls.past_pickup_url = cls.url + str(cls.past_pickup.id) + '/'
cls.past_join_url = cls.past_pickup_url + 'add/'
cls.past_leave_url = cls.past_pickup_url + 'remove/'
def setUp(self):
self.url = '/api/pickup-dates/'
# pickup date for group with one member and one place
self.member = UserFactory()
self.second_member = UserFactory()
self.group = GroupFactory(members=[self.member, self.second_member])
self.place = PlaceFactory(group=self.group)
self.pickup = PickupDateFactory(place=self.place)
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 place
self.pickup_data = {
'date': to_range(timezone.now() + relativedelta(days=2)).as_list(),
'max_collectors': 5,
'place': self.place.id
}
# past pickup date
self.past_pickup_data = {
'date': to_range(timezone.now() - relativedelta(days=1)).as_list(),
'max_collectors': 5,
'place': self.place.id
}
self.past_pickup = PickupDateFactory(
place=self.place,
date=to_range(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 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,
'pickups_done': 0,
})
one_day_ago = to_range(timezone.now() - relativedelta(days=1))
users = [UserFactory() for _ in range(9)]
pickups = [
PickupDateFactory(
place=place,
date=one_day_ago,
collectors=users,
is_done=True,
feedback_as_sum=False,
) for _ in range(3)
]
feedback = [
FeedbackFactory(about=choice(pickups), 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,
'pickups_done': len(pickups),
})
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_matches_empty(self):
now = timezone.now()
every_day = [now + relativedelta(days=n) for n in range(1, 3)]
pickups = [PickupDate(date=to_range(d, minutes=30)) for d in every_day]
self.assertIteratorEqual(
match_pickups_with_dates([], every_day),
zip((None, None), every_day),
)
self.assertIteratorEqual(
match_pickups_with_dates(pickups, []),
zip(pickups, (None, None)),
)
self.assertIteratorEqual(
match_pickups_with_dates([], []),
[],
)
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 test_not_matches_shifted_pickups_with_more_difference(self):
now = timezone.now()
every_day = [now + relativedelta(days=n) for n in range(1, 3)]
pickups = [
PickupDate(date=to_range(d +
relativedelta(minutes=10), minutes=30))
for d in every_day
]
self.assertIteratorEqual(
match_pickups_with_dates(pickups, every_day),
[
(None, every_day[0]),
(pickups[0], None),
(None, every_day[1]),
(pickups[1], None),
],
)
def make_pickup(place):
date = to_range(
faker.date_time_between(start_date='+2d',
end_date='+7d',
tzinfo=pytz.utc))
response = c.post(
'/api/pickup-dates/',
{
'date': date.as_list(),
'place': place,
'max_collectors': 10
},
format='json',
)
if response.status_code != 201:
raise Exception('could not make pickup', response.data)
data = response.data
p = PickupDate.objects.get(pk=data['id'])
print('created pickup: ', data, p.date)
return data
