def test_get_with_anonymous(self):
     view = ProjectCreate.as_view()
     url = reverse('admin:project_create')
     request = APIRequestFactory().get(url)
     request.user = AnonymousUser()
     response = view(request)
     self.assertTrue(isinstance(response, HttpResponseRedirect))

 def test_get_with_anonymous(self):
     view = ApplicationConnected.as_view()
     url = reverse('admin:app_connected')
     request = APIRequestFactory().get(url)
     request.user = AnonymousUser()
     response = view(request)
     self.assertTrue(isinstance(response, HttpResponseRedirect))

class CreateProjectTests(APITestCase):
    def setUp(self):
        self.anonymous_user = AnonymousUserFactory()
        self.user = UserFactory.create()
        self.group = GroupFactory.create(name=self.user.username)
        self.project = ProjectFactory.build(owner=self.group)

        self.view = ProjectViewSet.as_view({"post": "create"})
        self.factory = APIRequestFactory()
        self.url = reverse("api:v2:project-list")
        self.request = self.factory.post(self.url, {"name": self.project.name, "description": self.project.description})

    def test_anonymous_user_cannot_create_project(self):
        force_authenticate(self.request, user=self.anonymous_user)
        response = self.view(self.request)
        self.assertEquals(response.status_code, 403)

    def test_required_fields(self):
        bad_request = self.factory.post(self.url)
        force_authenticate(bad_request, user=self.user)
        response = self.view(bad_request)
        data = response.data

        self.assertEquals(response.status_code, 400)
        self.assertEquals(len(data), 1)
        self.assertIn("name", data)

    def test_authenticated_user_can_create_project(self):
        self.assertEquals(Project.objects.count(), 0)
        force_authenticate(self.request, user=self.user)
        response = self.view(self.request)
        self.assertEquals(response.status_code, 201)
        self.assertEquals(Project.objects.count(), 1)
        project = Project.objects.first()
        self.assertEquals(project.owner, self.group)

 def test_get_with_user(self):
     view = ApplicationOverview.as_view()
     url = reverse('admin:app_overview')
     request = APIRequestFactory().get(url)
     request.user = UserFactory.create()
     response = view(request).render()
     self.assertEqual(response.status_code, 200)

    def test_post_with_anonymous(self):
        data = {
            'name': 'test app',
            'description': '',
            'download_url': 'http://example.com/download',
            'redirect_uris': 'http://example.com/redirect',
            'authorization_grant_type': 'password'
        }

        view = ApplicationSettings.as_view()
        url = reverse('admin:app_settings', kwargs={'app_id': self.app.id})
        request = APIRequestFactory().post(url, data)
        request.user = AnonymousUser()
        response = view(request, app_id=self.app.id)
        self.assertTrue(isinstance(response, HttpResponseRedirect))

        ref = Application.objects.get(pk=self.app.id)
        self.assertNotEqual(ref.name, data.get('name'))
        self.assertNotEqual(ref.description, data.get('description'))
        self.assertNotEqual(ref.download_url, data.get('download_url'))
        self.assertNotEqual(ref.redirect_uris, data.get('redirect_uris'))
        self.assertNotEqual(
            ref.authorization_grant_type,
            data.get('authorization_grant_type')
        )

    def test_actions(self):
        class ExampleView(views.APIView):
            """Example view."""

            def post(self, request):
                pass  # pragma: nocover

            def get_serializer(self):
                return PersonSerializer()

        def _choices(response, key):
            """Helper method for unpacking response JSON."""
            return response.data["actions"]["POST"][key]["choices"]

        view = ExampleView.as_view()

        factory = APIRequestFactory()
        request = factory.options("/")
        response = view(request=request)
        country_choices = _choices(response, "country")
        fantasy_choices_en = _choices(response, "fantasy_country")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(country_choices, countries_display(countries))
        self.assertEqual(fantasy_choices_en, countries_display(FantasyCountries()))

        with override_settings(LANGUAGE_CODE="fr"):
            response = view(request=request)
            fantasy_choices_fr = _choices(response, "fantasy_country")
            self.assertNotEqual(fantasy_choices_en, fantasy_choices_fr)

    def test_post_with_superuser_when_updating(self):
        """Test POST with superuser."""
        data = {"client_id": "xxxxxxxxxxxxxxxxxx", "secret": "xxxxxxxxxxxxxxxxxx", "key": ""}
        view = ProviderOverview.as_view()
        request = APIRequestFactory().post(self.url, data)
        request.user = UserFactory.create(**{"is_superuser": True})

        social_app = SocialApp.objects.create(
            provider="google", name="Google", client_id="yyyyyyyyyyyyyyyyyy", secret="yyyyyyyyyyyyyyyyyy", key=""
        )
        social_app.sites.add(get_current_site(request))

        setattr(request, "session", "session")
        messages = FallbackStorage(request)
        setattr(request, "_messages", messages)

        response = view(request, provider_id="google").render()
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Provider has been updated.")
        self.assertEqual(SocialApp.objects.latest("id"), social_app)

        reference = SocialApp.objects.get(pk=social_app.id)
        self.assertEqual(reference.client_id, data.get("client_id"))
        self.assertEqual(reference.secret, data.get("secret"))
        self.assertEqual(reference.key, data.get("key"))

    def test_post_first_turn(self):
        """
        Post output of game return back to django.
        Authenticated user on their turn only.
        Same url as get: /play/<session_id>/ag
        """
        test_session = GameSession.objects.get(id=1)
        test_session.set_turn_data(test_json_data_global, "V")

        factory = APIRequestFactory()
        user = User.objects.get(username='john')
        view = GameREST.as_view()
        url = 'play/' + str(test_session.id) + '/ag/'
        request = factory.post(url, {'virus_player': '{"test": 1}',
                                     'health_player': '{"test2": 2}',
                                     'starting_from': 'india',
                                     'testing': True,
                                     'choice_outcome': '{"test3": 3}',
                                     'virus_tech': '{"dog": 1}',
                                     'health_tech': '{"cat": 2}',
                                     'change': '{"frog": "monkey"}'
                                     }, format='json')
        force_authenticate(request, user=user)

        response = view(request, test_session.id)
        
        # for the tests, reload the session from the DB
        test_session = GameSession.objects.get(id=1)
        self.assertNotEqual(response.data, test_json_data_global)
        self.assertEqual(response.data, 'complete')
        self.assertEqual(test_session.turn_data, '{"dog": "india"}')
        self.assertEqual(test_session.next_to_play, 'H')

    def test(self):
        admin = UserF.create()
        project = ProjectF(add_admins=[admin])
        observation = ObservationFactory.create(**{
            'project': project
        })
        comment = CommentFactory.create()

        factory = APIRequestFactory()
        request = factory.post(
            '/api/projects/%s/observations/%s/comments/' %
            (project.id, observation.id),
            {
                'text': 'Response to a comment',
                'respondsto': comment.id
            }
        )
        force_authenticate(request, user=admin)
        view = AllContributionsCommentsAPIView.as_view()
        response = view(
            request,
            project_id=project.id,
            observation_id=observation.id
        ).render()

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(
            json.loads(response.content).get('error'),
            'The comment you try to respond to is not a comment to the '
            'observation.'
        )

    def test_get_game_data_player(self):
        """
        Should return game session data for authenticated user upon GET
        request to /play/<session_id>/ag

        Should only return when its that users turn to play.
        """
        test_session = GameSession.objects.get(id=1)
        test_session.set_turn_data(test_json_data_global, "V")

        factory = APIRequestFactory()
        user = User.objects.get(username='john')
        view = GameREST.as_view()
        url = 'play/' + str(test_session.id) + '/ag/'
        request = factory.get(url)
        force_authenticate(request, user=user)
        response = view(request, test_session.id)

        self.assertEqual(response.data['turn_data'], test_json_data_global)
        
        # This test is not the user that should play next
        user2 = User.objects.get(username='ringo')
        request2 = factory.get(url)
        force_authenticate(request2, user=user2)
        response2 = view(request2, test_session.id)
        
        self.assertEqual(response2.data['detail'], 
                         'You do not have permission to perform this action.')

    def test_trailing_slash(self):
        factory = APIRequestFactory()
        urlpatterns = format_suffix_patterns([
            url(r'^test/$', dummy_view),
        ])
        resolver = RegexURLResolver(r'^/', urlpatterns)

        test_paths = [
            (URLTestPath('/test.api', (), {'format': 'api'}), True),
            (URLTestPath('/test/.api', (), {'format': 'api'}), False),
            (URLTestPath('/test.api/', (), {'format': 'api'}), True),
        ]

        for test_path, expected_resolved in test_paths:
            request = factory.get(test_path.path)
            try:
                callback, callback_args, callback_kwargs = resolver.resolve(request.path_info)
            except Resolver404:
                callback, callback_args, callback_kwargs = (None, None, None)
            if not expected_resolved:
                assert callback is None
                continue

            assert callback_args == test_path.args
            assert callback_kwargs == test_path.kwargs

 def test_any_post_view(self):
     factory = APIRequestFactory()
     request = factory.get('/posts/3/', format='json')
     force_authenticate(request, user=User.objects.get_by_natural_key('admin'))
     view = AnyPostDetail.as_view()
     response = view(request, pk=3)
     self.assertEqual(response.data['contents'], 'Cool post!')

 def test_api_is_correct(self):
     factory = APIRequestFactory()
     request = factory.get('/topics/1/', format='json')
     force_authenticate(request, user=User.objects.get_by_natural_key('admin'))
     view = TopicDetail.as_view()
     response = view(request, pk=1)
     self.assertEqual(response.data['reply_count'], 2)

    def test_builtin_license(self):
        addon = addon_factory()
        self.version = addon.current_version
        license = self.version.license
        license.update(builtin=18)
        assert license._constant == LICENSES_BY_BUILTIN[18]

        result = LicenseSerializer(
            context={'request': self.request}).to_representation(license)
        assert result['id'] == license.pk
        # A request with no ?lang gets you the site default l10n in a dict to
        # match how non-constant values are returned.
        assert result['name'] == {
            'en-US': unicode(LICENSES_BY_BUILTIN[18].name)}

        accept_request = APIRequestFactory().get('/')
        accept_request.LANG = 'de'
        result = LicenseSerializer(
            context={'request': accept_request}).to_representation(license)
        # An Accept-Language should result in a different default though.
        assert result['name'] == {
            'de': unicode(LICENSES_BY_BUILTIN[18].name)}

        # But a requested lang returns a flat string
        lang_request = APIRequestFactory().get('/?lang=fr')
        result = LicenseSerializer(
            context={'request': lang_request}).to_representation(license)
        assert result['name'] == unicode(LICENSES_BY_BUILTIN[18].name)

    def test_VersatileImageFieldSerializer_output(self):
        """Ensure VersatileImageFieldSerializer serializes correctly"""
        factory = APIRequestFactory()
        request = factory.get('/admin/')
        serializer = VersatileImageTestModelSerializer(
            self.jpg,
            context={'request': request}
        )

        self.assertEqual(
            serializer.data.get('optional_image'),
            {
                'test_crop': (
                    'http://testserver/media/__sized__/__placeholder__/placeholder-crop'
                    '-c0-5__0-5-100x100.png'
                ),
                'test_invert_crop': (
                    'http://testserver/media/__sized__/__placeholder__/__filtered__/placeholder__invert__'
                    '-crop-c0-5__0-5-100x100.png'
                ),
                'test_invert_thumb': (
                    'http://testserver/media/__sized__/__placeholder__/__filtered__/placeholder__invert__'
                    '-thumbnail-100x100.png'
                ),
                'test_invert': (
                    'http://testserver/media/__placeholder__/__filtered__/placeholder'
                    '__invert__.png'
                ),
                'test_thumb': (
                    'http://testserver/media/__sized__/__placeholder__/placeholder-thumbnail'
                    '-100x100.png'
                )
            }
        )

