示例#1
0
 def test_optimize_through_fields(self):
     """
     field-level through checking is working. This should manage to collapse
     model Foo to nonexistence, and model Bar to a single IntegerField
     called "width".
     """
     self.assertOptimizesTo(
         [
             migrations.CreateModel(
                 "Foo", [("name", models.CharField(max_length=255))]),
             migrations.CreateModel("Bar",
                                    [("size", models.IntegerField())]),
             migrations.AddField("Foo", "age", models.IntegerField()),
             migrations.AddField("Bar", "width", models.IntegerField()),
             migrations.AlterField("Foo", "age", models.IntegerField()),
             migrations.RenameField("Bar", "size", "dimensions"),
             migrations.RemoveField("Foo", "age"),
             migrations.RenameModel("Foo", "Phou"),
             migrations.RemoveField("Bar", "dimensions"),
             migrations.RenameModel("Phou", "Fou"),
             migrations.DeleteModel("Fou"),
         ],
         [
             migrations.CreateModel("Bar",
                                    [("width", models.IntegerField())]),
         ],
     )
示例#2
0
 def test_alter_field_delete_field(self):
     """
     RemoveField should absorb AlterField
     """
     self.assertOptimizesTo(
         [
             migrations.AlterField("Foo", "age", models.IntegerField()),
             migrations.RemoveField("Foo", "age"),
         ],
         [
             migrations.RemoveField("Foo", "age"),
         ],
     )
示例#3
0
 def test_create_model_remove_field(self):
     """
     RemoveField should optimize into CreateModel.
     """
     managers = [('objects', EmptyManager())]
     self.assertOptimizesTo(
         [
             migrations.CreateModel(
                 name="Foo",
                 fields=[
                     ("name", models.CharField(max_length=255)),
                     ("age", models.IntegerField()),
                 ],
                 options={'verbose_name': 'Foo'},
                 bases=(UnicodeModel, ),
                 managers=managers,
             ),
             migrations.RemoveField("Foo", "age"),
         ],
         [
             migrations.CreateModel(
                 name="Foo",
                 fields=[
                     ("name", models.CharField(max_length=255)),
                 ],
                 options={'verbose_name': 'Foo'},
                 bases=(UnicodeModel, ),
                 managers=managers,
             ),
         ],
     )
class Migration(migrations.Migration):

    dependencies = [
        ('contenttypes', '0001_initial'),
    ]

    operations = [
        migrations.AlterModelOptions(
            name='contenttype',
            options={
                'verbose_name': 'content type',
                'verbose_name_plural': 'content types'
            },
        ),
        migrations.AlterField(
            model_name='contenttype',
            name='name',
            field=models.CharField(max_length=100, null=True),
        ),
        migrations.RunPython(
            migrations.RunPython.noop,
            add_legacy_name,
            hints={'model_name': 'contenttype'},
        ),
        migrations.RemoveField(
            model_name='contenttype',
            name='name',
        ),
    ]
示例#5
0
 def test_add_field_delete_field(self):
     """
     RemoveField should cancel AddField
     """
     self.assertOptimizesTo(
         [
             migrations.AddField("Foo", "age", models.IntegerField()),
             migrations.RemoveField("Foo", "age"),
         ],
         [],
     )
class Migration(migrations.Migration):

    dependencies = [
        ('migrations', '0001_initial'),
    ]

    operations = [
        migrations.RemoveField(
            model_name='ipaddressfield',
            name='ip',
        ),
    ]
示例#7
0
class Migration(migrations.Migration):

    dependencies = [("unspecified_app_with_conflict", "0001_initial")]

    operations = [
        migrations.DeleteModel("Tribble"),
        migrations.RemoveField("Author", "silly_field"),
        migrations.AddField("Author", "rating",
                            models.IntegerField(default=0)),
        migrations.CreateModel(
            "Book",
            [
                ("id", models.AutoField(primary_key=True)),
            ],
        )
    ]
示例#8
0
class Migration(migrations.Migration):

    dependencies = []

    operations = [
        migrations.DeleteModel("Tribble"),
        migrations.RemoveField("Author", "silly_field"),
        migrations.AddField("Author", "rating",
                            models.IntegerField(default=0)),
        migrations.CreateModel(
            "Book",
            [
                ("id", models.AutoField(primary_key=True)),
                ("author",
                 models.ForeignKey(
                     "migrations.Author", models.SET_NULL, null=True)),
            ],
        )
    ]
