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)
class StoreReceiverTests(WSTestCase):
def setUp(self):
super().setUp()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
def test_receive_store_changes(self):
self.client = self.connect_as(self.member)
name = faker.name()
self.store.name = name
self.store.save()
response = self.client.messages_by_topic.get('stores:store')[0]
self.assertEqual(response['payload']['name'], name)
self.assertEqual(len(self.client.messages), 1)
class StoreReceiverTests(ChannelTestCase):
def setUp(self):
self.client = WSClient()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
def test_receive_store_changes(self):
self.client.force_login(self.member)
self.client.send_and_consume('websocket.connect', path='/')
name = faker.name()
self.store.name = name
self.store.save()
response = self.client.receive(json=True)
self.assertEqual(response['topic'], 'stores:store')
self.assertEqual(response['payload']['name'], name)
self.assertIsNone(self.client.receive(json=True))
class TestStoreChangesPickupDateSeriesAPI(APITestCase, ExtractPaginationMixin):
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)
self.series.update_pickup_dates(start=lambda: self.now)
def test_reduce_weeks_in_advance(self):
self.client.force_login(user=self.member)
url = '/api/pickup-dates/'
response = self.get_results(url, {
'series': self.series.id,
'date_min': self.now
})
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
response = self.client.patch(self.store_url, {'weeks_in_advance': 2})
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(response.data['weeks_in_advance'], 2)
url = '/api/pickup-dates/'
response = self.get_results(url, {'series': self.series.id})
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
for _ in response.data:
self.assertLessEqual(parse(_['date']),
self.now + relativedelta(weeks=2, hours=1))
def test_increase_weeks_in_advance(self):
self.client.force_login(user=self.member)
url = '/api/pickup-dates/'
response = self.get_results(url, {
'series': self.series.id,
'date_min': self.now
})
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
original_dates = [parse(_['date']) for _ in response.data]
response = self.client.patch(self.store_url, {'weeks_in_advance': 10})
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(response.data['weeks_in_advance'], 10)
url = '/api/pickup-dates/'
response = self.get_results(url, {'series': self.series.id})
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertGreater(len(response.data), len(original_dates))
for return_date in response.data:
self.assertLessEqual(parse(return_date['date']),
self.now + relativedelta(weeks=10))
def test_set_weeks_to_invalid_value(self):
self.client.force_login(user=self.member)
response = self.client.patch(self.store_url, {'weeks_in_advance': 0})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
def test_set_store_active_status_updates_pickup_dates(self):
self.store.status = StoreStatus.ARCHIVED.value
self.store.save()
self.store.pickup_dates.all().delete()
self.client.force_login(user=self.member)
response = self.client.patch(self.store_url,
{'status': StoreStatus.ACTIVE.value},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertGreater(self.store.pickup_dates.count(), 0)
class TestPickupDateSeriesModel(TestCase):
def setUp(self):
self.store = StoreFactory()
self.recurrence = rrule.rrule(freq=rrule.WEEKLY, )
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))
series = PickupDateSeries(store=self.store,
rule=str(self.recurrence),
start_date=start_date)
series.save()
PickupDate.objects.all().delete()
PickupDateSeries.objects.create_all_pickup_dates()
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))
series = PickupDateSeries(store=self.store,
rule=str(self.recurrence),
start_date=start_date)
series.save()
series.update_pickup_dates(
start=lambda: timezone.now().replace(2017, 3, 18, 4, 40, 13))
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))
series = PickupDateSeries(store=self.store,
rule=str(self.recurrence),
start_date=start_date)
series.save()
series.update_pickup_dates(
start=lambda: timezone.now().replace(2016, 10, 22, 4, 40, 13))
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)
series = PickupDateSeries(store=self.store,
rule=str(self.recurrence),
start_date=two_weeks_ago)
series.save()
series.update_pickup_dates(start=lambda: 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()
self.assertEqual(
PickupDate.objects.filter(date__gte=now, deleted=False).count(), 0)
self.assertEqual(
PickupDate.objects.filter(date__lt=now).count(), past_date_count)