class TestPOSTAccessed(TestCase):
    def setUp(self):
        self.factory = APIRequestFactory()

    def test_post_accessed_in_post_method(self):
        django_request = self.factory.post('/', {'foo': 'bar'})
        request = Request(django_request, parsers=[FormParser(), MultiPartParser()])
        django_request.POST
        assert request.POST == {'foo': ['bar']}
        assert request.data == {'foo': ['bar']}

    def test_post_accessed_in_post_method_with_json_parser(self):
        django_request = self.factory.post('/', {'foo': 'bar'})
        request = Request(django_request, parsers=[JSONParser()])
        django_request.POST
        assert request.POST == {}
        assert request.data == {}

    def test_post_accessed_in_put_method(self):
        django_request = self.factory.put('/', {'foo': 'bar'})
        request = Request(django_request, parsers=[FormParser(), MultiPartParser()])
        django_request.POST
        assert request.POST == {'foo': ['bar']}
        assert request.data == {'foo': ['bar']}

    def test_request_read_before_parsing(self):
        django_request = self.factory.put('/', {'foo': 'bar'})
        request = Request(django_request, parsers=[FormParser(), MultiPartParser()])
        django_request.read()
        with pytest.raises(RawPostDataException):
            request.POST
        with pytest.raises(RawPostDataException):
            request.POST
            request.data

 def setUp(self):
     self.tag = TagFactory.create()
     self.view = TagViewSet.as_view({'get': 'retrieve'})
     self.anonymous_user = AnonymousUserFactory()
     factory = APIRequestFactory()
     url = reverse('api:v2:tag-detail', args=(self.tag.id,))
     self.request = factory.get(url)

 def test_VersatileImageFieldSerializer_output(self):
     """Ensures VersatileImageFieldSerializer serializes correctly"""
     factory = APIRequestFactory()
     request = factory.get('/admin/')
     serializer = VersatileImageTestModelSerializer(
         self.jpg,
         context={'request': request}
     )
     self.assertEqual(
         serializer.data.get('image'),
         {
             'test_crop': (
                 'http://testserver/media/__sized__/python-logo-crop'
                 '-c0-25__0-25-100x100.jpg'
             ),
             'test_invert_crop': (
                 'http://testserver/media/__sized__/__filtered__/'
                 'python-logo__invert__-crop-c0-25__0-25-100x100.jpg'
             ),
             'test_invert_thumb': (
                 'http://testserver/media/__sized__/__filtered__/'
                 'python-logo__invert__-thumbnail-100x100.jpg'
             ),
             'test_invert': (
                 'http://testserver/media/__filtered__/'
                 'python-logo__invert__.jpg'
             ),
             'test_thumb': (
                 'http://testserver/media/__sized__/python-logo-thumbnail'
                 '-100x100.jpg'
             )
         }
     )