示例#9
0
    def _test_create_alter_foo_field(self, alter):
        """
        CreateModel, AlterFooTogether/AlterOrderWithRespectTo followed by an
        add/alter/rename field should optimize to CreateModel with options.
        """
        option_value = getattr(alter, alter.option_name)
        options = {alter.option_name: option_value}

        # AddField
        self.assertOptimizesTo(
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                ]),
                alter,
                migrations.AddField("Foo", "c", models.IntegerField()),
            ],
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                    ("c", models.IntegerField()),
                ],
                                       options=options),
            ],
        )

        # AlterField
        self.assertOptimizesTo(
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                ]),
                alter,
                migrations.AlterField("Foo", "b",
                                      models.CharField(max_length=255)),
            ],
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.CharField(max_length=255)),
                ],
                                       options=options),
            ],
        )

        self.assertOptimizesTo(
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                    ("c", models.IntegerField()),
                ]),
                alter,
                migrations.AlterField("Foo", "c",
                                      models.CharField(max_length=255)),
            ],
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                    ("c", models.CharField(max_length=255)),
                ],
                                       options=options),
            ],
        )

        # RenameField
        if isinstance(option_value, str):
            renamed_options = {alter.option_name: 'c'}
        else:
            renamed_options = {
                alter.option_name: {
                    tuple('c' if value == 'b' else value for value in item)
                    for item in option_value
                }
            }
        self.assertOptimizesTo(
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                ]),
                alter,
                migrations.RenameField("Foo", "b", "c"),
            ],
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("c", models.IntegerField()),
                ],
                                       options=renamed_options),
            ],
        )

        self.assertOptimizesTo(
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                ]),
                alter,
                migrations.RenameField("Foo", "b", "x"),
                migrations.RenameField("Foo", "x", "c"),
            ],
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("c", models.IntegerField()),
                ],
                                       options=renamed_options),
            ],
        )

        self.assertOptimizesTo(
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                    ("c", models.IntegerField()),
                ]),
                alter,
                migrations.RenameField("Foo", "c", "d"),
            ],
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                    ("d", models.IntegerField()),
                ],
                                       options=options),
            ],
        )

        # RemoveField
        if isinstance(option_value, str):
            removed_options = None
        else:
            removed_options = {
                alter.option_name: {
                    tuple(value for value in item if value != 'b')
                    for item in option_value
                }
            }
        self.assertOptimizesTo([
            migrations.CreateModel("Foo", [
                ("a", models.IntegerField()),
                ("b", models.IntegerField()),
            ]),
            alter,
            migrations.RemoveField("Foo", "b"),
        ], [
            migrations.CreateModel("Foo", [
                ("a", models.IntegerField()),
            ],
                                   options=removed_options),
        ])

        self.assertOptimizesTo(
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                    ("c", models.IntegerField()),
                ]),
                alter,
                migrations.RemoveField("Foo", "c"),
            ],
            [
                migrations.CreateModel("Foo", [
                    ("a", models.IntegerField()),
                    ("b", models.IntegerField()),
                ],
                                       options=options),
            ],
        )
