Example #1
0
 def test_if_modified_since_and_redirect(self):
     self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
     self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
     self.resp['Location'] = '/'
     self.resp.status_code = 301
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 301)
Example #2
0
 def test_content_length_header_added(self):
     content_length = len(self.resp.content)
     # Already set by CommonMiddleware, remove it to check that
     # ConditionalGetMiddleware readds it.
     del self.resp['Content-Length']
     self.assertNotIn('Content-Length', self.resp)
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertIn('Content-Length', self.resp)
     self.assertEqual(int(self.resp['Content-Length']), content_length)
Example #3
0
 def test_if_none_match_and_same_etag(self):
     self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = '"spam"'
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 304)
Example #4
0
 def test_middleware_wont_overwrite_etag(self):
     self.resp['ETag'] = 'eggs'
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
     self.assertEqual('eggs', self.resp['ETag'])
Example #5
0
class ConditionalGetMiddlewareTest(SimpleTestCase):

    def setUp(self):
        self.req = RequestFactory().get('/')
        self.resp = self.client.get(self.req.path_info)

    # Tests for the ETag header

    def test_middleware_calculates_etag(self):
        self.assertNotIn('ETag', self.resp)
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)
        self.assertNotEqual('', self.resp['ETag'])

    def test_middleware_wont_overwrite_etag(self):
        self.resp['ETag'] = 'eggs'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)
        self.assertEqual('eggs', self.resp['ETag'])

    def test_no_etag_streaming_response(self):
        res = StreamingHttpResponse(['content'])
        self.assertFalse(ConditionalGetMiddleware().process_response(self.req, res).has_header('ETag'))

    def test_no_etag_no_store_cache(self):
        self.resp['Cache-Control'] = 'No-Cache, No-Store, Max-age=0'
        self.assertFalse(ConditionalGetMiddleware().process_response(self.req, self.resp).has_header('ETag'))

    def test_etag_extended_cache_control(self):
        self.resp['Cache-Control'] = 'my-directive="my-no-store"'
        self.assertTrue(ConditionalGetMiddleware().process_response(self.req, self.resp).has_header('ETag'))

    def test_if_none_match_and_no_etag(self):
        self.req.META['HTTP_IF_NONE_MATCH'] = 'spam'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_no_if_none_match_and_etag(self):
        self.resp['ETag'] = 'eggs'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_none_match_and_same_etag(self):
        self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = '"spam"'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 304)

    def test_if_none_match_and_different_etag(self):
        self.req.META['HTTP_IF_NONE_MATCH'] = 'spam'
        self.resp['ETag'] = 'eggs'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_none_match_and_redirect(self):
        self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = 'spam'
        self.resp['Location'] = '/'
        self.resp.status_code = 301
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 301)

    def test_if_none_match_and_client_error(self):
        self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = 'spam'
        self.resp.status_code = 400
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 400)

    # Tests for the Last-Modified header

    def test_if_modified_since_and_no_last_modified(self):
        self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_no_if_modified_since_and_last_modified(self):
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_modified_since_and_same_last_modified(self):
        self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 304)

    def test_if_modified_since_and_last_modified_in_the_past(self):
        self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 304)

    def test_if_modified_since_and_last_modified_in_the_future(self):
        self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:41:44 GMT'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_modified_since_and_redirect(self):
        self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
        self.resp['Location'] = '/'
        self.resp.status_code = 301
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 301)

    def test_if_modified_since_and_client_error(self):
        self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
        self.resp.status_code = 400
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 400)

    def test_not_modified_headers(self):
        """
        The 304 Not Modified response should include only the headers required
        by section 4.1 of RFC 7232, Last-Modified, and the cookies.
        """
        self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = '"spam"'
        self.resp['Date'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
        self.resp['Expires'] = 'Sun, 13 Feb 2011 17:35:44 GMT'
        self.resp['Vary'] = 'Cookie'
        self.resp['Cache-Control'] = 'public'
        self.resp['Content-Location'] = '/alt'
        self.resp['Content-Language'] = 'en'  # shouldn't be preserved
        self.resp.set_cookie('key', 'value')

        new_response = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(new_response.status_code, 304)
        for header in ('Cache-Control', 'Content-Location', 'Date', 'ETag', 'Expires', 'Last-Modified', 'Vary'):
            self.assertEqual(new_response[header], self.resp[header])
        self.assertEqual(new_response.cookies, self.resp.cookies)
        self.assertNotIn('Content-Language', new_response)

    def test_no_unsafe(self):
        """
        ConditionalGetMiddleware shouldn't return a conditional response on an
        unsafe request. A response has already been generated by the time
        ConditionalGetMiddleware is called, so it's too late to return a 412
        Precondition Failed.
        """
        get_response = ConditionalGetMiddleware().process_response(self.req, self.resp)
        etag = get_response['ETag']
        put_request = RequestFactory().put('/', HTTP_IF_MATCH=etag)
        put_response = HttpResponse(status=200)
        conditional_get_response = ConditionalGetMiddleware().process_response(put_request, put_response)
        self.assertEqual(conditional_get_response.status_code, 200)  # should never be a 412

    def test_no_head(self):
        """
        ConditionalGetMiddleware shouldn't compute and return an ETag on a
        HEAD request since it can't do so accurately without access to the
        response body of the corresponding GET.
        """
        request = RequestFactory().head('/')
        response = HttpResponse(status=200)
        conditional_get_response = ConditionalGetMiddleware().process_response(request, response)
        self.assertNotIn('ETag', conditional_get_response)
Example #6
0
 def test_if_none_match_and_redirect(self):
     self.req.META["HTTP_IF_NONE_MATCH"] = self.resp["ETag"] = "spam"
     self.resp["Location"] = "/"
     self.resp.status_code = 301
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 301)
Example #7
0
 def test_middleware_wont_overwrite_etag(self):
     self.resp["ETag"] = "eggs"
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
     self.assertEqual("eggs", self.resp["ETag"])
