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

     2 

     3 from django.conf import settings

     4 from django.http import HttpRequest

     5 from django.middleware.common import CommonMiddleware

     6 from django.test import TestCase

     7 

     8 

     9 class CommonMiddlewareTest(TestCase):

    10     def setUp(self):

    11         self.slash = settings.APPEND_SLASH

    12         self.www = settings.PREPEND_WWW

    13 

    14     def tearDown(self):

    15         settings.APPEND_SLASH = self.slash

    16         settings.PREPEND_WWW = self.www

    17 

    18     def _get_request(self, path):

    19         request = HttpRequest()

    20         request.META = {

    21             'SERVER_NAME': 'testserver',

    22             'SERVER_PORT': 80,

    23         }

    24         request.path = request.path_info = "/middleware/%s" % path

    25         return request

    26 

    27     def test_append_slash_have_slash(self):

    28         """

    29         Tests that URLs with slashes go unmolested.

    30         """

    31         settings.APPEND_SLASH = True

    32         request = self._get_request('slash/')

    33         self.assertEquals(CommonMiddleware().process_request(request), None)

    34 

    35     def test_append_slash_slashless_resource(self):

    36         """

    37         Tests that matches to explicit slashless URLs go unmolested.

    38         """

    39         settings.APPEND_SLASH = True

    40         request = self._get_request('noslash')

    41         self.assertEquals(CommonMiddleware().process_request(request), None)

    42 

    43     def test_append_slash_slashless_unknown(self):

    44         """

    45         Tests that APPEND_SLASH doesn't redirect to unknown resources.

    46         """

    47         settings.APPEND_SLASH = True

    48         request = self._get_request('unknown')

    49         self.assertEquals(CommonMiddleware().process_request(request), None)

    50 

    51     def test_append_slash_redirect(self):

    52         """

    53         Tests that APPEND_SLASH redirects slashless URLs to a valid pattern.

    54         """

    55         settings.APPEND_SLASH = True

    56         request = self._get_request('slash')

    57         r = CommonMiddleware().process_request(request)

    58         self.assertEquals(r.status_code, 301)

    59         self.assertEquals(r['Location'], 'http://testserver/middleware/slash/')

    60 

    61     def test_append_slash_no_redirect_on_POST_in_DEBUG(self):

    62         """

    63         Tests that while in debug mode, an exception is raised with a warning

    64         when a failed attempt is made to POST to an URL which would normally be

    65         redirected to a slashed version.

    66         """

    67         settings.APPEND_SLASH = True

    68         settings.DEBUG = True

    69         request = self._get_request('slash')

    70         request.method = 'POST'

    71         self.assertRaises(

    72             RuntimeError,

    73             CommonMiddleware().process_request,

    74             request)

    75         try:

    76             CommonMiddleware().process_request(request)

    77         except RuntimeError, e:

    78             self.assertTrue('end in a slash' in str(e))

    79         settings.DEBUG = False

    80 

    81     def test_append_slash_disabled(self):

    82         """

    83         Tests disabling append slash functionality.

    84         """

    85         settings.APPEND_SLASH = False

    86         request = self._get_request('slash')

    87         self.assertEquals(CommonMiddleware().process_request(request), None)

    88 

    89     def test_append_slash_quoted(self):

    90         """

    91         Tests that URLs which require quoting are redirected to their slash

    92         version ok.

    93         """

    94         settings.APPEND_SLASH = True

    95         request = self._get_request('needsquoting#')

    96         r = CommonMiddleware().process_request(request)

    97         self.assertEquals(r.status_code, 301)

    98         self.assertEquals(

    99             r['Location'],

   100             'http://testserver/middleware/needsquoting%23/')

   101 

   102     def test_prepend_www(self):

   103         settings.PREPEND_WWW = True

   104         settings.APPEND_SLASH = False

   105         request = self._get_request('path/')

   106         r = CommonMiddleware().process_request(request)

   107         self.assertEquals(r.status_code, 301)

   108         self.assertEquals(

   109             r['Location'],

   110             'http://www.testserver/middleware/path/')

   111 

   112     def test_prepend_www_append_slash_have_slash(self):

   113         settings.PREPEND_WWW = True

   114         settings.APPEND_SLASH = True

   115         request = self._get_request('slash/')

   116         r = CommonMiddleware().process_request(request)

   117         self.assertEquals(r.status_code, 301)

   118         self.assertEquals(r['Location'],

   119                           'http://www.testserver/middleware/slash/')

   120 

   121     def test_prepend_www_append_slash_slashless(self):

   122         settings.PREPEND_WWW = True

   123         settings.APPEND_SLASH = True

   124         request = self._get_request('slash')

   125         r = CommonMiddleware().process_request(request)

   126         self.assertEquals(r.status_code, 301)

   127         self.assertEquals(r['Location'],

   128                           'http://www.testserver/middleware/slash/')

   129 

   130 

   131     # The following tests examine expected behavior given a custom urlconf that

   132     # overrides the default one through the request object.

   133 

   134     def test_append_slash_have_slash_custom_urlconf(self):

   135       """

   136       Tests that URLs with slashes go unmolested.

   137       """

   138       settings.APPEND_SLASH = True

   139       request = self._get_request('customurlconf/slash/')

   140       request.urlconf = 'regressiontests.middleware.extra_urls'

   141       self.assertEquals(CommonMiddleware().process_request(request), None)

   142 

   143     def test_append_slash_slashless_resource_custom_urlconf(self):

   144       """

   145       Tests that matches to explicit slashless URLs go unmolested.

   146       """

   147       settings.APPEND_SLASH = True

   148       request = self._get_request('customurlconf/noslash')

   149       request.urlconf = 'regressiontests.middleware.extra_urls'

   150       self.assertEquals(CommonMiddleware().process_request(request), None)

   151 

   152     def test_append_slash_slashless_unknown_custom_urlconf(self):

   153       """

   154       Tests that APPEND_SLASH doesn't redirect to unknown resources.

   155       """

   156       settings.APPEND_SLASH = True

   157       request = self._get_request('customurlconf/unknown')

   158       request.urlconf = 'regressiontests.middleware.extra_urls'

   159       self.assertEquals(CommonMiddleware().process_request(request), None)

   160 

   161     def test_append_slash_redirect_custom_urlconf(self):

   162       """

   163       Tests that APPEND_SLASH redirects slashless URLs to a valid pattern.

   164       """

   165       settings.APPEND_SLASH = True

   166       request = self._get_request('customurlconf/slash')

   167       request.urlconf = 'regressiontests.middleware.extra_urls'

   168       r = CommonMiddleware().process_request(request)

   169       self.assertFalse(r is None,

   170           "CommonMiddlware failed to return APPEND_SLASH redirect using request.urlconf")

   171       self.assertEquals(r.status_code, 301)

   172       self.assertEquals(r['Location'], 'http://testserver/middleware/customurlconf/slash/')

   173 

   174     def test_append_slash_no_redirect_on_POST_in_DEBUG_custom_urlconf(self):

   175       """

   176       Tests that while in debug mode, an exception is raised with a warning

   177       when a failed attempt is made to POST to an URL which would normally be

   178       redirected to a slashed version.

   179       """

   180       settings.APPEND_SLASH = True

   181       settings.DEBUG = True

   182       request = self._get_request('customurlconf/slash')

   183       request.urlconf = 'regressiontests.middleware.extra_urls'

   184       request.method = 'POST'

   185       self.assertRaises(

   186           RuntimeError,

   187           CommonMiddleware().process_request,

   188           request)

   189       try:

   190           CommonMiddleware().process_request(request)

   191       except RuntimeError, e:

   192           self.assertTrue('end in a slash' in str(e))

   193       settings.DEBUG = False

   194 

   195     def test_append_slash_disabled_custom_urlconf(self):

   196       """

   197       Tests disabling append slash functionality.

   198       """

   199       settings.APPEND_SLASH = False

   200       request = self._get_request('customurlconf/slash')

   201       request.urlconf = 'regressiontests.middleware.extra_urls'

   202       self.assertEquals(CommonMiddleware().process_request(request), None)

   203 

   204     def test_append_slash_quoted_custom_urlconf(self):

   205       """

   206       Tests that URLs which require quoting are redirected to their slash

   207       version ok.

   208       """

   209       settings.APPEND_SLASH = True

   210       request = self._get_request('customurlconf/needsquoting#')

   211       request.urlconf = 'regressiontests.middleware.extra_urls'

   212       r = CommonMiddleware().process_request(request)

   213       self.assertFalse(r is None,

   214           "CommonMiddlware failed to return APPEND_SLASH redirect using request.urlconf")

   215       self.assertEquals(r.status_code, 301)

   216       self.assertEquals(

   217           r['Location'],

   218           'http://testserver/middleware/customurlconf/needsquoting%23/')

   219 

   220     def test_prepend_www_custom_urlconf(self):

   221       settings.PREPEND_WWW = True

   222       settings.APPEND_SLASH = False

   223       request = self._get_request('customurlconf/path/')

   224       request.urlconf = 'regressiontests.middleware.extra_urls'

   225       r = CommonMiddleware().process_request(request)

   226       self.assertEquals(r.status_code, 301)

   227       self.assertEquals(

   228           r['Location'],

   229           'http://www.testserver/middleware/customurlconf/path/')

   230 

   231     def test_prepend_www_append_slash_have_slash_custom_urlconf(self):

   232       settings.PREPEND_WWW = True

   233       settings.APPEND_SLASH = True

   234       request = self._get_request('customurlconf/slash/')

   235       request.urlconf = 'regressiontests.middleware.extra_urls'

   236       r = CommonMiddleware().process_request(request)

   237       self.assertEquals(r.status_code, 301)

   238       self.assertEquals(r['Location'],

   239                         'http://www.testserver/middleware/customurlconf/slash/')

   240 

   241     def test_prepend_www_append_slash_slashless_custom_urlconf(self):

   242       settings.PREPEND_WWW = True

   243       settings.APPEND_SLASH = True

   244       request = self._get_request('customurlconf/slash')

   245       request.urlconf = 'regressiontests.middleware.extra_urls'

   246       r = CommonMiddleware().process_request(request)

   247       self.assertEquals(r.status_code, 301)

   248       self.assertEquals(r['Location'],

   249                         'http://www.testserver/middleware/customurlconf/slash/')