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 test_group_message_title(self):
author = UserFactory()
group = GroupFactory(members=[author])
conversation = Conversation.objects.get_or_create_for_target(group)
message = conversation.messages.create(author=author, content='bla')
title = get_message_title(message, 'en')
self.assertEqual(title, '{} / {}'.format(group.name,
author.display_name))
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))
def test_leave_group(self):
user = UserFactory()
GroupMembership.objects.create(group=self.group, user=user)
self.client.force_login(user)
self.client.post(self.group_url + 'leave/')
self.client.force_login(self.member)
response = self.get_results(history_url)
self.assertEqual(response.data[0]['typus'], 'GROUP_LEAVE')
def test_other_participants_receive_update_on_join(self):
user = UserFactory()
joining_user = UserFactory()
# join a conversation
conversation = ConversationFactory(participants=[
user,
])
# login and connect
client = self.connect_as(user)
conversation.join(joining_user)
response = client.messages[0]
self.assertEqual(response['topic'], 'conversations:conversation')
self.assertEqual(set(response['payload']['participants']),
{user.id, joining_user.id})
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.place = PlaceFactory(group=self.group)
self.activity = ActivityFactory(place=self.place,
date=to_range(timezone.now() -
relativedelta(days=1)))
# No one joined the activity
Activity.objects.process_finished_activities()
def test_no_notifications_by_default_in_playground(self):
user = UserFactory()
group = PlaygroundGroupFactory()
membership = group.groupmembership_set.create(user=user)
self.assertEqual([], membership.notification_types)
conversation = Conversation.objects.get_for_target(group)
conversation_participant = ConversationParticipant.objects.get(
conversation=conversation, user=user)
self.assertTrue(conversation_participant.muted)
def test_no_reply_notification_if_muted(self, notify):
author = UserFactory()
reply_author = UserFactory()
group = GroupFactory(members=[author, reply_author])
conversation = Conversation.objects.get_or_create_for_target(group)
message = conversation.messages.create(author=author, content='bla')
reply = ConversationMessage.objects.create(
author=reply_author, conversation=conversation, thread=message, content='reply'
)
participant = ConversationThreadParticipant.objects.get(user=author, thread=reply.thread)
participant.muted = True
participant.save()
PushSubscription.objects.create(user=author, token='', platform=PushSubscriptionPlatform.ANDROID.value)
notify.reset_mock()
notify_message_push_subscribers(reply)
notify.assert_not_called()
def test_create_activity_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.activity_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.activity_url,
{'max_participants': 1},
format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN,
response.data)
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.group = GroupFactory()
self.user = UserFactory()
self.author = UserFactory()
self.group.add_member(self.user)
self.group.add_member(self.author)
self.token = faker.uuid4()
self.content = faker.text()
self.conversation = self.group.conversation
# add a push subscriber
self.subscription = PushSubscription.objects.create(
user=self.user,
token=self.token,
platform=PushSubscriptionPlatform.ANDROID.value,
)
def test_list_own_applications(self):
[
ApplicationFactory(group=self.group, user=UserFactory())
for _ in range(4)
]
self.client.force_login(user=self.applicant)
response = self.get_results('/api/applications/?user={}'.format(
self.applicant.id))
self.assertEqual(len(response.data), 1)
def test_exclude_unverified_addresses(self):
user = UserFactory() # not verified
self.group.add_member(user)
mail.outbox = []
ConversationMessage.objects.create(author=self.user,
conversation=self.conversation,
content='asdf')
self.assertEqual(len(mail.outbox), 0)
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_place_statistics_as_average(self):
user = UserFactory()
self.client.force_login(user=user)
group = GroupFactory(members=[user])
place = PlaceFactory(group=group)
response = self.client.get('/api/places/{}/statistics/'.format(
place.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, {
'feedback_count': 0,
'feedback_weight': 0,
'activities_done': 0,
})
one_day_ago = to_range(timezone.now() - relativedelta(days=1))
users = [UserFactory() for _ in range(9)]
activities = [
ActivityFactory(
place=place,
date=one_day_ago,
participants=users,
is_done=True,
) for _ in range(3)
]
feedback = [
FeedbackFactory(about=choice(activities), given_by=u)
for u in users
]
# calculate weight from feedback
feedback.sort(key=attrgetter('about.id'))
weight = float(sum(f.weight for f in feedback))
response = self.client.get('/api/places/{}/statistics/'.format(
place.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.data, {
'feedback_count': len(feedback),
'feedback_weight': weight,
'activities_done': len(activities),
})
def setUp(self):
self.url = '/api/pickup-date-series/'
self.series = PickupDateSeriesFactory()
self.series_url = '/api/pickup-date-series/{}/'.format(self.series.id)
self.non_member = UserFactory()
self.series_data = {
'place': self.series.place.id,
'rule': 'FREQ=WEEKLY',
'start_date': timezone.now()
}
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)
def test_newcomer_becomes_editor(self):
editor = UserFactory()
newcomer = UserFactory()
group = GroupFactory(members=[editor], newcomers=[newcomer])
two_days_ago = timezone.now() - relativedelta(days=2)
GroupMembership.objects.filter(group=group).update(
created_at=two_days_ago)
mail.outbox = []
membership = GroupMembership.objects.get(user=newcomer, group=group)
Trust.objects.create(membership=membership, given_by=editor)
self.assertTrue(group.is_editor(newcomer))
self.assertEqual(len(mail.outbox), 1)
self.assertIn('You gained editing permissions', mail.outbox[0].subject)
self.assertEqual(
History.objects.filter(
typus=HistoryTypus.MEMBER_BECAME_EDITOR).count(), 1)
def test_pickup_message_title(self):
author = UserFactory()
group = GroupFactory(members=[author], timezone='Europe/Berlin')
place = PlaceFactory(group=group)
pickup = PickupDateFactory(place=place, collectors=[author], date=to_range(parse('2018-11-11T20:00:00Z')))
conversation = Conversation.objects.get_or_create_for_target(pickup)
message = conversation.messages.create(author=author, content='bla')
title = get_message_title(message, 'en')
self.assertEqual(title, 'Pickup Sunday 9:00 PM / {}'.format(author.display_name))
def test_only_notifies_active_group_members(self):
self.group.add_member(UserFactory())
inactive_user = VerifiedUserFactory()
self.group.add_member(inactive_user)
self.group.groupmembership_set.filter(user=inactive_user).update(inactive_at=timezone.now())
mail.outbox = []
self.group.conversation.messages.create(author=self.author, content='foo')
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, [self.user.email])
def test_member_becomes_editor(self):
user = UserFactory()
GroupMembership.objects.create(group=self.group, user=user)
url = reverse('group-trust-user', args=(self.group.id, user.id))
self.client.force_login(self.member)
self.client.post(url)
response = self.get_results(history_url)
self.assertEqual(response.data[0]['typus'], 'MEMBER_BECAME_EDITOR')
def test_notifications_on_by_default(self):
user = UserFactory()
group = GroupFactory(members=[user])
membership = GroupMembership.objects.get(user=user, group=group)
self.assertEqual(get_default_notification_types(),
membership.notification_types)
conversation = Conversation.objects.get_for_target(group)
conversation_participant = ConversationParticipant.objects.get(
conversation=conversation, user=user)
self.assertFalse(conversation_participant.muted)
def setUpTestData(cls):
cls.url = '/api/activities/'
# activity for group with one member and one place
cls.member = UserFactory()
cls.second_member = UserFactory()
cls.group = GroupFactory(members=[cls.member, cls.second_member])
cls.place = PlaceFactory(group=cls.group)
cls.activity_type = ActivityTypeFactory(group=cls.group)
cls.archived_activity_type = ActivityTypeFactory(group=cls.group,
status='archived')
cls.activity = ActivityFactory(activity_type=cls.activity_type,
place=cls.place)
cls.activity_url = cls.url + str(cls.activity.id) + '/'
cls.join_url = cls.activity_url + 'add/'
cls.leave_url = cls.activity_url + 'remove/'
cls.conversation_url = cls.activity_url + 'conversation/'
# not a member of the group
cls.user = UserFactory()
# another activity for above place
cls.activity_data = {
'activity_type': cls.activity_type.id,
'date': to_range(timezone.now() + relativedelta(days=2)).as_list(),
'max_participants': 5,
'place': cls.place.id
}
# past activity
cls.past_activity_data = {
'activity_type': cls.activity_type.id,
'date': to_range(timezone.now() - relativedelta(days=1)).as_list(),
'max_participants': 5,
'place': cls.place.id
}
cls.past_activity = ActivityFactory(
activity_type=cls.activity_type,
place=cls.place,
date=to_range(timezone.now() - relativedelta(days=1)))
cls.past_activity_url = cls.url + str(cls.past_activity.id) + '/'
cls.past_join_url = cls.past_activity_url + 'add/'
cls.past_leave_url = cls.past_activity_url + 'remove/'
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.place = PlaceFactory(group=self.group)
self.pickup = PickupDateFactory(
place=self.place,
date=to_range(timezone.now() - relativedelta(days=1)),
is_disabled=True,
)
PickupDate.objects.process_finished_pickup_dates()
def test_join_full_activity_fails(self):
self.client.force_login(user=self.member)
self.activity.max_participants = 1
self.activity.save()
u2 = UserFactory()
GroupMembership.objects.create(group=self.group, user=u2)
self.activity.add_participant(u2)
response = self.client.post(self.join_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
self.assertEqual(response.data['detail'], 'Activity is already full.')
def setUp(self):
self.user = UserFactory()
self.url_user = '******'
self.url_change_email = '/api/auth/password/' # Should be url_change_password ?
self.url_request_account_deletion = '/api/auth/user/request_delete/'
# Mock AnymailMessage to throw error on send
self.mail_class = email_utils.AnymailMessage
self._original_send = self.mail_class.send
self.mail_class.send = MagicMock(side_effect=AnymailAPIError())
def setUp(self):
self.user = UserFactory()
self.user.photo = 'photo.jpg'
self.user.save()
self.user2 = UserFactory()
self.url = '/api/users/'
self.user_data = {
'email': faker.email(),
'password': faker.name(),
'display_name': faker.name(),
'address': faker.address(),
'latitude': faker.latitude(),
'longitude': faker.longitude()
}
self.group = GroupFactory(members=[self.user, self.user2])
self.another_common_group = GroupFactory(members=[self.user, self.user2])
self.user_in_another_group = UserFactory()
self.another_group = GroupFactory(members=[self.user_in_another_group])
mail.outbox = []
def test_create_voting_ends_soon_notifications(self):
creator, affected_user, voter = UserFactory(), UserFactory(), UserFactory()
group = GroupFactory(members=[creator, affected_user, voter])
issue = IssueFactory(group=group, created_by=creator, affected_user=affected_user)
voting = issue.latest_voting()
# let's vote with user "voter"
vote_for_further_discussion(voting=voting, user=voter)
Notification.objects.all().delete()
with fast_forward_just_before_voting_expiration(voting):
create_voting_ends_soon_notifications()
# can call it a second time without duplicating notifications
create_voting_ends_soon_notifications()
notifications = Notification.objects.filter(type=NotificationType.VOTING_ENDS_SOON.value)
# user "voter" is not being notified
self.assertEqual(
sorted([n.user_id for n in notifications]), sorted([issue.affected_user_id, issue.created_by_id])
)
def test_playground_members_are_always_editors(self):
new_member = UserFactory()
mail.outbox = []
self.group.add_member(new_member)
self.assertTrue(self.group.is_editor(new_member))
# no email should be sent when joining playground
self.assertEqual(len(mail.outbox), 0)
# no email should be sent when giving trust
membership = GroupMembership.objects.get(group=self.group,
user=new_member)
another_user = UserFactory()
self.group.add_member(another_user)
mail.outbox = []
Trust.objects.create(membership=membership, given_by=another_user)
self.assertEqual(len(mail.outbox), 0)