Example #8
0
 def test_content_length_header_not_changed(self):
     bad_content_length = len(self.resp.content) + 10
     self.resp['Content-Length'] = bad_content_length
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(int(self.resp['Content-Length']), bad_content_length)
Example #9
0
 def test_content_length_header_added(self):
     content_length = len(self.resp.content)
     self.assertNotIn('Content-Length', self.resp)
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertIn('Content-Length', self.resp)
     self.assertEqual(int(self.resp['Content-Length']), content_length)
Example #10
0
 def test_if_none_match_and_same_etag(self):
     self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = '"spam"'
     self.resp = ConditionalGetMiddleware().process_response(
         self.req, self.resp)
     self.assertEqual(self.resp.status_code, 304)
Example #11
0
 def test_etag_extended_cache_control(self):
     self.resp['Cache-Control'] = 'my-directive="my-no-store"'
     self.assertTrue(ConditionalGetMiddleware().process_response(
         self.req, self.resp).has_header('ETag'))
Example #12
0
 def test_no_etag_no_store_cache(self):
     self.resp['Cache-Control'] = 'No-Cache, No-Store, Max-age=0'
     self.assertFalse(ConditionalGetMiddleware().process_response(
         self.req, self.resp).has_header('ETag'))
Example #13
0
 def test_no_etag_streaming_response(self):
     res = StreamingHttpResponse(['content'])
     self.assertFalse(ConditionalGetMiddleware().process_response(
         self.req, res).has_header('ETag'))
Example #14
0
 def test_middleware_wont_overwrite_etag(self):
     self.resp['ETag'] = 'eggs'
     self.resp = ConditionalGetMiddleware().process_response(
         self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
     self.assertEqual('eggs', self.resp['ETag'])
Example #15
0
 def test_if_none_match_and_redirect(self):
     self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = 'spam'
     self.resp['Location'] = '/'
     self.resp.status_code = 301
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 301)
Example #16
0
 def test_no_if_modified_since_and_last_modified(self):
     self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
