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))
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)
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 test_creates_feedback_possible_notification(self):
member = UserFactory()
group = GroupFactory(members=[member])
store = StoreFactory(group=group)
pickup = PickupDateFactory(store=store)
pickup.add_collector(member)
pickup.done_and_processed = 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 + relativedelta(days=settings.FEEDBACK_POSSIBLE_DAYS)
)
def test_creates_pickup_moved_notification(self):
user1, user2 = UserFactory(), UserFactory()
group = GroupFactory(members=[user1, user2])
store = StoreFactory(group=group)
pickup = PickupDateFactory(store=store, 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['store'], store.id)
def test_creates_pickup_enabled_notification(self):
user1, user2 = UserFactory(), UserFactory()
group = GroupFactory(members=[user1, user2])
store = StoreFactory(group=group)
pickup = PickupDateFactory(store=store, 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['store'], store.id)
class FinishedPickupReceiverTest(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, collectors=[self.member])
def test_receive_history_and_notification(self):
self.pickup.date = 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_creates_pickup_disabled_notification_and_deletes_pickup_upcoming_notification(self):
user1, user2 = UserFactory(), UserFactory()
group = GroupFactory(members=[user1, user2])
store = StoreFactory(group=group)
in_one_hour = timezone.now() + relativedelta(hours=1)
pickup = PickupDateFactory(store=store, 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['store'], store.id)
class FinishedPickupReceiverTest(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, collectors=[self.member])
def test_receive_feedback_possible_and_history(self):
self.pickup.date = timezone.now() - relativedelta(days=1)
self.pickup.save()
self.client = self.connect_as(self.member)
PickupDate.objects.process_finished_pickup_dates()
response = self.client.messages[0]
self.assertEqual(response['topic'], 'history:history')
self.assertEqual(response['payload']['typus'], 'PICKUP_DONE')
response = self.client.messages[1]
self.assertEqual(response['topic'], 'pickups:feedback_possible')
self.assertEqual(response['payload']['id'], self.pickup.id)
self.assertEqual(len(self.client.messages), 2)
class TestPickupDatesAPI(APITestCase, ExtractPaginationMixin):
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 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_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, store=self.store)
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_403_FORBIDDEN)
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_not_as_collector(self):
self.client.force_login(user=self.member)
response = self.client.get(self.conversation_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response.data['detail'], 'You are not in this conversation')
def test_get_conversation_as_collector(self):
self.client.force_login(user=self.member)
self.pickup.add_collector(self.member)
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')
class TestPickupDatesAPI(APITestCase, ExtractPaginationMixin):
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/'
# 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 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_400_BAD_REQUEST,
response.data)
self.assertEqual(
response.data,
{'store': ['You are not member of the store\'s group.']})
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_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_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_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_delete_pickup(self):
response = self.client.delete(self.pickup_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
def test_delete_pickup_as_user(self):
self.client.force_login(user=self.user)
response = self.client.delete(self.pickup_url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND,
response.data)
def test_delete_pickup_as_group_member(self):
self.client.force_login(user=self.member)
response = self.client.delete(self.pickup_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT,
response.data)
def test_delete_past_pickup_fails(self):
self.client.force_login(user=self.member)
response = self.client.delete(self.past_pickup_url)
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)
def test_join_pickup_without_max_collectors_as_member(self):
self.client.force_login(user=self.member)
p = PickupDateFactory(max_collectors=None, store=self.store)
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.collectors.add(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.collectors.add(self.member)
response = self.client.post(self.leave_url)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
def test_leave_past_pickup_fails(self):
self.client.force_login(user=self.member)
self.past_pickup.collectors.add(self.member)
response = self.client.post(self.past_leave_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
class TestHistoryAPIWithExistingPickups(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)
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)
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})
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']), self.pickup.date)
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']), self.pickup.date)
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')