Ticket #11505: restore_cache_during_tests.diff

django/core/cache/backends/dummy.py

@@ -32 +32 @@
         self.validate_key(key)
         return False
 
-    def set_many(self, data, version=None):
+    def set_many(self, data, timeout=None, version=None):
         pass
 
     def delete_many(self, keys, version=None):

django/test/testcases.py

@@ -16 +16 @@
 from django.http import QueryDict
 from django.test import _doctest as doctest
 from django.test.client import Client
-from django.test.utils import get_warnings_state, restore_warnings_state, override_settings
+from django.test.utils import get_warnings_state, restore_warnings_state, override_settings, _caches_used_during_test
 from django.utils import simplejson, unittest as ut2
 from django.utils.encoding import smart_str
 
@@ -251 +251 @@
               ROOT_URLCONF with it.
             * Clearing the mail test outbox.
         """
+        self._cache_setup()
         self._fixture_setup()
         self._urlconf_setup()
         mail.outbox = []
@@ -276 +277 @@
             settings.ROOT_URLCONF = self.urls
             clear_url_caches()
 
+    def _cache_setup(self):
+        """
+        Resets the list of caches used in preparation for test
+        """
+        global _caches_used_during_test
+        _caches_used_during_test.clear()
+
     def __call__(self, result=None):
         """
         Wrapper around default __call__ method to perform common Django test
@@ -315 +323 @@
         """
         self._fixture_teardown()
         self._urlconf_teardown()
+        self._cache_teardown()
         # Some DB cursors include SQL statements as part of cursor
         # creation. If you have a test that does rollback, the effect
         # of these statements is lost, which can effect the operation
@@ -332 +341 @@
         if hasattr(self, '_old_root_urlconf'):
             settings.ROOT_URLCONF = self._old_root_urlconf
             clear_url_caches()
+    
+    def _cache_teardown(self):
+        """
+        Clears values set in cache during test
+        """
+        for cache in _caches_used_during_test:
+            cache.delete_many(list(cache._keys_set_during_test))
 
     def save_warnings_state(self):
         """

django/test/utils.py

@@ -2 +2 @@
 
 import sys
 import time
+import types
 import os
 import warnings
 from django.conf import settings, UserSettingsHolder
-from django.core import mail
+from django.core import mail, cache
 from django.core.mail.backends import locmem
 from django.test.signals import template_rendered, setting_changed
 from django.template import Template, loader, TemplateDoesNotExist
@@ -66 +67 @@
     return self.nodelist.render(context)
 
 