Example #17
0
 def test_if_none_match_and_redirect(self):
     self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = 'spam'
     self.resp['Location'] = '/'
     self.resp.status_code = 301
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 301)
Example #18
0
 def test_middleware_calculates_etag(self):
     self.assertNotIn('ETag', self.resp)
     self.resp = ConditionalGetMiddleware().process_response(
         self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
     self.assertNotEqual('', self.resp['ETag'])
Example #19
0
 def test_if_modified_since_and_client_error(self):
     self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
     self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
     self.resp.status_code = 400
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 400)
Example #20
0
class ConditionalGetMiddlewareTest(SimpleTestCase):
    def setUp(self):
        self.req = RequestFactory().get("/")
        self.resp = self.client.get(self.req.path_info)

    # Tests for the ETag header

    def test_middleware_calculates_etag(self):
        self.assertNotIn("ETag", self.resp)
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)
        self.assertNotEqual("", self.resp["ETag"])

    def test_middleware_wont_overwrite_etag(self):
        self.resp["ETag"] = "eggs"
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)
        self.assertEqual("eggs", self.resp["ETag"])

    def test_no_etag_streaming_response(self):
        res = StreamingHttpResponse(["content"])
        self.assertFalse(ConditionalGetMiddleware().process_response(self.req, res).has_header("ETag"))

    def test_no_etag_no_store_cache(self):
        self.resp["Cache-Control"] = "No-Cache, No-Store, Max-age=0"
        self.assertFalse(ConditionalGetMiddleware().process_response(self.req, self.resp).has_header("ETag"))

    def test_etag_extended_cache_control(self):
        self.resp["Cache-Control"] = 'my-directive="my-no-store"'
        self.assertTrue(ConditionalGetMiddleware().process_response(self.req, self.resp).has_header("ETag"))

    def test_if_none_match_and_no_etag(self):
        self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_no_if_none_match_and_etag(self):
        self.resp["ETag"] = "eggs"
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_none_match_and_same_etag(self):
        self.req.META["HTTP_IF_NONE_MATCH"] = self.resp["ETag"] = '"spam"'
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 304)

    def test_if_none_match_and_different_etag(self):
        self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
        self.resp["ETag"] = "eggs"
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_none_match_and_redirect(self):
        self.req.META["HTTP_IF_NONE_MATCH"] = self.resp["ETag"] = "spam"
        self.resp["Location"] = "/"
        self.resp.status_code = 301
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 301)

    def test_if_none_match_and_client_error(self):
        self.req.META["HTTP_IF_NONE_MATCH"] = self.resp["ETag"] = "spam"
        self.resp.status_code = 400
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 400)

    # Tests for the Last-Modified header

    def test_if_modified_since_and_no_last_modified(self):
        self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_no_if_modified_since_and_last_modified(self):
        self.resp["Last-Modified"] = "Sat, 12 Feb 2011 17:38:44 GMT"
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_modified_since_and_same_last_modified(self):
        self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
        self.resp["Last-Modified"] = "Sat, 12 Feb 2011 17:38:44 GMT"
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 304)

    def test_if_modified_since_and_last_modified_in_the_past(self):
        self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
        self.resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 304)

    def test_if_modified_since_and_last_modified_in_the_future(self):
        self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
        self.resp["Last-Modified"] = "Sat, 12 Feb 2011 17:41:44 GMT"
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_modified_since_and_redirect(self):
        self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
        self.resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
        self.resp["Location"] = "/"
        self.resp.status_code = 301
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 301)

    def test_if_modified_since_and_client_error(self):
        self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
        self.resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
        self.resp.status_code = 400
        self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(self.resp.status_code, 400)

    def test_not_modified_headers(self):
        """
        The 304 Not Modified response should include only the headers required
        by section 4.1 of RFC 7232, Last-Modified, and the cookies.
        """
        self.req.META["HTTP_IF_NONE_MATCH"] = self.resp["ETag"] = '"spam"'
        self.resp["Date"] = "Sat, 12 Feb 2011 17:35:44 GMT"
        self.resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
        self.resp["Expires"] = "Sun, 13 Feb 2011 17:35:44 GMT"
        self.resp["Vary"] = "Cookie"
        self.resp["Cache-Control"] = "public"
        self.resp["Content-Location"] = "/alt"
        self.resp["Content-Language"] = "en"  # shouldn't be preserved
        self.resp.set_cookie("key", "value")

        new_response = ConditionalGetMiddleware().process_response(self.req, self.resp)
        self.assertEqual(new_response.status_code, 304)
        for header in ("Cache-Control", "Content-Location", "Date", "ETag", "Expires", "Last-Modified", "Vary"):
            self.assertEqual(new_response[header], self.resp[header])
        self.assertEqual(new_response.cookies, self.resp.cookies)
        self.assertNotIn("Content-Language", new_response)

    def test_no_unsafe(self):
        """
        ConditionalGetMiddleware shouldn't return a conditional response on an
        unsafe request. A response has already been generated by the time
        ConditionalGetMiddleware is called, so it's too late to return a 412
        Precondition Failed.
        """
        get_response = ConditionalGetMiddleware().process_response(self.req, self.resp)
        etag = get_response["ETag"]
        put_request = RequestFactory().put("/", HTTP_IF_MATCH=etag)
        put_response = HttpResponse(status=200)
        conditional_get_response = ConditionalGetMiddleware().process_response(put_request, put_response)
        self.assertEqual(conditional_get_response.status_code, 200)  # should never be a 412

    def test_no_head(self):
        """
        ConditionalGetMiddleware shouldn't compute and return an ETag on a
        HEAD request since it can't do so accurately without access to the
        response body of the corresponding GET.
        """
        request = RequestFactory().head("/")
        response = HttpResponse(status=200)
        conditional_get_response = ConditionalGetMiddleware().process_response(request, response)
        self.assertNotIn("ETag", conditional_get_response)
