Ticket #15255: 15255.4.diff

django/db/backends/creation.py

@@ -261 +261 @@
         for cache_alias in settings.CACHES:
             cache = get_cache(cache_alias)
             if isinstance(cache, BaseDatabaseCache):
-                from django.db import router
-                if router.allow_syncdb(self.connection.alias, cache.cache_model_class):
-                    call_command('createcachetable', cache._table, database=self.connection.alias)
+                call_command('createcachetable', cache._table, database=self.connection.alias)
 
         # Get a cursor (even though we don't need one yet). This has
         # the side effect of initializing the test database.

django/core/management/commands/createcachetable.py

@@ -1 +1 @@
 from optparse import make_option
 
 from django.core.management.base import LabelCommand
-from django.db import connections, transaction, models, DEFAULT_DB_ALIAS
+from django.core.cache.backends.db import BaseDatabaseCache
+from django.db import connections, router, transaction, models, DEFAULT_DB_ALIAS
 
 class Command(LabelCommand):
     help = "Creates the table needed to use the SQL cache backend."
@@ -18 +19 @@
     requires_model_validation = False
 
     def handle_label(self, tablename, **options):
-        alias = options.get('database', DEFAULT_DB_ALIAS)
-        connection = connections[alias]
+        db = options.get('database', DEFAULT_DB_ALIAS)
+        cache = BaseDatabaseCache(tablename, {})
+        if not router.allow_syncdb(db, cache.cache_model_class):
+            return
+        connection = connections[db]
         fields = (
             # "key" is a reserved word in MySQL, so use "cache_key" instead.
             models.CharField(name='cache_key', max_length=255, unique=True, primary_key=True),
@@ -50 +54 @@
         curs.execute("\n".join(full_statement))
         for statement in index_output:
             curs.execute(statement)
-        transaction.commit_unless_managed(using=alias)
+        transaction.commit_unless_managed(using=db)

django/contrib/gis/db/backends/spatialite/creation.py

@@ -33 +33 @@
         for cache_alias in settings.CACHES:
             cache = get_cache(cache_alias)
             if isinstance(cache, BaseDatabaseCache):
-                from django.db import router
-                if router.allow_syncdb(self.connection.alias, cache.cache_model_class):
-                    call_command('createcachetable', cache._table, database=self.connection.alias)
+                call_command('createcachetable', cache._table, database=self.connection.alias)
         # Get a cursor (even though we don't need one yet). This has
         # the side effect of initializing the test database.
         cursor = self.connection.cursor()

tests/regressiontests/cache/tests.py

@@ -14 +14 @@
 from django.core import management
 from django.core.cache import get_cache, DEFAULT_CACHE_ALIAS
 from django.core.cache.backends.base import CacheKeyWarning, InvalidCacheBackendError
+from django.db import router
 from django.http import HttpResponse, HttpRequest, QueryDict
 from django.middleware.cache import FetchFromCacheMiddleware, UpdateCacheMiddleware, CacheMiddleware
-from django.test import RequestFactory
+from django.test import RequestFactory, TestCase
 from django.test.utils import get_warnings_state, restore_warnings_state
 from django.utils import translation
 from django.utils import unittest
@@ -758 +759 @@
         self.cache = get_cache('db://%s?max_entries=30&cull_frequency=0' % self._table_name)
         self.perform_cull_test(50, 18)
 
+class DBCacheRouter(object):
+    """A router that puts the cache table on the 'other' database."""
 
+    def db_for_read(self, model, **hints):
+        if model._meta.app_label == 'django_cache':
+            return 'other'
+
+    def db_for_write(self, model, **hints):
+        if model._meta.app_label == 'django_cache':
+            return 'other'
+
+    def allow_syncdb(self, db, model):
+        if model._meta.app_label == 'django_cache':
+            return db == 'other'
+
+
+class CreateCacheTableForDBCacheTests(TestCase):
+    multi_db = True
+
+    def test_createcachetable_observes_database_router(self):
+        old_routers = router.routers
+        try:
+            router.routers = [DBCacheRouter()]
+            # cache table should not be created on 'default'
+            with self.assertNumQueries(0, using='default'):
+                management.call_command('createcachetable', 'cache_table',
+                                        database='default',
+                                        verbosity=0, interactive=False)
+            # cache table should be created on 'other'
+            # one query is used to create the table and another one the index
+            with self.assertNumQueries(2, using='other'):
+                management.call_command('createcachetable', 'cache_table',
+                                        database='other',
+                                        verbosity=0, interactive=False)
+        finally:
+            router.routers = old_routers
+
+
 class LocMemCacheTests(unittest.TestCase, BaseCacheTests):
     backend_name = 'django.core.cache.backends.locmem.LocMemCache'