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.user = VerifiedUserFactory()
self.other_user = VerifiedUserFactory()
self.non_verified_user = UserFactory()
self.group = GroupFactory(
members=[self.user, self.other_user, self.non_verified_user])
self.store = StoreFactory(group=self.group)
self.declined_store = StoreFactory(group=self.group,
status=StoreStatus.DECLINED.value)
# unsubscribe other_user from notifications
GroupMembership.objects.filter(
group=self.group,
user=self.other_user).update(notification_types=[])
# add some random inactive users, to make sure we don't send to them
inactive_users = [
VerifiedUserFactory(language='en')
for _ in list(range(randint(2, 5)))
]
for user in inactive_users:
membership = self.group.add_member(user)
membership.inactive_at = timezone.now()
membership.save()
mail.outbox = []
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)
def setUpClass(cls):
super().setUpClass()
cls.url = '/api/pickup-dates/'
# pickup date for group with one member and one store
cls.member = UserFactory()
cls.group = GroupFactory(members=[
cls.member,
])
cls.store = StoreFactory(group=cls.group)
cls.pickup = PickupDateFactory(store=cls.store)
# and another store + group + pick-update
cls.group2 = GroupFactory(members=[
cls.member,
])
cls.store2 = StoreFactory(group=cls.group2)
cls.pickup2 = PickupDateFactory(store=cls.store2)
# a pickup date series
cls.series = PickupDateSeriesFactory(store=cls.store)
cls.series.update_pickup_dates()
# another pickup date series
cls.series2 = PickupDateSeriesFactory(store=cls.store)
cls.series2.update_pickup_dates()
def setUp(self):
self.now = timezone.now()
self.url = '/api/stores/'
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.store_url = self.url + str(self.store.id) + '/'
self.series = PickupDateSeriesFactory(max_collectors=3, store=self.store)
def setUp(self):
self.url = '/api/stores/'
# two groups one store
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.group2 = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.store2 = StoreFactory(group=self.group2)
class TestPickupDateSeriesModel(TestCase):
def setUp(self):
self.store = StoreFactory()
def test_create_all_pickup_dates_inactive_stores(self):
self.store.status = StoreStatus.ARCHIVED.value
self.store.save()
start_date = self.store.group.timezone.localize(datetime.now().replace(2017, 3, 18, 15, 0, 0, 0))
PickupDateSeriesFactory(store=self.store, start_date=start_date)
PickupDate.objects.all().delete()
PickupDateSeries.objects.update_pickups()
self.assertEqual(PickupDate.objects.count(), 0)
def test_daylight_saving_time_to_summer(self):
start_date = self.store.group.timezone.localize(datetime.now().replace(2017, 3, 18, 15, 0, 0, 0))
before_dst_switch = timezone.now().replace(2017, 3, 18, 4, 40, 13)
with freeze_time(before_dst_switch, tick=True):
series = PickupDateSeriesFactory(store=self.store, start_date=start_date)
expected_dates = []
for month, day in [(3, 18), (3, 25), (4, 1), (4, 8)]:
expected_dates.append(self.store.group.timezone.localize(datetime(2017, month, day, 15, 0)))
for actual_date, expected_date in zip(PickupDate.objects.filter(series=series), expected_dates):
self.assertEqual(actual_date.date, expected_date)
def test_daylight_saving_time_to_winter(self):
start_date = self.store.group.timezone.localize(datetime.now().replace(2016, 10, 22, 15, 0, 0, 0))
before_dst_switch = timezone.now().replace(2016, 10, 22, 4, 40, 13)
with freeze_time(before_dst_switch, tick=True):
series = PickupDateSeriesFactory(store=self.store, start_date=start_date)
expected_dates = []
for month, day in [(10, 22), (10, 29), (11, 5), (11, 12)]:
expected_dates.append(self.store.group.timezone.localize(datetime(2016, month, day, 15, 0)))
for actual_date, expected_date in zip(PickupDate.objects.filter(series=series), expected_dates):
self.assertEqual(actual_date.date, expected_date)
def test_delete(self):
now = timezone.now()
two_weeks_ago = now - relativedelta(weeks=2)
with freeze_time(two_weeks_ago, tick=True):
series = PickupDateSeriesFactory(store=self.store, start_date=two_weeks_ago)
pickup_dates = series.pickup_dates.all()
past_date_count = pickup_dates.filter(date__lt=now).count()
self.assertGreater(pickup_dates.count(), 2)
series.delete()
upcoming_pickups = PickupDate.objects.filter(date__gte=now, is_disabled=False)
self.assertEqual(upcoming_pickups.count(), 0, upcoming_pickups)
self.assertEqual(PickupDate.objects.filter(date__lt=now).count(), past_date_count)
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 setUp(self):
self.url = '/api/pickup-dates/'
self.oneWeekAgo = timezone.now() - relativedelta(weeks=1)
self.tooLongAgo = timezone.now() - relativedelta(
days=settings.FEEDBACK_POSSIBLE_DAYS + 1)
self.member = UserFactory()
self.member2 = UserFactory()
self.group = GroupFactory(members=[self.member, self.member2])
self.store = StoreFactory(group=self.group)
# not member (anymore)
self.group2 = GroupFactory(members=[])
self.store2 = StoreFactory(group=self.group2)
self.pickupFeedbackPossible = PickupDateFactory(store=self.store,
collectors=[
self.member,
],
date=self.oneWeekAgo)
# now the cases where no feedback can be given
self.pickupUpcoming = PickupDateFactory(store=self.store,
collectors=[
self.member,
])
self.pickupNotCollector = PickupDateFactory(store=self.store,
date=self.oneWeekAgo)
self.pickupTooLongAgo = PickupDateFactory(store=self.store,
date=self.tooLongAgo)
self.pickupFeedbackAlreadyGiven = PickupDateFactory(
store=self.store, collectors=[
self.member,
], date=self.oneWeekAgo)
self.feedback = FeedbackFactory(about=self.pickupFeedbackAlreadyGiven,
given_by=self.member)
self.pickupCollectorLeftGroup = PickupDateFactory(store=self.store2,
collectors=[
self.member,
],
date=self.oneWeekAgo)
self.pickupDoneByAnotherUser = PickupDateFactory(store=self.store,
collectors=[
self.member2,
],
date=self.oneWeekAgo)
PickupDateModel.objects.process_finished_pickup_dates()
def setUpClass(cls):
super().setUpClass()
cls.url = '/api/stores/'
# two groups one store
cls.member = UserFactory()
cls.group = GroupFactory(members=[
cls.member,
])
cls.group2 = GroupFactory(members=[
cls.member,
])
cls.store = StoreFactory(group=cls.group)
cls.store2 = StoreFactory(group=cls.group2)
def test_set_invalid_store_fails(self):
unrelated_store = StoreFactory()
self.client.force_login(user=self.member)
url = '/api/pickup-date-series/{}/'.format(self.series.id)
response = self.client.patch(url, {'store': unrelated_store.id})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
def setUp(self):
self.now = timezone.now()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
self.series = PickupDateSeriesFactory(max_collectors=3, store=self.store)
self.series.update_pickup_dates(start=lambda: self.now)
def setUpClass(cls):
super().setUpClass()
cls.url = '/api/stores/'
# group with two members and one store
cls.member = UserFactory()
cls.member2 = UserFactory()
cls.group = GroupFactory(members=[cls.member, cls.member2])
cls.store = StoreFactory(group=cls.group)
cls.store_url = cls.url + str(cls.store.id) + '/'
# not a member
cls.user = UserFactory()
# another store for above group
cls.store_data = {
'name': faker.name(),
'description': faker.name(),
'group': cls.group.id,
'address': faker.address(),
'latitude': faker.latitude(),
'longitude': faker.longitude()
}
# another group
cls.different_group = GroupFactory(members=[
cls.member2,
])
def setUpTestData(cls):
cls.member = UserFactory()
cls.group = GroupFactory(members=[
cls.member,
])
cls.store = StoreFactory(group=cls.group)
cls.store_url = '/api/stores/{}/'.format(cls.store.id)
def setUpClass(cls):
super().setUpClass()
cls.url = '/api/pickup-dates/'
# pickup date for group with one member and one store
cls.member = UserFactory()
cls.group = GroupFactory(members=[cls.member, ])
cls.store = StoreFactory(group=cls.group)
cls.pickup = PickupDateFactory(store=cls.store)
cls.pickup_url = cls.url + str(cls.pickup.id) + '/'
cls.join_url = cls.pickup_url + 'add/'
cls.leave_url = cls.pickup_url + 'remove/'
# not a member of the group
cls.user = UserFactory()
# another pickup date for above store
cls.pickup_data = {'date': timezone.now() + relativedelta(days=2),
'max_collectors': 5,
'store': cls.store.id}
# past pickup date
cls.past_pickup_data = {'date': timezone.now() - relativedelta(days=1),
'max_collectors': 5,
'store': cls.store.id}
cls.past_pickup = PickupDateFactory(store=cls.store, date=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.member = UserFactory()
self.group = GroupFactory(members=[
self.member,
])
self.store = StoreFactory(group=self.group)
self.store_url = '/api/stores/{}/'.format(self.store.id)
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
PickupDate.objects.process_finished_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])
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 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.member = UserFactory()
self.group = GroupFactory(members=[
self.member,
])
self.store = StoreFactory(group=self.group)
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 setUp(self):
self.url = '/api/stores/'
# group with two members and one store
self.member = UserFactory()
self.member2 = UserFactory()
self.group = GroupFactory(members=[self.member, self.member2])
self.store = StoreFactory(group=self.group)
self.store_url = self.url + str(self.store.id) + '/'
# not a member
self.user = UserFactory()
# another store for above group
self.store_data = {
'name': faker.name(),
'description': faker.name(),
'group': self.group.id,
'address': faker.address(),
'latitude': faker.latitude(),
'longitude': faker.longitude()
}
# another group
self.different_group = GroupFactory(members=[self.member2])
def setUpClass(cls):
super().setUpClass()
cls.member = UserFactory()
cls.group = GroupFactory(members=[
cls.member,
])
cls.store = StoreFactory(group=cls.group)
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,
],
)
unrelated_pickupdate.store.group.members.add(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 setUp(self):
self.user = VerifiedUserFactory()
self.other_user = VerifiedUserFactory()
self.non_verified_user = UserFactory()
self.group = GroupFactory(
members=[self.user, self.other_user, self.non_verified_user])
self.store = StoreFactory(group=self.group)
self.declined_store = StoreFactory(group=self.group,
status=StoreStatus.DECLINED.value)
# unsubscribe other_user from notifications
GroupMembership.objects.filter(
group=self.group,
user=self.other_user).update(notification_types=[])
mail.outbox = []
def test_set_invalid_store_fails(self):
unrelated_store = StoreFactory()
self.client.force_login(user=self.member)
url = '/api/pickup-date-series/{}/'.format(self.series.id)
response = self.client.patch(url, {'store': unrelated_store.id})
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 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 setUpTestData(cls):
cls.member = UserFactory()
cls.group = GroupFactory(members=[cls.member, ])
cls.store = StoreFactory(group=cls.group)
cls.pickup = PickupDateFactory(store=cls.store)
cls.pickup_url = '/api/pickup-dates/{}/'.format(cls.pickup.id)
cls.series = PickupDateSeriesFactory(store=cls.store)
cls.series_url = '/api/pickup-date-series/{}/'.format(cls.series.id)
