コード例 #1
0
 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')
コード例 #2
0
    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])
コード例 #3
0
 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)
コード例 #4
0
ファイル: test_tasks.py プロジェクト: cstefanj/karrot-backend
 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')
コード例 #5
0
    def setUp(self):
        self.group = GroupFactory()

        self.user_without_notifications = VerifiedUserFactory(language='en')
        self.group.add_member(self.user_without_notifications)
        m = GroupMembership.objects.get(group=self.group,
                                        user=self.user_without_notifications)
        m.notification_types = []
        m.save()

        # it should ignore unverified and inactive users so adding a random number
        # of them here should not change anything

        unverified_users = [
            UserFactory(language='en') for _ in list(range(randint(2, 5)))
        ]
        for user in unverified_users:
            self.group.add_member(user)

        inactive_users = [
            VerifiedUserFactory(language='en')
            for _ in list(range(randint(2, 5)))
        ]
        for user in inactive_users:
            membership = self.group.add_member(user)
            membership.inactive_at = timezone.now()
            membership.save()
コード例 #6
0
    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])
コード例 #7
0
class GroupConversationReceiverPushTests(TransactionTestCase):
    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_sends_to_push_subscribers(self, notify_subscribers):
        # add a message to the conversation
        ConversationMessage.objects.create(conversation=self.conversation,
                                           content=self.content,
                                           author=self.author)

        self.assertEqual(notify_subscribers.call_count, 2)
        kwargs = notify_subscribers.call_args_list[0][1]
        self.assertEqual(list(kwargs['subscriptions']), [self.subscription])
        self.assertEqual(kwargs['fcm_options']['message_title'],
                         self.group.name + ' / ' + self.author.display_name)
        self.assertEqual(kwargs['fcm_options']['message_body'], self.content)
コード例 #8
0
class TestApplicationConversationModel(APITestCase):
    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)

    def test_member_leaves_group(self):
        GroupMembership.objects.filter(user=self.member, group=self.group).delete()
        self.assertNotIn(
            self.member,
            self.conversation.participants.all(),
        )

    def test_user_erased(self):
        self.applicant.refresh_from_db()  # otherwise user.photo.name is None
        self.applicant.erase()

        self.application.refresh_from_db()
        self.assertEqual(self.application.status, ApplicationStatus.WITHDRAWN.value)

    def test_deleting_application_deletes_conversation(self):
        Application.objects.filter(user=self.applicant, group=self.group).delete()
        self.assertIsNone(Conversation.objects.get_for_target(self.application))

    def test_sets_group(self):
        self.assertEqual(self.conversation.group, self.group)

    def test_withdraw_pending_application_when_user_joins_group(self):
        self.group.add_member(self.applicant)

        self.application.refresh_from_db()
        self.assertEqual(self.application.status, ApplicationStatus.WITHDRAWN.value)
コード例 #9
0
 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)
コード例 #10
0
 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])
コード例 #11
0
 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)
コード例 #12
0
    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)
コード例 #13
0
ファイル: test_trust.py プロジェクト: cstefanj/karrot-backend
 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)
コード例 #14
0
 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)
コード例 #15
0
    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)
コード例 #16
0
    def test_remove_trust_when_giver_leaves_group(self):
        editor = UserFactory()
        newcomer = UserFactory()
        group = GroupFactory(members=[editor], newcomers=[newcomer])
        membership = GroupMembership.objects.get(user=newcomer, group=group)
        Trust.objects.create(membership=membership, given_by=editor)

        group.remove_member(editor)

        self.assertEqual(0, Trust.objects.filter(membership=membership).count())
コード例 #17
0
ファイル: test_api.py プロジェクト: cstefanj/karrot-backend
    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'
コード例 #18
0
    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())
コード例 #19
0
    def test_removes_notification_when_leaving_group(self):
        user = UserFactory()
        group = GroupFactory(members=[user])
        Notification.objects.all().delete()
        Notification.objects.create(user=user,
                                    type='foo',
                                    context={'group': group.id})

        group.remove_member(user)

        self.assertEqual(Notification.objects.count(), 0)
コード例 #20
0
    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()
コード例 #21
0
    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()
コード例 #22
0
    def setUp(self):
        self.member = VerifiedUserFactory()
        self.affected_member = VerifiedUserFactory()
        self.group = GroupFactory(members=[self.member, self.affected_member])
        self.issue = IssueFactory(group=self.group,
                                  created_by=self.member,
                                  affected_user=self.affected_member)

        # add notification type to send out emails
        for membership in self.group.groupmembership_set.all():
            membership.add_notification_types(
                [GroupNotificationType.CONFLICT_RESOLUTION])
            membership.save()
コード例 #23
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()
        )
コード例 #24
0
 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'
     }
コード例 #25
0
    def test_creates_new_member_notification(self):
        member1 = UserFactory()
        member2 = UserFactory()
        group = GroupFactory(members=[member1, member2])
        Notification.objects.all().delete()

        user = UserFactory()
        group.add_member(user, added_by=member1)

        notifications = Notification.objects.filter(
            type=NotificationType.NEW_MEMBER.value)
        # member1 doesn't get a notification, as they added the user
        self.assertEqual(notifications.count(), 1, notifications)
        self.assertEqual(notifications[0].user, member2)
        self.assertEqual(notifications[0].context['user'], user.id)
コード例 #26
0
    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)
コード例 #27
0
    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,
            },
        }])
コード例 #28
0
ファイル: test_api.py プロジェクト: cstefanj/karrot-backend
    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)
コード例 #29
0
ファイル: test_api.py プロジェクト: cstefanj/karrot-backend
 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')
コード例 #30
0
    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,
            },
        }])