Example #21
0
 def test_if_none_match_and_client_error(self):
     self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = 'spam'
     self.resp.status_code = 400
     self.resp = ConditionalGetMiddleware().process_response(
         self.req, self.resp)
     self.assertEqual(self.resp.status_code, 400)
Example #22
0
 def test_if_none_match_and_different_etag(self):
     self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
     self.resp["ETag"] = "eggs"
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
Example #23
0
 def test_no_if_modified_since_and_last_modified(self):
     self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
     self.resp = ConditionalGetMiddleware().process_response(
         self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
Example #24
0
 def test_if_modified_since_and_last_modified_in_the_past(self):
     self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
     self.resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 304)
Example #25
0
 def test_date_header_added(self):
     self.assertFalse('Date' in self.resp)
     self.resp = ConditionalGetMiddleware().process_response(
         self.req, self.resp)
     self.assertTrue('Date' in self.resp)
Example #26
0
 def test_middleware_calculates_etag(self):
     self.assertNotIn('ETag', self.resp)
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
     self.assertNotEqual('', self.resp['ETag'])
Example #27
0
 def test_content_length_header_not_added(self):
     resp = StreamingHttpResponse('content')
     self.assertFalse('Content-Length' in resp)
     resp = ConditionalGetMiddleware().process_response(self.req, resp)
     self.assertFalse('Content-Length' in resp)
Example #28
0
 def test_no_if_none_match_and_etag(self):
     self.resp['ETag'] = 'eggs'
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
Example #29
0
 def test_content_length_header_not_changed(self):
     bad_content_length = len(self.resp.content) + 10
     self.resp['Content-Length'] = bad_content_length
     self.resp = ConditionalGetMiddleware().process_response(
         self.req, self.resp)
     self.assertEqual(int(self.resp['Content-Length']), bad_content_length)
