From 3de1288042f2dc1cb8a2b36ae0fc4d9e0beb6494 Mon Sep 17 00:00:00 2001 From: Donald Stufft Date: Fri, 17 May 2013 18:18:35 -0400 Subject: [PATCH] Fixed #11398 - Added a pre_syncdb signal --- django/core/management/commands/flush.py | 2 +- django/core/management/commands/syncdb.py | 6 +- django/core/management/sql.py | 14 ++++ django/db/models/signals.py | 1 + docs/ref/signals.txt | 47 ++++++++++++++ tests/syncdb_signals/__init__.py | 0 tests/syncdb_signals/models.py | 11 ++++ tests/syncdb_signals/tests.py | 79 +++++++++++++++++++++++ 8 files changed, 158 insertions(+), 2 deletions(-) create mode 100644 tests/syncdb_signals/__init__.py create mode 100644 tests/syncdb_signals/models.py create mode 100644 tests/syncdb_signals/tests.py diff --git a/django/core/management/commands/flush.py b/django/core/management/commands/flush.py index 10066417a1..c56fc1e1b0 100644 --- a/django/core/management/commands/flush.py +++ b/django/core/management/commands/flush.py @@ -20,7 +20,7 @@ class Command(NoArgsCommand): default=DEFAULT_DB_ALIAS, help='Nominates a database to flush. ' 'Defaults to the "default" database.'), make_option('--no-initial-data', action='store_false', dest='load_initial_data', default=True, - help='Tells Django not to load any initial data after database synchronization.'), + help='Tells Django not to load any initial data after database synchronization.'), ) help = ('Returns the database to the state it was in immediately after ' 'syncdb was executed. This means that all data will be removed ' diff --git a/django/core/management/commands/syncdb.py b/django/core/management/commands/syncdb.py index ab80d8aece..3e73d24a04 100644 --- a/django/core/management/commands/syncdb.py +++ b/django/core/management/commands/syncdb.py @@ -1,11 +1,12 @@ from optparse import make_option +import itertools import traceback from django.conf import settings from django.core.management import call_command from django.core.management.base import NoArgsCommand from django.core.management.color import no_style -from django.core.management.sql import custom_sql_for_model, emit_post_sync_signal +from django.core.management.sql import custom_sql_for_model, emit_post_sync_signal, emit_pre_sync_signal from django.db import connections, router, transaction, models, DEFAULT_DB_ALIAS from django.utils.datastructures import SortedDict from django.utils.importlib import import_module @@ -80,6 +81,9 @@ class Command(NoArgsCommand): for app_name, model_list in all_models ) + create_models = set([x for x in itertools.chain(*manifest.values())]) + emit_pre_sync_signal(create_models, verbosity, interactive, db) + # Create the tables for each model if verbosity >= 1: self.stdout.write("Creating tables ...\n") diff --git a/django/core/management/sql.py b/django/core/management/sql.py index ac60ed470c..27ada10248 100644 --- a/django/core/management/sql.py +++ b/django/core/management/sql.py @@ -137,6 +137,7 @@ def sql_indexes(app, style, connection): output.extend(connection.creation.sql_indexes_for_model(model, style)) return output + def sql_destroy_indexes(app, style, connection): "Returns a list of the DROP INDEX SQL statements for all models in the given app." output = [] @@ -191,6 +192,19 @@ def custom_sql_for_model(model, style, connection): return output +def emit_pre_sync_signal(create_models, verbosity, interactive, db): + # Emit the pre_sync signal for every application. + for app in models.get_apps(): + app_name = app.__name__.split('.')[-2] + if verbosity >= 2: + print("Running pre-sync handlers for application %s" % app_name) + models.signals.pre_syncdb.send(sender=app, app=app, + create_models=create_models, + verbosity=verbosity, + interactive=interactive, + db=db) + + def emit_post_sync_signal(created_models, verbosity, interactive, db): # Emit the post_sync signal for every application. for app in models.get_apps(): diff --git a/django/db/models/signals.py b/django/db/models/signals.py index 09f93d0f77..3e321893c1 100644 --- a/django/db/models/signals.py +++ b/django/db/models/signals.py @@ -12,6 +12,7 @@ post_save = Signal(providing_args=["instance", "raw", "created", "using", "updat pre_delete = Signal(providing_args=["instance", "using"], use_caching=True) post_delete = Signal(providing_args=["instance", "using"], use_caching=True) +pre_syncdb = Signal(providing_args=["app", "create_models", "verbosity", "interactive", "db"]) post_syncdb = Signal(providing_args=["class", "app", "created_models", "verbosity", "interactive", "db"], use_caching=True) m2m_changed = Signal(providing_args=["action", "instance", "reverse", "model", "pk_set", "using"], use_caching=True) diff --git a/docs/ref/signals.txt b/docs/ref/signals.txt index ca472bd60e..e7270e1957 100644 --- a/docs/ref/signals.txt +++ b/docs/ref/signals.txt @@ -360,6 +360,53 @@ Management signals Signals sent by :doc:`django-admin `. +pre_syncdb +---------- + +.. data:: django.db.models.signals.pre_syncdb + :module: + +Sent by the :djadmin:`syncdb` command before it starts to install an +application. + +Any handlers that listen to this signal need to be written in a particular +place: a ``management`` module in one of your :setting:`INSTALLED_APPS`. If +handlers are registered anywhere else they may not be loaded by +:djadmin:`syncdb`. + +Arguments sent with this signal: + +``sender`` + The ``models`` module that was just installed. That is, if + :djadmin:`syncdb` just installed an app called ``"foo.bar.myapp"``, + ``sender`` will be the ``foo.bar.myapp.models`` module. + +``app`` + Same as ``sender``. + +``create_models`` + A list of the model classes from any app which :djadmin:`syncdb` plans to + create. + + +``verbosity`` + Indicates how much information manage.py is printing on screen. See + the :djadminopt:`--verbosity` flag for details. + + Functions which listen for :data:`pre_syncdb` should adjust what they + output to the screen based on the value of this argument. + +``interactive`` + If ``interactive`` is ``True``, it's safe to prompt the user to input + things on the command line. If ``interactive`` is ``False``, functions + which listen for this signal should not try to prompt for anything. + + For example, the :mod:`django.contrib.auth` app only prompts to create a + superuser when ``interactive`` is ``True``. + +``db`` + The alias of database on which a command will operate. + post_syncdb ----------- diff --git a/tests/syncdb_signals/__init__.py b/tests/syncdb_signals/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/tests/syncdb_signals/models.py b/tests/syncdb_signals/models.py new file mode 100644 index 0000000000..c41d993e94 --- /dev/null +++ b/tests/syncdb_signals/models.py @@ -0,0 +1,11 @@ +# from django.db import models + + +# class Author(models.Model): +# name = models.CharField(max_length=100) + +# class Meta: +# ordering = ['name'] + +# def __unicode__(self): +# return self.name diff --git a/tests/syncdb_signals/tests.py b/tests/syncdb_signals/tests.py new file mode 100644 index 0000000000..fd2d442d08 --- /dev/null +++ b/tests/syncdb_signals/tests.py @@ -0,0 +1,79 @@ +from django.db import connections +from django.db.models import signals +from django.test import TestCase +from django.core import management +from django.utils import six + +from shared_models import models + + +PRE_SYNCDB_ARGS = ['app', 'create_models', 'verbosity', 'interactive', 'db'] +SYNCDB_DATABASE = 'default' +SYNCDB_VERBOSITY = 1 +SYNCDB_INTERACTIVE = False + + +class PreSyncdbReceiver(object): + def __init__(self): + self.call_counter = 0 + self.call_args = None + + def __call__(self, signal, sender, **kwargs): + self.call_counter = self.call_counter + 1 + self.call_args = kwargs + + +class OneTimeReceiver(object): + """ + Special receiver for handle the fact that test runner calls syncdb for + several databases and several times for some of them. + """ + + def __init__(self): + self.call_counter = 0 + self.call_args = None + self.tables = None # list of tables at the time of the call + + def __call__(self, signal, sender, **kwargs): + # Although test runner calls syncdb for several databases, + # testing for only one of them is quite sufficient. + if kwargs['db'] == SYNCDB_DATABASE: + self.call_counter = self.call_counter + 1 + self.call_args = kwargs + connection = connections[SYNCDB_DATABASE] + self.tables = connection.introspection.table_names() + # we need to test only one call of syncdb + signals.pre_syncdb.disconnect(pre_syncdb_receiver, sender=models) + + +# We connect receiver here and not in unit test code because we need to +# connect receiver before test runner creates database. That is, sequence of +# actions would be: +# +# 1. Test runner imports this module. +# 2. We connect receiver. +# 3. Test runner calls syncdb for create default database. +# 4. Test runner execute our unit test code. +pre_syncdb_receiver = OneTimeReceiver() +signals.pre_syncdb.connect(pre_syncdb_receiver, sender=models) + + +class SyncdbSignalTests(TestCase): + def test_pre_syncdb_call_time(self): + self.assertEqual(pre_syncdb_receiver.call_counter, 1) + self.assertFalse(pre_syncdb_receiver.tables) + + def test_pre_syncdb_args(self): + r = PreSyncdbReceiver() + signals.pre_syncdb.connect(r, sender=models) + management.call_command('syncdb', database=SYNCDB_DATABASE, + verbosity=SYNCDB_VERBOSITY, interactive=SYNCDB_INTERACTIVE, + load_initial_data=False, stdout=six.StringIO()) + + args = r.call_args + self.assertEqual(r.call_counter, 1) + self.assertEqual(set(args), set(PRE_SYNCDB_ARGS)) + self.assertEqual(args['app'], models) + self.assertEqual(args['verbosity'], SYNCDB_VERBOSITY) + self.assertEqual(args['interactive'], SYNCDB_INTERACTIVE) + self.assertEqual(args['db'], 'default')