def test_cache_write_unpicklable_object(self):
fetch_middleware = FetchFromCacheMiddleware(empty_response)
fetch_middleware.cache = cache
request = self.factory.get("/cache/test")
request._cache_update_cache = True
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(
request
)
assert get_cache_data is None
content = "Testing cookie serialization."
def get_response(req):
response = HttpResponse(content)
response.set_cookie("foo", "bar")
return response
update_middleware = UpdateCacheMiddleware(get_response)
update_middleware.cache = cache
response = update_middleware(request)
get_cache_data = fetch_middleware.process_request(request)
assert get_cache_data is not None
assert get_cache_data.content == content.encode()
assert get_cache_data.cookies == response.cookies
UpdateCacheMiddleware(lambda req: get_cache_data)(request)
get_cache_data = fetch_middleware.process_request(request)
assert get_cache_data is not None
assert get_cache_data.content == content.encode()
assert get_cache_data.cookies == response.cookies
def test_cache_write_unpickable_object(self):
update_middleware = UpdateCacheMiddleware()
update_middleware.cache = self.cache
fetch_middleware = FetchFromCacheMiddleware()
fetch_middleware.cache = self.cache
request = self._get_request_cache('/cache/test')
get_cache_data = FetchFromCacheMiddleware().process_request(request)
self.assertEqual(get_cache_data, None)
response = HttpResponse()
content = 'Testing cookie serialization.'
response.content = content
response.set_cookie('foo', 'bar')
update_middleware.process_response(request, response)
get_cache_data = fetch_middleware.process_request(request)
self.assertNotEqual(get_cache_data, None)
self.assertEqual(get_cache_data.content, content.encode('utf-8'))
self.assertEqual(get_cache_data.cookies, response.cookies)
update_middleware.process_response(request, get_cache_data)
get_cache_data = fetch_middleware.process_request(request)
self.assertNotEqual(get_cache_data, None)
self.assertEqual(get_cache_data.content, content.encode('utf-8'))
self.assertEqual(get_cache_data.cookies, response.cookies)
def test_cache_write_unpickable_object(self):
update_middleware = UpdateCacheMiddleware()
update_middleware.cache = cache
fetch_middleware = FetchFromCacheMiddleware()
fetch_middleware.cache = cache
factory = RequestFactory()
request = factory.get("/cache/test")
request._cache_update_cache = True
get_cache_data = FetchFromCacheMiddleware().process_request(request)
assert get_cache_data is None
response = HttpResponse()
content = "Testing cookie serialization."
response.content = content
response.set_cookie("foo", "bar")
update_middleware.process_response(request, response)
get_cache_data = fetch_middleware.process_request(request)
assert get_cache_data is not None
assert get_cache_data.content == content.encode("utf-8")
assert get_cache_data.cookies == response.cookies
update_middleware.process_response(request, get_cache_data)
get_cache_data = fetch_middleware.process_request(request)
assert get_cache_data is not None
assert get_cache_data.content == content.encode("utf-8")
assert get_cache_data.cookies == response.cookies
def test_vary_with_original_update_cache_middleware(self):
"""
Mainly to demonstrate the need to remove the Vary: Cookie header
during caching. Same basic test as test_vary() but with django's
UpdateCacheMiddleware instead of PatchedVaryUpdateCacheMiddleware.
This does not get a cache hit if the cookies are not the same.
"""
request = self.factory.get('/')
request.method = 'GET'
request.COOKIES = {'test': 'foo'}
request.META['HTTP_COOKIE'] = 'test=foo'
response = HttpResponse()
patch_vary_headers(response, ['Cookie'])
response.set_cookie('test', 'foo')
SessionMiddleware().process_request(request)
AuthenticationMiddleware().process_request(request)
cache_hit = FetchFromCacheMiddleware().process_request(request)
self.assertEqual(cache_hit, None)
response = UpdateCacheMiddleware().process_response(request, response)
cache_hit = FetchFromCacheMiddleware().process_request(request)
self.assertTrue(isinstance(cache_hit, HttpResponse))
new_request = self.factory.get('/')
new_request.method = 'GET'
# note: not using cookies here. this demonstrates that cookies don't
# affect the cache key
cache_hit = FetchFromCacheMiddleware().process_request(new_request)
self.assertEqual(cache_hit, None)
def test_middleware(self):
def set_cache(request, lang, msg):
translation.activate(lang)
response = HttpResponse()
response.content = msg
return UpdateCacheMiddleware().process_response(request, response)
settings.CACHE_MIDDLEWARE_SECONDS = 60
settings.CACHE_MIDDLEWARE_KEY_PREFIX = "test"
settings.CACHE_BACKEND = 'locmem:///'
settings.USE_I18N = True
en_message = "Hello world!"
es_message = "Hola mundo!"
request = self._get_request_cache()
set_cache(request, 'en', en_message)
get_cache_data = FetchFromCacheMiddleware().process_request(request)
# Check that we can recover the cache
self.assertNotEqual(get_cache_data.content, None)
self.assertEqual(en_message, get_cache_data.content)
# change the session language and set content
request = self._get_request_cache()
set_cache(request, 'es', es_message)
# change again the language
translation.activate('en')
# retrieve the content from cache
get_cache_data = FetchFromCacheMiddleware().process_request(request)
self.assertEqual(get_cache_data.content, en_message)
# change again the language
translation.activate('es')
get_cache_data = FetchFromCacheMiddleware().process_request(request)
self.assertEqual(get_cache_data.content, es_message)
def test_vary(self):
"""
Ensure caching works even when cookies are present and `Vary: Cookie` is on.
"""
request = self.factory.get('/test/vary')
request.COOKIES = {'test': 'foo'}
request.META['HTTP_COOKIE'] = 'test=foo'
response = HttpResponse()
patch_vary_headers(response, ['Cookie'])
response.set_cookie('test', 'foo')
SessionMiddleware().process_request(request)
AuthenticationMiddleware().process_request(request)
cache_hit = FetchFromCacheMiddleware().process_request(request)
self.assertTrue(cache_hit is None)
response = PatchedVaryUpdateCacheMiddleware().process_response(request, response)
cache_hit = FetchFromCacheMiddleware().process_request(request)
self.assertTrue(isinstance(cache_hit, HttpResponse))
new_request = self.factory.get('/test/vary')
# note: not using cookies here. this demonstrates that cookies don't
# affect the cache key
cache_hit = FetchFromCacheMiddleware().process_request(new_request)
self.assertTrue(isinstance(cache_hit, HttpResponse))
def test_cache_write_unpicklable_object(self):
fetch_middleware = FetchFromCacheMiddleware(empty_response)
fetch_middleware.cache = cache
request = self.factory.get('/cache/test')
request._cache_update_cache = True
get_cache_data = FetchFromCacheMiddleware(
empty_response).process_request(request)
self.assertIsNone(get_cache_data)
content = 'Testing cookie serialization.'
def get_response(req):
response = HttpResponse(content)
response.set_cookie('foo', 'bar')
return response
update_middleware = UpdateCacheMiddleware(get_response)
update_middleware.cache = cache
response = update_middleware(request)
get_cache_data = fetch_middleware.process_request(request)
self.assertIsNotNone(get_cache_data)
self.assertEqual(get_cache_data.content, content.encode())
self.assertEqual(get_cache_data.cookies, response.cookies)
UpdateCacheMiddleware(lambda req: get_cache_data)(request)
get_cache_data = fetch_middleware.process_request(request)
self.assertIsNotNone(get_cache_data)
self.assertEqual(get_cache_data.content, content.encode())
self.assertEqual(get_cache_data.cookies, response.cookies)
def test_no_vary(self):
"""
Ensure basic caching works.
"""
request = self.factory.get('/test/no-vary')
response = HttpResponse()
SessionMiddleware().process_request(request)
AuthenticationMiddleware().process_request(request)
cache_hit = FetchFromCacheMiddleware().process_request(request)
self.assertEqual(cache_hit, None)
response = PatchedVaryUpdateCacheMiddleware().process_response(request, response)
cache_hit = FetchFromCacheMiddleware().process_request(request)
self.assertTrue(isinstance(cache_hit, HttpResponse))
def test_head_with_cached_get(self):
test_content = 'test content'
request = self._get_request_cache('GET')
self._set_cache(request, test_content)
request = self._get_request('HEAD')
get_cache_data = FetchFromCacheMiddleware().process_request(request)
self.assertNotEqual(get_cache_data, None)
self.assertEqual(test_content, get_cache_data.content)
def _cache_miss(self, path):
request = self._get_request('GET', path)
get_cache_data = FetchFromCacheMiddleware().process_request(request)
return get_cache_data is None