def test_get_review_request_private_multi_groups_site(self):
        """Testing the GET search/ API with a review request on a Local Site
        assigned to multiple private groups, one containing the user
        """
        self.user = self._login_user(local_site=True)
        non_member_group = self.create_review_group(invite_only=True,
                                                    name='non-member',
                                                    with_local_site=True)
        member_group = self.create_review_group(invite_only=True,
                                                name='member',
                                                with_local_site=True)
        member_group.users.add(self.user)
        review_request = self.create_review_request(public=True,
                                                    with_local_site=True,
                                                    submitter='admin')
        review_request.target_groups = [
            member_group,
            non_member_group,
        ]

        self.assertTrue(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(self.local_site_name),
                           query={'q': review_request.local_id},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(len(rsp['search']['review_requests']), 1)

    def test_get_review_request_private_repo_access_invite_only_site(self):
        """Testing the GET search/ API with a review request on a Local Site in
        a private repository and assigned to an invite-only group that contains
        the user
        """
        self.user = self._login_user(local_site=True)
        repository = self.create_repository(public=False,
                                            with_local_site=True)
        review_group = self.create_review_group(invite_only=True,
                                                with_local_site=True)
        review_group.users.add(self.user)

        review_request = self.create_review_request(repository=repository,
                                                    with_local_site=True,
                                                    submitter='admin',
                                                    public=True)
        review_request.target_groups.add(review_group)

        self.assertFalse(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(),
                           query={'q': review_request.pk},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['review_requests'], [])

    def test_get_review_request_private_public_groups_site(self):
        """Testing the GET search/ API with a review request on a Local Site
        assigned to public and private groups
        """
        self.user = self._login_user(local_site=True)
        private_group = self.create_review_group(invite_only=True,
                                                 name='private',
                                                 with_local_site=True)
        public_group = self.create_review_group(name='public',
                                                with_local_site=True)
        review_request = self.create_review_request(public=True,
                                                    with_local_site=True,
                                                    submitter='admin')
        review_request.target_groups = [
            public_group,
            private_group,
        ]

        self.assertTrue(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(self.local_site_name),
                           query={'q': review_request.local_id},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(len(rsp['search']['review_requests']), 1)

    def test_get_review_request_draft_only(self):
        """Testing the GET search/ API with a draft review request"""
        review_request = self.create_review_request(public=False)

        self.assertFalse(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(),
                           query={'q': review_request.pk},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['groups'], [])

    def test_get_review_group_different_site(self):
        """Testing the GET search/ API with a group on a different site"""
        group = self.create_review_group(with_local_site=True)

        self.assertFalse(group.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(),
                           query={'q': group.name},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['groups'], [])

    def test_get_private_review_group(self):
        """Testing the GET search/ API with an invite-only review group"""
        group = self.create_review_group(invite_only=True)

        self.assertFalse(group.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(),
                           query={'q': group.name},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['groups'], [])

    def test_get_with_max_results(self):
        """Testing the GET search/ API with max_results"""
        for i in range(20):
            self.create_review_request(public=True)

        max_results = 10

        rsp = self.api_get(get_search_url(),
                           query={'max_results': max_results},
                           expected_mimetype=search_mimetype)
        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(len(rsp['search']['review_requests']), max_results)

    def test_get_private_review_group_local_site(self):
        """Testing the GET search/ API with access to a Local Site and an
        invite-only review group
        """
        self._login_user(local_site=True)
        group = self.create_review_group(invite_only=True,
                                         with_local_site=True)

        rsp = self.api_get(get_search_url(self.local_site_name),
                           query={'q': group.name},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['groups'], [])

    def test_get_review_request_global_site_superuser(self):
        """Testing the GET search/ API with a review request on a global site
        from a Local Site as superuser
        """
        self.user = self._login_user(admin=True)
        review_request = self.create_review_request(public=True)

        self.assertTrue(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(self.local_site_name),
                           query={'q': review_request.local_id},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['review_requests'], [])

    def test_get_invisible_review_group_local_site_superuser(self):
        """Testing the GET search/ API with an invisible review group on a
        Local Site as a superuser
        """
        self.user = self._login_user(admin=True)
        group = self.create_review_group(visible=False, with_local_site=True)

        self.assertTrue(group.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(self.local_site_name),
                           query={'q': group.name},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['groups'], [])

    def test_get_private_review_group_superuser(self):
        """Testing the GET search/ API with an invite-only review group as a
        superuser
        """
        self.user = self._login_user(admin=True)
        group = self.create_review_group(invite_only=True)

        self.assertTrue(group.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(),
                           query={'q': group.name},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(len(rsp['search']['groups']), 1)

    def test_get_review_group_global_from_site(self):
        """Testing the GET search/ API with access to a Local Site with a group
        on the global site
        """
        self.user = self._login_user(local_site=True)
        group = self.create_review_group()

        self.assertTrue(group.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(self.local_site_name),
                           query={'q': group.name},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['groups'], [])

    def test_get_review_request_local_site(self):
        """Testing the GET search/ API with a review request on a Local Site
        """
        self.user = self._login_user(local_site=True)
        review_request = self.create_review_request(submitter='admin',
                                                    with_local_site=True,
                                                    public=True)

        self.assertTrue(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(self.local_site_name),
                           query={'q': review_request.local_id},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(len(rsp['search']['review_requests']), 1)

    def test_get_review_request_invite_only_group(self):
        """Testing the GET search/ API with a review request assigned to an
        invite-only group not containing the user
        """
        review_group = self.create_review_group(invite_only=True)
        review_request = self.create_review_request(public=True)
        review_request.target_groups.add(review_group)

        self.assertFalse(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(),
                           query={'q': review_request.pk},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['review_requests'], [])

    def test_get_review_request_private_repository(self):
        """Testing the GET search/ API with a review request in a private
        repository
        """
        repository = self.create_repository(public=False)
        review_request = self.create_review_request(repository=repository,
                                                    public=True)

        self.assertFalse(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(),
                           query={'q': review_request.pk},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['review_requests'], [])

    def test_get_user_public_profile_unindexed(self):
        """Testing the GET <URL> API with the search index disabled for a user
        with a public profile
        """
        rsp = self.api_get(get_search_url(),
                           query={'q': 'doc'},
                           expected_mimetype=search_mimetype)

        search_results = rsp['search']
        self.assertEqual(len(search_results['groups']), 0)
        self.assertEqual(len(search_results['review_requests']), 0)
        self.assertEqual(len(search_results['users']), 1)

        item_rsp = search_results['users'][0]
        self.assertIn('first_name', item_rsp)
        self.assertIn('last_name', item_rsp)
        self.assertIn('fullname', item_rsp)

    def test_get_review_request_private_public_groups_targeted(self):
        """Testing the GET search/ API with a review request assigned to public
        and private groups
        """
        private_group = self.create_review_group(invite_only=True)
        review_request = self.create_review_request(public=True)
        review_request.target_groups.add(private_group)
        review_request.target_people.add(self.user)

        self.assertTrue(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(),
                           query={'q': review_request.pk},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(len(rsp['search']['review_requests']), 1)

    def test_get_private_review_group_member_local_site(self):
        """Testing the GET search/ API with access to an invite-only review
        group on a Local Site
        """
        self.user = self._login_user(local_site=True)
        group = self.create_review_group(invite_only=True,
                                         with_local_site=True)
        group.users.add(self.user)

        self.assertTrue(group.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(self.local_site_name),
                           query={'q': group.name},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(len(rsp['search']['groups']), 1)

    def test_get_review_request_different_local_site_superuser(self):
        """Testing the GET search/ API with a review request on a different
        Local Site as a superuser
        """
        self.user = self._login_user(admin=True)
        review_request = self.create_review_request(with_local_site=True,
                                                    submitter='admin',
                                                    public=True)

        self.assertTrue(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(),
                           query={'q': review_request.local_id},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(rsp['search']['review_requests'], [])

    def test_get_review_request_invite_only_group_superuser(self):
        """Testing the GET search/ API with a review request assigned to an
        invite-only group as a superuser
        """
        self.user = self._login_user(admin=True)
        review_group = self.create_review_group(invite_only=True)
        review_request = self.create_review_request(public=True)
        review_request.target_groups.add(review_group)

        self.assertTrue(review_request.is_accessible_by(self.user))

        rsp = self.api_get(get_search_url(),
                           query={'q': review_request.pk},
                           expected_mimetype=search_mimetype)

        self.assertEqual(rsp['stat'], 'ok')
        self.assertEqual(len(rsp['search']['review_requests']), 1)