Debian Codegraph @

tests/migrations/test_state.py

raw
1 from django.apps.registry import Apps
2 from django.contrib.contenttypes.fields import GenericForeignKey
3 from django.db import models
4 from django.db.migrations.exceptions import InvalidBasesError
5 from django.db.migrations.operations import (
6 AddField,
7 AlterField,
8 DeleteModel,
9 RemoveField,
10 )
11 from django.db.migrations.state import (
12 ModelState,
13 ProjectState,
14 get_related_models_recursive,
15 )
16 from django.test import SimpleTestCase, override_settings
17 from django.test.utils import isolate_apps
18
19 from .models import (
20 FoodManager,
21 FoodQuerySet,
22 ModelWithCustomBase,
23 NoMigrationFoodManager,
24 UnicodeModel,
25 )
26
27
28 class StateTests(SimpleTestCase):
29 """
30 Tests state construction, rendering and modification by operations.
31 """
32
33 def test_create(self):
34 """
35 Tests making a ProjectState from an Apps
36 """
37
38 new_apps = Apps(["migrations"])
39
40 class Author(models.Model):
41 name = models.CharField(max_length=255)
42 bio = models.TextField()
43 age = models.IntegerField(blank=True, null=True)
44
45 class Meta:
46 app_label = "migrations"
47 apps = new_apps
48 unique_together = ["name", "bio"]
49
50 class AuthorProxy(Author):
51 class Meta:
52 app_label = "migrations"
53 apps = new_apps
54 proxy = True
55 ordering = ["name"]
56
57 class SubAuthor(Author):
58 width = models.FloatField(null=True)
59
60 class Meta:
61 app_label = "migrations"
62 apps = new_apps
63
64 class Book(models.Model):
65 title = models.CharField(max_length=1000)
66 author = models.ForeignKey(Author, models.CASCADE)
67 contributors = models.ManyToManyField(Author)
68
69 class Meta:
70 app_label = "migrations"
71 apps = new_apps
72 verbose_name = "tome"
73 db_table = "test_tome"
74 indexes = [models.Index(fields=["title"])]
75
76 class Food(models.Model):
77 food_mgr = FoodManager("a", "b")
78 food_qs = FoodQuerySet.as_manager()
79 food_no_mgr = NoMigrationFoodManager("x", "y")
80
81 class Meta:
82 app_label = "migrations"
83 apps = new_apps
84
85 class FoodNoManagers(models.Model):
86 class Meta:
87 app_label = "migrations"
88 apps = new_apps
89
90 class FoodNoDefaultManager(models.Model):
91 food_no_mgr = NoMigrationFoodManager("x", "y")
92 food_mgr = FoodManager("a", "b")
93 food_qs = FoodQuerySet.as_manager()
94
95 class Meta:
96 app_label = "migrations"
97 apps = new_apps
98
99 mgr1 = FoodManager("a", "b")
100 mgr2 = FoodManager("x", "y", c=3, d=4)
101
102 class FoodOrderedManagers(models.Model):
103 # The managers on this model should be ordered by their creation
104 # counter and not by the order in model body
105
106 food_no_mgr = NoMigrationFoodManager("x", "y")
107 food_mgr2 = mgr2
108 food_mgr1 = mgr1
109
110 class Meta:
111 app_label = "migrations"
112 apps = new_apps
113
114 project_state = ProjectState.from_apps(new_apps)
115 author_state = project_state.models["migrations", "author"]
116 author_proxy_state = project_state.models["migrations", "authorproxy"]
117 sub_author_state = project_state.models["migrations", "subauthor"]
118 book_state = project_state.models["migrations", "book"]
119 food_state = project_state.models["migrations", "food"]
120 food_no_managers_state = project_state.models["migrations", "foodnomanagers"]
121 food_no_default_manager_state = project_state.models[
122 "migrations", "foodnodefaultmanager"
123 ]
124 food_order_manager_state = project_state.models[
125 "migrations", "foodorderedmanagers"
126 ]
127 book_index = models.Index(fields=["title"])
128 book_index.set_name_with_model(Book)
129
130 self.assertEqual(author_state.app_label, "migrations")
131 self.assertEqual(author_state.name, "Author")
132 self.assertEqual(list(author_state.fields), ["id", "name", "bio", "age"])
133 self.assertEqual(author_state.fields["name"].max_length, 255)
134 self.assertIs(author_state.fields["bio"].null, False)
135 self.assertIs(author_state.fields["age"].null, True)
136 self.assertEqual(
137 author_state.options,
138 {
139 "unique_together": {("name", "bio")},
140 "indexes": [],
141 "constraints": [],
142 },
143 )
144 self.assertEqual(author_state.bases, (models.Model,))
145
146 self.assertEqual(book_state.app_label, "migrations")
147 self.assertEqual(book_state.name, "Book")
148 self.assertEqual(
149 list(book_state.fields), ["id", "title", "author", "contributors"]
150 )
151 self.assertEqual(book_state.fields["title"].max_length, 1000)
152 self.assertIs(book_state.fields["author"].null, False)
153 self.assertEqual(
154 book_state.fields["contributors"].__class__.__name__, "ManyToManyField"
155 )
156 self.assertEqual(
157 book_state.options,
158 {
159 "verbose_name": "tome",
160 "db_table": "test_tome",
161 "indexes": [book_index],
162 "constraints": [],
163 },
164 )
165 self.assertEqual(book_state.bases, (models.Model,))
166
167 self.assertEqual(author_proxy_state.app_label, "migrations")
168 self.assertEqual(author_proxy_state.name, "AuthorProxy")
169 self.assertEqual(author_proxy_state.fields, {})
170 self.assertEqual(
171 author_proxy_state.options,
172 {"proxy": True, "ordering": ["name"], "indexes": [], "constraints": []},
173 )
174 self.assertEqual(author_proxy_state.bases, ("migrations.author",))
175
176 self.assertEqual(sub_author_state.app_label, "migrations")
177 self.assertEqual(sub_author_state.name, "SubAuthor")
178 self.assertEqual(len(sub_author_state.fields), 2)
179 self.assertEqual(sub_author_state.bases, ("migrations.author",))
180
181 # The default manager is used in migrations
182 self.assertEqual([name for name, mgr in food_state.managers], ["food_mgr"])
183 self.assertTrue(all(isinstance(name, str) for name, mgr in food_state.managers))
184 self.assertEqual(food_state.managers[0][1].args, ("a", "b", 1, 2))
185
186 # No explicit managers defined. Migrations will fall back to the default
187 self.assertEqual(food_no_managers_state.managers, [])
188
189 # food_mgr is used in migration but isn't the default mgr, hence add the
190 # default
191 self.assertEqual(
192 [name for name, mgr in food_no_default_manager_state.managers],
193 ["food_no_mgr", "food_mgr"],
194 )
195 self.assertTrue(
196 all(
197 isinstance(name, str)
198 for name, mgr in food_no_default_manager_state.managers
199 )
200 )
201 self.assertEqual(
202 food_no_default_manager_state.managers[0][1].__class__, models.Manager
203 )
204 self.assertIsInstance(food_no_default_manager_state.managers[1][1], FoodManager)
205
206 self.assertEqual(
207 [name for name, mgr in food_order_manager_state.managers],
208 ["food_mgr1", "food_mgr2"],
209 )
210 self.assertTrue(
211 all(
212 isinstance(name, str) for name, mgr in food_order_manager_state.managers
213 )
214 )
215 self.assertEqual(
216 [mgr.args for name, mgr in food_order_manager_state.managers],
217 [("a", "b", 1, 2), ("x", "y", 3, 4)],
218 )
219
220 def test_custom_default_manager_added_to_the_model_state(self):
221 """
222 When the default manager of the model is a custom manager,
223 it needs to be added to the model state.
224 """
225 new_apps = Apps(["migrations"])
226 custom_manager = models.Manager()
227
228 class Author(models.Model):
229 objects = models.TextField()
230 authors = custom_manager
231
232 class Meta:
233 app_label = "migrations"
234 apps = new_apps
235
236 project_state = ProjectState.from_apps(new_apps)
237 author_state = project_state.models["migrations", "author"]
238 self.assertEqual(author_state.managers, [("authors", custom_manager)])
239
240 def test_custom_default_manager_named_objects_with_false_migration_flag(self):
241 """
242 When a manager is added with a name of 'objects' but it does not
243 have `use_in_migrations = True`, no migration should be added to the
244 model state (#26643).
245 """
246 new_apps = Apps(["migrations"])
247
248 class Author(models.Model):
249 objects = models.Manager()
250
251 class Meta:
252 app_label = "migrations"
253 apps = new_apps
254
255 project_state = ProjectState.from_apps(new_apps)
256 author_state = project_state.models["migrations", "author"]
257 self.assertEqual(author_state.managers, [])
258
259 def test_no_duplicate_managers(self):
260 """
261 When a manager is added with `use_in_migrations = True` and a parent
262 model had a manager with the same name and `use_in_migrations = True`,
263 the parent's manager shouldn't appear in the model state (#26881).
264 """
265 new_apps = Apps(["migrations"])
266
267 class PersonManager(models.Manager):
268 use_in_migrations = True
269
270 class Person(models.Model):
271 objects = PersonManager()
272
273 class Meta:
274 abstract = True
275
276 class BossManager(PersonManager):
277 use_in_migrations = True
278
279 class Boss(Person):
280 objects = BossManager()
281
282 class Meta:
283 app_label = "migrations"
284 apps = new_apps
285
286 project_state = ProjectState.from_apps(new_apps)
287 boss_state = project_state.models["migrations", "boss"]
288 self.assertEqual(boss_state.managers, [("objects", Boss.objects)])
289
290 def test_custom_default_manager(self):
291 new_apps = Apps(["migrations"])
292
293 class Author(models.Model):
294 manager1 = models.Manager()
295 manager2 = models.Manager()
296
297 class Meta:
298 app_label = "migrations"
299 apps = new_apps
300 default_manager_name = "manager2"
301
302 project_state = ProjectState.from_apps(new_apps)
303 author_state = project_state.models["migrations", "author"]
304 self.assertEqual(author_state.options["default_manager_name"], "manager2")
305 self.assertEqual(author_state.managers, [("manager2", Author.manager1)])
306
307 def test_custom_base_manager(self):
308 new_apps = Apps(["migrations"])
309
310 class Author(models.Model):
311 manager1 = models.Manager()
312 manager2 = models.Manager()
313
314 class Meta:
315 app_label = "migrations"
316 apps = new_apps
317 base_manager_name = "manager2"
318
319 class Author2(models.Model):
320 manager1 = models.Manager()
321 manager2 = models.Manager()
322
323 class Meta:
324 app_label = "migrations"
325 apps = new_apps
326 base_manager_name = "manager1"
327
328 project_state = ProjectState.from_apps(new_apps)
329
330 author_state = project_state.models["migrations", "author"]
331 self.assertEqual(author_state.options["base_manager_name"], "manager2")
332 self.assertEqual(
333 author_state.managers,
334 [
335 ("manager1", Author.manager1),
336 ("manager2", Author.manager2),
337 ],
338 )
339
340 author2_state = project_state.models["migrations", "author2"]
341 self.assertEqual(author2_state.options["base_manager_name"], "manager1")
342 self.assertEqual(
343 author2_state.managers,
344 [
345 ("manager1", Author2.manager1),
346 ],
347 )
348
349 def test_apps_bulk_update(self):
350 """
351 StateApps.bulk_update() should update apps.ready to False and reset
352 the value afterward.
353 """
354 project_state = ProjectState()
355 apps = project_state.apps
356 with apps.bulk_update():
357 self.assertFalse(apps.ready)
358 self.assertTrue(apps.ready)
359 with self.assertRaises(ValueError):
360 with apps.bulk_update():
361 self.assertFalse(apps.ready)
362 raise ValueError()
363 self.assertTrue(apps.ready)
364
365 def test_render(self):
366 """
367 Tests rendering a ProjectState into an Apps.
368 """
369 project_state = ProjectState()
370 project_state.add_model(
371 ModelState(
372 app_label="migrations",
373 name="Tag",
374 fields=[
375 ("id", models.AutoField(primary_key=True)),
376 ("name", models.CharField(max_length=100)),
377 ("hidden", models.BooleanField()),
378 ],
379 )
380 )
381 project_state.add_model(
382 ModelState(
383 app_label="migrations",
384 name="SubTag",
385 fields=[
386 (
387 "tag_ptr",
388 models.OneToOneField(
389 "migrations.Tag",
390 models.CASCADE,
391 auto_created=True,
392 parent_link=True,
393 primary_key=True,
394 to_field="id",
395 serialize=False,
396 ),
397 ),
398 ("awesome", models.BooleanField()),
399 ],
400 bases=("migrations.Tag",),
401 )
402 )
403
404 base_mgr = models.Manager()
405 mgr1 = FoodManager("a", "b")
406 mgr2 = FoodManager("x", "y", c=3, d=4)
407 project_state.add_model(
408 ModelState(
409 app_label="migrations",
410 name="Food",
411 fields=[
412 ("id", models.AutoField(primary_key=True)),
413 ],
414 managers=[
415 # The ordering we really want is objects, mgr1, mgr2
416 ("default", base_mgr),
417 ("food_mgr2", mgr2),
418 ("food_mgr1", mgr1),
419 ],
420 )
421 )
422
423 new_apps = project_state.apps
424 self.assertEqual(
425 new_apps.get_model("migrations", "Tag")._meta.get_field("name").max_length,
426 100,
427 )
428 self.assertIs(
429 new_apps.get_model("migrations", "Tag")._meta.get_field("hidden").null,
430 False,
431 )
432
433 self.assertEqual(
434 len(new_apps.get_model("migrations", "SubTag")._meta.local_fields), 2
435 )
436
437 Food = new_apps.get_model("migrations", "Food")
438 self.assertEqual(
439 [mgr.name for mgr in Food._meta.managers],
440 ["default", "food_mgr1", "food_mgr2"],
441 )
442 self.assertTrue(all(isinstance(mgr.name, str) for mgr in Food._meta.managers))
443 self.assertEqual(
444 [mgr.__class__ for mgr in Food._meta.managers],
445 [models.Manager, FoodManager, FoodManager],
446 )
447
448 def test_render_model_inheritance(self):
449 class Book(models.Model):
450 title = models.CharField(max_length=1000)
451
452 class Meta:
453 app_label = "migrations"
454 apps = Apps()
455
456 class Novel(Book):
457 class Meta:
458 app_label = "migrations"
459 apps = Apps()
460
461 # First, test rendering individually
462 apps = Apps(["migrations"])
463
464 # We shouldn't be able to render yet
465 ms = ModelState.from_model(Novel)
466 with self.assertRaises(InvalidBasesError):
467 ms.render(apps)
468
469 # Once the parent model is in the app registry, it should be fine
470 ModelState.from_model(Book).render(apps)
471 ModelState.from_model(Novel).render(apps)
472
473 def test_render_model_with_multiple_inheritance(self):
474 class Foo(models.Model):
475 class Meta:
476 app_label = "migrations"
477 apps = Apps()
478
479 class Bar(models.Model):
480 class Meta:
481 app_label = "migrations"
482 apps = Apps()
483
484 class FooBar(Foo, Bar):
485 class Meta:
486 app_label = "migrations"
487 apps = Apps()
488
489 class AbstractSubFooBar(FooBar):
490 class Meta:
491 abstract = True
492 apps = Apps()
493
494 class SubFooBar(AbstractSubFooBar):
495 class Meta:
496 app_label = "migrations"
497 apps = Apps()
498
499 apps = Apps(["migrations"])
500
501 # We shouldn't be able to render yet
502 ms = ModelState.from_model(FooBar)
503 with self.assertRaises(InvalidBasesError):
504 ms.render(apps)
505
506 # Once the parent models are in the app registry, it should be fine
507 ModelState.from_model(Foo).render(apps)
508 self.assertSequenceEqual(ModelState.from_model(Foo).bases, [models.Model])
509 ModelState.from_model(Bar).render(apps)
510 self.assertSequenceEqual(ModelState.from_model(Bar).bases, [models.Model])
511 ModelState.from_model(FooBar).render(apps)
512 self.assertSequenceEqual(
513 ModelState.from_model(FooBar).bases, ["migrations.foo", "migrations.bar"]
514 )
515 ModelState.from_model(SubFooBar).render(apps)
516 self.assertSequenceEqual(
517 ModelState.from_model(SubFooBar).bases, ["migrations.foobar"]
518 )
519
520 def test_render_project_dependencies(self):
521 """
522 The ProjectState render method correctly renders models
523 to account for inter-model base dependencies.
524 """
525 new_apps = Apps()
526
527 class A(models.Model):
528 class Meta:
529 app_label = "migrations"
530 apps = new_apps
531
532 class B(A):
533 class Meta:
534 app_label = "migrations"
535 apps = new_apps
536
537 class C(B):
538 class Meta:
539 app_label = "migrations"
540 apps = new_apps
541
542 class D(A):
543 class Meta:
544 app_label = "migrations"
545 apps = new_apps
546
547 class E(B):
548 class Meta:
549 app_label = "migrations"
550 apps = new_apps
551 proxy = True
552
553 class F(D):
554 class Meta:
555 app_label = "migrations"
556 apps = new_apps
557 proxy = True
558
559 # Make a ProjectState and render it
560 project_state = ProjectState()
561 project_state.add_model(ModelState.from_model(A))
562 project_state.add_model(ModelState.from_model(B))
563 project_state.add_model(ModelState.from_model(C))
564 project_state.add_model(ModelState.from_model(D))
565 project_state.add_model(ModelState.from_model(E))
566 project_state.add_model(ModelState.from_model(F))
567 final_apps = project_state.apps
568 self.assertEqual(len(final_apps.get_models()), 6)
569
570 # Now make an invalid ProjectState and make sure it fails
571 project_state = ProjectState()
572 project_state.add_model(ModelState.from_model(A))
573 project_state.add_model(ModelState.from_model(B))
574 project_state.add_model(ModelState.from_model(C))
575 project_state.add_model(ModelState.from_model(F))
576 with self.assertRaises(InvalidBasesError):
577 project_state.apps
578
579 def test_render_unique_app_labels(self):
580 """
581 The ProjectState render method doesn't raise an
582 ImproperlyConfigured exception about unique labels if two dotted app
583 names have the same last part.
584 """
585
586 class A(models.Model):
587 class Meta:
588 app_label = "django.contrib.auth"
589
590 class B(models.Model):
591 class Meta:
592 app_label = "vendor.auth"
593
594 # Make a ProjectState and render it
595 project_state = ProjectState()
596 project_state.add_model(ModelState.from_model(A))
597 project_state.add_model(ModelState.from_model(B))
598 self.assertEqual(len(project_state.apps.get_models()), 2)
599
600 def test_reload_related_model_on_non_relational_fields(self):
601 """
602 The model is reloaded even on changes that are not involved in
603 relations. Other models pointing to or from it are also reloaded.
604 """
605 project_state = ProjectState()
606 project_state.apps # Render project state.
607 project_state.add_model(ModelState("migrations", "A", []))
608 project_state.add_model(
609 ModelState(
610 "migrations",
611 "B",
612 [
613 ("a", models.ForeignKey("A", models.CASCADE)),
614 ],
615 )
616 )
617 project_state.add_model(
618 ModelState(
619 "migrations",
620 "C",
621 [
622 ("b", models.ForeignKey("B", models.CASCADE)),
623 ("name", models.TextField()),
624 ],
625 )
626 )
627 project_state.add_model(
628 ModelState(
629 "migrations",
630 "D",
631 [
632 ("a", models.ForeignKey("A", models.CASCADE)),
633 ],
634 )
635 )
636 operation = AlterField(
637 model_name="C",
638 name="name",
639 field=models.TextField(blank=True),
640 )
641 operation.state_forwards("migrations", project_state)
642 project_state.reload_model("migrations", "a", delay=True)
643 A = project_state.apps.get_model("migrations.A")
644 B = project_state.apps.get_model("migrations.B")
645 D = project_state.apps.get_model("migrations.D")
646 self.assertIs(B._meta.get_field("a").related_model, A)
647 self.assertIs(D._meta.get_field("a").related_model, A)
648
649 def test_reload_model_relationship_consistency(self):
650 project_state = ProjectState()
651 project_state.add_model(ModelState("migrations", "A", []))
652 project_state.add_model(
653 ModelState(
654 "migrations",
655 "B",
656 [
657 ("a", models.ForeignKey("A", models.CASCADE)),
658 ],
659 )
660 )
661 project_state.add_model(
662 ModelState(
663 "migrations",
664 "C",
665 [
666 ("b", models.ForeignKey("B", models.CASCADE)),
667 ],
668 )
669 )
670 A = project_state.apps.get_model("migrations.A")
671 B = project_state.apps.get_model("migrations.B")
672 C = project_state.apps.get_model("migrations.C")
673 self.assertEqual([r.related_model for r in A._meta.related_objects], [B])
674 self.assertEqual([r.related_model for r in B._meta.related_objects], [C])
675 self.assertEqual([r.related_model for r in C._meta.related_objects], [])
676
677 project_state.reload_model("migrations", "a", delay=True)
678 A = project_state.apps.get_model("migrations.A")
679 B = project_state.apps.get_model("migrations.B")
680 C = project_state.apps.get_model("migrations.C")
681 self.assertEqual([r.related_model for r in A._meta.related_objects], [B])
682 self.assertEqual([r.related_model for r in B._meta.related_objects], [C])
683 self.assertEqual([r.related_model for r in C._meta.related_objects], [])
684
685 def test_add_relations(self):
686 """
687 #24573 - Adding relations to existing models should reload the
688 referenced models too.
689 """
690 new_apps = Apps()
691
692 class A(models.Model):
693 class Meta:
694 app_label = "something"
695 apps = new_apps
696
697 class B(A):
698 class Meta:
699 app_label = "something"
700 apps = new_apps
701
702 class C(models.Model):
703 class Meta:
704 app_label = "something"
705 apps = new_apps
706
707 project_state = ProjectState()
708 project_state.add_model(ModelState.from_model(A))
709 project_state.add_model(ModelState.from_model(B))
710 project_state.add_model(ModelState.from_model(C))
711
712 project_state.apps # We need to work with rendered models
713
714 old_state = project_state.clone()
715 model_a_old = old_state.apps.get_model("something", "A")
716 model_b_old = old_state.apps.get_model("something", "B")
717 model_c_old = old_state.apps.get_model("something", "C")
718 # The relations between the old models are correct
719 self.assertIs(model_a_old._meta.get_field("b").related_model, model_b_old)
720 self.assertIs(model_b_old._meta.get_field("a_ptr").related_model, model_a_old)
721
722 operation = AddField(
723 "c",
724 "to_a",
725 models.OneToOneField(
726 "something.A",
727 models.CASCADE,
728 related_name="from_c",
729 ),
730 )
731 operation.state_forwards("something", project_state)
732 model_a_new = project_state.apps.get_model("something", "A")
733 model_b_new = project_state.apps.get_model("something", "B")
734 model_c_new = project_state.apps.get_model("something", "C")
735
736 # All models have changed
737 self.assertIsNot(model_a_old, model_a_new)
738 self.assertIsNot(model_b_old, model_b_new)
739 self.assertIsNot(model_c_old, model_c_new)
740 # The relations between the old models still hold
741 self.assertIs(model_a_old._meta.get_field("b").related_model, model_b_old)
742 self.assertIs(model_b_old._meta.get_field("a_ptr").related_model, model_a_old)
743 # The relations between the new models correct
744 self.assertIs(model_a_new._meta.get_field("b").related_model, model_b_new)
745 self.assertIs(model_b_new._meta.get_field("a_ptr").related_model, model_a_new)
746 self.assertIs(model_a_new._meta.get_field("from_c").related_model, model_c_new)
747 self.assertIs(model_c_new._meta.get_field("to_a").related_model, model_a_new)
748
749 def test_remove_relations(self):
750 """
751 #24225 - Relations between models are updated while
752 remaining the relations and references for models of an old state.
753 """
754 new_apps = Apps()
755
756 class A(models.Model):
757 class Meta:
758 app_label = "something"
759 apps = new_apps
760
761 class B(models.Model):
762 to_a = models.ForeignKey(A, models.CASCADE)
763
764 class Meta:
765 app_label = "something"
766 apps = new_apps
767
768 def get_model_a(state):
769 return [
770 mod for mod in state.apps.get_models() if mod._meta.model_name == "a"
771 ][0]
772
773 project_state = ProjectState()
774 project_state.add_model(ModelState.from_model(A))
775 project_state.add_model(ModelState.from_model(B))
776 self.assertEqual(len(get_model_a(project_state)._meta.related_objects), 1)
777 old_state = project_state.clone()
778
779 operation = RemoveField("b", "to_a")
780 operation.state_forwards("something", project_state)
781 # Model from old_state still has the relation
782 model_a_old = get_model_a(old_state)
783 model_a_new = get_model_a(project_state)
784 self.assertIsNot(model_a_old, model_a_new)
785 self.assertEqual(len(model_a_old._meta.related_objects), 1)
786 self.assertEqual(len(model_a_new._meta.related_objects), 0)
787
788 # Same test for deleted model
789 project_state = ProjectState()
790 project_state.add_model(ModelState.from_model(A))
791 project_state.add_model(ModelState.from_model(B))
792 old_state = project_state.clone()
793
794 operation = DeleteModel("b")
795 operation.state_forwards("something", project_state)
796 model_a_old = get_model_a(old_state)
797 model_a_new = get_model_a(project_state)
798 self.assertIsNot(model_a_old, model_a_new)
799 self.assertEqual(len(model_a_old._meta.related_objects), 1)
800 self.assertEqual(len(model_a_new._meta.related_objects), 0)
801
802 def test_self_relation(self):
803 """
804 #24513 - Modifying an object pointing to itself would cause it to be
805 rendered twice and thus breaking its related M2M through objects.
806 """
807
808 class A(models.Model):
809 to_a = models.ManyToManyField("something.A", symmetrical=False)
810
811 class Meta:
812 app_label = "something"
813
814 def get_model_a(state):
815 return [
816 mod for mod in state.apps.get_models() if mod._meta.model_name == "a"
817 ][0]
818
819 project_state = ProjectState()
820 project_state.add_model(ModelState.from_model(A))
821 self.assertEqual(len(get_model_a(project_state)._meta.related_objects), 1)
822 old_state = project_state.clone()
823
824 operation = AlterField(
825 model_name="a",
826 name="to_a",
827 field=models.ManyToManyField("something.A", symmetrical=False, blank=True),
828 )
829 # At this point the model would be rendered twice causing its related
830 # M2M through objects to point to an old copy and thus breaking their
831 # attribute lookup.
832 operation.state_forwards("something", project_state)
833
834 model_a_old = get_model_a(old_state)
835 model_a_new = get_model_a(project_state)
836 self.assertIsNot(model_a_old, model_a_new)
837
838 # The old model's _meta is still consistent
839 field_to_a_old = model_a_old._meta.get_field("to_a")
840 self.assertEqual(field_to_a_old.m2m_field_name(), "from_a")
841 self.assertEqual(field_to_a_old.m2m_reverse_field_name(), "to_a")
842 self.assertIs(field_to_a_old.related_model, model_a_old)
843 self.assertIs(
844 field_to_a_old.remote_field.through._meta.get_field("to_a").related_model,
845 model_a_old,
846 )
847 self.assertIs(
848 field_to_a_old.remote_field.through._meta.get_field("from_a").related_model,
849 model_a_old,
850 )
851
852 # The new model's _meta is still consistent
853 field_to_a_new = model_a_new._meta.get_field("to_a")
854 self.assertEqual(field_to_a_new.m2m_field_name(), "from_a")
855 self.assertEqual(field_to_a_new.m2m_reverse_field_name(), "to_a")
856 self.assertIs(field_to_a_new.related_model, model_a_new)
857 self.assertIs(
858 field_to_a_new.remote_field.through._meta.get_field("to_a").related_model,
859 model_a_new,
860 )
861 self.assertIs(
862 field_to_a_new.remote_field.through._meta.get_field("from_a").related_model,
863 model_a_new,
864 )
865
866 def test_equality(self):
867 """
868 == and != are implemented correctly.
869 """
870 # Test two things that should be equal
871 project_state = ProjectState()
872 project_state.add_model(
873 ModelState(
874 "migrations",
875 "Tag",
876 [
877 ("id", models.AutoField(primary_key=True)),
878 ("name", models.CharField(max_length=100)),
879 ("hidden", models.BooleanField()),
880 ],
881 {},
882 None,
883 )
884 )
885 project_state.apps # Fill the apps cached property
886 other_state = project_state.clone()
887 self.assertEqual(project_state, project_state)
888 self.assertEqual(project_state, other_state)
889 self.assertIs(project_state != project_state, False)
890 self.assertIs(project_state != other_state, False)
891 self.assertNotEqual(project_state.apps, other_state.apps)
892
893 # Make a very small change (max_len 99) and see if that affects it
894 project_state = ProjectState()
895 project_state.add_model(
896 ModelState(
897 "migrations",
898 "Tag",
899 [
900 ("id", models.AutoField(primary_key=True)),
901 ("name", models.CharField(max_length=99)),
902 ("hidden", models.BooleanField()),
903 ],
904 {},
905 None,
906 )
907 )
908 self.assertNotEqual(project_state, other_state)
909 self.assertIs(project_state == other_state, False)
910
911 def test_dangling_references_throw_error(self):
912 new_apps = Apps()
913
914 class Author(models.Model):
915 name = models.TextField()
916
917 class Meta:
918 app_label = "migrations"
919 apps = new_apps
920
921 class Publisher(models.Model):
922 name = models.TextField()
923
924 class Meta:
925 app_label = "migrations"
926 apps = new_apps
927
928 class Book(models.Model):
929 author = models.ForeignKey(Author, models.CASCADE)
930 publisher = models.ForeignKey(Publisher, models.CASCADE)
931
932 class Meta:
933 app_label = "migrations"
934 apps = new_apps
935
936 class Magazine(models.Model):
937 authors = models.ManyToManyField(Author)
938
939 class Meta:
940 app_label = "migrations"
941 apps = new_apps
942
943 # Make a valid ProjectState and render it
944 project_state = ProjectState()
945 project_state.add_model(ModelState.from_model(Author))
946 project_state.add_model(ModelState.from_model(Publisher))
947 project_state.add_model(ModelState.from_model(Book))
948 project_state.add_model(ModelState.from_model(Magazine))
949 self.assertEqual(len(project_state.apps.get_models()), 4)
950
951 # now make an invalid one with a ForeignKey
952 project_state = ProjectState()
953 project_state.add_model(ModelState.from_model(Book))
954 msg = (
955 "The field migrations.Book.author was declared with a lazy reference "
956 "to 'migrations.author', but app 'migrations' doesn't provide model "
957 "'author'.\n"
958 "The field migrations.Book.publisher was declared with a lazy reference "
959 "to 'migrations.publisher', but app 'migrations' doesn't provide model "
960 "'publisher'."
961 )
962 with self.assertRaisesMessage(ValueError, msg):
963 project_state.apps
964
965 # And another with ManyToManyField.
966 project_state = ProjectState()
967 project_state.add_model(ModelState.from_model(Magazine))
968 msg = (
969 "The field migrations.Magazine.authors was declared with a lazy reference "
970 "to 'migrations.author', but app 'migrations' doesn't provide model "
971 "'author'.\n"
972 "The field migrations.Magazine_authors.author was declared with a lazy "
973 "reference to 'migrations.author', but app 'migrations' doesn't provide "
974 "model 'author'."
975 )
976 with self.assertRaisesMessage(ValueError, msg):
977 project_state.apps
978
979 # And now with multiple models and multiple fields.
980 project_state.add_model(ModelState.from_model(Book))
981 msg = (
982 "The field migrations.Book.author was declared with a lazy reference "
983 "to 'migrations.author', but app 'migrations' doesn't provide model "
984 "'author'.\n"
985 "The field migrations.Book.publisher was declared with a lazy reference "
986 "to 'migrations.publisher', but app 'migrations' doesn't provide model "
987 "'publisher'.\n"
988 "The field migrations.Magazine.authors was declared with a lazy reference "
989 "to 'migrations.author', but app 'migrations' doesn't provide model "
990 "'author'.\n"
991 "The field migrations.Magazine_authors.author was declared with a lazy "
992 "reference to 'migrations.author', but app 'migrations' doesn't provide "
993 "model 'author'."
994 )
995 with self.assertRaisesMessage(ValueError, msg):
996 project_state.apps
997
998 def test_reference_mixed_case_app_label(self):
999 new_apps = Apps()
1000
1001 class Author(models.Model):
1002 class Meta:
1003 app_label = "MiXedCase_migrations"
1004 apps = new_apps
1005
1006 class Book(models.Model):
1007 author = models.ForeignKey(Author, models.CASCADE)
1008
1009 class Meta:
1010 app_label = "MiXedCase_migrations"
1011 apps = new_apps
1012
1013 class Magazine(models.Model):
1014 authors = models.ManyToManyField(Author)
1015
1016 class Meta:
1017 app_label = "MiXedCase_migrations"
1018 apps = new_apps
1019
1020 project_state = ProjectState()
1021 project_state.add_model(ModelState.from_model(Author))
1022 project_state.add_model(ModelState.from_model(Book))
1023 project_state.add_model(ModelState.from_model(Magazine))
1024 self.assertEqual(len(project_state.apps.get_models()), 3)
1025
1026 def test_real_apps(self):
1027 """
1028 Including real apps can resolve dangling FK errors.
1029 This test relies on the fact that contenttypes is always loaded.
1030 """
1031 new_apps = Apps()
1032
1033 class TestModel(models.Model):
1034 ct = models.ForeignKey("contenttypes.ContentType", models.CASCADE)
1035
1036 class Meta:
1037 app_label = "migrations"
1038 apps = new_apps
1039
1040 # If we just stick it into an empty state it should fail
1041 project_state = ProjectState()
1042 project_state.add_model(ModelState.from_model(TestModel))
1043 with self.assertRaises(ValueError):
1044 project_state.apps
1045
1046 # If we include the real app it should succeed
1047 project_state = ProjectState(real_apps={"contenttypes"})
1048 project_state.add_model(ModelState.from_model(TestModel))
1049 rendered_state = project_state.apps
1050 self.assertEqual(
1051 len(
1052 [
1053 x
1054 for x in rendered_state.get_models()
1055 if x._meta.app_label == "migrations"
1056 ]
1057 ),
1058 1,
1059 )
1060
1061 def test_real_apps_non_set(self):
1062 with self.assertRaises(AssertionError):
1063 ProjectState(real_apps=["contenttypes"])
1064
1065 def test_ignore_order_wrt(self):
1066 """
1067 Makes sure ProjectState doesn't include OrderWrt fields when
1068 making from existing models.
1069 """
1070 new_apps = Apps()
1071
1072 class Author(models.Model):
1073 name = models.TextField()
1074
1075 class Meta:
1076 app_label = "migrations"
1077 apps = new_apps
1078
1079 class Book(models.Model):
1080 author = models.ForeignKey(Author, models.CASCADE)
1081
1082 class Meta:
1083 app_label = "migrations"
1084 apps = new_apps
1085 order_with_respect_to = "author"
1086
1087 # Make a valid ProjectState and render it
1088 project_state = ProjectState()
1089 project_state.add_model(ModelState.from_model(Author))
1090 project_state.add_model(ModelState.from_model(Book))
1091 self.assertEqual(
1092 list(project_state.models["migrations", "book"].fields),
1093 ["id", "author"],
1094 )
1095
1096 def test_modelstate_get_field_order_wrt(self):
1097 new_apps = Apps()
1098
1099 class Author(models.Model):
1100 name = models.TextField()
1101
1102 class Meta:
1103 app_label = "migrations"
1104 apps = new_apps
1105
1106 class Book(models.Model):
1107 author = models.ForeignKey(Author, models.CASCADE)
1108
1109 class Meta:
1110 app_label = "migrations"
1111 apps = new_apps
1112 order_with_respect_to = "author"
1113
1114 model_state = ModelState.from_model(Book)
1115 order_wrt_field = model_state.get_field("_order")
1116 self.assertIsInstance(order_wrt_field, models.ForeignKey)
1117 self.assertEqual(order_wrt_field.related_model, "migrations.author")
1118
1119 def test_modelstate_get_field_no_order_wrt_order_field(self):
1120 new_apps = Apps()
1121
1122 class HistoricalRecord(models.Model):
1123 _order = models.PositiveSmallIntegerField()
1124
1125 class Meta:
1126 app_label = "migrations"
1127 apps = new_apps
1128
1129 model_state = ModelState.from_model(HistoricalRecord)
1130 order_field = model_state.get_field("_order")
1131 self.assertIsNone(order_field.related_model)
1132 self.assertIsInstance(order_field, models.PositiveSmallIntegerField)
1133
1134 def test_get_order_field_after_removed_order_with_respect_to_field(self):
1135 new_apps = Apps()
1136
1137 class HistoricalRecord(models.Model):
1138 _order = models.PositiveSmallIntegerField()
1139
1140 class Meta:
1141 app_label = "migrations"
1142 apps = new_apps
1143
1144 model_state = ModelState.from_model(HistoricalRecord)
1145 model_state.options["order_with_respect_to"] = None
1146 order_field = model_state.get_field("_order")
1147 self.assertIsNone(order_field.related_model)
1148 self.assertIsInstance(order_field, models.PositiveSmallIntegerField)
1149
1150 def test_manager_refer_correct_model_version(self):
1151 """
1152 #24147 - Managers refer to the correct version of a
1153 historical model
1154 """
1155 project_state = ProjectState()
1156 project_state.add_model(
1157 ModelState(
1158 app_label="migrations",
1159 name="Tag",
1160 fields=[
1161 ("id", models.AutoField(primary_key=True)),
1162 ("hidden", models.BooleanField()),
1163 ],
1164 managers=[
1165 ("food_mgr", FoodManager("a", "b")),
1166 ("food_qs", FoodQuerySet.as_manager()),
1167 ],
1168 )
1169 )
1170
1171 old_model = project_state.apps.get_model("migrations", "tag")
1172
1173 new_state = project_state.clone()
1174 operation = RemoveField("tag", "hidden")
1175 operation.state_forwards("migrations", new_state)
1176
1177 new_model = new_state.apps.get_model("migrations", "tag")
1178
1179 self.assertIsNot(old_model, new_model)
1180 self.assertIs(old_model, old_model.food_mgr.model)
1181 self.assertIs(old_model, old_model.food_qs.model)
1182 self.assertIs(new_model, new_model.food_mgr.model)
1183 self.assertIs(new_model, new_model.food_qs.model)
1184 self.assertIsNot(old_model.food_mgr, new_model.food_mgr)
1185 self.assertIsNot(old_model.food_qs, new_model.food_qs)
1186 self.assertIsNot(old_model.food_mgr.model, new_model.food_mgr.model)
1187 self.assertIsNot(old_model.food_qs.model, new_model.food_qs.model)
1188
1189 def test_choices_iterator(self):
1190 """
1191 #24483 - ProjectState.from_apps should not destructively consume
1192 Field.choices iterators.
1193 """
1194 new_apps = Apps(["migrations"])
1195 choices = [("a", "A"), ("b", "B")]
1196
1197 class Author(models.Model):
1198 name = models.CharField(max_length=255)
1199 choice = models.CharField(max_length=255, choices=iter(choices))
1200
1201 class Meta:
1202 app_label = "migrations"
1203 apps = new_apps
1204
1205 ProjectState.from_apps(new_apps)
1206 choices_field = Author._meta.get_field("choice")
1207 self.assertEqual(list(choices_field.choices), choices)
1208
1209 def test_composite_pk_state(self):
1210 new_apps = Apps(["migrations"])
1211
1212 class Foo(models.Model):
1213 pk = models.CompositePrimaryKey("account_id", "id")
1214 account_id = models.SmallIntegerField()
1215 id = models.SmallIntegerField()
1216
1217 class Meta:
1218 app_label = "migrations"
1219 apps = new_apps
1220
1221 project_state = ProjectState.from_apps(new_apps)
1222 model_state = project_state.models["migrations", "foo"]
1223 self.assertEqual(len(model_state.options), 2)
1224 self.assertEqual(model_state.options["constraints"], [])
1225 self.assertEqual(model_state.options["indexes"], [])
1226 self.assertEqual(len(model_state.fields), 3)
1227 self.assertIn("pk", model_state.fields)
1228 self.assertIn("account_id", model_state.fields)
1229 self.assertIn("id", model_state.fields)
1230
1231
1232 class StateRelationsTests(SimpleTestCase):
1233 def get_base_project_state(self):
1234 new_apps = Apps()
1235
1236 class User(models.Model):
1237 class Meta:
1238 app_label = "tests"
1239 apps = new_apps
1240
1241 class Comment(models.Model):
1242 text = models.TextField()
1243 user = models.ForeignKey(User, models.CASCADE)
1244 comments = models.ManyToManyField("self")
1245
1246 class Meta:
1247 app_label = "tests"
1248 apps = new_apps
1249
1250 class Post(models.Model):
1251 text = models.TextField()
1252 authors = models.ManyToManyField(User)
1253
1254 class Meta:
1255 app_label = "tests"
1256 apps = new_apps
1257
1258 project_state = ProjectState()
1259 project_state.add_model(ModelState.from_model(User))
1260 project_state.add_model(ModelState.from_model(Comment))
1261 project_state.add_model(ModelState.from_model(Post))
1262 return project_state
1263
1264 def test_relations_population(self):
1265 tests = [
1266 (
1267 "add_model",
1268 [
1269 ModelState(
1270 app_label="migrations",
1271 name="Tag",
1272 fields=[("id", models.AutoField(primary_key=True))],
1273 ),
1274 ],
1275 ),
1276 ("remove_model", ["tests", "comment"]),
1277 ("rename_model", ["tests", "comment", "opinion"]),
1278 (
1279 "add_field",
1280 [
1281 "tests",
1282 "post",
1283 "next_post",
1284 models.ForeignKey("self", models.CASCADE),
1285 True,
1286 ],
1287 ),
1288 ("remove_field", ["tests", "post", "text"]),
1289 ("rename_field", ["tests", "comment", "user", "author"]),
1290 (
1291 "alter_field",
1292 [
1293 "tests",
1294 "comment",
1295 "user",
1296 models.IntegerField(),
1297 True,
1298 ],
1299 ),
1300 ]
1301 for method, args in tests:
1302 with self.subTest(method=method):
1303 project_state = self.get_base_project_state()
1304 getattr(project_state, method)(*args)
1305 # ProjectState's `_relations` are populated on `relations` access.
1306 self.assertIsNone(project_state._relations)
1307 self.assertEqual(project_state.relations, project_state._relations)
1308 self.assertIsNotNone(project_state._relations)
1309
1310 def test_add_model(self):
1311 project_state = self.get_base_project_state()
1312 self.assertEqual(
1313 list(project_state.relations["tests", "user"]),
1314 [("tests", "comment"), ("tests", "post")],
1315 )
1316 self.assertEqual(
1317 list(project_state.relations["tests", "comment"]),
1318 [("tests", "comment")],
1319 )
1320 self.assertNotIn(("tests", "post"), project_state.relations)
1321
1322 def test_add_model_no_relations(self):
1323 project_state = ProjectState()
1324 project_state.add_model(
1325 ModelState(
1326 app_label="migrations",
1327 name="Tag",
1328 fields=[("id", models.AutoField(primary_key=True))],
1329 )
1330 )
1331 self.assertEqual(project_state.relations, {})
1332
1333 def test_add_model_other_app(self):
1334 project_state = self.get_base_project_state()
1335 self.assertEqual(
1336 list(project_state.relations["tests", "user"]),
1337 [("tests", "comment"), ("tests", "post")],
1338 )
1339 project_state.add_model(
1340 ModelState(
1341 app_label="tests_other",
1342 name="comment",
1343 fields=[
1344 ("id", models.AutoField(primary_key=True)),
1345 ("user", models.ForeignKey("tests.user", models.CASCADE)),
1346 ],
1347 )
1348 )
1349 self.assertEqual(
1350 list(project_state.relations["tests", "user"]),
1351 [("tests", "comment"), ("tests", "post"), ("tests_other", "comment")],
1352 )
1353
1354 def test_remove_model(self):
1355 project_state = self.get_base_project_state()
1356 self.assertEqual(
1357 list(project_state.relations["tests", "user"]),
1358 [("tests", "comment"), ("tests", "post")],
1359 )
1360 self.assertEqual(
1361 list(project_state.relations["tests", "comment"]),
1362 [("tests", "comment")],
1363 )
1364
1365 project_state.remove_model("tests", "comment")
1366 self.assertEqual(
1367 list(project_state.relations["tests", "user"]),
1368 [("tests", "post")],
1369 )
1370 self.assertNotIn(("tests", "comment"), project_state.relations)
1371 project_state.remove_model("tests", "post")
1372 self.assertEqual(project_state.relations, {})
1373 project_state.remove_model("tests", "user")
1374 self.assertEqual(project_state.relations, {})
1375
1376 def test_rename_model(self):
1377 project_state = self.get_base_project_state()
1378 self.assertEqual(
1379 list(project_state.relations["tests", "user"]),
1380 [("tests", "comment"), ("tests", "post")],
1381 )
1382 self.assertEqual(
1383 list(project_state.relations["tests", "comment"]),
1384 [("tests", "comment")],
1385 )
1386
1387 related_field = project_state.relations["tests", "user"]["tests", "comment"]
1388 project_state.rename_model("tests", "comment", "opinion")
1389 self.assertEqual(
1390 list(project_state.relations["tests", "user"]),
1391 [("tests", "post"), ("tests", "opinion")],
1392 )
1393 self.assertEqual(
1394 list(project_state.relations["tests", "opinion"]),
1395 [("tests", "opinion")],
1396 )
1397 self.assertNotIn(("tests", "comment"), project_state.relations)
1398 self.assertEqual(
1399 project_state.relations["tests", "user"]["tests", "opinion"],
1400 related_field,
1401 )
1402
1403 project_state.rename_model("tests", "user", "author")
1404 self.assertEqual(
1405 list(project_state.relations["tests", "author"]),
1406 [("tests", "post"), ("tests", "opinion")],
1407 )
1408 self.assertNotIn(("tests", "user"), project_state.relations)
1409
1410 def test_rename_model_no_relations(self):
1411 project_state = self.get_base_project_state()
1412 self.assertEqual(
1413 list(project_state.relations["tests", "user"]),
1414 [("tests", "comment"), ("tests", "post")],
1415 )
1416 related_field = project_state.relations["tests", "user"]["tests", "post"]
1417 self.assertNotIn(("tests", "post"), project_state.relations)
1418 # Rename a model without relations.
1419 project_state.rename_model("tests", "post", "blog")
1420 self.assertEqual(
1421 list(project_state.relations["tests", "user"]),
1422 [("tests", "comment"), ("tests", "blog")],
1423 )
1424 self.assertNotIn(("tests", "blog"), project_state.relations)
1425 self.assertEqual(
1426 related_field,
1427 project_state.relations["tests", "user"]["tests", "blog"],
1428 )
1429
1430 def test_add_field(self):
1431 project_state = self.get_base_project_state()
1432 self.assertNotIn(("tests", "post"), project_state.relations)
1433 # Add a self-referential foreign key.
1434 new_field = models.ForeignKey("self", models.CASCADE)
1435 project_state.add_field(
1436 "tests",
1437 "post",
1438 "next_post",
1439 new_field,
1440 preserve_default=True,
1441 )
1442 self.assertEqual(
1443 list(project_state.relations["tests", "post"]),
1444 [("tests", "post")],
1445 )
1446 self.assertEqual(
1447 project_state.relations["tests", "post"]["tests", "post"],
1448 {"next_post": new_field},
1449 )
1450 # Add a foreign key.
1451 new_field = models.ForeignKey("tests.post", models.CASCADE)
1452 project_state.add_field(
1453 "tests",
1454 "comment",
1455 "post",
1456 new_field,
1457 preserve_default=True,
1458 )
1459 self.assertEqual(
1460 list(project_state.relations["tests", "post"]),
1461 [("tests", "post"), ("tests", "comment")],
1462 )
1463 self.assertEqual(
1464 project_state.relations["tests", "post"]["tests", "comment"],
1465 {"post": new_field},
1466 )
1467
1468 def test_add_field_m2m_with_through(self):
1469 project_state = self.get_base_project_state()
1470 project_state.add_model(
1471 ModelState(
1472 app_label="tests",
1473 name="Tag",
1474 fields=[("id", models.AutoField(primary_key=True))],
1475 )
1476 )
1477 project_state.add_model(
1478 ModelState(
1479 app_label="tests",
1480 name="PostTag",
1481 fields=[
1482 ("id", models.AutoField(primary_key=True)),
1483 ("post", models.ForeignKey("tests.post", models.CASCADE)),
1484 ("tag", models.ForeignKey("tests.tag", models.CASCADE)),
1485 ],
1486 )
1487 )
1488 self.assertEqual(
1489 list(project_state.relations["tests", "post"]),
1490 [("tests", "posttag")],
1491 )
1492 self.assertEqual(
1493 list(project_state.relations["tests", "tag"]),
1494 [("tests", "posttag")],
1495 )
1496 # Add a many-to-many field with the through model.
1497 new_field = models.ManyToManyField("tests.tag", through="tests.posttag")
1498 project_state.add_field(
1499 "tests",
1500 "post",
1501 "tags",
1502 new_field,
1503 preserve_default=True,
1504 )
1505 self.assertEqual(
1506 list(project_state.relations["tests", "post"]),
1507 [("tests", "posttag")],
1508 )
1509 self.assertEqual(
1510 list(project_state.relations["tests", "tag"]),
1511 [("tests", "posttag"), ("tests", "post")],
1512 )
1513 self.assertEqual(
1514 project_state.relations["tests", "tag"]["tests", "post"],
1515 {"tags": new_field},
1516 )
1517
1518 def test_remove_field(self):
1519 project_state = self.get_base_project_state()
1520 self.assertEqual(
1521 list(project_state.relations["tests", "user"]),
1522 [("tests", "comment"), ("tests", "post")],
1523 )
1524 # Remove a many-to-many field.
1525 project_state.remove_field("tests", "post", "authors")
1526 self.assertEqual(
1527 list(project_state.relations["tests", "user"]),
1528 [("tests", "comment")],
1529 )
1530 # Remove a foreign key.
1531 project_state.remove_field("tests", "comment", "user")
1532 self.assertEqual(project_state.relations["tests", "user"], {})
1533
1534 def test_remove_field_no_relations(self):
1535 project_state = self.get_base_project_state()
1536 self.assertEqual(
1537 list(project_state.relations["tests", "user"]),
1538 [("tests", "comment"), ("tests", "post")],
1539 )
1540 # Remove a non-relation field.
1541 project_state.remove_field("tests", "post", "text")
1542 self.assertEqual(
1543 list(project_state.relations["tests", "user"]),
1544 [("tests", "comment"), ("tests", "post")],
1545 )
1546
1547 def test_rename_field(self):
1548 project_state = self.get_base_project_state()
1549 field = project_state.models["tests", "comment"].fields["user"]
1550 self.assertEqual(
1551 project_state.relations["tests", "user"]["tests", "comment"],
1552 {"user": field},
1553 )
1554
1555 project_state.rename_field("tests", "comment", "user", "author")
1556 renamed_field = project_state.models["tests", "comment"].fields["author"]
1557 self.assertEqual(
1558 project_state.relations["tests", "user"]["tests", "comment"],
1559 {"author": renamed_field},
1560 )
1561 self.assertEqual(field, renamed_field)
1562
1563 def test_rename_field_no_relations(self):
1564 project_state = self.get_base_project_state()
1565 self.assertEqual(
1566 list(project_state.relations["tests", "user"]),
1567 [("tests", "comment"), ("tests", "post")],
1568 )
1569 # Rename a non-relation field.
1570 project_state.rename_field("tests", "post", "text", "description")
1571 self.assertEqual(
1572 list(project_state.relations["tests", "user"]),
1573 [("tests", "comment"), ("tests", "post")],
1574 )
1575
1576 def test_alter_field(self):
1577 project_state = self.get_base_project_state()
1578 self.assertEqual(
1579 list(project_state.relations["tests", "user"]),
1580 [("tests", "comment"), ("tests", "post")],
1581 )
1582 # Alter a foreign key to a non-relation field.
1583 project_state.alter_field(
1584 "tests",
1585 "comment",
1586 "user",
1587 models.IntegerField(),
1588 preserve_default=True,
1589 )
1590 self.assertEqual(
1591 list(project_state.relations["tests", "user"]),
1592 [("tests", "post")],
1593 )
1594 # Alter a non-relation field to a many-to-many field.
1595 m2m_field = models.ManyToManyField("tests.user")
1596 project_state.alter_field(
1597 "tests",
1598 "comment",
1599 "user",
1600 m2m_field,
1601 preserve_default=True,
1602 )
1603 self.assertEqual(
1604 list(project_state.relations["tests", "user"]),
1605 [("tests", "post"), ("tests", "comment")],
1606 )
1607 self.assertEqual(
1608 project_state.relations["tests", "user"]["tests", "comment"],
1609 {"user": m2m_field},
1610 )
1611
1612 def test_alter_field_m2m_to_fk(self):
1613 project_state = self.get_base_project_state()
1614 project_state.add_model(
1615 ModelState(
1616 app_label="tests_other",
1617 name="user_other",
1618 fields=[("id", models.AutoField(primary_key=True))],
1619 )
1620 )
1621 self.assertEqual(
1622 list(project_state.relations["tests", "user"]),
1623 [("tests", "comment"), ("tests", "post")],
1624 )
1625 self.assertNotIn(("tests_other", "user_other"), project_state.relations)
1626 # Alter a many-to-many field to a foreign key.
1627 foreign_key = models.ForeignKey("tests_other.user_other", models.CASCADE)
1628 project_state.alter_field(
1629 "tests",
1630 "post",
1631 "authors",
1632 foreign_key,
1633 preserve_default=True,
1634 )
1635 self.assertEqual(
1636 list(project_state.relations["tests", "user"]),
1637 [("tests", "comment")],
1638 )
1639 self.assertEqual(
1640 list(project_state.relations["tests_other", "user_other"]),
1641 [("tests", "post")],
1642 )
1643 self.assertEqual(
1644 project_state.relations["tests_other", "user_other"]["tests", "post"],
1645 {"authors": foreign_key},
1646 )
1647
1648 def test_many_relations_to_same_model(self):
1649 project_state = self.get_base_project_state()
1650 new_field = models.ForeignKey("tests.user", models.CASCADE)
1651 project_state.add_field(
1652 "tests",
1653 "comment",
1654 "reviewer",
1655 new_field,
1656 preserve_default=True,
1657 )
1658 self.assertEqual(
1659 list(project_state.relations["tests", "user"]),
1660 [("tests", "comment"), ("tests", "post")],
1661 )
1662 comment_rels = project_state.relations["tests", "user"]["tests", "comment"]
1663 # Two foreign keys to the same model.
1664 self.assertEqual(len(comment_rels), 2)
1665 self.assertEqual(comment_rels["reviewer"], new_field)
1666 # Rename the second foreign key.
1667 project_state.rename_field("tests", "comment", "reviewer", "supervisor")
1668 self.assertEqual(len(comment_rels), 2)
1669 self.assertEqual(comment_rels["supervisor"], new_field)
1670 # Remove the first foreign key.
1671 project_state.remove_field("tests", "comment", "user")
1672 self.assertEqual(comment_rels, {"supervisor": new_field})
1673
1674
1675 class ModelStateTests(SimpleTestCase):
1676 def test_custom_model_base(self):
1677 state = ModelState.from_model(ModelWithCustomBase)
1678 self.assertEqual(state.bases, (models.Model,))
1679
1680 def test_bound_field_sanity_check(self):
1681 field = models.CharField(max_length=1)
1682 field.model = models.Model
1683 with self.assertRaisesMessage(
1684 ValueError, 'ModelState.fields cannot be bound to a model - "field" is.'
1685 ):
1686 ModelState("app", "Model", [("field", field)])
1687
1688 def test_sanity_check_to(self):
1689 field = models.ForeignKey(UnicodeModel, models.CASCADE)
1690 with self.assertRaisesMessage(
1691 ValueError,
1692 'Model fields in "ModelState.fields" cannot refer to a model class - '
1693 '"app.Model.field.to" does. Use a string reference instead.',
1694 ):
1695 ModelState("app", "Model", [("field", field)])
1696
1697 def test_sanity_check_through(self):
1698 field = models.ManyToManyField("UnicodeModel")
1699 field.remote_field.through = UnicodeModel
1700 with self.assertRaisesMessage(
1701 ValueError,
1702 'Model fields in "ModelState.fields" cannot refer to a model class - '
1703 '"app.Model.field.through" does. Use a string reference instead.',
1704 ):
1705 ModelState("app", "Model", [("field", field)])
1706
1707 def test_sanity_index_name(self):
1708 field = models.IntegerField()
1709 options = {"indexes": [models.Index(fields=["field"])]}
1710 msg = (
1711 "Indexes passed to ModelState require a name attribute. <Index: "
1712 "fields=['field']> doesn't have one."
1713 )
1714 with self.assertRaisesMessage(ValueError, msg):
1715 ModelState("app", "Model", [("field", field)], options=options)
1716
1717 def test_fields_immutability(self):
1718 """
1719 Rendering a model state doesn't alter its internal fields.
1720 """
1721 apps = Apps()
1722 field = models.CharField(max_length=1)
1723 state = ModelState("app", "Model", [("name", field)])
1724 Model = state.render(apps)
1725 self.assertNotEqual(Model._meta.get_field("name"), field)
1726
1727 def test_repr(self):
1728 field = models.CharField(max_length=1)
1729 state = ModelState(
1730 "app", "Model", [("name", field)], bases=["app.A", "app.B", "app.C"]
1731 )
1732 self.assertEqual(repr(state), "<ModelState: 'app.Model'>")
1733
1734 project_state = ProjectState()
1735 project_state.add_model(state)
1736 with self.assertRaisesMessage(
1737 InvalidBasesError, "Cannot resolve bases for [<ModelState: 'app.Model'>]"
1738 ):
1739 project_state.apps
1740
1741 def test_fields_ordering_equality(self):
1742 state = ModelState(
1743 "migrations",
1744 "Tag",
1745 [
1746 ("id", models.AutoField(primary_key=True)),
1747 ("name", models.CharField(max_length=100)),
1748 ("hidden", models.BooleanField()),
1749 ],
1750 )
1751 reordered_state = ModelState(
1752 "migrations",
1753 "Tag",
1754 [
1755 ("id", models.AutoField(primary_key=True)),
1756 # Purposely re-ordered.
1757 ("hidden", models.BooleanField()),
1758 ("name", models.CharField(max_length=100)),
1759 ],
1760 )
1761 self.assertEqual(state, reordered_state)
1762
1763 @override_settings(TEST_SWAPPABLE_MODEL="migrations.SomeFakeModel")
1764 def test_create_swappable(self):
1765 """
1766 Tests making a ProjectState from an Apps with a swappable model
1767 """
1768 new_apps = Apps(["migrations"])
1769
1770 class Author(models.Model):
1771 name = models.CharField(max_length=255)
1772 bio = models.TextField()
1773 age = models.IntegerField(blank=True, null=True)
1774
1775 class Meta:
1776 app_label = "migrations"
1777 apps = new_apps
1778 swappable = "TEST_SWAPPABLE_MODEL"
1779
1780 author_state = ModelState.from_model(Author)
1781 self.assertEqual(author_state.app_label, "migrations")
1782 self.assertEqual(author_state.name, "Author")
1783 self.assertEqual(list(author_state.fields), ["id", "name", "bio", "age"])
1784 self.assertEqual(author_state.fields["name"].max_length, 255)
1785 self.assertIs(author_state.fields["bio"].null, False)
1786 self.assertIs(author_state.fields["age"].null, True)
1787 self.assertEqual(
1788 author_state.options,
1789 {"swappable": "TEST_SWAPPABLE_MODEL", "indexes": [], "constraints": []},
1790 )
1791 self.assertEqual(author_state.bases, (models.Model,))
1792 self.assertEqual(author_state.managers, [])
1793
1794 @override_settings(TEST_SWAPPABLE_MODEL="migrations.SomeFakeModel")
1795 def test_create_swappable_from_abstract(self):
1796 """
1797 A swappable model inheriting from a hierarchy:
1798 concrete -> abstract -> concrete.
1799 """
1800 new_apps = Apps(["migrations"])
1801
1802 class SearchableLocation(models.Model):
1803 keywords = models.CharField(max_length=256)
1804
1805 class Meta:
1806 app_label = "migrations"
1807 apps = new_apps
1808
1809 class Station(SearchableLocation):
1810 name = models.CharField(max_length=128)
1811
1812 class Meta:
1813 abstract = True
1814
1815 class BusStation(Station):
1816 bus_routes = models.CharField(max_length=128)
1817 inbound = models.BooleanField(default=False)
1818
1819 class Meta(Station.Meta):
1820 app_label = "migrations"
1821 apps = new_apps
1822 swappable = "TEST_SWAPPABLE_MODEL"
1823
1824 station_state = ModelState.from_model(BusStation)
1825 self.assertEqual(station_state.app_label, "migrations")
1826 self.assertEqual(station_state.name, "BusStation")
1827 self.assertEqual(
1828 list(station_state.fields),
1829 ["searchablelocation_ptr", "name", "bus_routes", "inbound"],
1830 )
1831 self.assertEqual(station_state.fields["name"].max_length, 128)
1832 self.assertIs(station_state.fields["bus_routes"].null, False)
1833 self.assertEqual(
1834 station_state.options,
1835 {
1836 "abstract": False,
1837 "swappable": "TEST_SWAPPABLE_MODEL",
1838 "indexes": [],
1839 "constraints": [],
1840 },
1841 )
1842 self.assertEqual(station_state.bases, ("migrations.searchablelocation",))
1843 self.assertEqual(station_state.managers, [])
1844
1845 @override_settings(TEST_SWAPPABLE_MODEL="migrations.SomeFakeModel")
1846 def test_custom_manager_swappable(self):
1847 """
1848 Tests making a ProjectState from unused models with custom managers
1849 """
1850 new_apps = Apps(["migrations"])
1851
1852 class Food(models.Model):
1853 food_mgr = FoodManager("a", "b")
1854 food_qs = FoodQuerySet.as_manager()
1855 food_no_mgr = NoMigrationFoodManager("x", "y")
1856
1857 class Meta:
1858 app_label = "migrations"
1859 apps = new_apps
1860 swappable = "TEST_SWAPPABLE_MODEL"
1861
1862 food_state = ModelState.from_model(Food)
1863
1864 # The default manager is used in migrations
1865 self.assertEqual([name for name, mgr in food_state.managers], ["food_mgr"])
1866 self.assertEqual(food_state.managers[0][1].args, ("a", "b", 1, 2))
1867
1868 @isolate_apps("migrations", "django.contrib.contenttypes")
1869 def test_order_with_respect_to_private_field(self):
1870 class PrivateFieldModel(models.Model):
1871 content_type = models.ForeignKey("contenttypes.ContentType", models.CASCADE)
1872 object_id = models.PositiveIntegerField()
1873 private = GenericForeignKey()
1874
1875 class Meta:
1876 order_with_respect_to = "private"
1877
1878 state = ModelState.from_model(PrivateFieldModel)
1879 self.assertNotIn("order_with_respect_to", state.options)
1880
1881 @isolate_apps("migrations")
1882 def test_abstract_model_children_inherit_indexes(self):
1883 class Abstract(models.Model):
1884 name = models.CharField(max_length=50)
1885
1886 class Meta:
1887 app_label = "migrations"
1888 abstract = True
1889 indexes = [models.Index(fields=["name"])]
1890
1891 class Child1(Abstract):
1892 pass
1893
1894 class Child2(Abstract):
1895 pass
1896
1897 abstract_state = ModelState.from_model(Abstract)
1898 child1_state = ModelState.from_model(Child1)
1899 child2_state = ModelState.from_model(Child2)
1900 index_names = [index.name for index in abstract_state.options["indexes"]]
1901 self.assertEqual(index_names, ["migrations__name_ae16a4_idx"])
1902 index_names = [index.name for index in child1_state.options["indexes"]]
1903 self.assertEqual(index_names, ["migrations__name_b0afd7_idx"])
1904 index_names = [index.name for index in child2_state.options["indexes"]]
1905 self.assertEqual(index_names, ["migrations__name_016466_idx"])
1906
1907 # Modifying the state doesn't modify the index on the model.
1908 child1_state.options["indexes"][0].name = "bar"
1909 self.assertEqual(Child1._meta.indexes[0].name, "migrations__name_b0afd7_idx")
1910
1911 @isolate_apps("migrations")
1912 def test_explicit_index_name(self):
1913 class TestModel(models.Model):
1914 name = models.CharField(max_length=50)
1915
1916 class Meta:
1917 app_label = "migrations"
1918 indexes = [models.Index(fields=["name"], name="foo_idx")]
1919
1920 model_state = ModelState.from_model(TestModel)
1921 index_names = [index.name for index in model_state.options["indexes"]]
1922 self.assertEqual(index_names, ["foo_idx"])
1923
1924 @isolate_apps("migrations")
1925 def test_from_model_constraints(self):
1926 class ModelWithConstraints(models.Model):
1927 size = models.IntegerField()
1928
1929 class Meta:
1930 constraints = [
1931 models.CheckConstraint(
1932 condition=models.Q(size__gt=1), name="size_gt_1"
1933 )
1934 ]
1935
1936 state = ModelState.from_model(ModelWithConstraints)
1937 model_constraints = ModelWithConstraints._meta.constraints
1938 state_constraints = state.options["constraints"]
1939 self.assertEqual(model_constraints, state_constraints)
1940 self.assertIsNot(model_constraints, state_constraints)
1941 self.assertIsNot(model_constraints[0], state_constraints[0])
1942
1943
1944 class RelatedModelsTests(SimpleTestCase):
1945 def setUp(self):
1946 self.apps = Apps(["migrations.related_models_app"])
1947
1948 def create_model(
1949 self, name, foreign_keys=[], bases=(), abstract=False, proxy=False
1950 ):
1951 test_name = "related_models_app"
1952 assert not (abstract and proxy)
1953 meta_contents = {
1954 "abstract": abstract,
1955 "app_label": test_name,
1956 "apps": self.apps,
1957 "proxy": proxy,
1958 }
1959 meta = type("Meta", (), meta_contents)
1960 if not bases:
1961 bases = (models.Model,)
1962 body = {
1963 "Meta": meta,
1964 "__module__": "__fake__",
1965 }
1966 fname_base = fname = "%s_%%d" % name.lower()
1967 for i, fk in enumerate(foreign_keys, 1):
1968 fname = fname_base % i
1969 body[fname] = fk
1970 return type(name, bases, body)
1971
1972 def assertRelated(self, model, needle):
1973 self.assertEqual(
1974 get_related_models_recursive(model),
1975 {(n._meta.app_label, n._meta.model_name) for n in needle},
1976 )
1977
1978 def test_unrelated(self):
1979 A = self.create_model("A")
1980 B = self.create_model("B")
1981 self.assertRelated(A, [])
1982 self.assertRelated(B, [])
1983
1984 def test_direct_fk(self):
1985 A = self.create_model(
1986 "A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
1987 )
1988 B = self.create_model("B")
1989 self.assertRelated(A, [B])
1990 self.assertRelated(B, [A])
1991
1992 def test_direct_hidden_fk(self):
1993 A = self.create_model(
1994 "A", foreign_keys=[models.ForeignKey("B", models.CASCADE, related_name="+")]
1995 )
1996 B = self.create_model("B")
1997 self.assertRelated(A, [B])
1998 self.assertRelated(B, [A])
1999
2000 def test_fk_through_proxy(self):
2001 A = self.create_model("A")
2002 B = self.create_model("B", bases=(A,), proxy=True)
2003 C = self.create_model("C", bases=(B,), proxy=True)
2004 D = self.create_model(
2005 "D", foreign_keys=[models.ForeignKey("C", models.CASCADE)]
2006 )
2007 self.assertRelated(A, [B, C, D])
2008 self.assertRelated(B, [A, C, D])
2009 self.assertRelated(C, [A, B, D])
2010 self.assertRelated(D, [A, B, C])
2011
2012 def test_nested_fk(self):
2013 A = self.create_model(
2014 "A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
2015 )
2016 B = self.create_model(
2017 "B", foreign_keys=[models.ForeignKey("C", models.CASCADE)]
2018 )
2019 C = self.create_model("C")
2020 self.assertRelated(A, [B, C])
2021 self.assertRelated(B, [A, C])
2022 self.assertRelated(C, [A, B])
2023
2024 def test_two_sided(self):
2025 A = self.create_model(
2026 "A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
2027 )
2028 B = self.create_model(
2029 "B", foreign_keys=[models.ForeignKey("A", models.CASCADE)]
2030 )
2031 self.assertRelated(A, [B])
2032 self.assertRelated(B, [A])
2033
2034 def test_circle(self):
2035 A = self.create_model(
2036 "A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
2037 )
2038 B = self.create_model(
2039 "B", foreign_keys=[models.ForeignKey("C", models.CASCADE)]
2040 )
2041 C = self.create_model(
2042 "C", foreign_keys=[models.ForeignKey("A", models.CASCADE)]
2043 )
2044 self.assertRelated(A, [B, C])
2045 self.assertRelated(B, [A, C])
2046 self.assertRelated(C, [A, B])
2047
2048 def test_base(self):
2049 A = self.create_model("A")
2050 B = self.create_model("B", bases=(A,))
2051 self.assertRelated(A, [B])
2052 self.assertRelated(B, [A])
2053
2054 def test_nested_base(self):
2055 A = self.create_model("A")
2056 B = self.create_model("B", bases=(A,))
2057 C = self.create_model("C", bases=(B,))
2058 self.assertRelated(A, [B, C])
2059 self.assertRelated(B, [A, C])
2060 self.assertRelated(C, [A, B])
2061
2062 def test_multiple_bases(self):
2063 A = self.create_model("A")
2064 B = self.create_model("B")
2065 C = self.create_model(
2066 "C",
2067 bases=(
2068 A,
2069 B,
2070 ),
2071 )
2072 self.assertRelated(A, [B, C])
2073 self.assertRelated(B, [A, C])
2074 self.assertRelated(C, [A, B])
2075
2076 def test_multiple_nested_bases(self):
2077 A = self.create_model("A")
2078 B = self.create_model("B")
2079 C = self.create_model(
2080 "C",
2081 bases=(
2082 A,
2083 B,
2084 ),
2085 )
2086 D = self.create_model("D")
2087 E = self.create_model("E", bases=(D,))
2088 F = self.create_model(
2089 "F",
2090 bases=(
2091 C,
2092 E,
2093 ),
2094 )
2095 Y = self.create_model("Y")
2096 Z = self.create_model("Z", bases=(Y,))
2097 self.assertRelated(A, [B, C, D, E, F])
2098 self.assertRelated(B, [A, C, D, E, F])
2099 self.assertRelated(C, [A, B, D, E, F])
2100 self.assertRelated(D, [A, B, C, E, F])
2101 self.assertRelated(E, [A, B, C, D, F])
2102 self.assertRelated(F, [A, B, C, D, E])
2103 self.assertRelated(Y, [Z])
2104 self.assertRelated(Z, [Y])
2105
2106 def test_base_to_base_fk(self):
2107 A = self.create_model(
2108 "A", foreign_keys=[models.ForeignKey("Y", models.CASCADE)]
2109 )
2110 B = self.create_model("B", bases=(A,))
2111 Y = self.create_model("Y")
2112 Z = self.create_model("Z", bases=(Y,))
2113 self.assertRelated(A, [B, Y, Z])
2114 self.assertRelated(B, [A, Y, Z])
2115 self.assertRelated(Y, [A, B, Z])
2116 self.assertRelated(Z, [A, B, Y])
2117
2118 def test_base_to_subclass_fk(self):
2119 A = self.create_model(
2120 "A", foreign_keys=[models.ForeignKey("Z", models.CASCADE)]
2121 )
2122 B = self.create_model("B", bases=(A,))
2123 Y = self.create_model("Y")
2124 Z = self.create_model("Z", bases=(Y,))
2125 self.assertRelated(A, [B, Y, Z])
2126 self.assertRelated(B, [A, Y, Z])
2127 self.assertRelated(Y, [A, B, Z])
2128 self.assertRelated(Z, [A, B, Y])
2129
2130 def test_direct_m2m(self):
2131 A = self.create_model("A", foreign_keys=[models.ManyToManyField("B")])
2132 B = self.create_model("B")
2133 self.assertRelated(A, [A.a_1.rel.through, B])
2134 self.assertRelated(B, [A, A.a_1.rel.through])
2135
2136 def test_direct_m2m_self(self):
2137 A = self.create_model("A", foreign_keys=[models.ManyToManyField("A")])
2138 self.assertRelated(A, [A.a_1.rel.through])
2139
2140 def test_intermediate_m2m_self(self):
2141 A = self.create_model(
2142 "A", foreign_keys=[models.ManyToManyField("A", through="T")]
2143 )
2144 T = self.create_model(
2145 "T",
2146 foreign_keys=[
2147 models.ForeignKey("A", models.CASCADE),
2148 models.ForeignKey("A", models.CASCADE),
2149 ],
2150 )
2151 self.assertRelated(A, [T])
2152 self.assertRelated(T, [A])
2153
2154 def test_intermediate_m2m(self):
2155 A = self.create_model(
2156 "A", foreign_keys=[models.ManyToManyField("B", through="T")]
2157 )
2158 B = self.create_model("B")
2159 T = self.create_model(
2160 "T",
2161 foreign_keys=[
2162 models.ForeignKey("A", models.CASCADE),
2163 models.ForeignKey("B", models.CASCADE),
2164 ],
2165 )
2166 self.assertRelated(A, [B, T])
2167 self.assertRelated(B, [A, T])
2168 self.assertRelated(T, [A, B])
2169
2170 def test_intermediate_m2m_extern_fk(self):
2171 A = self.create_model(
2172 "A", foreign_keys=[models.ManyToManyField("B", through="T")]
2173 )
2174 B = self.create_model("B")
2175 Z = self.create_model("Z")
2176 T = self.create_model(
2177 "T",
2178 foreign_keys=[
2179 models.ForeignKey("A", models.CASCADE),
2180 models.ForeignKey("B", models.CASCADE),
2181 models.ForeignKey("Z", models.CASCADE),
2182 ],
2183 )
2184 self.assertRelated(A, [B, T, Z])
2185 self.assertRelated(B, [A, T, Z])
2186 self.assertRelated(T, [A, B, Z])
2187 self.assertRelated(Z, [A, B, T])
2188
2189 def test_intermediate_m2m_base(self):
2190 A = self.create_model(
2191 "A", foreign_keys=[models.ManyToManyField("B", through="T")]
2192 )
2193 B = self.create_model("B")
2194 S = self.create_model("S")
2195 T = self.create_model(
2196 "T",
2197 foreign_keys=[
2198 models.ForeignKey("A", models.CASCADE),
2199 models.ForeignKey("B", models.CASCADE),
2200 ],
2201 bases=(S,),
2202 )
2203 self.assertRelated(A, [B, S, T])
2204 self.assertRelated(B, [A, S, T])
2205 self.assertRelated(S, [A, B, T])
2206 self.assertRelated(T, [A, B, S])
2207
2208 def test_generic_fk(self):
2209 A = self.create_model(
2210 "A",
2211 foreign_keys=[
2212 models.ForeignKey("B", models.CASCADE),
2213 GenericForeignKey(),
2214 ],
2215 )
2216 B = self.create_model(
2217 "B",
2218 foreign_keys=[
2219 models.ForeignKey("C", models.CASCADE),
2220 ],
2221 )
2222 self.assertRelated(A, [B])
2223 self.assertRelated(B, [A])
2224
2225 def test_abstract_base(self):
2226 A = self.create_model("A", abstract=True)
2227 B = self.create_model("B", bases=(A,))
2228 self.assertRelated(A, [B])
2229 self.assertRelated(B, [])
2230
2231 def test_nested_abstract_base(self):
2232 A = self.create_model("A", abstract=True)
2233 B = self.create_model("B", bases=(A,), abstract=True)
2234 C = self.create_model("C", bases=(B,))
2235 self.assertRelated(A, [B, C])
2236 self.assertRelated(B, [C])
2237 self.assertRelated(C, [])
2238
2239 def test_proxy_base(self):
2240 A = self.create_model("A")
2241 B = self.create_model("B", bases=(A,), proxy=True)
2242 self.assertRelated(A, [B])
2243 self.assertRelated(B, [])
2244
2245 def test_nested_proxy_base(self):
2246 A = self.create_model("A")
2247 B = self.create_model("B", bases=(A,), proxy=True)
2248 C = self.create_model("C", bases=(B,), proxy=True)
2249 self.assertRelated(A, [B, C])
2250 self.assertRelated(B, [C])
2251 self.assertRelated(C, [])
2252
2253 def test_multiple_mixed_bases(self):
2254 A = self.create_model("A", abstract=True)
2255 M = self.create_model("M")
2256 P = self.create_model("P")
2257 Q = self.create_model("Q", bases=(P,), proxy=True)
2258 Z = self.create_model("Z", bases=(A, M, Q))
2259 # M has a pointer O2O field p_ptr to P
2260 self.assertRelated(A, [M, P, Q, Z])
2261 self.assertRelated(M, [P, Q, Z])
2262 self.assertRelated(P, [M, Q, Z])
2263 self.assertRelated(Q, [M, P, Z])
2264 self.assertRelated(Z, [M, P, Q])