Ticket #15255: 15255.5.diff

File 15255.5.diff, 5.9 KB (added by aaugustin, 4 years ago)
  • tests/regressiontests/cache/tests.py

     
    1414from django.core import management
    1515from django.core.cache import get_cache, DEFAULT_CACHE_ALIAS
    1616from django.core.cache.backends.base import CacheKeyWarning, InvalidCacheBackendError
     17from django.db import router
    1718from django.http import HttpResponse, HttpRequest, QueryDict
    1819from django.middleware.cache import FetchFromCacheMiddleware, UpdateCacheMiddleware, CacheMiddleware
    19 from django.test import RequestFactory
     20from django.test import RequestFactory, TestCase
    2021from django.test.utils import get_warnings_state, restore_warnings_state
    2122from django.utils import translation
    2223from django.utils import unittest
     
    763764        self.cache = get_cache('db://%s?max_entries=30&cull_frequency=0' % self._table_name)
    764765        self.perform_cull_test(50, 18)
    765766
     767class DBCacheRouter(object):
     768    """A router that puts the cache table on the 'other' database."""
    766769
     770    def db_for_read(self, model, **hints):
     771        if model._meta.app_label == 'django_cache':
     772            return 'other'
     773
     774    def db_for_write(self, model, **hints):
     775        if model._meta.app_label == 'django_cache':
     776            return 'other'
     777
     778    def allow_syncdb(self, db, model):
     779        if model._meta.app_label == 'django_cache':
     780            return db == 'other'
     781
     782
     783class CreateCacheTableForDBCacheTests(TestCase):
     784    multi_db = True
     785
     786    def test_createcachetable_observes_database_router(self):
     787        old_routers = router.routers
     788        try:
     789            router.routers = [DBCacheRouter()]
     790            # cache table should not be created on 'default'
     791            with self.assertNumQueries(0, using='default'):
     792                management.call_command('createcachetable', 'cache_table',
     793                                        database='default',
     794                                        verbosity=0, interactive=False)
     795            # cache table should be created on 'other'
     796            # one query is used to create the table and another one the index
     797            with self.assertNumQueries(2, using='other'):
     798                management.call_command('createcachetable', 'cache_table',
     799                                        database='other',
     800                                        verbosity=0, interactive=False)
     801        finally:
     802            router.routers = old_routers
     803
     804
    767805class LocMemCacheTests(unittest.TestCase, BaseCacheTests):
    768806    backend_name = 'django.core.cache.backends.locmem.LocMemCache'
    769807
  • django/db/backends/creation.py

     
    261261        for cache_alias in settings.CACHES:
    262262            cache = get_cache(cache_alias)
    263263            if isinstance(cache, BaseDatabaseCache):
    264                 from django.db import router
    265                 if router.allow_syncdb(self.connection.alias, cache.cache_model_class):
    266                     call_command('createcachetable', cache._table, database=self.connection.alias)
     264                call_command('createcachetable', cache._table, database=self.connection.alias)
    267265
    268266        # Get a cursor (even though we don't need one yet). This has
    269267        # the side effect of initializing the test database.
  • django/core/management/commands/createcachetable.py

     
    11from optparse import make_option
    22
    33from django.core.management.base import LabelCommand
    4 from django.db import connections, transaction, models, DEFAULT_DB_ALIAS
     4from django.core.cache.backends.db import BaseDatabaseCache
     5from django.db import connections, router, transaction, models, DEFAULT_DB_ALIAS
    56
    67class Command(LabelCommand):
    78    help = "Creates the table needed to use the SQL cache backend."
     
    1819    requires_model_validation = False
    1920
    2021    def handle_label(self, tablename, **options):
    21         alias = options.get('database', DEFAULT_DB_ALIAS)
    22         connection = connections[alias]
     22        db = options.get('database', DEFAULT_DB_ALIAS)
     23        cache = BaseDatabaseCache(tablename, {})
     24        if not router.allow_syncdb(db, cache.cache_model_class):
     25            return
     26        connection = connections[db]
    2327        fields = (
    2428            # "key" is a reserved word in MySQL, so use "cache_key" instead.
    2529            models.CharField(name='cache_key', max_length=255, unique=True, primary_key=True),
     
    5054        curs.execute("\n".join(full_statement))
    5155        for statement in index_output:
    5256            curs.execute(statement)
    53         transaction.commit_unless_managed(using=alias)
     57        transaction.commit_unless_managed(using=db)
  • django/contrib/gis/db/backends/spatialite/creation.py

     
    3333        for cache_alias in settings.CACHES:
    3434            cache = get_cache(cache_alias)
    3535            if isinstance(cache, BaseDatabaseCache):
    36                 from django.db import router
    37                 if router.allow_syncdb(self.connection.alias, cache.cache_model_class):
    38                     call_command('createcachetable', cache._table, database=self.connection.alias)
     36                call_command('createcachetable', cache._table, database=self.connection.alias)
    3937        # Get a cursor (even though we don't need one yet). This has
    4038        # the side effect of initializing the test database.
    4139        cursor = self.connection.cursor()
Back to Top