+_caches_used_during_test = set()
+
+def modified_get_cache(backend, **kwargs):
+    """
+    Modifies the original get_cache so that we can track any keys set during a cache run and reset
+    them at the end.
+    """
+    requested_cache = cache.original_get_cache(backend, **kwargs)
+    
+    # Add '_test_' to key_prefix to ensure pre-existing cache values don't get touched
+    requested_cache.original_key_prefix = requested_cache.key_prefix
+    requested_cache.key_prefix = '_test_%s' % requested_cache.original_key_prefix
+    
+    # Keep track of which caches we use during a test
+    global _caches_used_during_test
+    _caches_used_during_test.add(requested_cache)
+    
+    requested_cache._keys_set_during_test = set()
+    
+    # Modify cache.set() to collect keys in _keys_set_during_test
+    requested_cache.original_set = requested_cache.set
+    def modified_set(self, key, value, timeout=None, version=None):
+        requested_cache._keys_set_during_test.add(key)
+        requested_cache.original_set(key, value, timeout, version)
+    requested_cache.set = types.MethodType(modified_set, requested_cache)
+    
+    # Modify cache.add() to collect keys in _keys_set_during_test
+    requested_cache.original_add = requested_cache.add
+    def modified_add(self, key, value, timeout=None, version=None):
+        requested_cache._keys_set_during_test.add(key)
+        return requested_cache.original_add(key, value, timeout, version)
+    requested_cache.add = types.MethodType(modified_add, requested_cache)
+    
+    # Modify cache.incr() to collect keys in _keys_set_during_test
+    requested_cache.original_incr = requested_cache.incr
+    def modified_incr(self, key, delta=1, version=None):
+        requested_cache._keys_set_during_test.add(key)
+        return requested_cache.original_incr(key, delta, version)
+    requested_cache.incr = types.MethodType(modified_incr, requested_cache)
+    
+    # Modify cache.decr() to collect keys in _keys_set_during_test
+    requested_cache.original_decr = requested_cache.decr
+    def modified_decr(self, key, delta=1, version=None):
+        requested_cache._keys_set_during_test.add(key)
+        return requested_cache.original_decr(key, delta, version)
+    requested_cache.decr = types.MethodType(modified_decr, requested_cache)
+    
+    # Modify cache.set_many() to collect keys in _keys_set_during_test
+    requested_cache.original_set_many = requested_cache.set_many
+    def modified_set_many(self, data, timeout=None, version=None):
+        requested_cache._keys_set_during_test.update(data.keys())
+        requested_cache.original_set_many(data, timeout, version)
+    requested_cache.set_many = types.MethodType(modified_set_many, requested_cache)
+    
+    return requested_cache
+
+
 def setup_test_environment():
     """Perform any global pre-test setup. This involves:
 
@@ -78 +136 @@
 
     mail.original_email_backend = settings.EMAIL_BACKEND
     settings.EMAIL_BACKEND = 'django.core.mail.backends.locmem.EmailBackend'
-
     mail.outbox = []
+    
+    cache.original_get_cache = cache.get_cache
+    cache.get_cache = modified_get_cache
+    
+    # Make sure django.core.cache.cache also uses the modified cache
+    cache.original_cache = cache.cache
+    cache.cache = cache.get_cache(cache.DEFAULT_CACHE_ALIAS)
 
     deactivate()
 
@@ -96 +160 @@
 
     settings.EMAIL_BACKEND = mail.original_email_backend
     del mail.original_email_backend
-
     del mail.outbox
+    
+    cache.cache = cache.original_cache
+    del cache.original_cache
+    cache.get_cache = cache.original_get_cache
+    del cache.original_get_cache
 
 
 def get_warnings_state():

tests/regressiontests/test_utils/tests.py

@@ -1 +1 @@
 from __future__ import with_statement
 
 import sys
+import tempfile
 
 from django.test import TestCase, skipUnlessDBFeature, skipIfDBFeature
-from django.utils.unittest import skip
+from django.utils.unittest import skip, skipUnless
+from django.conf import settings
+from django.core import management
+from django.core.cache import get_cache, DEFAULT_CACHE_ALIAS
 
 from models import Person
 
@@ -131 +135 @@
         pass
 
 
+# We must set this via a function to confirm that cache set test has run
+# before cache get test
+_cache_set_test_has_run = False
+
+def cache_set_test_run():
+    global _cache_set_test_has_run
+    _cache_set_test_has_run = True
+
+def cache_get_test_finished():
+    global _cache_set_test_has_run
+    _cache_set_test_has_run = False
+
+
+class BaseCacheReset(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        # Setup everything here, because setupClass is guaranteed to run first
+        cache = cls.original_cache()
+
+        # Add a "pre-existing" value to cache to ensure it gets reset properly
+        cache.set('salt', 'pepper') # We won't touch this one
+        cache.set('sweet', 'sour') # We will touch a key with this name and check if it's restored at the end
+        
+        # Sanity checks
+        assert cache.get('salt') == 'pepper'
+        assert cache.get('sweet') == 'sour'
+
+        # We manually prefix the test_ here because we are not trying to pretend these are part
+        # of the original cache. We're just making sure the values exist so that we can call incr/decr
+        # without using cache.set() first
+        cache.orig_key_prefix = cache.key_prefix
+        cache.key_prefix = '_test_%s' % cache.orig_key_prefix
+        try:
+            cache.set('going_up', 1)
+            cache.set('going_down', 2)
+        finally:
+            cache.key_prefix = cache.orig_key_prefix
+
+    def setUp(self):
+        # Set up cache again at the instance level. This one will get reset
+        self.cache = self.modified_cache()
+
+
+class CacheResetTestsMixin(object):
+    # Note test names start with a/b. This ensures test order is correct (which we're normally
+    # not supposed to worry about)
+    def test_a_set_cache_in_various_ways_in_one_test_method(self):
+        """
+        Set some cache stuff in this method, and then we'll sure it doesn't carry over to the next
+        """
+        sweet_result = self.cache.set('sweet', 'bitter')
+        left_result = self.cache.set('left', 'right')
+        loud_result = self.cache.add('loud', 'quiet')
+        
+        assert self.cache.get('going_up') == 1
+        going_up_result = self.cache.incr('going_up')
+        
+        assert self.cache.get('going_down') == 2
+        going_down_result = self.cache.decr('going_down')
+        
+        over_above_result = self.cache.set_many({'over': 'under', 'above': 'below'})
+
+        # Sanity checks
+        self.assertEqual(self.cache.get('sweet'), 'bitter')
+        self.assertEqual(sweet_result, None)
+        
+        self.assertEqual(self.cache.get('left'), 'right')
+        self.assertEqual(left_result, None)
+        
+        self.assertEqual(self.cache.get('loud'), 'quiet')
+        self.assertEqual(loud_result, True)
+        
+        self.assertEqual(self.cache.get('going_up'), 2)
+        self.assertEqual(going_up_result, 2)
+        
+        self.assertEqual(self.cache.get('going_down'), 1)
+        self.assertEqual(going_down_result, 1)
+        
+        self.assertEqual(self.cache.get('over'), 'under')
+        self.assertEqual(self.cache.get('above'), 'below')
+        self.assertEqual(over_above_result, None)
+
+        # Mark that set_cache tests have run
+        cache_set_test_run()
+
+    def test_b_get_cache_in_another_test_method(self):
+        # Confirm that set tests has already run
+        if not _cache_set_test_has_run:
+            self.skipTest("set_cache test did not run first!")
+
+        try:
+            self.assertEqual(self.cache.get('left'), None)
+            self.assertEqual(self.cache.get('loud'), None)
+            self.assertEqual(self.cache.get('going_up'), None)
+            self.assertEqual(self.cache.get('going_down'), None)
+            self.assertEqual(self.cache.get('over'), None)
+            self.assertEqual(self.cache.get('above'), None)
+
+            # Make sure pre-existing values are still correct
+            original_cache = self.__class__.original_cache()
+            self.assertEqual(original_cache.get('sweet'), 'sour')
+            self.assertEqual(original_cache.get('salt'), 'pepper')
+        finally:
+            # Mark get_cache tests finished
+            cache_get_test_finished()
+
+
+class LocMemCacheResetTests(BaseCacheReset, CacheResetTestsMixin):
+    backend_name = 'django.core.cache.backends.locmem.LocMemCache'
+
+    @classmethod
+    def original_cache(cls):
+        if not hasattr(cls, '_original_cache'):
+            from django.core.cache import original_get_cache
+            cls._original_cache = original_get_cache(cls.backend_name, LOCATION='test')
+        return cls._original_cache
+
+    def modified_cache(self):
+        return get_cache(self.backend_name, LOCATION='test')
+
+
+class FileBasedCacheResetTests(BaseCacheReset, CacheResetTestsMixin):
+    backend_name = 'django.core.cache.backends.filebased.FileBasedCache'
+
+    @classmethod
+    def original_cache(cls):
+        if not hasattr(cls, '_original_cache'):
+            cls.cache_dirname = tempfile.mkdtemp()
+            from django.core.cache import original_get_cache
+            cls._original_cache = original_get_cache(cls.backend_name, LOCATION=cls.cache_dirname)
+        return cls._original_cache
+
+    def modified_cache(self):
+        return get_cache(self.backend_name, LOCATION=self.cache_dirname)
+
+
+class DBCacheResetTests(BaseCacheReset, CacheResetTestsMixin):
+    backend_name = 'django.core.cache.backends.db.DatabaseCache'
+
+    @classmethod
+    def original_cache(cls):
+        if not hasattr(cls, '_original_cache'):
+            cls.cache_table_name = 'test_cache_table'
+            management.call_command('createcachetable', cls.cache_table_name, verbosity=0, interactive=False)
+            from django.core.cache import original_get_cache
+            cls._original_cache = original_get_cache(cls.backend_name, LOCATION=cls.cache_table_name)
+        return cls._original_cache
+
+    def modified_cache(self):
+        return get_cache(self.backend_name, LOCATION=self.cache_table_name)
+
+    @classmethod
+    def tearDownClass(cls):
+        from django.db import connection
+        cursor = connection.cursor()
+        cursor.execute('DROP TABLE %s' % connection.ops.quote_name(cls.cache_table_name))
+
+
+@skipUnless(settings.CACHES[DEFAULT_CACHE_ALIAS]['BACKEND'].startswith('django.core.cache.backends.memcached.'), "memcached not available")
+class MemcachedCacheResetTests(BaseCacheReset, CacheResetTestsMixin):
+    backend_name = 'django.core.cache.backends.memcached.MemcachedCache'
+
+    @classmethod
+    def original_cache(cls):
+        if not hasattr(cls, '_original_cache'):
+            cls.memcached_location = settings.CACHES[DEFAULT_CACHE_ALIAS]['LOCATION']
+            from django.core.cache import original_get_cache
+            cls._original_cache = original_get_cache(cls.backend_name, LOCATION=cls.memcached_location)
+        return cls._original_cache
+
+    def modified_cache(self):
+        return get_cache(self.backend_name, LOCATION=self.memcached_location)
+
+
 __test__ = {"API_TEST": r"""
 # Some checks of the doctest output normalizer.
 # Standard doctests do fairly