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.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 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 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.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/'
# 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.member = UserFactory()
self.member2 = UserFactory()
self.newcomer = UserFactory()
self.group = GroupFactory(members=[self.member, self.member2],
newcomers=[self.newcomer])
self.group2 = GroupFactory(members=[self.member])
# effectively disable throttling
from karrot.invitations.api import InvitesPerDayThrottle
InvitesPerDayThrottle.rate = '1000/min'
def test_do_not_remove_trust_in_other_groups(self):
editor = UserFactory()
newcomer = UserFactory()
group = GroupFactory(members=[editor], newcomers=[newcomer])
membership = GroupMembership.objects.get(user=newcomer, group=group)
other_group = GroupFactory(members=[editor])
Trust.objects.create(membership=membership, given_by=editor)
other_group.remove_member(editor)
self.assertEqual(1, Trust.objects.filter(membership=membership).count())
def setUp(self):
self.url = '/api/groups-info/'
# some user
self.user = UserFactory()
# two groups with different members
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.member2 = UserFactory()
self.group2 = GroupFactory(members=[self.member2])
self.empty_group = GroupFactory()
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 setUp(self):
self.normal_member = UserFactory()
self.agreement_manager = UserFactory()
self.group = GroupFactory(members=[self.normal_member, self.agreement_manager])
self.agreement = Agreement.objects.create(group=self.group, title=faker.text(), content=faker.text())
membership = GroupMembership.objects.get(group=self.group, user=self.agreement_manager)
membership.roles.append(roles.GROUP_AGREEMENT_MANAGER)
membership.save()
# other group/agreement that neither user is part of
self.other_group = GroupFactory()
self.other_agreement = Agreement.objects.create(
group=self.other_group, title=faker.text(), content=faker.text()
)
def test_groups_marked_inactive(self):
recent_treshold = timezone.now() - timedelta(
days=settings.NUMBER_OF_DAYS_UNTIL_GROUP_INACTIVE)
group_without_recent_activity = GroupFactory(
last_active_at=recent_treshold - timedelta(days=3))
group_with_recent_activity = GroupFactory(
last_active_at=recent_treshold + timedelta(days=3))
mark_inactive_groups()
group_without_recent_activity.refresh_from_db()
group_with_recent_activity.refresh_from_db()
self.assertEqual(group_without_recent_activity.status,
GroupStatus.INACTIVE.value)
self.assertEqual(group_with_recent_activity.status,
GroupStatus.ACTIVE.value)
def setUp(self):
self.user = UserFactory()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member], is_open=True)
self.group_with_password = GroupFactory(password='******', is_open=True)
self.join_password_url = '/api/groups/{}/join/'.format(self.group_with_password.id)
self.url = '/api/groups/'
self.group_data = {
'name': faker.name(),
'description': faker.text(),
'address': faker.address(),
'latitude': faker.latitude(),
'longitude': faker.longitude(),
'timezone': 'Europe/Berlin'
}
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 test_no_summary_email_if_no_activity_in_group(self, write_points):
group = GroupFactory(members=[VerifiedUserFactory()])
with freeze_time(
datetime.datetime(2018, 8, 19, 6, 0, 0, tzinfo=pytz.utc)):
write_points.reset_mock()
mail.outbox = []
send_summary_emails()
self.assertEqual(len(mail.outbox), 0)
write_points.assert_called_with([{
'measurement': 'karrot.email.group_summary',
'tags': {
'group': str(group.id),
'group_status': 'active',
},
'fields': {
'value': 1,
'new_user_count': 0,
'email_recipient_count': 0,
'feedback_count': 0,
'activities_missed_count': 0,
'message_count': 0,
'activities_done_count': 0,
'has_activity': False,
},
}])
def setUp(self):
self.user = VerifiedUserFactory()
self.author = VerifiedUserFactory()
self.group = GroupFactory(members=[self.author, self.user])
mail.outbox = []
with suppressed_notifications():
self.message = self.group.conversation.messages.create(author=self.author, content='initial message')
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 setUp(self):
self.user = VerifiedUserFactory()
self.user2 = VerifiedUserFactory()
self.group = GroupFactory(members=[self.user, self.user2])
self.conversation = self.group.conversation
self.thread = self.conversation.messages.create(author=self.user,
content='yay')
def test_clicked(self, write_points):
user = UserFactory()
group = GroupFactory(members=[user])
two_hours_ago = timezone.now() - relativedelta(hours=2)
notification = Notification.objects.create(
created_at=two_hours_ago,
user=user,
type=NotificationType.USER_BECAME_EDITOR.value,
context={'group': group.id},
)
write_points.reset_mock()
notification.clicked = True
notification.save()
write_points.assert_called_with([{
'measurement': 'karrot.events',
'tags': {
'group': str(group.id),
'group_status': group.status,
'notification_type': NotificationType.USER_BECAME_EDITOR.value,
},
'fields': {
'notification_clicked': 1,
'notification_clicked_seconds': 60 * 60 * 2,
},
}])
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 test_application_message_title(self):
author = UserFactory()
group = GroupFactory(members=[author])
applicant = UserFactory()
application = ApplicationFactory(group=group, user=applicant)
conversation = Conversation.objects.get_or_create_for_target(application)
message = conversation.messages.create(author=author, content='bla')
title = get_message_title(message, 'en')
self.assertEqual(title, '❓ {} / {}'.format(applicant.display_name, author.display_name))
application.accept(author)
message.refresh_from_db()
title = get_message_title(message, 'en')
self.assertEqual(title, '✅ {} / {}'.format(applicant.display_name, author.display_name))
application.decline(author)
message.refresh_from_db()
title = get_message_title(message, 'en')
self.assertEqual(title, '❌ {} / {}'.format(applicant.display_name, author.display_name))
application.withdraw()
message.refresh_from_db()
title = get_message_title(message, 'en')
self.assertEqual(title, '🗑️ {} / {}'.format(applicant.display_name, author.display_name))
message = conversation.messages.create(author=applicant, content='bla')
message.refresh_from_db()
title = get_message_title(message, 'en')
self.assertEqual(title, '🗑️ {}'.format(applicant.display_name))
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.user = UserFactory()
self.another_user = UserFactory()
self.group = GroupFactory(members=[self.user, self.another_user])
self.offer = OfferFactory(user=self.user,
group=self.group,
images=[image_path])
def setUp(self):
self.applicant = VerifiedUserFactory()
self.member = VerifiedUserFactory()
self.group = GroupFactory(members=[self.member])
self.application = ApplicationFactory(group=self.group, user=self.applicant)
self.conversation = Conversation.objects.get_for_target(self.application)
mail.outbox = []
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 create_group_with_members(self, member_count):
self.members = [UserFactory() for _ in range(member_count)]
self.group = GroupFactory(members=self.members)
# trust threshold calculation ignores recently joined users, so we need to create users before that
two_days_ago = timezone.now() - relativedelta(days=2)
GroupMembership.objects.filter(group=self.group).update(
created_at=two_days_ago)
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_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.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)