示例#10
0
    def test_optimize_through_create(self):
        """
        We should be able to optimize away create/delete through a create or delete
        of a different model, but only if the create operation does not mention the model
        at all.
        """
        # These should work
        self.assertOptimizesTo(
            [
                migrations.CreateModel(
                    "Foo", [("name", models.CharField(max_length=255))]),
                migrations.CreateModel("Bar",
                                       [("size", models.IntegerField())]),
                migrations.DeleteModel("Foo"),
            ],
            [
                migrations.CreateModel("Bar",
                                       [("size", models.IntegerField())]),
            ],
        )
        self.assertOptimizesTo(
            [
                migrations.CreateModel(
                    "Foo", [("name", models.CharField(max_length=255))]),
                migrations.CreateModel("Bar",
                                       [("size", models.IntegerField())]),
                migrations.DeleteModel("Bar"),
                migrations.DeleteModel("Foo"),
            ],
            [],
        )
        self.assertOptimizesTo(
            [
                migrations.CreateModel(
                    "Foo", [("name", models.CharField(max_length=255))]),
                migrations.CreateModel("Bar",
                                       [("size", models.IntegerField())]),
                migrations.DeleteModel("Foo"),
                migrations.DeleteModel("Bar"),
            ],
            [],
        )
        # This should not work - FK should block it
        self.assertDoesNotOptimize([
            migrations.CreateModel(
                "Foo", [("name", models.CharField(max_length=255))]),
            migrations.CreateModel("Bar", [
                ("other", models.ForeignKey("testapp.Foo", models.CASCADE))
            ]),
            migrations.DeleteModel("Foo"),
        ], )
        # The same operations should be optimized if app_label is specified and
        # a FK references a model from the other app.
        self.assertOptimizesTo(
            [
                migrations.CreateModel(
                    "Foo", [("name", models.CharField(max_length=255))]),
                migrations.CreateModel("Bar", [
                    ("other", models.ForeignKey("testapp.Foo", models.CASCADE))
                ]),
                migrations.DeleteModel("Foo"),
            ],
            [
                migrations.CreateModel("Bar", [
                    ("other", models.ForeignKey("testapp.Foo", models.CASCADE))
                ]),
            ],
            app_label="otherapp",
        )
        # But it shouldn't work if a FK references a model with the same
        # app_label.
        self.assertDoesNotOptimize(
            [
                migrations.CreateModel(
                    "Foo", [("name", models.CharField(max_length=255))]),
                migrations.CreateModel("Bar", [
                    ("other", models.ForeignKey("testapp.Foo", models.CASCADE))
                ]),
                migrations.DeleteModel("Foo"),
            ],
            app_label="testapp",
        )
        # This should not work - bases should block it
        self.assertDoesNotOptimize([
            migrations.CreateModel(
                "Foo", [("name", models.CharField(max_length=255))]),
            migrations.CreateModel("Bar", [("size", models.IntegerField())],
                                   bases=("testapp.Foo", )),
            migrations.DeleteModel("Foo"),
        ], )
        # The same operations should be optimized if app_label and none of
        # bases belong to that app.
        self.assertOptimizesTo(
            [
                migrations.CreateModel(
                    "Foo", [("name", models.CharField(max_length=255))]),
                migrations.CreateModel("Bar",
                                       [("size", models.IntegerField())],
                                       bases=("testapp.Foo", )),
                migrations.DeleteModel("Foo"),
            ],
            [
                migrations.CreateModel("Bar",
                                       [("size", models.IntegerField())],
                                       bases=("testapp.Foo", )),
            ],
            app_label="otherapp",
        )
        # But it shouldn't work if some of bases belongs to the specified app.
        self.assertDoesNotOptimize(
            [
                migrations.CreateModel(
                    "Foo", [("name", models.CharField(max_length=255))]),
                migrations.CreateModel("Bar",
                                       [("size", models.IntegerField())],
                                       bases=("testapp.Foo", )),
                migrations.DeleteModel("Foo"),
            ],
            app_label="testapp",
        )

        self.assertOptimizesTo(
            [
                migrations.CreateModel(
                    'Book', [('name', models.CharField(max_length=255))]),
                migrations.CreateModel(
                    'Person', [('name', models.CharField(max_length=255))]),
                migrations.AddField(
                    'book', 'author',
                    models.ForeignKey('test_app.Person', models.CASCADE)),
                migrations.CreateModel('Review', [
                    ('book', models.ForeignKey('test_app.Book',
                                               models.CASCADE))
                ]),
                migrations.CreateModel(
                    'Reviewer', [('name', models.CharField(max_length=255))]),
                migrations.AddField(
                    'review', 'reviewer',
                    models.ForeignKey('test_app.Reviewer', models.CASCADE)),
                migrations.RemoveField('book', 'author'),
                migrations.DeleteModel('Person'),
            ],
            [
                migrations.CreateModel(
                    'Book', [('name', models.CharField(max_length=255))]),
                migrations.CreateModel(
                    'Reviewer', [('name', models.CharField(max_length=255))]),
                migrations.CreateModel('Review', [
                    ('book', models.ForeignKey('test_app.Book',
                                               models.CASCADE)),
                    ('reviewer',
                     models.ForeignKey('test_app.Reviewer', models.CASCADE)),
                ]),
            ],
        )