def setUp(self):
self.user = UserFactory()
self.other_user = UserFactory()
self.group = GroupFactory(members=[self.user, self.other_user])
self.other_group = GroupFactory(members=[self.user, self.other_user])
self.place = PlaceFactory(group=self.group)
self.other_place = PlaceFactory(group=self.other_group)
def setUp(self):
self.url = '/api/activities/'
# activity for group with one member and one place
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.place = PlaceFactory(group=self.group)
self.activity_type = ActivityTypeFactory(group=self.group)
self.activity = ActivityFactory(activity_type=self.activity_type,
place=self.place)
# and another place + group + activity
self.group2 = GroupFactory(members=[self.member])
self.place2 = PlaceFactory(group=self.group2)
self.activity_type2 = ActivityTypeFactory(group=self.group2)
self.activity2 = ActivityFactory(activity_type=self.activity_type2,
place=self.place2)
# an activity series
self.series = ActivitySeriesFactory(activity_type=self.activity_type,
place=self.place)
# another activity series
self.series2 = ActivitySeriesFactory(activity_type=self.activity_type,
place=self.place)
def setUpTestData(cls):
cls.user = VerifiedUserFactory()
cls.other_user = VerifiedUserFactory()
cls.non_verified_user = UserFactory()
cls.group = GroupFactory(
members=[cls.user, cls.other_user, cls.non_verified_user])
cls.place = PlaceFactory(
group=cls.group,
subscribers=[cls.user, cls.other_user, cls.non_verified_user])
cls.declined_place = PlaceFactory(group=cls.group,
status=PlaceStatus.DECLINED.value)
# unsubscribe other_user from notifications
GroupMembership.objects.filter(
group=cls.group, user=cls.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 = cls.group.add_member(user)
membership.inactive_at = timezone.now()
membership.save()
def setUp(self):
self.now = timezone.now()
self.url = '/api/places/'
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.place = PlaceFactory(group=self.group)
self.place_url = self.url + str(self.place.id) + '/'
self.series = PickupDateSeriesFactory(max_collectors=3, place=self.place)
def setUp(self):
self.url = '/api/places/'
# two groups one place
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.group2 = GroupFactory(members=[self.member])
self.place = PlaceFactory(group=self.group)
self.place2 = PlaceFactory(group=self.group2)
def setUp(self):
self.now = timezone.now()
self.url = '/api/places/'
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.place = PlaceFactory(group=self.group)
self.place_url = self.url + str(self.place.id) + '/'
self.series = ActivitySeriesFactory(max_participants=3,
place=self.place)
class TestPickupDateSeriesModel(TestCase):
def setUp(self):
self.place = PlaceFactory()
def test_create_all_pickup_dates_inactive_places(self):
self.place.status = PlaceStatus.ARCHIVED.value
self.place.save()
start_date = self.place.group.timezone.localize(datetime.now().replace(2017, 3, 18, 15, 0, 0, 0))
PickupDateSeriesFactory(place=self.place, 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.place.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(place=self.place, start_date=start_date)
expected_dates = []
for month, day in [(3, 18), (3, 25), (4, 1), (4, 8)]:
expected_dates.append(self.place.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.start, expected_date)
def test_daylight_saving_time_to_winter(self):
start_date = self.place.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(place=self.place, start_date=start_date)
expected_dates = []
for month, day in [(10, 22), (10, 29), (11, 5), (11, 12)]:
expected_dates.append(self.place.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.start, 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(place=self.place, start_date=two_weeks_ago)
pickup_dates = series.pickup_dates.all()
past_date_count = pickup_dates.filter(date__startswith__lt=now).count()
self.assertGreater(pickup_dates.count(), 2)
series.delete()
upcoming_pickups = PickupDate.objects.filter(date__startswith__gte=now, is_disabled=False)
self.assertEqual(upcoming_pickups.count(), 0, upcoming_pickups)
self.assertEqual(PickupDate.objects.filter(date__startswith__lt=now).count(), past_date_count)
def setUp(self):
self.url = '/api/pickup-dates/'
# pickup date for group with one member and one place
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.active_place = PlaceFactory(group=self.group, status='active')
self.inactive_place = PlaceFactory(group=self.group, status='created')
PickupDateFactory(place=self.active_place)
PickupDateFactory(place=self.inactive_place)
def setUp(self):
self.url = '/api/activities/'
# activity for group with one member and one place
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.activity_type = ActivityTypeFactory(group=self.group)
self.active_place = PlaceFactory(group=self.group, status='active')
self.inactive_place = PlaceFactory(group=self.group, status='created')
ActivityFactory(activity_type=self.activity_type, place=self.active_place)
ActivityFactory(activity_type=self.activity_type, place=self.inactive_place)
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 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 setUp(self):
self.now = timezone.now()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.place = PlaceFactory(group=self.group)
self.series = PickupDateSeriesFactory(max_collectors=3,
place=self.place)
def setUp(self):
super().setUp()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.place = PlaceFactory(group=self.group)
self.activity = ActivityFactory(place=self.place,
participants=[self.member])
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_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_creates_activity_disabled_notification_and_deletes_activity_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))
activity = ActivityFactory(place=place,
date=in_one_hour,
participants=[user1, user2])
Notification.objects.all().delete()
create_activity_upcoming_notifications.call_local()
activity.last_changed_by = user2
activity.is_disabled = True
activity.save()
activity_upcoming_notifications = Notification.objects.filter(
type=NotificationType.ACTIVITY_UPCOMING.value)
self.assertEqual(activity_upcoming_notifications.count(), 0)
activity_disabled_notifications = Notification.objects.filter(
type=NotificationType.ACTIVITY_DISABLED.value)
self.assertEqual(activity_disabled_notifications.count(), 1)
self.assertEqual(activity_disabled_notifications[0].user, user1)
context = activity_disabled_notifications[0].context
self.assertEqual(context['group'], group.id)
self.assertEqual(context['activity'], activity.id)
self.assertEqual(context['place'], place.id)
def setUpTestData(cls):
cls.url = '/api/places/'
# group with two members and one place
cls.member = UserFactory()
cls.member2 = UserFactory()
cls.group = GroupFactory(members=[cls.member, cls.member2])
cls.place = PlaceFactory(group=cls.group)
cls.place_url = cls.url + str(cls.place.id) + '/'
# not a member
cls.user = UserFactory()
# another place for above group
cls.place_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 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 setUp(self):
self.maxDiff = None
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.place = PlaceFactory(group=self.group)
self.activity_type = ActivityTypeFactory(group=self.group)
self.archived_activity_type = ActivityTypeFactory(group=self.group, status='archived')
def setUp(self):
self.now = timezone.now()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.place = PlaceFactory(group=self.group)
self.series = ActivitySeriesFactory(max_participants=3,
place=self.place)
def test_create_activity_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))
activity1 = ActivityFactory(place=place, date=in_one_hour, participants=users)
in_two_hours = to_range(timezone.now() + relativedelta(hours=1))
ActivityFactory(place=place, date=in_two_hours, participants=users)
Notification.objects.all().delete()
create_activity_upcoming_notifications.call_local()
notifications = Notification.objects.filter(type=NotificationType.ACTIVITY_UPCOMING.value)
self.assertEqual(notifications.count(), 6)
self.assertEqual(set(n.user.id for n in notifications), set(user.id for user in users))
activity1_user1_participant = ActivityParticipant.objects.get(user=users[0], activity=activity1)
activity1_user1_notification = next(
n for n in notifications if n.context['activity_participant'] == activity1_user1_participant.id
)
self.assertEqual(
activity1_user1_notification.context, {
'group': group.id,
'place': place.id,
'activity': activity1.id,
'activity_participant': activity1_user1_participant.id,
}
)
self.assertEqual(activity1_user1_notification.expires_at, activity1.date.start)
def setUp(self):
self.user = UserFactory()
self.url = '/api/unsubscribe/{}/'
self.user = UserFactory()
self.group = GroupFactory(members=[self.user])
self.place = PlaceFactory(group=self.group)
self.other_group = GroupFactory(members=[self.user])
def setUp(self):
self.url = '/api/places/'
# group with two members and one place
self.member = UserFactory()
self.member2 = UserFactory()
self.group = GroupFactory(members=[self.member, self.member2])
self.place = PlaceFactory(group=self.group)
self.place_url = self.url + str(self.place.id) + '/'
# not a member
self.user = UserFactory()
# another place for above group
self.place_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 test_list_conversations_with_related_data_efficiently(self):
user = UserFactory()
group = GroupFactory(members=[user])
place = PlaceFactory(group=group)
pickup = PickupDateFactory(place=place)
application = ApplicationFactory(user=UserFactory(), group=group)
issue = IssueFactory(group=group)
conversations = [
t.conversation for t in (group, pickup, application, issue)
]
[c.sync_users([user]) for c in conversations]
[c.messages.create(content='hey', author=user) for c in conversations]
ConversationMeta.objects.get_or_create(user=user)
self.client.force_login(user=user)
with self.assertNumQueries(13):
response = self.client.get('/api/conversations/',
{'group': group.id},
format='json')
results = response.data['results']
self.assertEqual(len(results['conversations']), len(conversations))
self.assertEqual(results['pickups'][0]['id'], pickup.id)
self.assertEqual(results['applications'][0]['id'], application.id)
self.assertEqual(results['issues'][0]['id'], issue.id)
def make_activity_in_group(self, group):
place = PlaceFactory(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 activities
[
ActivityFactory(place=place)
for _ in range(self.activities_missed_count)
]
# fullfilled activities
activities = [
ActivityFactory(place=place,
max_participants=1,
participants=[user])
for _ in range(self.activities_done_count)
]
# activity feedback
[
FeedbackFactory(about=activity, given_by=user)
for activity in activities[:self.feedback_count]
]
def setUp(self):
self.user = VerifiedUserFactory()
self.group = GroupFactory(members=[self.user])
self.place = PlaceFactory(group=self.group)
self.pickup = PickupDateFactory(place=self.place,
collectors=[self.user])
self.conversation = self.pickup.conversation
def setUp(self):
self.user = VerifiedUserFactory()
self.user2 = VerifiedUserFactory()
self.group = GroupFactory(members=[self.user, self.user2])
self.place = PlaceFactory(subscribers=[self.user, self.user2])
self.conversation = self.place.conversation
mail.outbox = []
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 setUp(self):
self.first_member = UserFactory()
self.second_member = UserFactory()
self.group = GroupFactory(
members=[self.first_member, self.second_member])
self.place = PlaceFactory(group=self.group)
self.pickup = PickupDateFactory(place=self.place,
collectors=[self.first_member])
def test_place_message_title(self):
author = UserFactory()
place = PlaceFactory()
conversation = Conversation.objects.get_or_create_for_target(place)
message = conversation.messages.create(author=author, content='bla')
title = get_message_title(message, 'en')
self.assertEqual(title, '{} / {}'.format(place.name, author.display_name))
