# -*- coding: utf-8 -*-

"""

Regression tests for the Test Client, especially the customized assertions.

"""

import os

from django.conf import settings

from django.core.exceptions import SuspiciousOperation

from django.core.urlresolvers import reverse

from django.template import (TemplateDoesNotExist, TemplateSyntaxError,

    Context, loader)

from django.test import TestCase, Client

from django.test.client import encode_file

from django.test.utils import ContextList

class AssertContainsTests(TestCase):

    def setUp(self):

        self.old_templates = settings.TEMPLATE_DIRS

        settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), 'templates'),)

    def tearDown(self):

        settings.TEMPLATE_DIRS = self.old_templates

    def test_contains(self):

        "Responses can be inspected for content, including counting repeated substrings"

        response = self.client.get('/test_client_regress/no_template_view/')

        self.assertNotContains(response, 'never')

        self.assertContains(response, 'never', 0)

        self.assertContains(response, 'once')

        self.assertContains(response, 'once', 1)

        self.assertContains(response, 'twice')

        self.assertContains(response, 'twice', 2)

        try:

            self.assertContains(response, 'text', status_code=999)

        except AssertionError, e:

            self.assertEquals(str(e), "Couldn't retrieve page: Response code was 200 (expected 999)")

        try:

            self.assertContains(response, 'text', status_code=999, msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Couldn't retrieve page: Response code was 200 (expected 999)")

        try:

            self.assertNotContains(response, 'text', status_code=999)

        except AssertionError, e:

            self.assertEquals(str(e), "Couldn't retrieve page: Response code was 200 (expected 999)")

        try:

            self.assertNotContains(response, 'text', status_code=999, msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Couldn't retrieve page: Response code was 200 (expected 999)")

        try:

            self.assertNotContains(response, 'once')

        except AssertionError, e:

            self.assertEquals(str(e), "Response should not contain 'once'")

        try:

            self.assertNotContains(response, 'once', msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Response should not contain 'once'")

        try:

            self.assertContains(response, 'never', 1)

        except AssertionError, e:

            self.assertEquals(str(e), "Found 0 instances of 'never' in response (expected 1)")

        try:

            self.assertContains(response, 'never', 1, msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Found 0 instances of 'never' in response (expected 1)")

        try:

            self.assertContains(response, 'once', 0)

        except AssertionError, e:

            self.assertEquals(str(e), "Found 1 instances of 'once' in response (expected 0)")

        try:

            self.assertContains(response, 'once', 0, msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Found 1 instances of 'once' in response (expected 0)")

        try:

            self.assertContains(response, 'once', 2)

        except AssertionError, e:

            self.assertEquals(str(e), "Found 1 instances of 'once' in response (expected 2)")

        try:

            self.assertContains(response, 'once', 2, msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Found 1 instances of 'once' in response (expected 2)")

        try:

            self.assertContains(response, 'twice', 1)

        except AssertionError, e:

            self.assertEquals(str(e), "Found 2 instances of 'twice' in response (expected 1)")

        try:

            self.assertContains(response, 'twice', 1, msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Found 2 instances of 'twice' in response (expected 1)")

        try:

            self.assertContains(response, 'thrice')

        except AssertionError, e:

            self.assertEquals(str(e), "Couldn't find 'thrice' in response")

        try:

            self.assertContains(response, 'thrice', msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Couldn't find 'thrice' in response")

        try:

            self.assertContains(response, 'thrice', 3)

        except AssertionError, e:

            self.assertEquals(str(e), "Found 0 instances of 'thrice' in response (expected 3)")

        try:

            self.assertContains(response, 'thrice', 3, msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Found 0 instances of 'thrice' in response (expected 3)")

    def test_unicode_contains(self):

        "Unicode characters can be found in template context"

        #Regression test for #10183

        r = self.client.get('/test_client_regress/check_unicode/')

        self.assertContains(r, u'さかき')

        self.assertContains(r, '\xe5\xb3\xa0'.decode('utf-8'))

    def test_unicode_not_contains(self):

        "Unicode characters can be searched for, and not found in template context"

        #Regression test for #10183

        r = self.client.get('/test_client_regress/check_unicode/')

        self.assertNotContains(r, u'はたけ')

        self.assertNotContains(r, '\xe3\x81\xaf\xe3\x81\x9f\xe3\x81\x91'.decode('utf-8'))

class AssertTemplateUsedTests(TestCase):

    fixtures = ['testdata.json']

    def test_no_context(self):

        "Template usage assertions work then templates aren't in use"

        response = self.client.get('/test_client_regress/no_template_view/')

        # Check that the no template case doesn't mess with the template assertions

        self.assertTemplateNotUsed(response, 'GET Template')

        try:

            self.assertTemplateUsed(response, 'GET Template')

        except AssertionError, e:

            self.assertEquals(str(e), "No templates used to render the response")

        try:

            self.assertTemplateUsed(response, 'GET Template', msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: No templates used to render the response")

    def test_single_context(self):

        "Template assertions work when there is a single context"

        response = self.client.get('/test_client/post_view/', {})

        try:

            self.assertTemplateNotUsed(response, 'Empty GET Template')

        except AssertionError, e:

            self.assertEquals(str(e), "Template 'Empty GET Template' was used unexpectedly in rendering the response")

        try:

            self.assertTemplateNotUsed(response, 'Empty GET Template', msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Template 'Empty GET Template' was used unexpectedly in rendering the response")

        try:

            self.assertTemplateUsed(response, 'Empty POST Template')

        except AssertionError, e:

            self.assertEquals(str(e), "Template 'Empty POST Template' was not a template used to render the response. Actual template(s) used: Empty GET Template")

        try:

            self.assertTemplateUsed(response, 'Empty POST Template', msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Template 'Empty POST Template' was not a template used to render the response. Actual template(s) used: Empty GET Template")

    def test_multiple_context(self):

        "Template assertions work when there are multiple contexts"

        post_data = {

            'text': 'Hello World',

            'email': 'foo@example.com',

            'value': 37,

            'single': 'b',

            'multi': ('b','c','e')

        }

        response = self.client.post('/test_client/form_view_with_template/', post_data)

        self.assertContains(response, 'POST data OK')

        try:

            self.assertTemplateNotUsed(response, "form_view.html")

        except AssertionError, e:

            self.assertEquals(str(e), "Template 'form_view.html' was used unexpectedly in rendering the response")

        try:

            self.assertTemplateNotUsed(response, 'base.html')

        except AssertionError, e:

            self.assertEquals(str(e), "Template 'base.html' was used unexpectedly in rendering the response")

        try:

            self.assertTemplateUsed(response, "Valid POST Template")

        except AssertionError, e:

            self.assertEquals(str(e), "Template 'Valid POST Template' was not a template used to render the response. Actual template(s) used: form_view.html, base.html")

class AssertRedirectsTests(TestCase):

    def test_redirect_page(self):

        "An assertion is raised if the original page couldn't be retrieved as expected"

        # This page will redirect with code 301, not 302

        response = self.client.get('/test_client/permanent_redirect_view/')

        try:

            self.assertRedirects(response, '/test_client/get_view/')

        except AssertionError, e:

            self.assertEquals(str(e), "Response didn't redirect as expected: Response code was 301 (expected 302)")

        try:

            self.assertRedirects(response, '/test_client/get_view/', msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Response didn't redirect as expected: Response code was 301 (expected 302)")

    def test_lost_query(self):

        "An assertion is raised if the redirect location doesn't preserve GET parameters"

        response = self.client.get('/test_client/redirect_view/', {'var': 'value'})

        try:

            self.assertRedirects(response, '/test_client/get_view/')

        except AssertionError, e:

            self.assertEquals(str(e), "Response redirected to 'http://testserver/test_client/get_view/?var=value', expected 'http://testserver/test_client/get_view/'")

        try:

            self.assertRedirects(response, '/test_client/get_view/', msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Response redirected to 'http://testserver/test_client/get_view/?var=value', expected 'http://testserver/test_client/get_view/'")

    def test_incorrect_target(self):

        "An assertion is raised if the response redirects to another target"

        response = self.client.get('/test_client/permanent_redirect_view/')

        try:

            # Should redirect to get_view

            self.assertRedirects(response, '/test_client/some_view/')

        except AssertionError, e:

            self.assertEquals(str(e), "Response didn't redirect as expected: Response code was 301 (expected 302)")

    def test_target_page(self):

        "An assertion is raised if the response redirect target cannot be retrieved as expected"

        response = self.client.get('/test_client/double_redirect_view/')

        try:

            # The redirect target responds with a 301 code, not 200

            self.assertRedirects(response, 'http://testserver/test_client/permanent_redirect_view/')

        except AssertionError, e:

            self.assertEquals(str(e), "Couldn't retrieve redirection page '/test_client/permanent_redirect_view/': response code was 301 (expected 200)")

        try:

            # The redirect target responds with a 301 code, not 200

            self.assertRedirects(response, 'http://testserver/test_client/permanent_redirect_view/', msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Couldn't retrieve redirection page '/test_client/permanent_redirect_view/': response code was 301 (expected 200)")

    def test_redirect_chain(self):

        "You can follow a redirect chain of multiple redirects"

        response = self.client.get('/test_client_regress/redirects/further/more/', {}, follow=True)

        self.assertRedirects(response, '/test_client_regress/no_template_view/',

            status_code=301, target_status_code=200)

        self.assertEquals(len(response.redirect_chain), 1)

        self.assertEquals(response.redirect_chain[0], ('http://testserver/test_client_regress/no_template_view/', 301))

    def test_multiple_redirect_chain(self):

        "You can follow a redirect chain of multiple redirects"

        response = self.client.get('/test_client_regress/redirects/', {}, follow=True)

        self.assertRedirects(response, '/test_client_regress/no_template_view/',

            status_code=301, target_status_code=200)

        self.assertEquals(len(response.redirect_chain), 3)

        self.assertEquals(response.redirect_chain[0], ('http://testserver/test_client_regress/redirects/further/', 301))

        self.assertEquals(response.redirect_chain[1], ('http://testserver/test_client_regress/redirects/further/more/', 301))

        self.assertEquals(response.redirect_chain[2], ('http://testserver/test_client_regress/no_template_view/', 301))

    def test_redirect_chain_to_non_existent(self):

        "You can follow a chain to a non-existent view"

        response = self.client.get('/test_client_regress/redirect_to_non_existent_view2/', {}, follow=True)

        self.assertRedirects(response, '/test_client_regress/non_existent_view/',

            status_code=301, target_status_code=404)

    def test_redirect_chain_to_self(self):

        "Redirections to self are caught and escaped"

        response = self.client.get('/test_client_regress/redirect_to_self/', {}, follow=True)

        # The chain of redirects stops once the cycle is detected.

        self.assertRedirects(response, '/test_client_regress/redirect_to_self/',

            status_code=301, target_status_code=301)

        self.assertEquals(len(response.redirect_chain), 2)

    def test_circular_redirect(self):

        "Circular redirect chains are caught and escaped"

        response = self.client.get('/test_client_regress/circular_redirect_1/', {}, follow=True)

        # The chain of redirects will get back to the starting point, but stop there.

        self.assertRedirects(response, '/test_client_regress/circular_redirect_2/',

            status_code=301, target_status_code=301)

        self.assertEquals(len(response.redirect_chain), 4)

    def test_redirect_chain_post(self):

        "A redirect chain will be followed from an initial POST post"

        response = self.client.post('/test_client_regress/redirects/',

            {'nothing': 'to_send'}, follow=True)

        self.assertRedirects(response,

            '/test_client_regress/no_template_view/', 301, 200)

        self.assertEquals(len(response.redirect_chain), 3)

    def test_redirect_chain_head(self):

        "A redirect chain will be followed from an initial HEAD request"

        response = self.client.head('/test_client_regress/redirects/',

            {'nothing': 'to_send'}, follow=True)

        self.assertRedirects(response,

            '/test_client_regress/no_template_view/', 301, 200)

        self.assertEquals(len(response.redirect_chain), 3)

    def test_redirect_chain_options(self):

        "A redirect chain will be followed from an initial OPTIONS request"

        response = self.client.options('/test_client_regress/redirects/',

            {'nothing': 'to_send'}, follow=True)

        self.assertRedirects(response,

            '/test_client_regress/no_template_view/', 301, 200)

        self.assertEquals(len(response.redirect_chain), 3)

    def test_redirect_chain_put(self):

        "A redirect chain will be followed from an initial PUT request"

        response = self.client.put('/test_client_regress/redirects/',

            {'nothing': 'to_send'}, follow=True)

        self.assertRedirects(response,

            '/test_client_regress/no_template_view/', 301, 200)

        self.assertEquals(len(response.redirect_chain), 3)

    def test_redirect_chain_delete(self):

        "A redirect chain will be followed from an initial DELETE request"

        response = self.client.delete('/test_client_regress/redirects/',

            {'nothing': 'to_send'}, follow=True)

        self.assertRedirects(response,

            '/test_client_regress/no_template_view/', 301, 200)

        self.assertEquals(len(response.redirect_chain), 3)

    def test_redirect_chain_on_non_redirect_page(self):

        "An assertion is raised if the original page couldn't be retrieved as expected"

        # This page will redirect with code 301, not 302

        response = self.client.get('/test_client/get_view/', follow=True)

        try:

            self.assertRedirects(response, '/test_client/get_view/')

        except AssertionError, e:

            self.assertEquals(str(e), "Response didn't redirect as expected: Response code was 200 (expected 302)")

        try:

            self.assertRedirects(response, '/test_client/get_view/', msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Response didn't redirect as expected: Response code was 200 (expected 302)")

    def test_redirect_on_non_redirect_page(self):

        "An assertion is raised if the original page couldn't be retrieved as expected"

        # This page will redirect with code 301, not 302

        response = self.client.get('/test_client/get_view/')

        try:

            self.assertRedirects(response, '/test_client/get_view/')

        except AssertionError, e:

            self.assertEquals(str(e), "Response didn't redirect as expected: Response code was 200 (expected 302)")

        try:

            self.assertRedirects(response, '/test_client/get_view/', msg_prefix='abc')

        except AssertionError, e:

            self.assertEquals(str(e), "abc: Response didn't redirect as expected: Response code was 200 (expected 302)")

class AssertFormErrorTests(TestCase):

    def test_unknown_form(self):

        "An assertion is raised if the form name is unknown"

        post_data = {

            'text': 'Hello World',

            'email': 'not an email address',

            'value': 37,

            'single': 'b',

            'multi': ('b','c','e')

        }

        response = self.client.post('/test_client/form_view/', post_data)

        self.assertEqual(response.status_code, 200)

        self.assertTemplateUsed(response, "Invalid POST Template")

        try:

            self.assertFormError(response, 'wrong_form', 'some_field', 'Some error.')

        except AssertionError, e:

            self.assertEqual(str(e), "The form 'wrong_form' was not used to render the response")

        try:

            self.assertFormError(response, 'wrong_form', 'some_field', 'Some error.', msg_prefix='abc')

        except AssertionError, e:

            self.assertEqual(str(e), "abc: The form 'wrong_form' was not used to render the response")

    def test_unknown_field(self):

        "An assertion is raised if the field name is unknown"

        post_data = {

            'text': 'Hello World',

            'email': 'not an email address',

            'value': 37,

            'single': 'b',

            'multi': ('b','c','e')

        }

        response = self.client.post('/test_client/form_view/', post_data)

        self.assertEqual(response.status_code, 200)

        self.assertTemplateUsed(response, "Invalid POST Template")

        try:

            self.assertFormError(response, 'form', 'some_field', 'Some error.')

        except AssertionError, e:

            self.assertEqual(str(e), "The form 'form' in context 0 does not contain the field 'some_field'")

        try:

            self.assertFormError(response, 'form', 'some_field', 'Some error.', msg_prefix='abc')

        except AssertionError, e:

            self.assertEqual(str(e), "abc: The form 'form' in context 0 does not contain the field 'some_field'")

    def test_noerror_field(self):

        "An assertion is raised if the field doesn't have any errors"

        post_data = {

            'text': 'Hello World',

            'email': 'not an email address',

            'value': 37,

            'single': 'b',

            'multi': ('b','c','e')

        }

        response = self.client.post('/test_client/form_view/', post_data)

        self.assertEqual(response.status_code, 200)

        self.assertTemplateUsed(response, "Invalid POST Template")

        try:

            self.assertFormError(response, 'form', 'value', 'Some error.')

        except AssertionError, e:

            self.assertEqual(str(e), "The field 'value' on form 'form' in context 0 contains no errors")

        try:

            self.assertFormError(response, 'form', 'value', 'Some error.', msg_prefix='abc')

        except AssertionError, e:

            self.assertEqual(str(e), "abc: The field 'value' on form 'form' in context 0 contains no errors")

    def test_unknown_error(self):

        "An assertion is raised if the field doesn't contain the provided error"

        post_data = {

            'text': 'Hello World',

            'email': 'not an email address',

            'value': 37,

            'single': 'b',

            'multi': ('b','c','e')

        }

        response = self.client.post('/test_client/form_view/', post_data)

        self.assertEqual(response.status_code, 200)

        self.assertTemplateUsed(response, "Invalid POST Template")

        try:

            self.assertFormError(response, 'form', 'email', 'Some error.')

        except AssertionError, e:

            self.assertEqual(str(e), "The field 'email' on form 'form' in context 0 does not contain the error 'Some error.' (actual errors: [u'Enter a valid e-mail address.'])")

        try:

            self.assertFormError(response, 'form', 'email', 'Some error.', msg_prefix='abc')

        except AssertionError, e:

            self.assertEqual(str(e), "abc: The field 'email' on form 'form' in context 0 does not contain the error 'Some error.' (actual errors: [u'Enter a valid e-mail address.'])")

    def test_unknown_nonfield_error(self):

        """

        Checks that an assertion is raised if the form's non field errors

        doesn't contain the provided error.

        """

        post_data = {

            'text': 'Hello World',

            'email': 'not an email address',

            'value': 37,

            'single': 'b',

            'multi': ('b','c','e')

        }

        response = self.client.post('/test_client/form_view/', post_data)

        self.assertEqual(response.status_code, 200)

        self.assertTemplateUsed(response, "Invalid POST Template")

        try:

            self.assertFormError(response, 'form', None, 'Some error.')

        except AssertionError, e:

            self.assertEqual(str(e), "The form 'form' in context 0 does not contain the non-field error 'Some error.' (actual errors: )")

        try:

            self.assertFormError(response, 'form', None, 'Some error.', msg_prefix='abc')

        except AssertionError, e:

            self.assertEqual(str(e), "abc: The form 'form' in context 0 does not contain the non-field error 'Some error.' (actual errors: )")

class LoginTests(TestCase):

    fixtures = ['testdata']

    def test_login_different_client(self):

        "Check that using a different test client doesn't violate authentication"

        # Create a second client, and log in.

        c = Client()

        login = c.login(username='testclient', password='password')

        self.assertTrue(login, 'Could not log in')

        # Get a redirection page with the second client.

        response = c.get("/test_client_regress/login_protected_redirect_view/")

        # At this points, the self.client isn't logged in.

        # Check that assertRedirects uses the original client, not the

        # default client.

        self.assertRedirects(response, "http://testserver/test_client_regress/get_view/")

class SessionEngineTests(TestCase):

    fixtures = ['testdata']

    def setUp(self):

        self.old_SESSION_ENGINE = settings.SESSION_ENGINE

        settings.SESSION_ENGINE = 'regressiontests.test_client_regress.session'

    def tearDown(self):

        settings.SESSION_ENGINE = self.old_SESSION_ENGINE

    def test_login(self):

        "A session engine that modifies the session key can be used to log in"

        login = self.client.login(username='testclient', password='password')

        self.assertTrue(login, 'Could not log in')

        # Try to access a login protected page.

        response = self.client.get("/test_client/login_protected_view/")

        self.assertEqual(response.status_code, 200)

        self.assertEqual(response.context['user'].username, 'testclient')

class URLEscapingTests(TestCase):

    def test_simple_argument_get(self):

        "Get a view that has a simple string argument"

        response = self.client.get(reverse('arg_view', args=['Slartibartfast']))

        self.assertEqual(response.status_code, 200)

        self.assertEqual(response.content, 'Howdy, Slartibartfast')

    def test_argument_with_space_get(self):

        "Get a view that has a string argument that requires escaping"

        response = self.client.get(reverse('arg_view', args=['Arthur Dent']))

        self.assertEqual(response.status_code, 200)