diff --git a/django/middleware/cache.py b/django/middleware/cache.py index a58b21f58a..6faebcd3f3 100644 --- a/django/middleware/cache.py +++ b/django/middleware/cache.py @@ -43,12 +43,9 @@ More details about how the caching works: """ -import warnings - from django.conf import settings from django.core.cache import caches, DEFAULT_CACHE_ALIAS from django.utils.cache import get_cache_key, learn_cache_key, patch_response_headers, get_max_age -from django.utils.deprecation import RemovedInDjango18Warning class UpdateCacheMiddleware(object): @@ -63,7 +60,6 @@ class UpdateCacheMiddleware(object): def __init__(self): self.cache_timeout = settings.CACHE_MIDDLEWARE_SECONDS self.key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX - self.cache_anonymous_only = getattr(settings, 'CACHE_MIDDLEWARE_ANONYMOUS_ONLY', False) self.cache_alias = settings.CACHE_MIDDLEWARE_ALIAS self.cache = caches[self.cache_alias] @@ -74,17 +70,7 @@ class UpdateCacheMiddleware(object): return False def _should_update_cache(self, request, response): - if not hasattr(request, '_cache_update_cache') or not request._cache_update_cache: - return False - # If the session has not been accessed otherwise, we don't want to - # cause it to be accessed here. If it hasn't been accessed, then the - # user's logged-in status has not affected the response anyway. - if self.cache_anonymous_only and self._session_accessed(request): - assert hasattr(request, 'user'), "The Django cache middleware with CACHE_MIDDLEWARE_ANONYMOUS_ONLY=True requires authentication middleware to be installed. Edit your MIDDLEWARE_CLASSES setting to insert 'django.contrib.auth.middleware.AuthenticationMiddleware' before the CacheMiddleware." - if request.user.is_authenticated(): - # Don't cache user-variable requests from authenticated users. - return False - return True + return hasattr(request, '_cache_update_cache') and request._cache_update_cache def process_response(self, request, response): """Sets the cache, if needed.""" @@ -163,7 +149,7 @@ class CacheMiddleware(UpdateCacheMiddleware, FetchFromCacheMiddleware): Also used as the hook point for the cache decorator, which is generated using the decorator-from-middleware utility. """ - def __init__(self, cache_timeout=None, cache_anonymous_only=None, **kwargs): + def __init__(self, cache_timeout=None, **kwargs): # 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, @@ -188,13 +174,4 @@ class CacheMiddleware(UpdateCacheMiddleware, FetchFromCacheMiddleware): if cache_timeout is None: cache_timeout = settings.CACHE_MIDDLEWARE_SECONDS self.cache_timeout = cache_timeout - - if cache_anonymous_only is None: - cache_anonymous_only = getattr(settings, 'CACHE_MIDDLEWARE_ANONYMOUS_ONLY', False) - self.cache_anonymous_only = cache_anonymous_only - - if self.cache_anonymous_only: - msg = "CACHE_MIDDLEWARE_ANONYMOUS_ONLY has been deprecated and will be removed in Django 1.8." - warnings.warn(msg, RemovedInDjango18Warning, stacklevel=1) - self.cache = caches[self.cache_alias] diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt index dc1ecc85bb..c1d343fd0c 100644 --- a/docs/ref/settings.txt +++ b/docs/ref/settings.txt @@ -279,26 +279,6 @@ Default: ``default`` The cache connection to use for the cache middleware. -.. setting:: CACHE_MIDDLEWARE_ANONYMOUS_ONLY - -CACHE_MIDDLEWARE_ANONYMOUS_ONLY -------------------------------- - -Default: ``False`` - -.. deprecated:: 1.6 - - This setting was largely ineffective because of using cookies for sessions - and CSRF. See the :doc:`Django 1.6 release notes` for more - information. - -If the value of this setting is ``True``, only anonymous requests (i.e., not -those made by a logged-in user) will be cached. Otherwise, the middleware -caches every page that doesn't have GET or POST parameters. - -If you set the value of this setting to ``True``, you should make sure you've -activated ``AuthenticationMiddleware``. - .. setting:: CACHE_MIDDLEWARE_KEY_PREFIX CACHE_MIDDLEWARE_KEY_PREFIX @@ -2885,7 +2865,6 @@ Cache ----- * :setting:`CACHES` * :setting:`CACHE_MIDDLEWARE_ALIAS` -* :setting:`CACHE_MIDDLEWARE_ANONYMOUS_ONLY` * :setting:`CACHE_MIDDLEWARE_KEY_PREFIX` * :setting:`CACHE_MIDDLEWARE_SECONDS` diff --git a/tests/cache/tests.py b/tests/cache/tests.py index c08a489939..288af6e437 100644 --- a/tests/cache/tests.py +++ b/tests/cache/tests.py @@ -26,8 +26,7 @@ from django.middleware.cache import (FetchFromCacheMiddleware, from django.template import Template from django.template.response import TemplateResponse from django.test import TestCase, TransactionTestCase, RequestFactory, override_settings -from django.test.utils import (IgnoreDeprecationWarningsMixin, - IgnorePendingDeprecationWarningsMixin) +from django.test.utils import IgnorePendingDeprecationWarningsMixin from django.utils import six from django.utils import timezone from django.utils import translation @@ -1743,7 +1742,6 @@ def hello_world_view(request, value): CACHE_MIDDLEWARE_ALIAS='other', CACHE_MIDDLEWARE_KEY_PREFIX='middlewareprefix', CACHE_MIDDLEWARE_SECONDS=30, - CACHE_MIDDLEWARE_ANONYMOUS_ONLY=False, CACHES={ 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', @@ -1755,7 +1753,7 @@ def hello_world_view(request, value): }, }, ) -class CacheMiddlewareTest(IgnoreDeprecationWarningsMixin, TestCase): +class CacheMiddlewareTest(TestCase): def setUp(self): super(CacheMiddlewareTest, self).setUp() @@ -1781,7 +1779,6 @@ class CacheMiddlewareTest(IgnoreDeprecationWarningsMixin, TestCase): self.assertEqual(middleware.cache_timeout, 30) self.assertEqual(middleware.key_prefix, 'middlewareprefix') self.assertEqual(middleware.cache_alias, 'other') - self.assertEqual(middleware.cache_anonymous_only, False) # If arguments are being passed in construction, it's being used as a decorator. # First, test with "defaults": @@ -1790,15 +1787,13 @@ class CacheMiddlewareTest(IgnoreDeprecationWarningsMixin, TestCase): self.assertEqual(as_view_decorator.cache_timeout, 30) # Timeout value for 'default' cache, i.e. 30 self.assertEqual(as_view_decorator.key_prefix, '') self.assertEqual(as_view_decorator.cache_alias, 'default') # Value of DEFAULT_CACHE_ALIAS from django.core.cache - self.assertEqual(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') + as_view_decorator_with_custom = CacheMiddleware(cache_timeout=60, cache_alias='other', key_prefix='foo') self.assertEqual(as_view_decorator_with_custom.cache_timeout, 60) self.assertEqual(as_view_decorator_with_custom.key_prefix, 'foo') self.assertEqual(as_view_decorator_with_custom.cache_alias, 'other') - self.assertEqual(as_view_decorator_with_custom.cache_anonymous_only, True) def test_middleware(self): middleware = CacheMiddleware() @@ -1830,57 +1825,6 @@ class CacheMiddlewareTest(IgnoreDeprecationWarningsMixin, TestCase): self.assertNotEqual(result, None) self.assertEqual(result.content, b'Hello World 1') - @override_settings(CACHE_MIDDLEWARE_ANONYMOUS_ONLY=True) - def test_cache_middleware_anonymous_only_wont_cause_session_access(self): - """ The cache middleware shouldn't cause a session access due to - CACHE_MIDDLEWARE_ANONYMOUS_ONLY if nothing else has accessed the - session. Refs 13283 """ - - from django.contrib.sessions.middleware import SessionMiddleware - from django.contrib.auth.middleware import AuthenticationMiddleware - - middleware = CacheMiddleware() - session_middleware = SessionMiddleware() - auth_middleware = AuthenticationMiddleware() - - request = self.factory.get('/view_anon/') - - # Put the request through the request middleware - session_middleware.process_request(request) - auth_middleware.process_request(request) - result = middleware.process_request(request) - self.assertEqual(result, None) - - response = hello_world_view(request, '1') - - # Now put the response through the response middleware - session_middleware.process_response(request, response) - response = middleware.process_response(request, response) - - self.assertEqual(request.session.accessed, False) - - @override_settings(CACHE_MIDDLEWARE_ANONYMOUS_ONLY=True) - def test_cache_middleware_anonymous_only_with_cache_page(self): - """CACHE_MIDDLEWARE_ANONYMOUS_ONLY should still be effective when used - with the cache_page decorator: the response to a request from an - authenticated user should not be cached.""" - - request = self.factory.get('/view_anon/') - - class MockAuthenticatedUser(object): - def is_authenticated(self): - return True - - class MockAccessedSession(object): - accessed = True - - request.user = MockAuthenticatedUser() - request.session = MockAccessedSession() - - response = cache_page(60)(hello_world_view)(request, '1') - - self.assertFalse("Cache-Control" in response) - def test_view_decorator(self): # decorate the same view with different cache decorators default_view = cache_page(3)(hello_world_view)