From fa9ce4e9a691e4f8c8b093784bac752e488dc60b Mon Sep 17 00:00:00 2001 From: Tim Graham Date: Sat, 19 Dec 2015 08:53:53 -0500 Subject: Fixed #25922 -- Fixed migrate --fake-initial detection of many-to-many tables. --- .../0001_initial.py | 31 ++++++++++++ .../0002_initial.py | 20 ++++++++ .../__init__.py | 0 tests/migrations/test_executor.py | 59 ++++++++++++++++++++++ 4 files changed, 110 insertions(+) create mode 100644 tests/migrations/test_add_many_to_many_field_initial/0001_initial.py create mode 100644 tests/migrations/test_add_many_to_many_field_initial/0002_initial.py create mode 100644 tests/migrations/test_add_many_to_many_field_initial/__init__.py (limited to 'tests') diff --git a/tests/migrations/test_add_many_to_many_field_initial/0001_initial.py b/tests/migrations/test_add_many_to_many_field_initial/0001_initial.py new file mode 100644 index 0000000000..b50b3c68b8 --- /dev/null +++ b/tests/migrations/test_add_many_to_many_field_initial/0001_initial.py @@ -0,0 +1,31 @@ +from __future__ import unicode_literals + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + initial = True + + dependencies = [ + ] + + operations = [ + migrations.CreateModel( + name='Project', + fields=[ + ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ], + ), + migrations.CreateModel( + name='Task', + fields=[ + ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ], + ), + migrations.AddField( + model_name='project', + name='tasks', + field=models.ManyToManyField(to='Task'), + ), + ] diff --git a/tests/migrations/test_add_many_to_many_field_initial/0002_initial.py b/tests/migrations/test_add_many_to_many_field_initial/0002_initial.py new file mode 100644 index 0000000000..65739a5bb4 --- /dev/null +++ b/tests/migrations/test_add_many_to_many_field_initial/0002_initial.py @@ -0,0 +1,20 @@ +from __future__ import unicode_literals + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + initial = True + + dependencies = [ + ("migrations", "0001_initial"), + ] + + operations = [ + migrations.AddField( + model_name='task', + name='projects', + field=models.ManyToManyField(to='Project'), + ), + ] diff --git a/tests/migrations/test_add_many_to_many_field_initial/__init__.py b/tests/migrations/test_add_many_to_many_field_initial/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/tests/migrations/test_executor.py b/tests/migrations/test_executor.py index 32cdc5e09c..1bbed48e3c 100644 --- a/tests/migrations/test_executor.py +++ b/tests/migrations/test_executor.py @@ -301,6 +301,65 @@ class ExecutorTests(MigrationTestBase): self.assertTableNotExists("migrations_author") self.assertTableNotExists("migrations_tribble") + @override_settings( + MIGRATION_MODULES={ + "migrations": "migrations.test_add_many_to_many_field_initial", + }, + ) + def test_detect_soft_applied_add_field_manytomanyfield(self): + """ + executor.detect_soft_applied() detects ManyToManyField tables from an + AddField operation. This checks the case of AddField in a migration + with other operations (0001) and the case of AddField in its own + migration (0002). + """ + tables = [ + # from 0001 + "migrations_project", + "migrations_task", + "migrations_project_tasks", + # from 0002 + "migrations_task_projects", + ] + executor = MigrationExecutor(connection) + # Create the tables for 0001 but make it look like the migration hasn't + # been applied. + executor.migrate([("migrations", "0001_initial")]) + executor.migrate([("migrations", None)], fake=True) + for table in tables[:3]: + self.assertTableExists(table) + # Table detection sees 0001 is applied but not 0002. + migration = executor.loader.get_migration("migrations", "0001_initial") + self.assertEqual(executor.detect_soft_applied(None, migration)[0], True) + migration = executor.loader.get_migration("migrations", "0002_initial") + self.assertEqual(executor.detect_soft_applied(None, migration)[0], False) + + # Create the tables for both migrations but make it look like neither + # has been applied. + executor.loader.build_graph() + executor.migrate([("migrations", "0001_initial")], fake=True) + executor.migrate([("migrations", "0002_initial")]) + executor.loader.build_graph() + executor.migrate([("migrations", None)], fake=True) + # Table detection sees 0002 is applied. + migration = executor.loader.get_migration("migrations", "0002_initial") + self.assertEqual(executor.detect_soft_applied(None, migration)[0], True) + + # Leave the tables for 0001 except the many-to-many table. That missing + # table should cause detect_soft_applied() to return False. + with connection.schema_editor() as editor: + for table in tables[2:]: + editor.execute(editor.sql_delete_table % {"table": table}) + migration = executor.loader.get_migration("migrations", "0001_initial") + self.assertEqual(executor.detect_soft_applied(None, migration)[0], False) + + # Cleanup by removing the remaining tables. + with connection.schema_editor() as editor: + for table in tables[:2]: + editor.execute(editor.sql_delete_table % {"table": table}) + for table in tables: + self.assertTableNotExists(table) + @override_settings( INSTALLED_APPS=[ "migrations.migrations_test_apps.lookuperror_a", -- cgit v1.3