Example #30
0
 def test_if_none_match_and_different_etag(self):
     self.req.META['HTTP_IF_NONE_MATCH'] = 'spam'
     self.resp['ETag'] = 'eggs'
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
Example #31
0
 def test_no_if_none_match_and_etag(self):
     self.resp['ETag'] = 'eggs'
     self.resp = ConditionalGetMiddleware().process_response(
         self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
Example #32
0
 def test_if_none_match_and_client_error(self):
     self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = 'spam'
     self.resp.status_code = 400
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 400)
Example #33
0
 def test_if_none_match_and_different_etag(self):
     self.req.META['HTTP_IF_NONE_MATCH'] = 'spam'
     self.resp['ETag'] = 'eggs'
     self.resp = ConditionalGetMiddleware().process_response(
         self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
Example #34
0
 def test_if_modified_since_and_last_modified_in_the_future(self):
     self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
     self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:41:44 GMT'
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
Example #35
0
 def test_if_modified_since_and_no_last_modified(self):
     self.req.META[
         'HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
     self.resp = ConditionalGetMiddleware().process_response(
         self.req, self.resp)
     self.assertEqual(self.resp.status_code, 200)
Example #36
0
 def test_if_modified_since_and_client_error(self):
     self.req.META['HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
     self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
     self.resp.status_code = 400
     self.resp = ConditionalGetMiddleware().process_response(self.req, self.resp)
     self.assertEqual(self.resp.status_code, 400)
Example #37
0
class ConditionalGetMiddlewareTest(SimpleTestCase):
    request_factory = RequestFactory()

    def setUp(self):
        self.req = self.request_factory.get('/')
        self.resp = self.client.get(self.req.path_info)

    # Tests for the ETag header

    def test_middleware_calculates_etag(self):
        self.assertNotIn('ETag', self.resp)
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)
        self.assertNotEqual('', self.resp['ETag'])

    def test_middleware_wont_overwrite_etag(self):
        self.resp['ETag'] = 'eggs'
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)
        self.assertEqual('eggs', self.resp['ETag'])

    def test_no_etag_streaming_response(self):
        res = StreamingHttpResponse(['content'])
        self.assertFalse(ConditionalGetMiddleware().process_response(
            self.req, res).has_header('ETag'))

    def test_no_etag_no_store_cache(self):
        self.resp['Cache-Control'] = 'No-Cache, No-Store, Max-age=0'
        self.assertFalse(ConditionalGetMiddleware().process_response(
            self.req, self.resp).has_header('ETag'))

    def test_etag_extended_cache_control(self):
        self.resp['Cache-Control'] = 'my-directive="my-no-store"'
        self.assertTrue(ConditionalGetMiddleware().process_response(
            self.req, self.resp).has_header('ETag'))

    def test_if_none_match_and_no_etag(self):
        self.req.META['HTTP_IF_NONE_MATCH'] = 'spam'
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_no_if_none_match_and_etag(self):
        self.resp['ETag'] = 'eggs'
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_none_match_and_same_etag(self):
        self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = '"spam"'
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 304)

    def test_if_none_match_and_different_etag(self):
        self.req.META['HTTP_IF_NONE_MATCH'] = 'spam'
        self.resp['ETag'] = 'eggs'
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_none_match_and_redirect(self):
        self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = 'spam'
        self.resp['Location'] = '/'
        self.resp.status_code = 301
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 301)

    def test_if_none_match_and_client_error(self):
        self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = 'spam'
        self.resp.status_code = 400
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 400)

    # Tests for the Last-Modified header

    def test_if_modified_since_and_no_last_modified(self):
        self.req.META[
            'HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_no_if_modified_since_and_last_modified(self):
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_modified_since_and_same_last_modified(self):
        self.req.META[
            'HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 304)

    def test_if_modified_since_and_last_modified_in_the_past(self):
        self.req.META[
            'HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 304)

    def test_if_modified_since_and_last_modified_in_the_future(self):
        self.req.META[
            'HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:41:44 GMT'
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 200)

    def test_if_modified_since_and_redirect(self):
        self.req.META[
            'HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
        self.resp['Location'] = '/'
        self.resp.status_code = 301
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 301)

    def test_if_modified_since_and_client_error(self):
        self.req.META[
            'HTTP_IF_MODIFIED_SINCE'] = 'Sat, 12 Feb 2011 17:38:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
        self.resp.status_code = 400
        self.resp = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(self.resp.status_code, 400)

    def test_not_modified_headers(self):
        """
        The 304 Not Modified response should include only the headers required
        by section 4.1 of RFC 7232, Last-Modified, and the cookies.
        """
        self.req.META['HTTP_IF_NONE_MATCH'] = self.resp['ETag'] = '"spam"'
        self.resp['Date'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
        self.resp['Last-Modified'] = 'Sat, 12 Feb 2011 17:35:44 GMT'
        self.resp['Expires'] = 'Sun, 13 Feb 2011 17:35:44 GMT'
        self.resp['Vary'] = 'Cookie'
        self.resp['Cache-Control'] = 'public'
        self.resp['Content-Location'] = '/alt'
        self.resp['Content-Language'] = 'en'  # shouldn't be preserved
        self.resp.set_cookie('key', 'value')

        new_response = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        self.assertEqual(new_response.status_code, 304)
        for header in ('Cache-Control', 'Content-Location', 'Date', 'ETag',
                       'Expires', 'Last-Modified', 'Vary'):
            self.assertEqual(new_response[header], self.resp[header])
        self.assertEqual(new_response.cookies, self.resp.cookies)
        self.assertNotIn('Content-Language', new_response)

    def test_no_unsafe(self):
        """
        ConditionalGetMiddleware shouldn't return a conditional response on an
        unsafe request. A response has already been generated by the time
        ConditionalGetMiddleware is called, so it's too late to return a 412
        Precondition Failed.
        """
        get_response = ConditionalGetMiddleware().process_response(
            self.req, self.resp)
        etag = get_response['ETag']
        put_request = self.request_factory.put('/', HTTP_IF_MATCH=etag)
        put_response = HttpResponse(status=200)
        conditional_get_response = ConditionalGetMiddleware().process_response(
            put_request, put_response)
        self.assertEqual(conditional_get_response.status_code,
                         200)  # should never be a 412

    def test_no_head(self):
        """
        ConditionalGetMiddleware shouldn't compute and return an ETag on a
        HEAD request since it can't do so accurately without access to the
        response body of the corresponding GET.
        """
        request = self.request_factory.head('/')
        response = HttpResponse(status=200)
        conditional_get_response = ConditionalGetMiddleware().process_response(
            request, response)
        self.assertNotIn('ETag', conditional_get_response)