Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Beefed up the tests for multi-cache handling of the cache middleware …

…and view decorators, and made a couple of tweaks for edge cases as a result.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@15021 bcc190cf-cafb-0310-a4f2-bffc1f526a37
  • Loading branch information...
commit b22415214a7bdeaf8ccd7b8b21872038ab865991 1 parent 0fef92f
@freakboy3742 freakboy3742 authored
View
39 django/middleware/cache.py
@@ -85,7 +85,7 @@ def process_response(self, request, response):
return response
patch_response_headers(response, timeout)
if timeout:
- cache_key = learn_cache_key(request, response, timeout, self.key_prefix)
+ cache_key = learn_cache_key(request, response, timeout, self.key_prefix, cache=self.cache)
self.cache.set(cache_key, response, timeout)
return response
@@ -120,17 +120,14 @@ def process_request(self, request):
return None # Don't cache requests from authenticated users.
# try and get the cached GET response
- cache_key = get_cache_key(request, self.key_prefix, 'GET')
-
+ cache_key = get_cache_key(request, self.key_prefix, 'GET', cache=self.cache)
if cache_key is None:
request._cache_update_cache = True
return None # No cache information available, need to rebuild.
-
response = self.cache.get(cache_key, None)
-
# if it wasn't found and we are looking for a HEAD, try looking just for that
if response is None and request.method == 'HEAD':
- cache_key = get_cache_key(request, self.key_prefix, 'HEAD')
+ cache_key = get_cache_key(request, self.key_prefix, 'HEAD', cache=self.cache)
response = self.cache.get(cache_key, None)
if response is None:
@@ -149,28 +146,33 @@ class CacheMiddleware(UpdateCacheMiddleware, FetchFromCacheMiddleware):
using the decorator-from-middleware utility.
"""
def __init__(self, cache_timeout=None, cache_anonymous_only=None, **kwargs):
- self.cache_timeout = cache_timeout
- if cache_timeout is None:
- self.cache_timeout = settings.CACHE_MIDDLEWARE_SECONDS
-
# We need to differentiate between "provided, but using default value",
# and "not provided". If the value is provided using a default, then
# we fall back to system defaults. If it is not provided at all,
# we need to use middleware defaults.
+
+ cache_kwargs = {}
+ try:
+ self.key_prefix = kwargs.get('key_prefix')
+ if self.key_prefix is not None:
+ cache_kwargs['KEY_PREFIX'] = self.key_prefix
+ else:
+ self.key_prefix = ''
+ except KeyError:
+ self.key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX
+ cache_kwargs['KEY_PREFIX'] = self.key_prefix
try:
cache_alias = kwargs.get('cache_alias')
if cache_alias is None:
cache_alias = DEFAULT_CACHE_ALIAS
+ if cache_timeout is not None:
+ cache_kwargs['TIMEOUT'] = cache_timeout
except KeyError:
cache_alias = settings.CACHE_MIDDLEWARE_ALIAS
-
- cache_kwargs = {}
- try:
- key_prefix = kwargs.get('key_prefix')
- if key_prefix is not None:
- cache_kwargs['KEY_PREFIX'] = key_prefix
- except KeyError:
- cache_kwargs['KEY_PREFIX'] = settings.CACHE_MIDDLEWARE_KEY_PREFIX
+ if cache_timeout is None:
+ cache_kwargs['TIMEOUT'] = settings.CACHE_MIDDLEWARE_SECONDS
+ else:
+ cache_kwargs['TIMEOUT'] = cache_timeout
if cache_anonymous_only is None:
self.cache_anonymous_only = getattr(settings, 'CACHE_MIDDLEWARE_ANONYMOUS_ONLY', False)
@@ -178,3 +180,4 @@ def __init__(self, cache_timeout=None, cache_anonymous_only=None, **kwargs):
self.cache_anonymous_only = cache_anonymous_only
self.cache = get_cache(cache_alias, **cache_kwargs)
+ self.cache_timeout = self.cache.default_timeout
View
10 django/utils/cache.py
@@ -21,7 +21,7 @@
import time
from django.conf import settings
-from django.core.cache import cache
+from django.core.cache import get_cache
from django.utils.encoding import smart_str, iri_to_uri
from django.utils.http import http_date
from django.utils.hashcompat import md5_constructor
@@ -162,7 +162,7 @@ def _generate_cache_header_key(key_prefix, request):
key_prefix, path.hexdigest())
return _i18n_cache_key_suffix(request, cache_key)
-def get_cache_key(request, key_prefix=None, method='GET'):
+def get_cache_key(request, key_prefix=None, method='GET', cache=None):
"""
Returns a cache key based on the request path. It can be used in the
request phase because it pulls the list of headers to take into account
@@ -175,13 +175,15 @@ def get_cache_key(request, key_prefix=None, method='GET'):
if key_prefix is None:
key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX
cache_key = _generate_cache_header_key(key_prefix, request)
+ if cache is None:
+ cache = get_cache(settings.CACHE_MIDDLEWARE_ALIAS)
headerlist = cache.get(cache_key, None)
if headerlist is not None:
return _generate_cache_key(request, method, headerlist, key_prefix)
else:
return None
-def learn_cache_key(request, response, cache_timeout=None, key_prefix=None):
+def learn_cache_key(request, response, cache_timeout=None, key_prefix=None, cache=None):
"""
Learns what headers to take into account for some request path from the
response object. It stores those headers in a global path registry so that
@@ -199,6 +201,8 @@ def learn_cache_key(request, response, cache_timeout=None, key_prefix=None):
if cache_timeout is None:
cache_timeout = settings.CACHE_MIDDLEWARE_SECONDS
cache_key = _generate_cache_header_key(key_prefix, request)
+ if cache is None:
+ cache = get_cache(settings.CACHE_MIDDLEWARE_ALIAS)
if response.has_header('Vary'):
headerlist = ['HTTP_'+header.upper().replace('-', '_')
for header in cc_delim_re.split(response['Vary'])]
View
154 tests/regressiontests/cache/tests.py
@@ -14,12 +14,14 @@
from django.core.cache import get_cache, DEFAULT_CACHE_ALIAS
from django.core.cache.backends.base import InvalidCacheBackendError, CacheKeyWarning
from django.http import HttpResponse, HttpRequest
-from django.middleware.cache import FetchFromCacheMiddleware, UpdateCacheMiddleware
+from django.middleware.cache import FetchFromCacheMiddleware, UpdateCacheMiddleware, CacheMiddleware
+from django.test import RequestFactory
from django.test.utils import get_warnings_state, restore_warnings_state
from django.utils import translation
from django.utils import unittest
from django.utils.cache import patch_vary_headers, get_cache_key, learn_cache_key
from django.utils.hashcompat import md5_constructor
+from django.views.decorators.cache import cache_page
from regressiontests.cache.models import Poll, expensive_calculation
# functions/classes for complex data type tests
@@ -759,6 +761,15 @@ def test_old_initialization(self):
self.cache = get_cache('locmem://?max_entries=30&cull_frequency=0')
self.perform_cull_test(50, 19)
+ def test_multiple_caches(self):
+ "Check that multiple locmem caches are isolated"
+ mirror_cache = get_cache('django.core.cache.backends.locmem.LocMemCache')
+ other_cache = get_cache('django.core.cache.backends.locmem.LocMemCache', LOCATION='other')
+
+ self.cache.set('value1', 42)
+ self.assertEquals(mirror_cache.get('value1'), 42)
+ self.assertEquals(other_cache.get('value1'), None)
+
# memcached backend isn't guaranteed to be available.
# To check the memcached backend, the test settings file will
# need to contain a cache backend setting that points at
@@ -1117,5 +1128,146 @@ def tearDown(self):
else:
settings.CACHES['default']['KEY_PREFIX'] = self.old_cache_key_prefix
+class CacheMiddlewareTest(unittest.TestCase):
+
+ def setUp(self):
+ self.orig_cache_middleware_alias = settings.CACHE_MIDDLEWARE_ALIAS
+ self.orig_cache_middleware_key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX
+ self.orig_caches = settings.CACHES
+
+ settings.CACHE_MIDDLEWARE_ALIAS = 'other'
+ settings.CACHE_MIDDLEWARE_KEY_PREFIX = 'middlewareprefix'
+ settings.CACHES = {
+ 'default': {
+ 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'
+ },
+ 'other': {
+ 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
+ 'LOCATION': 'other',
+ 'TIMEOUT': '1'
+ }
+ }
+
+ def tearDown(self):
+ settings.CACHE_MIDDLEWARE_ALIAS = self.orig_cache_middleware_alias
+ settings.CACHE_MIDDLEWARE_KEY_PREFIX = self.orig_cache_middleware_key_prefix
+ settings.CACHES = self.orig_caches
+
+ def test_middleware(self):
+ def view(request, value):
+ return HttpResponse('Hello World %s' % value)
+
+ factory = RequestFactory()
+
+ middleware = CacheMiddleware()
+ prefix_middleware = CacheMiddleware(key_prefix='prefix1')
+ timeout_middleware = CacheMiddleware(cache_timeout=1)
+
+ request = factory.get('/view/')
+
+ # Put the request through the request middleware
+ result = middleware.process_request(request)
+ self.assertEquals(result, None)
+
+ response = view(request, '1')
+
+ # Now put the response through the response middleware
+ response = middleware.process_response(request, response)
+
+ # Repeating the request should result in a cache hit
+ result = middleware.process_request(request)
+ self.assertNotEquals(result, None)
+ self.assertEquals(result.content, 'Hello World 1')
+
+ # The same request through a different middleware won't hit
+ result = prefix_middleware.process_request(request)
+ self.assertEquals(result, None)
+
+ # The same request with a timeout _will_ hit
+ result = timeout_middleware.process_request(request)
+ self.assertNotEquals(result, None)
+ self.assertEquals(result.content, 'Hello World 1')
+
+ def test_view_decorator(self):
+ def view(request, value):
+ return HttpResponse('Hello World %s' % value)
+
+ # decorate the same view with different cache decorators
+ default_view = cache_page(view)
+ default_with_prefix_view = cache_page(key_prefix='prefix1')(view)
+
+ explicit_default_view = cache_page(cache='default')(view)
+ explicit_default_with_prefix_view = cache_page(cache='default', key_prefix='prefix1')(view)
+
+ other_view = cache_page(cache='other')(view)
+ other_with_prefix_view = cache_page(cache='other', key_prefix='prefix2')(view)
+
+ factory = RequestFactory()
+ request = factory.get('/view/')
+
+ # Request the view once
+ response = default_view(request, '1')
+ self.assertEquals(response.content, 'Hello World 1')
+
+ # Request again -- hit the cache
+ response = default_view(request, '2')
+ self.assertEquals(response.content, 'Hello World 1')
+
+ # Requesting the same view with the explicit cache should yield the same result
+ response = explicit_default_view(request, '3')
+ self.assertEquals(response.content, 'Hello World 1')
+
+ # Requesting with a prefix will hit a different cache key
+ response = explicit_default_with_prefix_view(request, '4')
+ self.assertEquals(response.content, 'Hello World 4')
+
+ # Hitting the same view again gives a cache hit
+ response = explicit_default_with_prefix_view(request, '5')
+ self.assertEquals(response.content, 'Hello World 4')
+
+ # And going back to the implicit cache will hit the same cache
+ response = default_with_prefix_view(request, '6')
+ self.assertEquals(response.content, 'Hello World 4')
+
+ # Requesting from an alternate cache won't hit cache
+ response = other_view(request, '7')
+ self.assertEquals(response.content, 'Hello World 7')
+
+ # But a repeated hit will hit cache
+ response = other_view(request, '8')
+ self.assertEquals(response.content, 'Hello World 7')
+
+ # And prefixing the alternate cache yields yet another cache entry
+ response = other_with_prefix_view(request, '9')
+ self.assertEquals(response.content, 'Hello World 9')
+
+ # But if we wait a couple of seconds...
+ time.sleep(2)
+
+ # ... the default cache will still hit
+ cache = get_cache('default')
+ response = default_view(request, '10')
+ self.assertEquals(response.content, 'Hello World 1')
+
+ # ... the default cache with a prefix will still hit
+ response = default_with_prefix_view(request, '11')
+ self.assertEquals(response.content, 'Hello World 4')
+
+ # ... the explicit default cache will still hit
+ response = explicit_default_view(request, '12')
+ self.assertEquals(response.content, 'Hello World 1')
+
+ # ... the explicit default cache with a prefix will still hit
+ response = explicit_default_with_prefix_view(request, '13')
+ self.assertEquals(response.content, 'Hello World 4')
+
+ # .. but a rapidly expiring cache won't hit
+ response = other_view(request, '14')
+ self.assertEquals(response.content, 'Hello World 14')
+
+ # .. even if it has a prefix
+ response = other_with_prefix_view(request, '15')
+ self.assertEquals(response.content, 'Hello World 15')
+
if __name__ == '__main__':
unittest.main()

0 comments on commit b224152

Please sign in to comment.
Something went wrong with that request. Please try again.