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()
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)
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 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 test_creates_feedback_possible_notification(self):
member = UserFactory()
group = GroupFactory(members=[member])
place = PlaceFactory(group=group)
pickup = PickupDateFactory(place=place)
pickup.add_collector(member)
pickup.is_done = True
pickup.save()
notification = Notification.objects.filter(
user=member, type=NotificationType.FEEDBACK_POSSIBLE.value)
self.assertEqual(notification.count(), 1)
self.assertLessEqual(
notification[0].expires_at, pickup.date.end +
relativedelta(days=settings.FEEDBACK_POSSIBLE_DAYS))
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_handle_zero_max_collectors_with_collectors_joined(self):
user = UserFactory()
self.pickup.group.add_member(user)
self.pickup.add_collector(user)
History.objects.all().delete()
self.pickup.max_collectors = 0
self.pickup.save()
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)
def test_creates_pickup_moved_notification(self):
user1, user2 = UserFactory(), UserFactory()
group = GroupFactory(members=[user1, user2])
place = PlaceFactory(group=group)
pickup = PickupDateFactory(place=place, collectors=[user1, user2])
Notification.objects.all().delete()
pickup.last_changed_by = user2
pickup.date = pickup.date + relativedelta(days=2)
pickup.save()
notifications = Notification.objects.all()
self.assertEqual(notifications.count(), 1)
self.assertEqual(notifications[0].type,
NotificationType.PICKUP_MOVED.value)
self.assertEqual(notifications[0].user, user1)
context = notifications[0].context
self.assertEqual(context['group'], group.id)
self.assertEqual(context['pickup'], pickup.id)
self.assertEqual(context['place'], place.id)
def test_creates_pickup_enabled_notification(self):
user1, user2 = UserFactory(), UserFactory()
group = GroupFactory(members=[user1, user2])
place = PlaceFactory(group=group)
pickup = PickupDateFactory(place=place, collectors=[user1, user2])
Notification.objects.all().delete()
pickup.last_changed_by = user2
pickup.is_disabled = True
pickup.save()
pickup.is_disabled = False
pickup.save()
pickup_enabled_notifications = Notification.objects.filter(
type=NotificationType.PICKUP_ENABLED.value)
self.assertEqual(pickup_enabled_notifications.count(), 1)
self.assertEqual(pickup_enabled_notifications[0].user, user1)
context = pickup_enabled_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)
class TestHistoryAPIWithExistingPickups(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)
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 test_modify_pickup(self):
self.client.force_login(self.member)
self.client.patch(self.pickup_url, {'max_collectors': '11'})
response = self.get_results(history_url)
self.assertEqual(response.data[0]['typus'], 'PICKUP_MODIFY')
self.assertEqual(response.data[0]['payload']['max_collectors'], '11')
def test_dont_modify_pickup(self):
self.client.force_login(self.member)
self.client.patch(self.pickup_url,
{'date': self.pickup.date.as_list()},
format='json')
response = self.get_results(history_url)
self.assertEqual(len(response.data), 0, response.data)
def test_modify_series(self):
self.client.force_login(self.member)
self.client.patch(self.series_url, {'max_collectors': '11'})
response = self.get_results(history_url)
self.assertEqual(response.data[0]['typus'], 'SERIES_MODIFY')
self.assertEqual(response.data[0]['payload']['max_collectors'], '11')
def test_dont_modify_series(self):
self.client.force_login(self.member)
self.client.patch(self.series_url, {'rule': self.series.rule})
response = self.get_results(history_url)
self.assertEqual(len(response.data), 0, response.data)
def test_delete_series(self):
self.client.force_login(self.member)
self.client.delete(self.series_url)
response = self.get_results(history_url)
self.assertEqual(response.data[0]['typus'], 'SERIES_DELETE')
self.assertEqual(response.data[0]['payload']['rule'], self.series.rule)
def test_join_pickup(self):
self.client.force_login(self.member)
self.client.post(self.pickup_url + 'add/')
response = self.get_results(history_url)
self.assertEqual(response.data[0]['typus'], 'PICKUP_JOIN')
self.assertEqual(parse(response.data[0]['payload']['date'][0]),
self.pickup.date.start)
def test_leave_pickup(self):
self.client.force_login(self.member)
self.pickup.add_collector(self.member)
self.client.post(self.pickup_url + 'remove/')
response = self.get_results(history_url)
self.assertEqual(response.data[0]['typus'], 'PICKUP_LEAVE')
self.assertEqual(parse(response.data[0]['payload']['date'][0]),
self.pickup.date.start)
def test_disable_pickup(self):
self.client.force_login(self.member)
History.objects.all().delete()
self.client.patch(self.pickup_url, {'is_disabled': True})
response = self.get_results(history_url)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['typus'], 'PICKUP_DISABLE')
def test_enable_pickup(self):
self.pickup.is_disabled = True
self.pickup.save()
self.client.force_login(self.member)
History.objects.all().delete()
self.client.patch(self.pickup_url, {'is_disabled': False})
response = self.get_results(history_url)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['typus'], 'PICKUP_ENABLE')
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):
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 = client.messages_by_topic.get('pickups:pickupdate')[0]
self.assertEqual(parse(response['payload']['date'][0]), date.start)
# join
client = self.connect_as(self.member)
self.pickup.add_collector(self.member)
response = client.messages_by_topic.get('pickups:pickupdate')[0]
self.assertEqual(response['payload']['collectors'], [self.member.id])
response = client.messages_by_topic.get(
'conversations:conversation')[0]
self.assertEqual(response['payload']['participants'], [self.member.id])
# leave
client = self.connect_as(self.member)
self.pickup.remove_collector(self.member)
response = client.messages_by_topic.get('pickups:pickupdate')[0]
self.assertEqual(response['payload']['collectors'], [])
self.assertIn('conversations:leave', client.messages_by_topic.keys())
def test_mark_as_done(self):
self.pickup.add_collector(self.member)
Notification.objects.all().delete()
client = self.connect_as(self.member)
self.pickup.is_done = True
self.pickup.save()
messages = client.messages_by_topic
self.assertEqual(len(messages['status']), 2, messages['status'])
self.assertEqual(messages['status'][0]['payload'],
{'unseen_notification_count': 1})
self.assertEqual(
messages['status'][1]['payload'],
{'groups': {
self.group.id: {
'feedback_possible_count': 1
}
}})
self.assertEqual(len(messages['notifications:notification']), 1,
messages['notifications:notification'])
self.assertEqual(
messages['notifications:notification'][0]['payload']['type'],
'feedback_possible')
def test_receive_pickup_delete(self):
client = self.connect_as(self.member)
pickup_id = self.pickup.id
self.pickup.delete()
response = client.messages_by_topic.get(
'pickups:pickupdate_deleted')[0]
self.assertEqual(response['payload']['id'], pickup_id)
self.assertEqual(len(client.messages), 1)
class TestPickupDatesAPI(APITestCase, ExtractPaginationMixin):
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_create_pickup(self):
response = self.client.post(self.url, self.pickup_data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_create_pickup_as_user(self):
self.client.force_login(user=self.user)
response = self.client.post(self.url, self.pickup_data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_create_pickup_as_group_member(self):
self.client.force_login(user=self.member)
response = self.client.post(self.url, self.pickup_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
def test_create_pickup_as_group_member_activates_group(self):
self.client.force_login(user=self.member)
self.group.status = GroupStatus.INACTIVE.value
self.group.save()
self.client.post(self.url, self.pickup_data, format='json')
self.group.refresh_from_db()
self.assertEqual(self.group.status, GroupStatus.ACTIVE.value)
def test_create_past_pickup_date_fails(self):
self.client.force_login(user=self.member)
response = self.client.post(self.url,
self.past_pickup_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
def test_create_pickup_as_newcomer_fails(self):
newcomer = UserFactory()
self.group.groupmembership_set.create(user=newcomer)
self.client.force_login(user=newcomer)
response = self.client.post(self.url, self.pickup_data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_list_pickups(self):
response = self.get_results(self.url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_list_pickups_as_user(self):
self.client.force_login(user=self.user)
response = self.get_results(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(len(response.data), 0)
def test_list_pickups_as_group_member(self):
self.client.force_login(user=self.member)
response = self.get_results(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(len(response.data), 2)
def test_retrieve_pickups(self):
response = self.client.get(self.pickup_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_retrieve_pickups_as_user(self):
self.client.force_login(user=self.user)
response = self.client.get(self.pickup_url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND,
response.data)
def test_retrieve_pickups_as_group_member(self):
self.client.force_login(user=self.member)
response = self.client.get(self.pickup_url)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
def test_patch_pickup(self):
response = self.client.patch(self.pickup_url,
self.pickup_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_patch_pickup_as_user(self):
self.client.force_login(user=self.user)
response = self.client.patch(self.pickup_url,
self.pickup_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND,
response.data)
def test_patch_pickup_as_group_member(self):
self.client.force_login(user=self.member)
response = self.client.patch(self.pickup_url,
self.pickup_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
def test_patch_pickup_as_group_member_activates_group(self):
self.client.force_login(user=self.member)
self.group.status = GroupStatus.INACTIVE.value
self.group.save()
self.client.patch(self.pickup_url, self.pickup_data, format='json')
self.group.refresh_from_db()
self.assertEqual(self.group.status, GroupStatus.ACTIVE.value)
def test_patch_max_collectors_to_negative_value_fails(self):
self.client.force_login(user=self.member)
response = self.client.patch(self.pickup_url, {'max_collectors': -1})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
def test_patch_past_pickup_fails(self):
self.client.force_login(user=self.member)
response = self.client.patch(self.past_pickup_url,
self.pickup_data,
format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_patch_as_newcomer_fails(self):
newcomer = UserFactory()
self.group.groupmembership_set.create(user=newcomer)
self.client.force_login(user=newcomer)
response = self.client.patch(self.pickup_url, {'max_collectors': 1},
format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_join_pickup(self):
response = self.client.post(self.join_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_join_pickup_as_user(self):
self.client.force_login(user=self.user)
response = self.client.post(self.join_url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND,
response.data)
def test_join_pickup_as_member(self):
self.client.force_login(user=self.member)
response = self.client.post(self.join_url)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
# should have access to chat
response = self.client.get(self.conversation_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_join_pickup_order_by_sign_up(self):
self.client.force_login(user=self.second_member)
response = self.client.post(self.join_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.client.force_login(user=self.member)
response = self.client.post(self.join_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
collector_order = [self.second_member.id, self.member.id]
response = self.client.get(self.pickup_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['collectors'], collector_order)
response = self.get_results(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
pickup = next(p for p in response.data if p['id'] == self.pickup.id)
self.assertEqual(pickup['collectors'], collector_order)
# reverse order
collector = self.pickup.pickupdatecollector_set.earliest('created_at')
collector.created_at = timezone.now()
collector.save()
collector_order = [self.member.id, self.second_member.id]
response = self.client.get(self.pickup_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['collectors'], collector_order)
response = self.get_results(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
pickup = next(p for p in response.data if p['id'] == self.pickup.id)
self.assertEqual(pickup['collectors'], collector_order)
def test_join_pickup_as_newcomer(self):
newcomer = UserFactory()
self.group.groupmembership_set.create(user=newcomer)
self.client.force_login(user=newcomer)
response = self.client.post(self.join_url)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
def test_join_pickup_as_member_activates_group(self):
self.client.force_login(user=self.member)
self.group.status = GroupStatus.INACTIVE.value
self.group.save()
self.client.post(self.join_url)
self.group.refresh_from_db()
self.assertEqual(self.group.status, GroupStatus.ACTIVE.value)
def test_join_pickup_without_max_collectors_as_member(self):
self.client.force_login(user=self.member)
p = PickupDateFactory(max_collectors=None, place=self.place)
response = self.client.post('/api/pickup-dates/{}/add/'.format(p.id))
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
def test_join_full_pickup_fails(self):
self.client.force_login(user=self.member)
self.pickup.max_collectors = 1
self.pickup.save()
u2 = UserFactory()
GroupMembership.objects.create(group=self.group, user=u2)
self.pickup.add_collector(u2)
response = self.client.post(self.join_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
self.assertEqual(response.data['detail'],
'Pickup date is already full.')
def test_join_past_pickup_fails(self):
self.client.force_login(user=self.member)
response = self.client.post(self.past_join_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_leave_pickup(self):
response = self.client.post(self.leave_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_leave_pickup_as_user(self):
self.client.force_login(user=self.user)
response = self.client.post(self.leave_url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND,
response.data)
def test_leave_pickup_as_member(self):
self.client.force_login(user=self.member)
self.pickup.add_collector(self.member)
response = self.client.post(self.leave_url)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
# should be removed from chat
response = self.client.get(self.conversation_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['notifications'],
ConversationNotificationStatus.NONE.value)
def test_leave_pickup_as_newcomer(self):
newcomer = UserFactory()
self.group.groupmembership_set.create(user=newcomer)
self.pickup.add_collector(newcomer)
self.client.force_login(user=newcomer)
response = self.client.post(self.leave_url)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
def test_leave_pickup_activates_group(self):
self.client.force_login(user=self.member)
self.pickup.add_collector(self.member)
self.group.status = GroupStatus.INACTIVE.value
self.group.save()
self.client.post(self.leave_url)
self.group.refresh_from_db()
self.assertEqual(self.group.status, GroupStatus.ACTIVE.value)
def test_leave_past_pickup_fails(self):
self.client.force_login(user=self.member)
self.past_pickup.add_collector(self.member)
response = self.client.post(self.past_leave_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_get_conversation_as_collector(self):
self.client.force_login(user=self.member)
self.pickup.add_collector(self.member)
# can get via pickup
response = self.client.get(self.conversation_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn(self.member.id, response.data['participants'])
self.assertEqual(response.data['type'], 'pickup')
# can get via conversations
conversation_id = self.pickup.conversation.id
response = self.client.get(
'/api/conversations/{}/'.format(conversation_id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
# can write a message
response = self.client.post('/api/messages/', {
'conversation': response.data['id'],
'content': 'hey',
})
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
def test_can_participate_in_conversation_as_noncollector(self):
self.client.force_login(user=self.member)
# can get via pickup
response = self.client.get(self.conversation_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
# can get via conversation
conversation_id = self.pickup.conversation.id
response = self.client.get(
'/api/conversations/{}/'.format(conversation_id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
# can write a message
response = self.client.post('/api/messages/', {
'conversation': response.data['id'],
'content': 'hey',
})
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
def test_cannot_get_conversation_as_nonmember(self):
self.client.force_login(user=self.user)
# cannot get via pickup
response = self.client.get(self.conversation_url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
# cannot get via conversation info
conversation_id = self.pickup.conversation.id
response = self.client.get(
'/api/conversations/{}/'.format(conversation_id))
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
# cannot write a message
conversation_id = self.pickup.conversation.id
response = self.client.post('/api/messages/', {
'conversation': conversation_id,
'content': 'hey',
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
self.assertEqual(response.data['detail'],
'You are not in this conversation')
def test_patch_date(self):
self.client.force_login(user=self.member)
start = timezone.now() + timedelta(hours=1)
end = timezone.now() + timedelta(hours=2)
response = self.client.patch(self.pickup_url, {
'date': [start, end],
},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.pickup.refresh_from_db()
self.assertEqual(self.pickup.date, CustomDateTimeTZRange(start, end))
def test_patch_start_date_only_uses_default_duration(self):
self.client.force_login(user=self.member)
start = timezone.now() + timedelta(hours=1)
response = self.client.patch(self.pickup_url, {
'date': [start],
},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.pickup.refresh_from_db()
self.assertEqual(self.pickup.date.end, start + timedelta(minutes=30))
def test_patch_date_with_single_date_fails(self):
self.client.force_login(user=self.member)
response = self.client.patch(self.pickup_url, {
'date': timezone.now(),
},
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
def test_patch_end_date_only_fails(self):
self.client.force_login(user=self.member)
response = self.client.patch(self.pickup_url, {
'date': [None, timezone.now()],
},
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
def test_cannot_mark_as_done(self):
# This is just temporarily - if we need this feature at some point, we should enable it
# Make sure to create history entries!
self.client.force_login(user=self.member)
self.assertEqual(self.pickup.is_done, False)
response = self.client.patch(self.pickup_url, {'is_done': True},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.pickup.refresh_from_db()
self.assertFalse(self.pickup.is_done, False)
