Debian Codegraph @

tests/migrations/test_optimizer.py

raw
1 from django.db import migrations, models
2 from django.db.migrations import operations
3 from django.db.migrations.optimizer import MigrationOptimizer
4 from django.db.models.functions import Abs
5
6 from .models import EmptyManager, UnicodeModel
7 from .test_base import OptimizerTestBase
8
9
10 class OptimizerTests(OptimizerTestBase):
11 """
12 Tests the migration optimizer.
13 """
14
15 def test_none_app_label(self):
16 optimizer = MigrationOptimizer()
17 with self.assertRaisesMessage(TypeError, "app_label must be a str"):
18 optimizer.optimize([], None)
19
20 def test_single(self):
21 """
22 The optimizer does nothing on a single operation,
23 and that it does it in just one pass.
24 """
25 self.assertOptimizesTo(
26 [migrations.DeleteModel("Foo")],
27 [migrations.DeleteModel("Foo")],
28 exact=1,
29 )
30
31 def test_create_delete_model(self):
32 """
33 CreateModel and DeleteModel should collapse into nothing.
34 """
35 self.assertOptimizesTo(
36 [
37 migrations.CreateModel(
38 "Foo", [("name", models.CharField(max_length=255))]
39 ),
40 migrations.DeleteModel("Foo"),
41 ],
42 [],
43 )
44
45 def test_create_rename_model(self):
46 """
47 CreateModel should absorb RenameModels.
48 """
49 managers = [("objects", EmptyManager())]
50 self.assertOptimizesTo(
51 [
52 migrations.CreateModel(
53 name="Foo",
54 fields=[("name", models.CharField(max_length=255))],
55 options={"verbose_name": "Foo"},
56 bases=(UnicodeModel,),
57 managers=managers,
58 ),
59 migrations.RenameModel("Foo", "Bar"),
60 ],
61 [
62 migrations.CreateModel(
63 "Bar",
64 [("name", models.CharField(max_length=255))],
65 options={"verbose_name": "Foo"},
66 bases=(UnicodeModel,),
67 managers=managers,
68 )
69 ],
70 )
71
72 def test_rename_model_self(self):
73 """
74 RenameModels should absorb themselves.
75 """
76 self.assertOptimizesTo(
77 [
78 migrations.RenameModel("Foo", "Baa"),
79 migrations.RenameModel("Baa", "Bar"),
80 ],
81 [
82 migrations.RenameModel("Foo", "Bar"),
83 ],
84 )
85
86 def test_create_alter_model_options(self):
87 self.assertOptimizesTo(
88 [
89 migrations.CreateModel("Foo", fields=[]),
90 migrations.AlterModelOptions(
91 name="Foo", options={"verbose_name_plural": "Foozes"}
92 ),
93 ],
94 [
95 migrations.CreateModel(
96 "Foo", fields=[], options={"verbose_name_plural": "Foozes"}
97 ),
98 ],
99 )
100
101 def test_create_alter_model_managers(self):
102 self.assertOptimizesTo(
103 [
104 migrations.CreateModel("Foo", fields=[]),
105 migrations.AlterModelManagers(
106 name="Foo",
107 managers=[
108 ("objects", models.Manager()),
109 ("things", models.Manager()),
110 ],
111 ),
112 ],
113 [
114 migrations.CreateModel(
115 "Foo",
116 fields=[],
117 managers=[
118 ("objects", models.Manager()),
119 ("things", models.Manager()),
120 ],
121 ),
122 ],
123 )
124
125 def test_create_alter_model_table(self):
126 self.assertOptimizesTo(
127 [
128 migrations.CreateModel("Foo", fields=[]),
129 migrations.AlterModelTable(
130 name="foo",
131 table="foo",
132 ),
133 ],
134 [
135 migrations.CreateModel(
136 "Foo",
137 fields=[],
138 options={
139 "db_table": "foo",
140 },
141 ),
142 ],
143 )
144
145 def test_create_alter_model_table_comment(self):
146 self.assertOptimizesTo(
147 [
148 migrations.CreateModel("Foo", fields=[]),
149 migrations.AlterModelTableComment(
150 name="foo",
151 table_comment="A lovely table.",
152 ),
153 ],
154 [
155 migrations.CreateModel(
156 "Foo",
157 fields=[],
158 options={
159 "db_table_comment": "A lovely table.",
160 },
161 ),
162 ],
163 )
164
165 def test_create_model_and_remove_model_options(self):
166 self.assertOptimizesTo(
167 [
168 migrations.CreateModel(
169 "MyModel",
170 fields=[],
171 options={"verbose_name": "My Model"},
172 ),
173 migrations.AlterModelOptions("MyModel", options={}),
174 ],
175 [migrations.CreateModel("MyModel", fields=[])],
176 )
177 self.assertOptimizesTo(
178 [
179 migrations.CreateModel(
180 "MyModel",
181 fields=[],
182 options={
183 "verbose_name": "My Model",
184 "verbose_name_plural": "My Model plural",
185 },
186 ),
187 migrations.AlterModelOptions(
188 "MyModel",
189 options={"verbose_name": "My Model"},
190 ),
191 ],
192 [
193 migrations.CreateModel(
194 "MyModel",
195 fields=[],
196 options={"verbose_name": "My Model"},
197 ),
198 ],
199 )
200
201 def _test_create_alter_foo_delete_model(self, alter_foo):
202 """
203 CreateModel, AlterModelTable, AlterUniqueTogether/AlterIndexTogether/
204 AlterOrderWithRespectTo, and DeleteModel should collapse into nothing.
205 """
206 self.assertOptimizesTo(
207 [
208 migrations.CreateModel(
209 "Foo", [("name", models.CharField(max_length=255))]
210 ),
211 migrations.AlterModelTable("Foo", "woohoo"),
212 alter_foo,
213 migrations.DeleteModel("Foo"),
214 ],
215 [],
216 )
217
218 def test_create_alter_unique_delete_model(self):
219 self._test_create_alter_foo_delete_model(
220 migrations.AlterUniqueTogether("Foo", [["a", "b"]])
221 )
222
223 def test_create_alter_index_delete_model(self):
224 self._test_create_alter_foo_delete_model(
225 migrations.AlterIndexTogether("Foo", [["a", "b"]])
226 )
227
228 def test_create_alter_owrt_delete_model(self):
229 self._test_create_alter_foo_delete_model(
230 migrations.AlterOrderWithRespectTo("Foo", "a")
231 )
232
233 def _test_alter_alter(self, alter_foo, alter_bar):
234 """
235 Two AlterUniqueTogether/AlterIndexTogether/AlterOrderWithRespectTo
236 /AlterField should collapse into the second.
237 """
238 self.assertOptimizesTo(
239 [
240 alter_foo,
241 alter_bar,
242 ],
243 [
244 alter_bar,
245 ],
246 )
247
248 def test_alter_alter_table_model(self):
249 self._test_alter_alter(
250 migrations.AlterModelTable("Foo", "a"),
251 migrations.AlterModelTable("Foo", "b"),
252 )
253
254 def test_alter_alter_unique_model(self):
255 self._test_alter_alter(
256 migrations.AlterUniqueTogether("Foo", [["a", "b"]]),
257 migrations.AlterUniqueTogether("Foo", [["a", "c"]]),
258 )
259
260 def test_alter_alter_index_model(self):
261 self._test_alter_alter(
262 migrations.AlterIndexTogether("Foo", [["a", "b"]]),
263 migrations.AlterIndexTogether("Foo", [["a", "c"]]),
264 )
265
266 def test_alter_alter_owrt_model(self):
267 self._test_alter_alter(
268 migrations.AlterOrderWithRespectTo("Foo", "a"),
269 migrations.AlterOrderWithRespectTo("Foo", "b"),
270 )
271
272 def test_alter_alter_field(self):
273 self._test_alter_alter(
274 migrations.AlterField("Foo", "name", models.IntegerField()),
275 migrations.AlterField("Foo", "name", models.IntegerField(help_text="help")),
276 )
277
278 def test_optimize_through_create(self):
279 """
280 We should be able to optimize away create/delete through a create or
281 delete of a different model, but only if the create operation does not
282 mention the model at all.
283 """
284 # These should work
285 self.assertOptimizesTo(
286 [
287 migrations.CreateModel(
288 "Foo", [("name", models.CharField(max_length=255))]
289 ),
290 migrations.CreateModel("Bar", [("size", models.IntegerField())]),
291 migrations.DeleteModel("Foo"),
292 ],
293 [
294 migrations.CreateModel("Bar", [("size", models.IntegerField())]),
295 ],
296 )
297 self.assertOptimizesTo(
298 [
299 migrations.CreateModel(
300 "Foo", [("name", models.CharField(max_length=255))]
301 ),
302 migrations.CreateModel("Bar", [("size", models.IntegerField())]),
303 migrations.DeleteModel("Bar"),
304 migrations.DeleteModel("Foo"),
305 ],
306 [],
307 )
308 self.assertOptimizesTo(
309 [
310 migrations.CreateModel(
311 "Foo", [("name", models.CharField(max_length=255))]
312 ),
313 migrations.CreateModel("Bar", [("size", models.IntegerField())]),
314 migrations.DeleteModel("Foo"),
315 migrations.DeleteModel("Bar"),
316 ],
317 [],
318 )
319 # Operations should be optimized if the FK references a model from the
320 # other app.
321 self.assertOptimizesTo(
322 [
323 migrations.CreateModel(
324 "Foo", [("name", models.CharField(max_length=255))]
325 ),
326 migrations.CreateModel(
327 "Bar", [("other", models.ForeignKey("testapp.Foo", models.CASCADE))]
328 ),
329 migrations.DeleteModel("Foo"),
330 ],
331 [
332 migrations.CreateModel(
333 "Bar", [("other", models.ForeignKey("testapp.Foo", models.CASCADE))]
334 ),
335 ],
336 app_label="otherapp",
337 )
338 # But it shouldn't work if a FK references a model with the same
339 # app_label.
340 self.assertDoesNotOptimize(
341 [
342 migrations.CreateModel(
343 "Foo", [("name", models.CharField(max_length=255))]
344 ),
345 migrations.CreateModel(
346 "Bar", [("other", models.ForeignKey("Foo", models.CASCADE))]
347 ),
348 migrations.DeleteModel("Foo"),
349 ],
350 )
351 self.assertDoesNotOptimize(
352 [
353 migrations.CreateModel(
354 "Foo", [("name", models.CharField(max_length=255))]
355 ),
356 migrations.CreateModel(
357 "Bar", [("other", models.ForeignKey("testapp.Foo", models.CASCADE))]
358 ),
359 migrations.DeleteModel("Foo"),
360 ],
361 app_label="testapp",
362 )
363 # This should not work - bases should block it
364 self.assertDoesNotOptimize(
365 [
366 migrations.CreateModel(
367 "Foo", [("name", models.CharField(max_length=255))]
368 ),
369 migrations.CreateModel(
370 "Bar", [("size", models.IntegerField())], bases=("Foo",)
371 ),
372 migrations.DeleteModel("Foo"),
373 ],
374 )
375 self.assertDoesNotOptimize(
376 [
377 migrations.CreateModel(
378 "Foo", [("name", models.CharField(max_length=255))]
379 ),
380 migrations.CreateModel(
381 "Bar", [("size", models.IntegerField())], bases=("testapp.Foo",)
382 ),
383 migrations.DeleteModel("Foo"),
384 ],
385 app_label="testapp",
386 )
387 # The same operations should be optimized if app_label and none of
388 # bases belong to that app.
389 self.assertOptimizesTo(
390 [
391 migrations.CreateModel(
392 "Foo", [("name", models.CharField(max_length=255))]
393 ),
394 migrations.CreateModel(
395 "Bar", [("size", models.IntegerField())], bases=("testapp.Foo",)
396 ),
397 migrations.DeleteModel("Foo"),
398 ],
399 [
400 migrations.CreateModel(
401 "Bar", [("size", models.IntegerField())], bases=("testapp.Foo",)
402 ),
403 ],
404 app_label="otherapp",
405 )
406 # But it shouldn't work if some of bases belongs to the specified app.
407 self.assertDoesNotOptimize(
408 [
409 migrations.CreateModel(
410 "Foo", [("name", models.CharField(max_length=255))]
411 ),
412 migrations.CreateModel(
413 "Bar", [("size", models.IntegerField())], bases=("testapp.Foo",)
414 ),
415 migrations.DeleteModel("Foo"),
416 ],
417 app_label="testapp",
418 )
419
420 self.assertOptimizesTo(
421 [
422 migrations.CreateModel(
423 "Book", [("name", models.CharField(max_length=255))]
424 ),
425 migrations.CreateModel(
426 "Person", [("name", models.CharField(max_length=255))]
427 ),
428 migrations.AddField(
429 "book",
430 "author",
431 models.ForeignKey("test_app.Person", models.CASCADE),
432 ),
433 migrations.CreateModel(
434 "Review",
435 [("book", models.ForeignKey("test_app.Book", models.CASCADE))],
436 ),
437 migrations.CreateModel(
438 "Reviewer", [("name", models.CharField(max_length=255))]
439 ),
440 migrations.AddField(
441 "review",
442 "reviewer",
443 models.ForeignKey("test_app.Reviewer", models.CASCADE),
444 ),
445 migrations.RemoveField("book", "author"),
446 migrations.DeleteModel("Person"),
447 ],
448 [
449 migrations.CreateModel(
450 "Book", [("name", models.CharField(max_length=255))]
451 ),
452 migrations.CreateModel(
453 "Reviewer", [("name", models.CharField(max_length=255))]
454 ),
455 migrations.CreateModel(
456 "Review",
457 [
458 ("book", models.ForeignKey("test_app.Book", models.CASCADE)),
459 (
460 "reviewer",
461 models.ForeignKey("test_app.Reviewer", models.CASCADE),
462 ),
463 ],
464 ),
465 ],
466 app_label="test_app",
467 )
468
469 def test_create_model_add_field(self):
470 """
471 AddField should optimize into CreateModel.
472 """
473 managers = [("objects", EmptyManager())]
474 self.assertOptimizesTo(
475 [
476 migrations.CreateModel(
477 name="Foo",
478 fields=[("name", models.CharField(max_length=255))],
479 options={"verbose_name": "Foo"},
480 bases=(UnicodeModel,),
481 managers=managers,
482 ),
483 migrations.AddField("Foo", "age", models.IntegerField()),
484 ],
485 [
486 migrations.CreateModel(
487 name="Foo",
488 fields=[
489 ("name", models.CharField(max_length=255)),
490 ("age", models.IntegerField()),
491 ],
492 options={"verbose_name": "Foo"},
493 bases=(UnicodeModel,),
494 managers=managers,
495 ),
496 ],
497 )
498
499 def test_create_model_reordering(self):
500 """
501 AddField optimizes into CreateModel if it's a FK to a model that's
502 between them (and there's no FK in the other direction), by changing
503 the order of the CreateModel operations.
504 """
505 self.assertOptimizesTo(
506 [
507 migrations.CreateModel(
508 "Foo", [("name", models.CharField(max_length=255))]
509 ),
510 migrations.CreateModel("Link", [("url", models.TextField())]),
511 migrations.AddField(
512 "Foo", "link", models.ForeignKey("migrations.Link", models.CASCADE)
513 ),
514 ],
515 [
516 migrations.CreateModel("Link", [("url", models.TextField())]),
517 migrations.CreateModel(
518 "Foo",
519 [
520 ("name", models.CharField(max_length=255)),
521 ("link", models.ForeignKey("migrations.Link", models.CASCADE)),
522 ],
523 ),
524 ],
525 )
526
527 def test_create_model_reordering_circular_fk(self):
528 """
529 CreateModel reordering behavior doesn't result in an infinite loop if
530 there are FKs in both directions.
531 """
532 self.assertOptimizesTo(
533 [
534 migrations.CreateModel("Bar", [("url", models.TextField())]),
535 migrations.CreateModel(
536 "Foo", [("name", models.CharField(max_length=255))]
537 ),
538 migrations.AddField(
539 "Bar", "foo_fk", models.ForeignKey("migrations.Foo", models.CASCADE)
540 ),
541 migrations.AddField(
542 "Foo", "bar_fk", models.ForeignKey("migrations.Bar", models.CASCADE)
543 ),
544 ],
545 [
546 migrations.CreateModel(
547 "Foo", [("name", models.CharField(max_length=255))]
548 ),
549 migrations.CreateModel(
550 "Bar",
551 [
552 ("url", models.TextField()),
553 ("foo_fk", models.ForeignKey("migrations.Foo", models.CASCADE)),
554 ],
555 ),
556 migrations.AddField(
557 "Foo", "bar_fk", models.ForeignKey("migrations.Bar", models.CASCADE)
558 ),
559 ],
560 )
561
562 def test_create_model_no_reordering_for_unrelated_fk(self):
563 """
564 CreateModel order remains unchanged if the later AddField operation
565 isn't a FK between them.
566 """
567 self.assertDoesNotOptimize(
568 [
569 migrations.CreateModel(
570 "Foo", [("name", models.CharField(max_length=255))]
571 ),
572 migrations.CreateModel("Link", [("url", models.TextField())]),
573 migrations.AddField(
574 "Other",
575 "link",
576 models.ForeignKey("migrations.Link", models.CASCADE),
577 ),
578 ],
579 )
580
581 def test_create_model_no_reordering_of_inherited_model(self):
582 """
583 A CreateModel that inherits from another isn't reordered to avoid
584 moving it earlier than its parent CreateModel operation.
585 """
586 self.assertOptimizesTo(
587 [
588 migrations.CreateModel(
589 "Other", [("foo", models.CharField(max_length=255))]
590 ),
591 migrations.CreateModel(
592 "ParentModel", [("bar", models.CharField(max_length=255))]
593 ),
594 migrations.CreateModel(
595 "ChildModel",
596 [("baz", models.CharField(max_length=255))],
597 bases=("migrations.parentmodel",),
598 ),
599 migrations.AddField(
600 "Other",
601 "fk",
602 models.ForeignKey("migrations.ChildModel", models.CASCADE),
603 ),
604 ],
605 [
606 migrations.CreateModel(
607 "ParentModel", [("bar", models.CharField(max_length=255))]
608 ),
609 migrations.CreateModel(
610 "ChildModel",
611 [("baz", models.CharField(max_length=255))],
612 bases=("migrations.parentmodel",),
613 ),
614 migrations.CreateModel(
615 "Other",
616 [
617 ("foo", models.CharField(max_length=255)),
618 (
619 "fk",
620 models.ForeignKey("migrations.ChildModel", models.CASCADE),
621 ),
622 ],
623 ),
624 ],
625 )
626
627 def test_create_model_add_field_not_through_m2m_through(self):
628 """
629 AddField should NOT optimize into CreateModel if it's an M2M using a
630 through that's created between them.
631 """
632 self.assertDoesNotOptimize(
633 [
634 migrations.CreateModel("Employee", []),
635 migrations.CreateModel("Employer", []),
636 migrations.CreateModel(
637 "Employment",
638 [
639 (
640 "employee",
641 models.ForeignKey("migrations.Employee", models.CASCADE),
642 ),
643 (
644 "employment",
645 models.ForeignKey("migrations.Employer", models.CASCADE),
646 ),
647 ],
648 ),
649 migrations.AddField(
650 "Employer",
651 "employees",
652 models.ManyToManyField(
653 "migrations.Employee",
654 through="migrations.Employment",
655 ),
656 ),
657 ],
658 )
659
660 def test_create_model_alter_field(self):
661 """
662 AlterField should optimize into CreateModel.
663 """
664 managers = [("objects", EmptyManager())]
665 self.assertOptimizesTo(
666 [
667 migrations.CreateModel(
668 name="Foo",
669 fields=[("name", models.CharField(max_length=255))],
670 options={"verbose_name": "Foo"},
671 bases=(UnicodeModel,),
672 managers=managers,
673 ),
674 migrations.AlterField("Foo", "name", models.IntegerField()),
675 ],
676 [
677 migrations.CreateModel(
678 name="Foo",
679 fields=[
680 ("name", models.IntegerField()),
681 ],
682 options={"verbose_name": "Foo"},
683 bases=(UnicodeModel,),
684 managers=managers,
685 ),
686 ],
687 )
688
689 def test_create_model_rename_field(self):
690 """
691 RenameField should optimize into CreateModel.
692 """
693 managers = [("objects", EmptyManager())]
694 self.assertOptimizesTo(
695 [
696 migrations.CreateModel(
697 name="Foo",
698 fields=[("name", models.CharField(max_length=255))],
699 options={"verbose_name": "Foo"},
700 bases=(UnicodeModel,),
701 managers=managers,
702 ),
703 migrations.RenameField("Foo", "name", "title"),
704 ],
705 [
706 migrations.CreateModel(
707 name="Foo",
708 fields=[
709 ("title", models.CharField(max_length=255)),
710 ],
711 options={"verbose_name": "Foo"},
712 bases=(UnicodeModel,),
713 managers=managers,
714 ),
715 ],
716 )
717
718 def test_add_field_rename_field(self):
719 """
720 RenameField should optimize into AddField
721 """
722 self.assertOptimizesTo(
723 [
724 migrations.AddField("Foo", "name", models.CharField(max_length=255)),
725 migrations.RenameField("Foo", "name", "title"),
726 ],
727 [
728 migrations.AddField("Foo", "title", models.CharField(max_length=255)),
729 ],
730 )
731
732 def test_alter_field_rename_field(self):
733 """
734 RenameField should optimize to the other side of AlterField,
735 and into itself.
736 """
737 self.assertOptimizesTo(
738 [
739 migrations.AlterField("Foo", "name", models.CharField(max_length=255)),
740 migrations.RenameField("Foo", "name", "title"),
741 migrations.RenameField("Foo", "title", "nom"),
742 ],
743 [
744 migrations.RenameField("Foo", "name", "nom"),
745 migrations.AlterField("Foo", "nom", models.CharField(max_length=255)),
746 ],
747 )
748
749 def test_swapping_fields_names(self):
750 self.assertDoesNotOptimize(
751 [
752 migrations.CreateModel(
753 "MyModel",
754 [
755 ("field_a", models.IntegerField()),
756 ("field_b", models.IntegerField()),
757 ],
758 ),
759 migrations.RunPython(migrations.RunPython.noop),
760 migrations.RenameField("MyModel", "field_a", "field_c"),
761 migrations.RenameField("MyModel", "field_b", "field_a"),
762 migrations.RenameField("MyModel", "field_c", "field_b"),
763 ],
764 )
765
766 def test_create_model_remove_field(self):
767 """
768 RemoveField should optimize into CreateModel.
769 """
770 managers = [("objects", EmptyManager())]
771 self.assertOptimizesTo(
772 [
773 migrations.CreateModel(
774 name="Foo",
775 fields=[
776 ("name", models.CharField(max_length=255)),
777 ("age", models.IntegerField()),
778 ],
779 options={"verbose_name": "Foo"},
780 bases=(UnicodeModel,),
781 managers=managers,
782 ),
783 migrations.RemoveField("Foo", "age"),
784 ],
785 [
786 migrations.CreateModel(
787 name="Foo",
788 fields=[
789 ("name", models.CharField(max_length=255)),
790 ],
791 options={"verbose_name": "Foo"},
792 bases=(UnicodeModel,),
793 managers=managers,
794 ),
795 ],
796 )
797
798 def test_add_field_alter_field(self):
799 """
800 AlterField should optimize into AddField.
801 """
802 self.assertOptimizesTo(
803 [
804 migrations.AddField("Foo", "age", models.IntegerField()),
805 migrations.AlterField("Foo", "age", models.FloatField(default=2.4)),
806 ],
807 [
808 migrations.AddField(
809 "Foo", name="age", field=models.FloatField(default=2.4)
810 ),
811 ],
812 )
813
814 def test_add_field_delete_field(self):
815 """
816 RemoveField should cancel AddField
817 """
818 self.assertOptimizesTo(
819 [
820 migrations.AddField("Foo", "age", models.IntegerField()),
821 migrations.RemoveField("Foo", "age"),
822 ],
823 [],
824 )
825
826 def test_alter_field_delete_field(self):
827 """
828 RemoveField should absorb AlterField
829 """
830 self.assertOptimizesTo(
831 [
832 migrations.AlterField("Foo", "age", models.IntegerField()),
833 migrations.RemoveField("Foo", "age"),
834 ],
835 [
836 migrations.RemoveField("Foo", "age"),
837 ],
838 )
839
840 def _test_create_alter_foo_field(self, alter):
841 """
842 CreateModel, AlterFooTogether/AlterOrderWithRespectTo followed by an
843 add/alter/rename field should optimize to CreateModel with options.
844 """
845 option_value = getattr(alter, alter.option_name)
846 options = {alter.option_name: option_value}
847
848 # AddField
849 self.assertOptimizesTo(
850 [
851 migrations.CreateModel(
852 "Foo",
853 [
854 ("a", models.IntegerField()),
855 ("b", models.IntegerField()),
856 ],
857 ),
858 alter,
859 migrations.AddField("Foo", "c", models.IntegerField()),
860 ],
861 [
862 migrations.CreateModel(
863 "Foo",
864 [
865 ("a", models.IntegerField()),
866 ("b", models.IntegerField()),
867 ("c", models.IntegerField()),
868 ],
869 options=options,
870 ),
871 ],
872 )
873
874 # AlterField
875 self.assertOptimizesTo(
876 [
877 migrations.CreateModel(
878 "Foo",
879 [
880 ("a", models.IntegerField()),
881 ("b", models.IntegerField()),
882 ],
883 ),
884 alter,
885 migrations.AlterField("Foo", "b", models.CharField(max_length=255)),
886 ],
887 [
888 migrations.CreateModel(
889 "Foo",
890 [
891 ("a", models.IntegerField()),
892 ("b", models.CharField(max_length=255)),
893 ],
894 options=options,
895 ),
896 ],
897 )
898
899 self.assertOptimizesTo(
900 [
901 migrations.CreateModel(
902 "Foo",
903 [
904 ("a", models.IntegerField()),
905 ("b", models.IntegerField()),
906 ("c", models.IntegerField()),
907 ],
908 ),
909 alter,
910 migrations.AlterField("Foo", "c", models.CharField(max_length=255)),
911 ],
912 [
913 migrations.CreateModel(
914 "Foo",
915 [
916 ("a", models.IntegerField()),
917 ("b", models.IntegerField()),
918 ("c", models.CharField(max_length=255)),
919 ],
920 options=options,
921 ),
922 ],
923 )
924
925 # RenameField
926 if isinstance(option_value, str):
927 renamed_options = {alter.option_name: "c"}
928 else:
929 renamed_options = {
930 alter.option_name: {
931 tuple("c" if value == "b" else value for value in item)
932 for item in option_value
933 }
934 }
935 self.assertOptimizesTo(
936 [
937 migrations.CreateModel(
938 "Foo",
939 [
940 ("a", models.IntegerField()),
941 ("b", models.IntegerField()),
942 ],
943 ),
944 alter,
945 migrations.RenameField("Foo", "b", "c"),
946 ],
947 [
948 migrations.CreateModel(
949 "Foo",
950 [
951 ("a", models.IntegerField()),
952 ("c", models.IntegerField()),
953 ],
954 options=renamed_options,
955 ),
956 ],
957 )
958
959 self.assertOptimizesTo(
960 [
961 migrations.CreateModel(
962 "Foo",
963 [
964 ("a", models.IntegerField()),
965 ("b", models.IntegerField()),
966 ],
967 ),
968 alter,
969 migrations.RenameField("Foo", "b", "x"),
970 migrations.RenameField("Foo", "x", "c"),
971 ],
972 [
973 migrations.CreateModel(
974 "Foo",
975 [
976 ("a", models.IntegerField()),
977 ("c", models.IntegerField()),
978 ],
979 options=renamed_options,
980 ),
981 ],
982 )
983
984 self.assertOptimizesTo(
985 [
986 migrations.CreateModel(
987 "Foo",
988 [
989 ("a", models.IntegerField()),
990 ("b", models.IntegerField()),
991 ("c", models.IntegerField()),
992 ],
993 ),
994 alter,
995 migrations.RenameField("Foo", "c", "d"),
996 ],
997 [
998 migrations.CreateModel(
999 "Foo",
1000 [
1001 ("a", models.IntegerField()),
1002 ("b", models.IntegerField()),
1003 ("d", models.IntegerField()),
1004 ],
1005 options=options,
1006 ),
1007 ],
1008 )
1009
1010 # RemoveField
1011 if isinstance(option_value, str):
1012 removed_options = None
1013 else:
1014 removed_options = {
1015 alter.option_name: {
1016 tuple(value for value in item if value != "b")
1017 for item in option_value
1018 }
1019 }
1020 self.assertOptimizesTo(
1021 [
1022 migrations.CreateModel(
1023 "Foo",
1024 [
1025 ("a", models.IntegerField()),
1026 ("b", models.IntegerField()),
1027 ],
1028 ),
1029 alter,
1030 migrations.RemoveField("Foo", "b"),
1031 ],
1032 [
1033 migrations.CreateModel(
1034 "Foo",
1035 [
1036 ("a", models.IntegerField()),
1037 ],
1038 options=removed_options,
1039 ),
1040 ],
1041 )
1042
1043 self.assertOptimizesTo(
1044 [
1045 migrations.CreateModel(
1046 "Foo",
1047 [
1048 ("a", models.IntegerField()),
1049 ("b", models.IntegerField()),
1050 ("c", models.IntegerField()),
1051 ],
1052 ),
1053 alter,
1054 migrations.RemoveField("Foo", "c"),
1055 ],
1056 [
1057 migrations.CreateModel(
1058 "Foo",
1059 [
1060 ("a", models.IntegerField()),
1061 ("b", models.IntegerField()),
1062 ],
1063 options=options,
1064 ),
1065 ],
1066 )
1067
1068 def test_create_alter_unique_field(self):
1069 self._test_create_alter_foo_field(
1070 migrations.AlterUniqueTogether("Foo", [["a", "b"]])
1071 )
1072
1073 def test_create_alter_index_field(self):
1074 self._test_create_alter_foo_field(
1075 migrations.AlterIndexTogether("Foo", [["a", "b"]])
1076 )
1077
1078 def test_create_alter_owrt_field(self):
1079 self._test_create_alter_foo_field(
1080 migrations.AlterOrderWithRespectTo("Foo", "b")
1081 )
1082
1083 def test_optimize_through_fields(self):
1084 """
1085 field-level through checking is working. This should manage to collapse
1086 model Foo to nonexistence, and model Bar to a single IntegerField
1087 called "width".
1088 """
1089 self.assertOptimizesTo(
1090 [
1091 migrations.CreateModel(
1092 "Foo", [("name", models.CharField(max_length=255))]
1093 ),
1094 migrations.CreateModel("Bar", [("size", models.IntegerField())]),
1095 migrations.AddField("Foo", "age", models.IntegerField()),
1096 migrations.AddField("Bar", "width", models.IntegerField()),
1097 migrations.AlterField("Foo", "age", models.IntegerField()),
1098 migrations.RenameField("Bar", "size", "dimensions"),
1099 migrations.RemoveField("Foo", "age"),
1100 migrations.RenameModel("Foo", "Phou"),
1101 migrations.RemoveField("Bar", "dimensions"),
1102 migrations.RenameModel("Phou", "Fou"),
1103 migrations.DeleteModel("Fou"),
1104 ],
1105 [
1106 migrations.CreateModel("Bar", [("width", models.IntegerField())]),
1107 ],
1108 )
1109
1110 def test_optimize_elidable_operation(self):
1111 elidable_operation = operations.base.Operation()
1112 elidable_operation.elidable = True
1113 self.assertOptimizesTo(
1114 [
1115 elidable_operation,
1116 migrations.CreateModel(
1117 "Foo", [("name", models.CharField(max_length=255))]
1118 ),
1119 elidable_operation,
1120 migrations.CreateModel("Bar", [("size", models.IntegerField())]),
1121 elidable_operation,
1122 migrations.RenameModel("Foo", "Phou"),
1123 migrations.DeleteModel("Bar"),
1124 elidable_operation,
1125 ],
1126 [
1127 migrations.CreateModel(
1128 "Phou", [("name", models.CharField(max_length=255))]
1129 ),
1130 ],
1131 )
1132
1133 def test_rename_index(self):
1134 self.assertOptimizesTo(
1135 [
1136 migrations.RenameIndex(
1137 "Pony", new_name="mid_name", old_fields=("weight", "pink")
1138 ),
1139 migrations.RenameIndex(
1140 "Pony", new_name="new_name", old_name="mid_name"
1141 ),
1142 ],
1143 [
1144 migrations.RenameIndex(
1145 "Pony", new_name="new_name", old_fields=("weight", "pink")
1146 ),
1147 ],
1148 )
1149 self.assertOptimizesTo(
1150 [
1151 migrations.RenameIndex(
1152 "Pony", new_name="mid_name", old_name="old_name"
1153 ),
1154 migrations.RenameIndex(
1155 "Pony", new_name="new_name", old_name="mid_name"
1156 ),
1157 ],
1158 [migrations.RenameIndex("Pony", new_name="new_name", old_name="old_name")],
1159 )
1160 self.assertDoesNotOptimize(
1161 [
1162 migrations.RenameIndex(
1163 "Pony", new_name="mid_name", old_name="old_name"
1164 ),
1165 migrations.RenameIndex(
1166 "Pony", new_name="new_name", old_fields=("weight", "pink")
1167 ),
1168 ]
1169 )
1170
1171 def test_add_rename_index(self):
1172 tests = [
1173 models.Index(fields=["weight", "pink"], name="mid_name"),
1174 models.Index(Abs("weight"), name="mid_name"),
1175 models.Index(
1176 Abs("weight"), name="mid_name", condition=models.Q(weight__gt=0)
1177 ),
1178 ]
1179 for index in tests:
1180 with self.subTest(index=index):
1181 renamed_index = index.clone()
1182 renamed_index.name = "new_name"
1183 self.assertOptimizesTo(
1184 [
1185 migrations.AddIndex("Pony", index),
1186 migrations.RenameIndex(
1187 "Pony", new_name="new_name", old_name="mid_name"
1188 ),
1189 ],
1190 [
1191 migrations.AddIndex("Pony", renamed_index),
1192 ],
1193 )
1194 self.assertDoesNotOptimize(
1195 [
1196 migrations.AddIndex("Pony", index),
1197 migrations.RenameIndex(
1198 "Pony", new_name="new_name", old_name="other_name"
1199 ),
1200 ],
1201 )
1202
1203 def test_add_remove_index(self):
1204 self.assertOptimizesTo(
1205 [
1206 migrations.AddIndex(
1207 "Pony",
1208 models.Index(
1209 fields=["weight", "pink"], name="idx_pony_weight_pink"
1210 ),
1211 ),
1212 migrations.RemoveIndex("Pony", "idx_pony_weight_pink"),
1213 ],
1214 [],
1215 )
1216
1217 def test_add_remove_constraint(self):
1218 gt_constraint = models.CheckConstraint(
1219 condition=models.Q(pink__gt=2), name="constraint_pony_pink_gt_2"
1220 )
1221 self.assertOptimizesTo(
1222 [
1223 migrations.AddConstraint("Pony", gt_constraint),
1224 migrations.RemoveConstraint("Pony", gt_constraint.name),
1225 ],
1226 [],
1227 )
1228 self.assertDoesNotOptimize(
1229 [
1230 migrations.AddConstraint("Pony", gt_constraint),
1231 migrations.RemoveConstraint("Pony", "other_name"),
1232 ],
1233 )
1234
1235 def test_multiple_alter_constraints(self):
1236 gt_constraint_violation_msg_added = models.CheckConstraint(
1237 condition=models.Q(pink__gt=2),
1238 name="pink_gt_2",
1239 violation_error_message="ERROR",
1240 )
1241 gt_constraint_violation_msg_altered = models.CheckConstraint(
1242 condition=models.Q(pink__gt=2),
1243 name="pink_gt_2",
1244 violation_error_message="error",
1245 )
1246 self.assertOptimizesTo(
1247 [
1248 migrations.AlterConstraint(
1249 "Pony", "pink_gt_2", gt_constraint_violation_msg_added
1250 ),
1251 migrations.AlterConstraint(
1252 "Pony", "pink_gt_2", gt_constraint_violation_msg_altered
1253 ),
1254 ],
1255 [
1256 migrations.AlterConstraint(
1257 "Pony", "pink_gt_2", gt_constraint_violation_msg_altered
1258 )
1259 ],
1260 )
1261 other_constraint_violation_msg = models.CheckConstraint(
1262 condition=models.Q(weight__gt=3),
1263 name="pink_gt_3",
1264 violation_error_message="error",
1265 )
1266 self.assertDoesNotOptimize(
1267 [
1268 migrations.AlterConstraint(
1269 "Pony", "pink_gt_2", gt_constraint_violation_msg_added
1270 ),
1271 migrations.AlterConstraint(
1272 "Pony", "pink_gt_3", other_constraint_violation_msg
1273 ),
1274 ]
1275 )
1276
1277 def test_alter_remove_constraint(self):
1278 self.assertOptimizesTo(
1279 [
1280 migrations.AlterConstraint(
1281 "Pony",
1282 "pink_gt_2",
1283 models.CheckConstraint(
1284 condition=models.Q(pink__gt=2), name="pink_gt_2"
1285 ),
1286 ),
1287 migrations.RemoveConstraint("Pony", "pink_gt_2"),
1288 ],
1289 [migrations.RemoveConstraint("Pony", "pink_gt_2")],
1290 )
1291
1292 def test_add_alter_constraint(self):
1293 constraint = models.CheckConstraint(
1294 condition=models.Q(pink__gt=2), name="pink_gt_2"
1295 )
1296 constraint_with_error = models.CheckConstraint(
1297 condition=models.Q(pink__gt=2),
1298 name="pink_gt_2",
1299 violation_error_message="error",
1300 )
1301 self.assertOptimizesTo(
1302 [
1303 migrations.AddConstraint("Pony", constraint),
1304 migrations.AlterConstraint("Pony", "pink_gt_2", constraint_with_error),
1305 ],
1306 [migrations.AddConstraint("Pony", constraint_with_error)],
1307 )
1308
1309 def test_create_model_add_index(self):
1310 self.assertOptimizesTo(
1311 [
1312 migrations.CreateModel(
1313 name="Pony",
1314 fields=[
1315 ("weight", models.IntegerField()),
1316 ("age", models.IntegerField()),
1317 ],
1318 options={
1319 "indexes": [models.Index(fields=["age"], name="idx_pony_age")],
1320 },
1321 ),
1322 migrations.AddIndex(
1323 "Pony",
1324 models.Index(fields=["weight"], name="idx_pony_weight"),
1325 ),
1326 ],
1327 [
1328 migrations.CreateModel(
1329 name="Pony",
1330 fields=[
1331 ("weight", models.IntegerField()),
1332 ("age", models.IntegerField()),
1333 ],
1334 options={
1335 "indexes": [
1336 models.Index(fields=["age"], name="idx_pony_age"),
1337 models.Index(fields=["weight"], name="idx_pony_weight"),
1338 ],
1339 },
1340 ),
1341 ],
1342 )
1343
1344 def test_create_model_remove_index(self):
1345 self.assertOptimizesTo(
1346 [
1347 migrations.CreateModel(
1348 name="Pony",
1349 fields=[
1350 ("weight", models.IntegerField()),
1351 ("age", models.IntegerField()),
1352 ],
1353 options={
1354 "indexes": [
1355 models.Index(fields=["age"], name="idx_pony_age"),
1356 models.Index(fields=["weight"], name="idx_pony_weight"),
1357 ],
1358 },
1359 ),
1360 migrations.RemoveIndex("Pony", "idx_pony_age"),
1361 ],
1362 [
1363 migrations.CreateModel(
1364 name="Pony",
1365 fields=[
1366 ("weight", models.IntegerField()),
1367 ("age", models.IntegerField()),
1368 ],
1369 options={
1370 "indexes": [
1371 models.Index(fields=["weight"], name="idx_pony_weight"),
1372 ],
1373 },
1374 ),
1375 ],
1376 )
1377
1378 def test_create_model_rename_index_no_old_fields(self):
1379 self.assertOptimizesTo(
1380 [
1381 migrations.CreateModel(
1382 name="Pony",
1383 fields=[
1384 ("weight", models.IntegerField()),
1385 ("age", models.IntegerField()),
1386 ],
1387 options={
1388 "indexes": [models.Index(fields=["age"], name="idx_pony_age")],
1389 },
1390 ),
1391 migrations.RenameIndex(
1392 "Pony", new_name="idx_pony_age_new", old_name="idx_pony_age"
1393 ),
1394 ],
1395 [
1396 migrations.CreateModel(
1397 name="Pony",
1398 fields=[
1399 ("weight", models.IntegerField()),
1400 ("age", models.IntegerField()),
1401 ],
1402 options={
1403 "indexes": [models.Index(fields=["age"], name="idx_pony_age")],
1404 },
1405 ),
1406 migrations.RenameIndex(
1407 "Pony", new_name="idx_pony_age_new", old_name="idx_pony_age"
1408 ),
1409 ],
1410 )
1411
1412 def test_create_model_add_constraint(self):
1413 gt_constraint = models.CheckConstraint(
1414 condition=models.Q(weight__gt=0), name="pony_weight_gt_0"
1415 )
1416 self.assertOptimizesTo(
1417 [
1418 migrations.CreateModel(
1419 name="Pony",
1420 fields=[
1421 ("weight", models.IntegerField()),
1422 ],
1423 ),
1424 migrations.AddConstraint("Pony", gt_constraint),
1425 ],
1426 [
1427 migrations.CreateModel(
1428 name="Pony",
1429 fields=[
1430 ("weight", models.IntegerField()),
1431 ],
1432 options={"constraints": [gt_constraint]},
1433 ),
1434 ],
1435 )
1436
1437 def test_create_model_remove_constraint(self):
1438 self.assertOptimizesTo(
1439 [
1440 migrations.CreateModel(
1441 name="Pony",
1442 fields=[
1443 ("weight", models.IntegerField()),
1444 ],
1445 options={
1446 "constraints": [
1447 models.CheckConstraint(
1448 condition=models.Q(weight__gt=0),
1449 name="pony_weight_gt_0",
1450 ),
1451 models.UniqueConstraint(
1452 "weight", name="pony_weight_unique"
1453 ),
1454 ],
1455 },
1456 ),
1457 migrations.RemoveConstraint("Pony", "pony_weight_gt_0"),
1458 ],
1459 [
1460 migrations.CreateModel(
1461 name="Pony",
1462 fields=[
1463 ("weight", models.IntegerField()),
1464 ],
1465 options={
1466 "constraints": [
1467 models.UniqueConstraint(
1468 "weight", name="pony_weight_unique"
1469 ),
1470 ]
1471 },
1472 ),
1473 ],
1474 )