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])