Removed settings.CACHE_MIDDLEWARE_ANONYMOUS_ONLY per deprecation timeline. (f567d04b) · Commits · Dom Sekotill / django

django/middleware/cache.py

+2 −25

Original line number	Diff line number	Diff line
		@@ -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]

docs/ref/settings.txt

+0 −21

Original line number	Diff line number	Diff line
		@@ -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</releases/1.6>` 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`

tests/cache/tests.py

+3 −59

Original line number	Diff line number	Diff line
		@@ -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)