Ticket #11398: pre_syncdb_updated.patch

django/core/management/commands/flush.py

@@ -5 +5 @@
 from django.core.management import call_command
 from django.core.management.base import NoArgsCommand, CommandError
 from django.core.management.color import no_style
-from django.core.management.sql import sql_flush, emit_post_sync_signal
+from django.core.management.sql import sql_flush, emit_post_sync_signal, emit_pre_sync_signal
 from django.utils.importlib import import_module
 
 
@@ -51 +51 @@
             confirm = 'yes'
 
         if confirm == 'yes':
+            emit_pre_sync_signal(verbosity, interactive, db)
             try:
                 cursor = connection.cursor()
                 for sql in sql_list:

django/core/management/commands/syncdb.py

@@ -5 +5 @@
 from django.conf import settings
 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
@@ -54 +54 @@
 
         db = options.get('database')
         connection = connections[db]
+        emit_pre_sync_signal(verbosity, interactive, db)
         cursor = connection.cursor()
 
         # Get a list of already installed *models* so that references work right.

django/core/management/sql.py

@@ -178 +178 @@
     return output
 
 
+def emit_pre_sync_signal(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", app_name 
+        models.signals.pre_syncdb.send(sender=app, app=app, 
+                                       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():
@@ -187 +199 @@
         models.signals.post_syncdb.send(sender=app, app=app,
             created_models=created_models, verbosity=verbosity,
             interactive=interactive, db=db)
+

django/db/models/signals.py

@@ -11 +11 @@
 pre_delete = Signal(providing_args=["instance", "using"])
 post_delete = Signal(providing_args=["instance", "using"])
 
+pre_syncdb = Signal(providing_args=["app", "verbosity", "interactive", "db"])
 post_syncdb = Signal(providing_args=["class", "app", "created_models", "verbosity", "interactive"])
 
 m2m_changed = Signal(providing_args=["action", "instance", "reverse", "model", "pk_set", "using"])

docs/ref/signals.txt

@@ -352 +352 @@
 
 Signals sent by :doc:`django-admin </ref/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, and the :djadmin:`flush` command.
+
+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``.
+
+``db``
+    The alias of database on which a command will operate.
+
+``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``.
+
 post_syncdb
 -----------
 

new file tests/regressiontests/syncdb/__init__.py

@@ +1 @@
+

new file tests/regressiontests/syncdb/models.py

@@ +1 @@
+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

new file tests/regressiontests/syncdb/tests.py

@@ +1 @@
+from django.db import connections
+from django.db.models import signals
+from django.test import TestCase
+from django.core import management
+
+import models
+
+
+PRE_SYNCDB_ARGS = ['app', '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)
+        
+        args = r.call_args
+        self.assertEqual(r.call_counter, 1)
+        self.assertItemsEqual(args, 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')