class ChoiceDetail(APITestCase):
    def setUp(self):
        self.factory = APIRequestFactory()
        self.client = APIClient()
        self.user = setup_user()
        self.view = views.PollList.as_view()
        self.uri = '/choices/pk/'

    def test_unauthenticated_uri(self):
        """
        If not authorized access not allowed
        """
        request = self.factory.get(self.uri)
        response = self.view(request, pk='2')
        self.assertEqual(response.status_code, 401,
                         'Expected Response Code 401, received {0} instead.'
                         .format(response.status_code))

    def test_authenticated_uri(self):
        """
        GET
        """
        request = self.factory.get(self.uri)
        force_authenticate(request, self.user)
        response = self.view(request, pk='2')
        self.assertEqual(response.status_code, 200,
                         'Expected Response Code 200, received {0} instead.'
                         .format(response.status_code))

    def test_post_with_creator(self):
        data = {
            'name': 'test app',
            'description': '',
            'download_url': 'http://example.com',
            'redirect_uris': 'http://example.com',
            'authorization_grant_type': 'password'
        }
        view = ApplicationSettings.as_view()
        url = reverse('admin:app_settings', kwargs={'app_id': self.app.id})
        request = APIRequestFactory().post(url, data)
        request.user = self.creator

        from django.contrib.messages.storage.fallback import FallbackStorage
        setattr(request, 'session', 'session')
        messages = FallbackStorage(request)
        setattr(request, '_messages', messages)

        response = view(request, app_id=self.app.id).render()
        self.assertEqual(response.status_code, 200)
        self.assertNotContains(
            response,
            'You are not the owner of this application and therefore not'
            'allowed to access this app.'
        )

        ref = Application.objects.get(pk=self.app.id)
        self.assertEqual(ref.name, data.get('name'))
        self.assertEqual(ref.description, data.get('description'))
        self.assertEqual(ref.download_url, data.get('download_url'))
        self.assertEqual(ref.redirect_uris, data.get('redirect_uris'))
        self.assertEqual(
            ref.authorization_grant_type,
            data.get('authorization_grant_type')
        )