def setUp(self):
super().setUp()
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group)
# Create far in the future to generate no pickup dates
# They would lead to interfering websocket messages
self.series = PickupDateSeriesFactory(store=self.store, start_date=timezone.now() + relativedelta(months=2))
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
PushSubscription.objects.create(
user=self.user,
token=self.token,
platform=PushSubscriptionPlatform.ANDROID.value,
)
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 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 setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[self.member])
self.store = StoreFactory(group=self.group, status='archived')
self.pickup = PickupDateFactory(store=self.store, date=timezone.now() - relativedelta(days=1))
self.pickup.add_collector(self.member)
PickupDateFactory(store=self.store, date=timezone.now() - relativedelta(days=1))
PickupDate.objects.process_finished_pickup_dates()
def test_no_notifications_by_default_in_playground(self):
user = UserFactory()
group = PlaygroundGroupFactory(members=[user])
membership = GroupMembership.objects.get(user=user, group=group)
self.assertEqual([], membership.notification_types)
conversation = Conversation.objects.get_for_target(group)
conversation_participant = ConversationParticipant.objects.get(
conversation=conversation, user=user)
self.assertFalse(conversation_participant.email_notifications)
def setUp(self):
self.user = UserFactory()
self.group = GroupFactory(members=[self.user])
self.exampleuser = {
'display_name': 'bla',
'email': '*****@*****.**',
'password': '******',
'current_group': self.group,
}
def test_store_statistics(self):
user = UserFactory()
self.client.force_login(user=user)
group = GroupFactory(members=[user])
store = StoreFactory(group=group)
response = self.client.get('/api/stores/{}/statistics/'.format(store.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, {
'feedback_count': 0,
'feedback_weight': 0,
'pickups_done': 0,
})
one_day_ago = timezone.now() - relativedelta(days=1)
users = [UserFactory() for _ in range(9)]
pickups = [
PickupDateFactory(
store=store,
date=one_day_ago,
collectors=users,
feedback_possible=True,
) for _ in range(3)
]
feedback = [FeedbackFactory(about=choice(pickups), given_by=u) for u in users]
# calculate weight from feedback
feedback.sort(key=attrgetter('about.id'))
weight = 0
for _, fs in groupby(feedback, key=attrgetter('about.id')):
len_list = [f.weight for f in fs]
weight += float(sum(len_list)) / len(len_list)
weight = round(weight)
response = self.client.get('/api/stores/{}/statistics/'.format(store.id))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.data, {
'feedback_count': len(feedback),
'feedback_weight': weight,
'pickups_done': len(pickups),
}
)
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 test_adds_subscription(self):
client = WSClient()
user = UserFactory()
client.force_login(user)
self.assertEqual(
ChannelSubscription.objects.filter(user=user).count(), 0)
client.send_and_consume('websocket.connect', path='/')
self.assertEqual(
ChannelSubscription.objects.filter(user=user).count(), 1,
'Did not add subscription')
def setUp(self):
self.user = UserFactory()
self.url_user = '******'
self.url_change_email = '/api/auth/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 test_other_participants_receive_update_on_join(self):
client = WSClient()
user = UserFactory()
joining_user = UserFactory()
# join a conversation
conversation = ConversationFactory()
conversation.join(user)
# login and connect
client.force_login(user)
client.send_and_consume('websocket.connect', path='/')
conversation.join(joining_user)
response = client.receive(json=True)
self.assertEqual(response['topic'], 'conversations:conversation')
self.assertEqual(set(response['payload']['participants']), {user.id, joining_user.id})
def setUpClass(cls):
super().setUpClass()
cls.now = timezone.now()
cls.member = UserFactory()
cls.group = GroupFactory(members=[
cls.member,
])
cls.store = StoreFactory(group=cls.group)
cls.series = PickupDateSeriesFactory(max_collectors=3, store=cls.store)
cls.series.update_pickup_dates(start=lambda: cls.now)
def setUpClass(cls):
super().setUpClass()
cls.url = '/api/conversations/'
# A chat with 2 participants
cls.participant = UserFactory()
cls.participant2 = UserFactory()
cls.conversation = Conversation(participants=[cls.participant, cls.participant2])
cls.conversation_url = cls.url + str(cls.conversation.id) + '/'
# not a participant
cls.user = UserFactory()
# another chat
cls.conversation_data = {'topic': faker.name(),
'with_participants': [cls.participant2.id, ],
'message': faker.text()}
cls.patch_data = {'topic': 'new topic'}
cls.put_data = {'topic': 'new topic'}
def test_no_message_notification_if_muted(self, notify):
author = UserFactory()
user = UserFactory()
group = GroupFactory(members=[author, user])
conversation = Conversation.objects.get_or_create_for_target(group)
message = conversation.messages.create(author=author, content='bla')
participant = ConversationParticipant.objects.get(
user=user, conversation=conversation)
participant.email_notifications = False
participant.save()
PushSubscription.objects.create(
user=user,
token='',
platform=PushSubscriptionPlatform.ANDROID.value)
notify.reset_mock()
notify_message_push_subscribers(message)
notify.assert_not_called()
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 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 = {
'store': self.series.store.id,
'rule': 'FREQ=WEEKLY',
'start_date': timezone.now()
}
def test_receive_group_join_as_nonmember(self):
self.client = self.connect_as(self.user)
join_user = UserFactory()
self.group.add_member(join_user)
self.assertNotIn('groups:group_detail', self.client.messages_by_topic.keys())
response = self.client.messages_by_topic.get('groups:group_preview')[0]
self.assertIn(join_user.id, response['payload']['members'])
self.assertNotIn('memberships', response['payload'])
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)
def test_creates_pickup_moved_notification(self):
user1, user2 = UserFactory(), UserFactory()
group = GroupFactory(members=[user1, user2])
store = StoreFactory(group=group)
pickup = PickupDateFactory(store=store, collectors=[user1, user2])
Notification.objects.all().delete()
pickup.last_changed_by = user2
pickup.date = pickup.date + relativedelta(days=2)
pickup.save()
notifications = Notification.objects.all()
self.assertEqual(notifications.count(), 1)
self.assertEqual(notifications[0].type, NotificationType.PICKUP_MOVED.value)
self.assertEqual(notifications[0].user, user1)
context = notifications[0].context
self.assertEqual(context['group'], group.id)
self.assertEqual(context['pickup'], pickup.id)
self.assertEqual(context['store'], store.id)
def test_join_full_pickup_fails(self):
self.client.force_login(user=self.member)
self.pickup.max_collectors = 1
self.pickup.save()
u2 = UserFactory()
self.group.members.add(u2)
self.pickup.collectors.add(u2)
response = self.client.post(self.join_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
self.assertEqual(response.data, {'detail': 'Pickup date is already full.'})
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 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),
deleted=True,
)
PickupDate.objects.process_finished_pickup_dates()
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 setUpClass(cls):
super().setUpClass()
cls.user = UserFactory()
cls.group = GroupFactory(members=[cls.user, ])
cls.exampleuser = {
'display_name': 'bla',
'email': '*****@*****.**',
'password': '******',
'current_group': cls.group,
}
def setUp(self):
self.member = UserFactory()
self.group = GroupFactory(members=[
self.member,
])
self.store = StoreFactory(group=self.group)
self.pickup = PickupDateFactory(store=self.store)
self.pickup_url = '/api/pickup-dates/{}/'.format(self.pickup.id)
self.series = PickupDateSeriesFactory(store=self.store)
self.series_url = '/api/pickup-date-series/{}/'.format(self.series.id)
def test_dont_escape_url_parameters(self):
g = GroupFactory()
u = UserFactory()
i = Invitation.objects.create(
email='*****@*****.**',
group=g,
invited_by=u
)
b = i.get_email_body()
self.assertNotIn('&', b)
def setUpClass(cls):
super().setUpClass()
cls.user = UserFactory()
cls.member = UserFactory()
cls.group = GroupFactory(members=[
cls.member,
])
cls.group_with_password = GroupFactory(password='******')
cls.join_password_url = '/api/groups/{}/join/'.format(
cls.group_with_password.id)
cls.url = '/api/groups/'
cls.group_data = {
'name': faker.name(),
'description': faker.text(),
'address': faker.address(),
'latitude': faker.latitude(),
'longitude': faker.longitude(),
'timezone': 'Europe/Berlin'
}
def test_join_full_pickup_fails(self):
self.client.force_login(user=self.member)
self.pickup.max_collectors = 1
self.pickup.save()
u2 = UserFactory()
GroupMembership.objects.create(group=self.group, user=u2)
self.pickup.add_collector(u2)
response = self.client.post(self.join_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN, response.data)
self.assertEqual(response.data['detail'], 'Pickup date is already full.')
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])
