Ticket #15144: fix_15144_regressions.patch

tests/regressiontests/cache/tests.py

@@ -1133 +1133 @@
     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_cache_middleware_seconds = settings.CACHE_MIDDLEWARE_SECONDS
+        self.orig_cache_middleware_anonymous_only = getattr(settings, 'CACHE_MIDDLEWARE_ANONYMOUS_ONLY', False)
         self.orig_caches = settings.CACHES
 
         settings.CACHE_MIDDLEWARE_ALIAS = 'other'
         settings.CACHE_MIDDLEWARE_KEY_PREFIX = 'middlewareprefix'
+        settings.CACHE_MIDDLEWARE_SECONDS = 30
+        settings.CACHE_MIDDLEWARE_ANONYMOUS_ONLY = False
         settings.CACHES = {
             'default': {
                 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'
@@ -1151 +1155 @@
     def tearDown(self):
         settings.CACHE_MIDDLEWARE_ALIAS = self.orig_cache_middleware_alias
         settings.CACHE_MIDDLEWARE_KEY_PREFIX = self.orig_cache_middleware_key_prefix
+        settings.CACHE_MIDDLEWARE_SECONDS = self.orig_cache_middleware_seconds
+        settings.CACHE_MIDDLEWARE_ANONYMOUS_ONLY = self.orig_cache_middleware_anonymous_only
         settings.CACHES = self.orig_caches
+    
+    def test_constructor(self):
+        """
+        Ensure the constructor is correctly distinguishing between usage of CacheMiddleware as
+        Middleware vs. usage of CacheMiddleware as view decorator and setting attributes
+        appropriately.
+        """
+        # If no arguments are passed in construction, it's being used as middleware.
+        middleware = CacheMiddleware()
+        
+        # Now test object attributes against values defined in setUp above
+        self.assertEquals(middleware.cache_timeout, 30)
+        self.assertEquals(middleware.key_prefix, 'middlewareprefix')
+        self.assertEquals(middleware.cache_alias, 'other')
+        self.assertEquals(middleware.cache_anonymous_only, False)
+        
+        # If arguments are being passed in construction, it's being used as a decorator.
+        # First, test with "defaults":
+        as_view_decorator = CacheMiddleware(cache_alias=None, key_prefix=None)
+        
+        self.assertEquals(as_view_decorator.cache_timeout, 300) # Timeout value for 'default' cache, i.e. 300
+        self.assertEquals(as_view_decorator.key_prefix, '')
+        self.assertEquals(as_view_decorator.cache_alias, 'default') # Value of DEFAULT_CACHE_ALIAS from django.core.cache
+        self.assertEquals(as_view_decorator.cache_anonymous_only, False)
+        
+        # Next, test with custom values:
+        as_view_decorator_with_custom = CacheMiddleware(cache_anonymous_only=True, cache_timeout=60, cache_alias='other', key_prefix='foo')
+        
+        self.assertEquals(as_view_decorator_with_custom.cache_timeout, 60)
+        self.assertEquals(as_view_decorator_with_custom.key_prefix, 'foo')
+        self.assertEquals(as_view_decorator_with_custom.cache_alias, 'other')
+        self.assertEquals(as_view_decorator_with_custom.cache_anonymous_only, True)
 
     def test_middleware(self):
         def view(request, value):
@@ -1201 +1239 @@
 
         other_view = cache_page(cache='other')(view)
         other_with_prefix_view = cache_page(cache='other', key_prefix='prefix2')(view)
-
+        other_with_timeout_view = cache_page(4, cache='other', key_prefix='prefix3')(view)
+        
         factory = RequestFactory()
         request = factory.get('/view/')
 
@@ -1240 +1279 @@
         # And prefixing the alternate cache yields yet another cache entry
         response = other_with_prefix_view(request, '9')
         self.assertEquals(response.content, 'Hello World 9')
-
+        
+        # Request from the alternate cache with a new prefix and a custom timeout
+        response = other_with_timeout_view(request, '20')
+        self.assertEquals(response.content, 'Hello World 20')
+        
         # But if we wait a couple of seconds...
         time.sleep(2)
 
@@ -1268 +1311 @@
         # .. even if it has a prefix
         response = other_with_prefix_view(request, '15')
         self.assertEquals(response.content, 'Hello World 15')
+        
+        # ... but a view with a custom timeout will still hit
+        response = other_with_timeout_view(request, '21')
+        self.assertEquals(response.content, 'Hello World 20')
+        
+        # And if we wait a few more seconds
+        time.sleep(2)
+        
+        # the custom timeouot cache will miss
+        response = other_with_timeout_view(request, '22')
+        self.assertEquals(response.content, 'Hello World 22')
 
 if __name__ == '__main__':
     unittest.main()

django/core/cache/__init__.py

@@ -153 +153 @@
             backend, location, params = parse_backend_uri(backend)
             if backend in BACKENDS:
                 backend = 'django.core.cache.backends.%s' % BACKENDS[backend]
-            params.update(kwargs)
             mod = importlib.import_module(backend)
             backend_cls = mod.CacheClass
         else:
@@ -164 +163 @@
     except (AttributeError, ImportError), e:
         raise InvalidCacheBackendError(
             "Could not find backend '%s': %s" % (backend, e))
+    params.update(kwargs) 
     return backend_cls(location, params)
 
 cache = get_cache(DEFAULT_CACHE_ALIAS)

django/middleware/cache.py

@@ -152 +152 @@
         # we need to use middleware defaults.
 
         cache_kwargs = {}
-        try:
-            self.key_prefix = kwargs.get('key_prefix')
-            if self.key_prefix is not None:
+        
+        if 'key_prefix' in kwargs:
+            self.key_prefix = kwargs['key_prefix']
+            if self.key_prefix:
                 cache_kwargs['KEY_PREFIX'] = self.key_prefix
             else:
                 self.key_prefix = ''
-        except KeyError:
+        else:
             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:
+            
+        if 'cache_alias' in kwargs:
+            self.cache_alias = kwargs['cache_alias'] or DEFAULT_CACHE_ALIAS
+            if cache_timeout:
                 cache_kwargs['TIMEOUT'] = cache_timeout
-        except KeyError:
-            cache_alias = settings.CACHE_MIDDLEWARE_ALIAS
-            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)
         else:
-            self.cache_anonymous_only = cache_anonymous_only
+            self.cache_alias = settings.CACHE_MIDDLEWARE_ALIAS
+            cache_kwargs['TIMEOUT'] = cache_timeout or settings.CACHE_MIDDLEWARE_SECONDS
 
-        self.cache = get_cache(cache_alias, **cache_kwargs)
+        self.cache_anonymous_only = cache_anonymous_only or getattr(settings, 'CACHE_MIDDLEWARE_ANONYMOUS_ONLY', False)
+        
+        self.cache = get_cache(self.cache_alias, **cache_kwargs)
         self.cache_timeout = self.cache.default_timeout