Debian Codegraph @

tests/invalid_models_tests/test_relative_fields.py

raw
1 from unittest import mock
2
3 from django.core.checks import Error
4 from django.core.checks import Warning as DjangoWarning
5 from django.db import connection, models
6 from django.test.testcases import SimpleTestCase
7 from django.test.utils import isolate_apps, modify_settings, override_settings
8
9
10 @isolate_apps("invalid_models_tests")
11 class RelativeFieldTests(SimpleTestCase):
12 def test_valid_foreign_key_without_accessor(self):
13 class Target(models.Model):
14 # There would be a clash if Model.field installed an accessor.
15 model = models.IntegerField()
16
17 class Model(models.Model):
18 field = models.ForeignKey(Target, models.CASCADE, related_name="+")
19
20 field = Model._meta.get_field("field")
21 self.assertEqual(field.check(), [])
22
23 def test_foreign_key_to_missing_model(self):
24 # Model names are resolved when a model is being created, so we cannot
25 # test relative fields in isolation and we need to attach them to a
26 # model.
27 class Model(models.Model):
28 foreign_key = models.ForeignKey("Rel1", models.CASCADE)
29
30 field = Model._meta.get_field("foreign_key")
31 self.assertEqual(
32 field.check(),
33 [
34 Error(
35 "Field defines a relation with model 'Rel1', "
36 "which is either not installed, or is abstract.",
37 obj=field,
38 id="fields.E300",
39 ),
40 ],
41 )
42
43 @isolate_apps("invalid_models_tests")
44 def test_foreign_key_to_isolate_apps_model(self):
45 """
46 #25723 - Referenced model registration lookup should be run against the
47 field's model registry.
48 """
49
50 class OtherModel(models.Model):
51 pass
52
53 class Model(models.Model):
54 foreign_key = models.ForeignKey("OtherModel", models.CASCADE)
55
56 field = Model._meta.get_field("foreign_key")
57 self.assertEqual(field.check(from_model=Model), [])
58
59 def test_many_to_many_to_missing_model(self):
60 class Model(models.Model):
61 m2m = models.ManyToManyField("Rel2")
62
63 field = Model._meta.get_field("m2m")
64 self.assertEqual(
65 field.check(from_model=Model),
66 [
67 Error(
68 "Field defines a relation with model 'Rel2', "
69 "which is either not installed, or is abstract.",
70 obj=field,
71 id="fields.E300",
72 ),
73 ],
74 )
75
76 @isolate_apps("invalid_models_tests")
77 def test_many_to_many_to_isolate_apps_model(self):
78 """
79 #25723 - Referenced model registration lookup should be run against the
80 field's model registry.
81 """
82
83 class OtherModel(models.Model):
84 pass
85
86 class Model(models.Model):
87 m2m = models.ManyToManyField("OtherModel")
88
89 field = Model._meta.get_field("m2m")
90 self.assertEqual(field.check(from_model=Model), [])
91
92 @isolate_apps("invalid_models_tests")
93 def test_auto_created_through_model(self):
94 class OtherModel(models.Model):
95 pass
96
97 class M2MModel(models.Model):
98 many_to_many_rel = models.ManyToManyField(OtherModel)
99
100 class O2OModel(models.Model):
101 one_to_one_rel = models.OneToOneField(
102 "invalid_models_tests.M2MModel_many_to_many_rel",
103 on_delete=models.CASCADE,
104 )
105
106 field = O2OModel._meta.get_field("one_to_one_rel")
107 self.assertEqual(field.check(from_model=O2OModel), [])
108
109 def test_many_to_many_with_useless_options(self):
110 class Model(models.Model):
111 name = models.CharField(max_length=20)
112
113 class ModelM2M(models.Model):
114 m2m = models.ManyToManyField(
115 Model, null=True, validators=[lambda x: x], db_comment="Column comment"
116 )
117
118 field = ModelM2M._meta.get_field("m2m")
119 self.assertEqual(
120 ModelM2M.check(),
121 [
122 DjangoWarning(
123 "null has no effect on ManyToManyField.",
124 obj=field,
125 id="fields.W340",
126 ),
127 DjangoWarning(
128 "ManyToManyField does not support validators.",
129 obj=field,
130 id="fields.W341",
131 ),
132 DjangoWarning(
133 "db_comment has no effect on ManyToManyField.",
134 obj=field,
135 id="fields.W346",
136 ),
137 ],
138 )
139
140 def test_many_to_many_with_useless_related_name(self):
141 class ModelM2M(models.Model):
142 m2m = models.ManyToManyField("self", related_name="children")
143
144 field = ModelM2M._meta.get_field("m2m")
145 self.assertEqual(
146 ModelM2M.check(),
147 [
148 DjangoWarning(
149 "related_name has no effect on ManyToManyField with "
150 'a symmetrical relationship, e.g. to "self".',
151 obj=field,
152 id="fields.W345",
153 ),
154 ],
155 )
156
157 def test_ambiguous_relationship_model_from(self):
158 class Person(models.Model):
159 pass
160
161 class Group(models.Model):
162 field = models.ManyToManyField("Person", through="AmbiguousRelationship")
163
164 class AmbiguousRelationship(models.Model):
165 person = models.ForeignKey(Person, models.CASCADE)
166 first_group = models.ForeignKey(Group, models.CASCADE, related_name="first")
167 second_group = models.ForeignKey(
168 Group, models.CASCADE, related_name="second"
169 )
170
171 field = Group._meta.get_field("field")
172 self.assertEqual(
173 field.check(from_model=Group),
174 [
175 Error(
176 "The model is used as an intermediate model by "
177 "'invalid_models_tests.Group.field', but it has more than one "
178 "foreign key from 'Group', which is ambiguous. You must "
179 "specify which foreign key Django should use via the "
180 "through_fields keyword argument.",
181 hint=(
182 "If you want to create a recursive relationship, use "
183 'ManyToManyField("self", through="AmbiguousRelationship").'
184 ),
185 obj=field,
186 id="fields.E334",
187 ),
188 ],
189 )
190
191 def test_ambiguous_relationship_model_to(self):
192 class Person(models.Model):
193 pass
194
195 class Group(models.Model):
196 field = models.ManyToManyField(
197 "Person", through="AmbiguousRelationship", related_name="tertiary"
198 )
199
200 class AmbiguousRelationship(models.Model):
201 # Too much foreign keys to Person.
202 first_person = models.ForeignKey(
203 Person, models.CASCADE, related_name="first"
204 )
205 second_person = models.ForeignKey(
206 Person, models.CASCADE, related_name="second"
207 )
208 second_model = models.ForeignKey(Group, models.CASCADE)
209
210 field = Group._meta.get_field("field")
211 self.assertEqual(
212 field.check(from_model=Group),
213 [
214 Error(
215 "The model is used as an intermediate model by "
216 "'invalid_models_tests.Group.field', but it has more than one "
217 "foreign key to 'Person', which is ambiguous. You must specify "
218 "which foreign key Django should use via the through_fields "
219 "keyword argument.",
220 hint=(
221 "If you want to create a recursive relationship, use "
222 'ManyToManyField("self", through="AmbiguousRelationship").'
223 ),
224 obj=field,
225 id="fields.E335",
226 ),
227 ],
228 )
229
230 def test_relationship_model_with_foreign_key_to_wrong_model(self):
231 class WrongModel(models.Model):
232 pass
233
234 class Person(models.Model):
235 pass
236
237 class Group(models.Model):
238 members = models.ManyToManyField("Person", through="InvalidRelationship")
239
240 class InvalidRelationship(models.Model):
241 person = models.ForeignKey(Person, models.CASCADE)
242 wrong_foreign_key = models.ForeignKey(WrongModel, models.CASCADE)
243 # The last foreign key should point to Group model.
244
245 field = Group._meta.get_field("members")
246 self.assertEqual(
247 field.check(from_model=Group),
248 [
249 Error(
250 "The model is used as an intermediate model by "
251 "'invalid_models_tests.Group.members', but it does not "
252 "have a foreign key to 'Group' or 'Person'.",
253 obj=InvalidRelationship,
254 id="fields.E336",
255 ),
256 ],
257 )
258
259 def test_relationship_model_missing_foreign_key(self):
260 class Person(models.Model):
261 pass
262
263 class Group(models.Model):
264 members = models.ManyToManyField("Person", through="InvalidRelationship")
265
266 class InvalidRelationship(models.Model):
267 group = models.ForeignKey(Group, models.CASCADE)
268 # No foreign key to Person
269
270 field = Group._meta.get_field("members")
271 self.assertEqual(
272 field.check(from_model=Group),
273 [
274 Error(
275 "The model is used as an intermediate model by "
276 "'invalid_models_tests.Group.members', but it does not have "
277 "a foreign key to 'Group' or 'Person'.",
278 obj=InvalidRelationship,
279 id="fields.E336",
280 ),
281 ],
282 )
283
284 def test_missing_relationship_model(self):
285 class Person(models.Model):
286 pass
287
288 class Group(models.Model):
289 members = models.ManyToManyField("Person", through="MissingM2MModel")
290
291 field = Group._meta.get_field("members")
292 self.assertEqual(
293 field.check(from_model=Group),
294 [
295 Error(
296 "Field specifies a many-to-many relation through model "
297 "'MissingM2MModel', which has not been installed.",
298 obj=field,
299 id="fields.E331",
300 ),
301 ],
302 )
303
304 def test_missing_relationship_model_on_model_check(self):
305 class Person(models.Model):
306 pass
307
308 class Group(models.Model):
309 members = models.ManyToManyField("Person", through="MissingM2MModel")
310
311 self.assertEqual(
312 Group.check(),
313 [
314 Error(
315 "Field specifies a many-to-many relation through model "
316 "'MissingM2MModel', which has not been installed.",
317 obj=Group._meta.get_field("members"),
318 id="fields.E331",
319 ),
320 ],
321 )
322
323 @isolate_apps("invalid_models_tests")
324 def test_many_to_many_through_isolate_apps_model(self):
325 """
326 #25723 - Through model registration lookup should be run against the
327 field's model registry.
328 """
329
330 class GroupMember(models.Model):
331 person = models.ForeignKey("Person", models.CASCADE)
332 group = models.ForeignKey("Group", models.CASCADE)
333
334 class Person(models.Model):
335 pass
336
337 class Group(models.Model):
338 members = models.ManyToManyField("Person", through="GroupMember")
339
340 field = Group._meta.get_field("members")
341 self.assertEqual(field.check(from_model=Group), [])
342
343 def test_too_many_foreign_keys_in_self_referential_model(self):
344 class Person(models.Model):
345 friends = models.ManyToManyField(
346 "self", through="InvalidRelationship", symmetrical=False
347 )
348
349 class InvalidRelationship(models.Model):
350 first = models.ForeignKey(
351 Person, models.CASCADE, related_name="rel_from_set_2"
352 )
353 second = models.ForeignKey(
354 Person, models.CASCADE, related_name="rel_to_set_2"
355 )
356 third = models.ForeignKey(
357 Person, models.CASCADE, related_name="too_many_by_far"
358 )
359
360 field = Person._meta.get_field("friends")
361 self.assertEqual(
362 field.check(from_model=Person),
363 [
364 Error(
365 "The model is used as an intermediate model by "
366 "'invalid_models_tests.Person.friends', but it has more than two "
367 "foreign keys to 'Person', which is ambiguous. You must specify "
368 "which two foreign keys Django should use via the through_fields "
369 "keyword argument.",
370 hint=(
371 "Use through_fields to specify which two foreign keys Django "
372 "should use."
373 ),
374 obj=InvalidRelationship,
375 id="fields.E333",
376 ),
377 ],
378 )
379
380 def test_foreign_key_to_abstract_model(self):
381 class AbstractModel(models.Model):
382 class Meta:
383 abstract = True
384
385 class Model(models.Model):
386 rel_string_foreign_key = models.ForeignKey("AbstractModel", models.CASCADE)
387 rel_class_foreign_key = models.ForeignKey(AbstractModel, models.CASCADE)
388
389 fields = [
390 Model._meta.get_field("rel_string_foreign_key"),
391 Model._meta.get_field("rel_class_foreign_key"),
392 ]
393 expected_error = Error(
394 "Field defines a relation with model 'AbstractModel', "
395 "which is either not installed, or is abstract.",
396 id="fields.E300",
397 )
398 for field in fields:
399 expected_error.obj = field
400 self.assertEqual(field.check(), [expected_error])
401
402 def test_m2m_to_abstract_model(self):
403 class AbstractModel(models.Model):
404 class Meta:
405 abstract = True
406
407 class Model(models.Model):
408 rel_string_m2m = models.ManyToManyField("AbstractModel")
409 rel_class_m2m = models.ManyToManyField(AbstractModel)
410
411 fields = [
412 Model._meta.get_field("rel_string_m2m"),
413 Model._meta.get_field("rel_class_m2m"),
414 ]
415 expected_error = Error(
416 "Field defines a relation with model 'AbstractModel', "
417 "which is either not installed, or is abstract.",
418 id="fields.E300",
419 )
420 for field in fields:
421 expected_error.obj = field
422 self.assertEqual(field.check(from_model=Model), [expected_error])
423
424 def test_unique_m2m(self):
425 class Person(models.Model):
426 name = models.CharField(max_length=5)
427
428 class Group(models.Model):
429 members = models.ManyToManyField("Person", unique=True)
430
431 field = Group._meta.get_field("members")
432 self.assertEqual(
433 field.check(from_model=Group),
434 [
435 Error(
436 "ManyToManyFields cannot be unique.",
437 obj=field,
438 id="fields.E330",
439 ),
440 ],
441 )
442
443 def test_foreignkey_to_model_with_composite_primary_key(self):
444 class Parent(models.Model):
445 pk = models.CompositePrimaryKey("version", "name")
446 version = models.IntegerField()
447 name = models.CharField(max_length=20)
448
449 class Child(models.Model):
450 rel_class_parent = models.ForeignKey(
451 Parent, on_delete=models.CASCADE, related_name="child_class_set"
452 )
453 rel_string_parent = models.ForeignKey(
454 "Parent", on_delete=models.CASCADE, related_name="child_string_set"
455 )
456
457 error = (
458 "Field defines a relation involving model 'Parent' which has a "
459 "CompositePrimaryKey and such relations are not supported."
460 )
461 field = Child._meta.get_field("rel_string_parent")
462 self.assertEqual(
463 field.check(),
464 [Error(error, obj=field, id="fields.E347")],
465 )
466 field = Child._meta.get_field("rel_class_parent")
467 self.assertEqual(
468 field.check(),
469 [Error(error, obj=field, id="fields.E347")],
470 )
471
472 def test_many_to_many_to_model_with_composite_primary_key(self):
473 class Parent(models.Model):
474 pk = models.CompositePrimaryKey("version", "name")
475 version = models.IntegerField()
476 name = models.CharField(max_length=20)
477
478 class Child(models.Model):
479 rel_class_parent = models.ManyToManyField(
480 Parent, related_name="child_class_set"
481 )
482 rel_string_parent = models.ManyToManyField(
483 "Parent", related_name="child_string_set"
484 )
485
486 error = (
487 "Field defines a relation involving model 'Parent' which has a "
488 "CompositePrimaryKey and such relations are not supported."
489 )
490 field = Child._meta.get_field("rel_string_parent")
491 self.assertEqual(
492 field.check(from_model=Child),
493 [Error(error, obj=field, id="fields.E347")],
494 )
495 field = Child._meta.get_field("rel_class_parent")
496 self.assertEqual(
497 field.check(from_model=Child),
498 [Error(error, obj=field, id="fields.E347")],
499 )
500
501 def test_many_to_many_from_model_with_composite_primary_key(self):
502 class Parent(models.Model):
503 name = models.CharField(max_length=20)
504
505 class Meta:
506 app_label = "invalid_models_tests"
507
508 class Child(models.Model):
509 pk = models.CompositePrimaryKey("version", "name")
510 version = models.IntegerField()
511 name = models.CharField(max_length=20)
512 parents = models.ManyToManyField(Parent)
513
514 class Meta:
515 app_label = "invalid_models_tests"
516
517 error = (
518 "Field defines a relation involving model 'Child' which has a "
519 "CompositePrimaryKey and such relations are not supported."
520 )
521 field = Child._meta.get_field("parents")
522 self.assertEqual(
523 field.check(from_model=Child),
524 [Error(error, obj=field, id="fields.E347")],
525 )
526
527 def test_foreign_key_to_non_unique_field(self):
528 class Target(models.Model):
529 bad = models.IntegerField() # No unique=True
530
531 class Model(models.Model):
532 foreign_key = models.ForeignKey("Target", models.CASCADE, to_field="bad")
533
534 field = Model._meta.get_field("foreign_key")
535 self.assertEqual(
536 field.check(),
537 [
538 Error(
539 "'Target.bad' must be unique because it is referenced by a foreign "
540 "key.",
541 hint=(
542 "Add unique=True to this field or add a UniqueConstraint "
543 "(without condition) in the model Meta.constraints."
544 ),
545 obj=field,
546 id="fields.E311",
547 ),
548 ],
549 )
550
551 def test_foreign_key_to_non_unique_field_under_explicit_model(self):
552 class Target(models.Model):
553 bad = models.IntegerField()
554
555 class Model(models.Model):
556 field = models.ForeignKey(Target, models.CASCADE, to_field="bad")
557
558 field = Model._meta.get_field("field")
559 self.assertEqual(
560 field.check(),
561 [
562 Error(
563 "'Target.bad' must be unique because it is referenced by a foreign "
564 "key.",
565 hint=(
566 "Add unique=True to this field or add a UniqueConstraint "
567 "(without condition) in the model Meta.constraints."
568 ),
569 obj=field,
570 id="fields.E311",
571 ),
572 ],
573 )
574
575 def test_foreign_key_to_partially_unique_field(self):
576 class Target(models.Model):
577 source = models.IntegerField()
578
579 class Meta:
580 constraints = [
581 models.UniqueConstraint(
582 fields=["source"],
583 name="tfktpuf_partial_unique",
584 condition=models.Q(pk__gt=2),
585 ),
586 ]
587
588 class Model(models.Model):
589 field = models.ForeignKey(Target, models.CASCADE, to_field="source")
590
591 field = Model._meta.get_field("field")
592 self.assertEqual(
593 field.check(),
594 [
595 Error(
596 "'Target.source' must be unique because it is referenced by a "
597 "foreign key.",
598 hint=(
599 "Add unique=True to this field or add a UniqueConstraint "
600 "(without condition) in the model Meta.constraints."
601 ),
602 obj=field,
603 id="fields.E311",
604 ),
605 ],
606 )
607
608 def test_foreign_key_to_unique_field_with_meta_constraint(self):
609 class Target(models.Model):
610 source = models.IntegerField()
611
612 class Meta:
613 constraints = [
614 models.UniqueConstraint(
615 fields=["source"],
616 name="tfktufwmc_unique",
617 ),
618 ]
619
620 class Model(models.Model):
621 field = models.ForeignKey(Target, models.CASCADE, to_field="source")
622
623 field = Model._meta.get_field("field")
624 self.assertEqual(field.check(), [])
625
626 def test_foreign_object_to_non_unique_fields(self):
627 class Person(models.Model):
628 # Note that both fields are not unique.
629 country_id = models.IntegerField()
630 city_id = models.IntegerField()
631
632 class MMembership(models.Model):
633 person_country_id = models.IntegerField()
634 person_city_id = models.IntegerField()
635
636 person = models.ForeignObject(
637 Person,
638 on_delete=models.CASCADE,
639 from_fields=["person_country_id", "person_city_id"],
640 to_fields=["country_id", "city_id"],
641 )
642
643 field = MMembership._meta.get_field("person")
644 self.assertEqual(
645 field.check(),
646 [
647 Error(
648 "No subset of the fields 'country_id', 'city_id' on model 'Person' "
649 "is unique.",
650 hint=(
651 "Mark a single field as unique=True or add a set of "
652 "fields to a unique constraint (via unique_together or a "
653 "UniqueConstraint (without condition) in the model "
654 "Meta.constraints)."
655 ),
656 obj=field,
657 id="fields.E310",
658 )
659 ],
660 )
661
662 def test_foreign_object_to_partially_unique_field(self):
663 class Person(models.Model):
664 country_id = models.IntegerField()
665 city_id = models.IntegerField()
666
667 class Meta:
668 constraints = [
669 models.UniqueConstraint(
670 fields=["country_id", "city_id"],
671 name="tfotpuf_partial_unique",
672 condition=models.Q(pk__gt=2),
673 ),
674 ]
675
676 class MMembership(models.Model):
677 person_country_id = models.IntegerField()
678 person_city_id = models.IntegerField()
679 person = models.ForeignObject(
680 Person,
681 on_delete=models.CASCADE,
682 from_fields=["person_country_id", "person_city_id"],
683 to_fields=["country_id", "city_id"],
684 )
685
686 field = MMembership._meta.get_field("person")
687 self.assertEqual(
688 field.check(),
689 [
690 Error(
691 "No subset of the fields 'country_id', 'city_id' on model "
692 "'Person' is unique.",
693 hint=(
694 "Mark a single field as unique=True or add a set of "
695 "fields to a unique constraint (via unique_together or a "
696 "UniqueConstraint (without condition) in the model "
697 "Meta.constraints)."
698 ),
699 obj=field,
700 id="fields.E310",
701 ),
702 ],
703 )
704
705 def test_foreign_object_to_unique_field_with_meta_constraint(self):
706 class Person(models.Model):
707 country_id = models.IntegerField()
708 city_id = models.IntegerField()
709
710 class Meta:
711 constraints = [
712 models.UniqueConstraint(
713 fields=["country_id", "city_id"],
714 name="tfotpuf_unique",
715 ),
716 ]
717
718 class MMembership(models.Model):
719 person_country_id = models.IntegerField()
720 person_city_id = models.IntegerField()
721 person = models.ForeignObject(
722 Person,
723 on_delete=models.CASCADE,
724 from_fields=["person_country_id", "person_city_id"],
725 to_fields=["country_id", "city_id"],
726 )
727
728 field = MMembership._meta.get_field("person")
729 self.assertEqual(field.check(), [])
730
731 def test_on_delete_set_null_on_non_nullable_field(self):
732 class Person(models.Model):
733 pass
734
735 class Model(models.Model):
736 foreign_key = models.ForeignKey("Person", models.SET_NULL)
737
738 field = Model._meta.get_field("foreign_key")
739 self.assertEqual(
740 field.check(),
741 [
742 Error(
743 "Field specifies on_delete=SET_NULL, but cannot be null.",
744 hint=(
745 "Set null=True argument on the field, or change the on_delete "
746 "rule."
747 ),
748 obj=field,
749 id="fields.E320",
750 ),
751 ],
752 )
753
754 def test_on_delete_set_default_without_default_value(self):
755 class Person(models.Model):
756 pass
757
758 class Model(models.Model):
759 foreign_key = models.ForeignKey("Person", models.SET_DEFAULT)
760
761 field = Model._meta.get_field("foreign_key")
762 self.assertEqual(
763 field.check(),
764 [
765 Error(
766 "Field specifies on_delete=SET_DEFAULT, but has no default value.",
767 hint="Set a default value, or change the on_delete rule.",
768 obj=field,
769 id="fields.E321",
770 ),
771 ],
772 )
773
774 def test_nullable_primary_key(self):
775 class Model(models.Model):
776 field = models.IntegerField(primary_key=True, null=True)
777
778 field = Model._meta.get_field("field")
779 with mock.patch.object(
780 connection.features, "interprets_empty_strings_as_nulls", False
781 ):
782 results = field.check()
783 self.assertEqual(
784 results,
785 [
786 Error(
787 "Primary keys must not have null=True.",
788 hint=(
789 "Set null=False on the field, or remove primary_key=True "
790 "argument."
791 ),
792 obj=field,
793 id="fields.E007",
794 ),
795 ],
796 )
797
798 def test_not_swapped_model(self):
799 class SwappableModel(models.Model):
800 # A model that can be, but isn't swapped out. References to this
801 # model should *not* raise any validation error.
802 class Meta:
803 swappable = "TEST_SWAPPABLE_MODEL"
804
805 class Model(models.Model):
806 explicit_fk = models.ForeignKey(
807 SwappableModel,
808 models.CASCADE,
809 related_name="explicit_fk",
810 )
811 implicit_fk = models.ForeignKey(
812 "invalid_models_tests.SwappableModel",
813 models.CASCADE,
814 related_name="implicit_fk",
815 )
816 explicit_m2m = models.ManyToManyField(
817 SwappableModel, related_name="explicit_m2m"
818 )
819 implicit_m2m = models.ManyToManyField(
820 "invalid_models_tests.SwappableModel",
821 related_name="implicit_m2m",
822 )
823
824 explicit_fk = Model._meta.get_field("explicit_fk")
825 self.assertEqual(explicit_fk.check(), [])
826
827 implicit_fk = Model._meta.get_field("implicit_fk")
828 self.assertEqual(implicit_fk.check(), [])
829
830 explicit_m2m = Model._meta.get_field("explicit_m2m")
831 self.assertEqual(explicit_m2m.check(from_model=Model), [])
832
833 implicit_m2m = Model._meta.get_field("implicit_m2m")
834 self.assertEqual(implicit_m2m.check(from_model=Model), [])
835
836 @override_settings(TEST_SWAPPED_MODEL="invalid_models_tests.Replacement")
837 def test_referencing_to_swapped_model(self):
838 class Replacement(models.Model):
839 pass
840
841 class SwappedModel(models.Model):
842 class Meta:
843 swappable = "TEST_SWAPPED_MODEL"
844
845 class Model(models.Model):
846 explicit_fk = models.ForeignKey(
847 SwappedModel,
848 models.CASCADE,
849 related_name="explicit_fk",
850 )
851 implicit_fk = models.ForeignKey(
852 "invalid_models_tests.SwappedModel",
853 models.CASCADE,
854 related_name="implicit_fk",
855 )
856 explicit_m2m = models.ManyToManyField(
857 SwappedModel, related_name="explicit_m2m"
858 )
859 implicit_m2m = models.ManyToManyField(
860 "invalid_models_tests.SwappedModel",
861 related_name="implicit_m2m",
862 )
863
864 fields = [
865 Model._meta.get_field("explicit_fk"),
866 Model._meta.get_field("implicit_fk"),
867 Model._meta.get_field("explicit_m2m"),
868 Model._meta.get_field("implicit_m2m"),
869 ]
870
871 expected_error = Error(
872 (
873 "Field defines a relation with the model "
874 "'invalid_models_tests.SwappedModel', which has been swapped out."
875 ),
876 hint="Update the relation to point at 'settings.TEST_SWAPPED_MODEL'.",
877 id="fields.E301",
878 )
879
880 for field in fields:
881 expected_error.obj = field
882 self.assertEqual(field.check(from_model=Model), [expected_error])
883
884 def test_related_field_has_invalid_related_name(self):
885 digit = 0
886 illegal_non_alphanumeric = "!"
887 whitespace = "\t"
888
889 invalid_related_names = [
890 "%s_begins_with_digit" % digit,
891 "%s_begins_with_illegal_non_alphanumeric" % illegal_non_alphanumeric,
892 "%s_begins_with_whitespace" % whitespace,
893 "contains_%s_illegal_non_alphanumeric" % illegal_non_alphanumeric,
894 "contains_%s_whitespace" % whitespace,
895 "ends_with_with_illegal_non_alphanumeric_%s" % illegal_non_alphanumeric,
896 "ends_with_whitespace_%s" % whitespace,
897 "with", # a Python keyword
898 "related_name\n",
899 "",
900 ",", # non-ASCII
901 ]
902
903 class Parent(models.Model):
904 pass
905
906 for invalid_related_name in invalid_related_names:
907 Child = type(
908 "Child%s" % invalid_related_name,
909 (models.Model,),
910 {
911 "parent": models.ForeignKey(
912 "Parent", models.CASCADE, related_name=invalid_related_name
913 ),
914 "__module__": Parent.__module__,
915 },
916 )
917
918 field = Child._meta.get_field("parent")
919 self.assertEqual(
920 Child.check(),
921 [
922 Error(
923 "The name '%s' is invalid related_name for field Child%s.parent"
924 % (invalid_related_name, invalid_related_name),
925 hint=(
926 "Related name must be a valid Python identifier or end "
927 "with a '+'"
928 ),
929 obj=field,
930 id="fields.E306",
931 ),
932 ],
933 )
934
935 def test_related_field_has_valid_related_name(self):
936 lowercase = "a"
937 uppercase = "A"
938 digit = 0
939
940 related_names = [
941 "%s_starts_with_lowercase" % lowercase,
942 "%s_tarts_with_uppercase" % uppercase,
943 "_starts_with_underscore",
944 "contains_%s_digit" % digit,
945 "ends_with_plus+",
946 "_+",
947 "+",
948 "試",
949 "試驗+",
950 ]
951
952 class Parent(models.Model):
953 pass
954
955 for related_name in related_names:
956 Child = type(
957 "Child%s" % related_name,
958 (models.Model,),
959 {
960 "parent": models.ForeignKey(
961 "Parent", models.CASCADE, related_name=related_name
962 ),
963 "__module__": Parent.__module__,
964 },
965 )
966 self.assertEqual(Child.check(), [])
967
968 def test_to_fields_exist(self):
969 class Parent(models.Model):
970 pass
971
972 class Child(models.Model):
973 a = models.PositiveIntegerField()
974 b = models.PositiveIntegerField()
975 parent = models.ForeignObject(
976 Parent,
977 on_delete=models.SET_NULL,
978 from_fields=("a", "b"),
979 to_fields=("a", "b"),
980 )
981
982 field = Child._meta.get_field("parent")
983 self.assertEqual(
984 field.check(),
985 [
986 Error(
987 "The to_field 'a' doesn't exist on the related model "
988 "'invalid_models_tests.Parent'.",
989 obj=field,
990 id="fields.E312",
991 ),
992 Error(
993 "The to_field 'b' doesn't exist on the related model "
994 "'invalid_models_tests.Parent'.",
995 obj=field,
996 id="fields.E312",
997 ),
998 ],
999 )
1000
1001 def test_to_fields_not_checked_if_related_model_doesnt_exist(self):
1002 class Child(models.Model):
1003 a = models.PositiveIntegerField()
1004 b = models.PositiveIntegerField()
1005 parent = models.ForeignObject(
1006 "invalid_models_tests.Parent",
1007 on_delete=models.SET_NULL,
1008 from_fields=("a", "b"),
1009 to_fields=("a", "b"),
1010 )
1011
1012 field = Child._meta.get_field("parent")
1013 self.assertEqual(
1014 field.check(),
1015 [
1016 Error(
1017 "Field defines a relation with model "
1018 "'invalid_models_tests.Parent', which is either not installed, or "
1019 "is abstract.",
1020 id="fields.E300",
1021 obj=field,
1022 ),
1023 ],
1024 )
1025
1026 def test_to_fields_with_composite_primary_key(self):
1027 class Parent(models.Model):
1028 pk = models.CompositePrimaryKey("version", "name")
1029 version = models.IntegerField()
1030 name = models.CharField(max_length=20)
1031
1032 class Child(models.Model):
1033 a = models.IntegerField()
1034 b = models.IntegerField()
1035 parent = models.ForeignObject(
1036 Parent,
1037 on_delete=models.SET_NULL,
1038 from_fields=("a", "b"),
1039 to_fields=("pk", "version"),
1040 )
1041
1042 field = Child._meta.get_field("parent")
1043 self.assertEqual(
1044 field.check(),
1045 [
1046 Error(
1047 "Field defines a relation involving model 'Parent' which has a "
1048 "CompositePrimaryKey and such relations are not supported.",
1049 obj=field,
1050 id="fields.E347",
1051 ),
1052 ],
1053 )
1054
1055 def test_to_field_to_composite_primery_key(self):
1056 class Parent(models.Model):
1057 pk = models.CompositePrimaryKey("version", "name")
1058 version = models.IntegerField()
1059 name = models.CharField(max_length=20)
1060
1061 class Child(models.Model):
1062 parent = models.ForeignKey(Parent, on_delete=models.CASCADE, to_field="pk")
1063
1064 field = Child._meta.get_field("parent")
1065 self.assertEqual(
1066 field.check(),
1067 [
1068 Error(
1069 "Field defines a relation involving model 'Parent' which has a "
1070 "CompositePrimaryKey and such relations are not supported.",
1071 obj=field,
1072 id="fields.E347",
1073 ),
1074 ],
1075 )
1076
1077 def test_invalid_related_query_name(self):
1078 class Target(models.Model):
1079 pass
1080
1081 class Model(models.Model):
1082 first = models.ForeignKey(
1083 Target, models.CASCADE, related_name="contains__double"
1084 )
1085 second = models.ForeignKey(
1086 Target, models.CASCADE, related_query_name="ends_underscore_"
1087 )
1088
1089 self.assertEqual(
1090 Model.check(),
1091 [
1092 Error(
1093 "Reverse query name 'contains__double' must not contain '__'.",
1094 hint=(
1095 "Add or change a related_name or related_query_name "
1096 "argument for this field."
1097 ),
1098 obj=Model._meta.get_field("first"),
1099 id="fields.E309",
1100 ),
1101 Error(
1102 "Reverse query name 'ends_underscore_' must not end with an "
1103 "underscore.",
1104 hint=(
1105 "Add or change a related_name or related_query_name "
1106 "argument for this field."
1107 ),
1108 obj=Model._meta.get_field("second"),
1109 id="fields.E308",
1110 ),
1111 ],
1112 )
1113
1114
1115 @isolate_apps("invalid_models_tests")
1116 class AccessorClashTests(SimpleTestCase):
1117 def test_fk_to_integer(self):
1118 self._test_accessor_clash(
1119 target=models.IntegerField(),
1120 relative=models.ForeignKey("Target", models.CASCADE),
1121 )
1122
1123 def test_fk_to_fk(self):
1124 self._test_accessor_clash(
1125 target=models.ForeignKey("Another", models.CASCADE),
1126 relative=models.ForeignKey("Target", models.CASCADE),
1127 )
1128
1129 def test_fk_to_m2m(self):
1130 self._test_accessor_clash(
1131 target=models.ManyToManyField("Another"),
1132 relative=models.ForeignKey("Target", models.CASCADE),
1133 )
1134
1135 def test_m2m_to_integer(self):
1136 self._test_accessor_clash(
1137 target=models.IntegerField(), relative=models.ManyToManyField("Target")
1138 )
1139
1140 def test_m2m_to_fk(self):
1141 self._test_accessor_clash(
1142 target=models.ForeignKey("Another", models.CASCADE),
1143 relative=models.ManyToManyField("Target"),
1144 )
1145
1146 def test_m2m_to_m2m(self):
1147 self._test_accessor_clash(
1148 target=models.ManyToManyField("Another"),
1149 relative=models.ManyToManyField("Target"),
1150 )
1151
1152 def _test_accessor_clash(self, target, relative):
1153 class Another(models.Model):
1154 pass
1155
1156 class Target(models.Model):
1157 model_set = target
1158
1159 class Model(models.Model):
1160 rel = relative
1161
1162 self.assertEqual(
1163 Model.check(),
1164 [
1165 Error(
1166 "Reverse accessor 'Target.model_set' for "
1167 "'invalid_models_tests.Model.rel' clashes with field name "
1168 "'invalid_models_tests.Target.model_set'.",
1169 hint=(
1170 "Rename field 'invalid_models_tests.Target.model_set', or "
1171 "add/change a related_name argument to the definition for "
1172 "field 'invalid_models_tests.Model.rel'."
1173 ),
1174 obj=Model._meta.get_field("rel"),
1175 id="fields.E302",
1176 ),
1177 ],
1178 )
1179
1180 def test_clash_between_accessors(self):
1181 class Target(models.Model):
1182 pass
1183
1184 class Model(models.Model):
1185 foreign = models.ForeignKey(Target, models.CASCADE)
1186 m2m = models.ManyToManyField(Target)
1187
1188 self.assertEqual(
1189 Model.check(),
1190 [
1191 Error(
1192 "Reverse accessor 'Target.model_set' for "
1193 "'invalid_models_tests.Model.foreign' clashes with reverse "
1194 "accessor for 'invalid_models_tests.Model.m2m'.",
1195 hint=(
1196 "Add or change a related_name argument to the definition "
1197 "for 'invalid_models_tests.Model.foreign' or "
1198 "'invalid_models_tests.Model.m2m'."
1199 ),
1200 obj=Model._meta.get_field("foreign"),
1201 id="fields.E304",
1202 ),
1203 Error(
1204 "Reverse accessor 'Target.model_set' for "
1205 "'invalid_models_tests.Model.m2m' clashes with reverse "
1206 "accessor for 'invalid_models_tests.Model.foreign'.",
1207 hint=(
1208 "Add or change a related_name argument to the definition "
1209 "for 'invalid_models_tests.Model.m2m' or "
1210 "'invalid_models_tests.Model.foreign'."
1211 ),
1212 obj=Model._meta.get_field("m2m"),
1213 id="fields.E304",
1214 ),
1215 ],
1216 )
1217
1218 def test_m2m_to_m2m_with_inheritance(self):
1219 """Ref #22047."""
1220
1221 class Target(models.Model):
1222 pass
1223
1224 class Model(models.Model):
1225 children = models.ManyToManyField(
1226 "Child", related_name="m2m_clash", related_query_name="no_clash"
1227 )
1228
1229 class Parent(models.Model):
1230 m2m_clash = models.ManyToManyField("Target")
1231
1232 class Child(Parent):
1233 pass
1234
1235 self.assertEqual(
1236 Model.check(),
1237 [
1238 Error(
1239 "Reverse accessor 'Child.m2m_clash' for "
1240 "'invalid_models_tests.Model.children' clashes with field "
1241 "name 'invalid_models_tests.Child.m2m_clash'.",
1242 hint=(
1243 "Rename field 'invalid_models_tests.Child.m2m_clash', or "
1244 "add/change a related_name argument to the definition for "
1245 "field 'invalid_models_tests.Model.children'."
1246 ),
1247 obj=Model._meta.get_field("children"),
1248 id="fields.E302",
1249 )
1250 ],
1251 )
1252
1253 def test_no_clash_for_hidden_related_name(self):
1254 class Stub(models.Model):
1255 pass
1256
1257 class ManyToManyRel(models.Model):
1258 thing1 = models.ManyToManyField(Stub, related_name="+")
1259 thing2 = models.ManyToManyField(Stub, related_name="+")
1260
1261 class FKRel(models.Model):
1262 thing1 = models.ForeignKey(Stub, models.CASCADE, related_name="+")
1263 thing2 = models.ForeignKey(Stub, models.CASCADE, related_name="+")
1264
1265 self.assertEqual(ManyToManyRel.check(), [])
1266 self.assertEqual(FKRel.check(), [])
1267
1268
1269 @isolate_apps("invalid_models_tests")
1270 class ReverseQueryNameClashTests(SimpleTestCase):
1271 def test_fk_to_integer(self):
1272 self._test_reverse_query_name_clash(
1273 target=models.IntegerField(),
1274 relative=models.ForeignKey("Target", models.CASCADE),
1275 )
1276
1277 def test_fk_to_fk(self):
1278 self._test_reverse_query_name_clash(
1279 target=models.ForeignKey("Another", models.CASCADE),
1280 relative=models.ForeignKey("Target", models.CASCADE),
1281 )
1282
1283 def test_fk_to_m2m(self):
1284 self._test_reverse_query_name_clash(
1285 target=models.ManyToManyField("Another"),
1286 relative=models.ForeignKey("Target", models.CASCADE),
1287 )
1288
1289 def test_m2m_to_integer(self):
1290 self._test_reverse_query_name_clash(
1291 target=models.IntegerField(), relative=models.ManyToManyField("Target")
1292 )
1293
1294 def test_m2m_to_fk(self):
1295 self._test_reverse_query_name_clash(
1296 target=models.ForeignKey("Another", models.CASCADE),
1297 relative=models.ManyToManyField("Target"),
1298 )
1299
1300 def test_m2m_to_m2m(self):
1301 self._test_reverse_query_name_clash(
1302 target=models.ManyToManyField("Another"),
1303 relative=models.ManyToManyField("Target"),
1304 )
1305
1306 def _test_reverse_query_name_clash(self, target, relative):
1307 class Another(models.Model):
1308 pass
1309
1310 class Target(models.Model):
1311 model = target
1312
1313 class Model(models.Model):
1314 rel = relative
1315
1316 self.assertEqual(
1317 Model.check(),
1318 [
1319 Error(
1320 "Reverse query name for 'invalid_models_tests.Model.rel' "
1321 "clashes with field name 'invalid_models_tests.Target.model'.",
1322 hint=(
1323 "Rename field 'invalid_models_tests.Target.model', or "
1324 "add/change a related_name argument to the definition for "
1325 "field 'invalid_models_tests.Model.rel'."
1326 ),
1327 obj=Model._meta.get_field("rel"),
1328 id="fields.E303",
1329 ),
1330 ],
1331 )
1332
1333 @modify_settings(INSTALLED_APPS={"append": "basic"})
1334 @isolate_apps("basic", "invalid_models_tests")
1335 def test_no_clash_across_apps_without_accessor(self):
1336 class Target(models.Model):
1337 class Meta:
1338 app_label = "invalid_models_tests"
1339
1340 class Model(models.Model):
1341 m2m = models.ManyToManyField(Target, related_name="+")
1342
1343 class Meta:
1344 app_label = "basic"
1345
1346 def _test():
1347 # Define model with the same name.
1348 class Model(models.Model):
1349 m2m = models.ManyToManyField(Target, related_name="+")
1350
1351 class Meta:
1352 app_label = "invalid_models_tests"
1353
1354 self.assertEqual(Model.check(), [])
1355
1356 _test()
1357 self.assertEqual(Model.check(), [])
1358
1359
1360 @isolate_apps("invalid_models_tests")
1361 class ExplicitRelatedNameClashTests(SimpleTestCase):
1362 def test_fk_to_integer(self):
1363 self._test_explicit_related_name_clash(
1364 target=models.IntegerField(),
1365 relative=models.ForeignKey("Target", models.CASCADE, related_name="clash"),
1366 )
1367
1368 def test_fk_to_fk(self):
1369 self._test_explicit_related_name_clash(
1370 target=models.ForeignKey("Another", models.CASCADE),
1371 relative=models.ForeignKey("Target", models.CASCADE, related_name="clash"),
1372 )
1373
1374 def test_fk_to_m2m(self):
1375 self._test_explicit_related_name_clash(
1376 target=models.ManyToManyField("Another"),
1377 relative=models.ForeignKey("Target", models.CASCADE, related_name="clash"),
1378 )
1379
1380 def test_m2m_to_integer(self):
1381 self._test_explicit_related_name_clash(
1382 target=models.IntegerField(),
1383 relative=models.ManyToManyField("Target", related_name="clash"),
1384 )
1385
1386 def test_m2m_to_fk(self):
1387 self._test_explicit_related_name_clash(
1388 target=models.ForeignKey("Another", models.CASCADE),
1389 relative=models.ManyToManyField("Target", related_name="clash"),
1390 )
1391
1392 def test_m2m_to_m2m(self):
1393 self._test_explicit_related_name_clash(
1394 target=models.ManyToManyField("Another"),
1395 relative=models.ManyToManyField("Target", related_name="clash"),
1396 )
1397
1398 def _test_explicit_related_name_clash(self, target, relative):
1399 class Another(models.Model):
1400 pass
1401
1402 class Target(models.Model):
1403 clash = target
1404
1405 class Model(models.Model):
1406 rel = relative
1407
1408 self.assertEqual(
1409 Model.check(),
1410 [
1411 Error(
1412 "Reverse accessor 'Target.clash' for "
1413 "'invalid_models_tests.Model.rel' clashes with field name "
1414 "'invalid_models_tests.Target.clash'.",
1415 hint=(
1416 "Rename field 'invalid_models_tests.Target.clash', or "
1417 "add/change a related_name argument to the definition for "
1418 "field 'invalid_models_tests.Model.rel'."
1419 ),
1420 obj=Model._meta.get_field("rel"),
1421 id="fields.E302",
1422 ),
1423 Error(
1424 "Reverse query name for 'invalid_models_tests.Model.rel' "
1425 "clashes with field name 'invalid_models_tests.Target.clash'.",
1426 hint=(
1427 "Rename field 'invalid_models_tests.Target.clash', or "
1428 "add/change a related_name argument to the definition for "
1429 "field 'invalid_models_tests.Model.rel'."
1430 ),
1431 obj=Model._meta.get_field("rel"),
1432 id="fields.E303",
1433 ),
1434 ],
1435 )
1436
1437
1438 @isolate_apps("invalid_models_tests")
1439 class ExplicitRelatedQueryNameClashTests(SimpleTestCase):
1440 def test_fk_to_integer(self, related_name=None):
1441 self._test_explicit_related_query_name_clash(
1442 target=models.IntegerField(),
1443 relative=models.ForeignKey(
1444 "Target",
1445 models.CASCADE,
1446 related_name=related_name,
1447 related_query_name="clash",
1448 ),
1449 )
1450
1451 def test_hidden_fk_to_integer(self, related_name=None):
1452 self.test_fk_to_integer(related_name="+")
1453
1454 def test_fk_to_fk(self, related_name=None):
1455 self._test_explicit_related_query_name_clash(
1456 target=models.ForeignKey("Another", models.CASCADE),
1457 relative=models.ForeignKey(
1458 "Target",
1459 models.CASCADE,
1460 related_name=related_name,
1461 related_query_name="clash",
1462 ),
1463 )
1464
1465 def test_hidden_fk_to_fk(self):
1466 self.test_fk_to_fk(related_name="+")
1467
1468 def test_fk_to_m2m(self, related_name=None):
1469 self._test_explicit_related_query_name_clash(
1470 target=models.ManyToManyField("Another"),
1471 relative=models.ForeignKey(
1472 "Target",
1473 models.CASCADE,
1474 related_name=related_name,
1475 related_query_name="clash",
1476 ),
1477 )
1478
1479 def test_hidden_fk_to_m2m(self):
1480 self.test_fk_to_m2m(related_name="+")
1481
1482 def test_m2m_to_integer(self, related_name=None):
1483 self._test_explicit_related_query_name_clash(
1484 target=models.IntegerField(),
1485 relative=models.ManyToManyField(
1486 "Target", related_name=related_name, related_query_name="clash"
1487 ),
1488 )
1489
1490 def test_hidden_m2m_to_integer(self):
1491 self.test_m2m_to_integer(related_name="+")
1492
1493 def test_m2m_to_fk(self, related_name=None):
1494 self._test_explicit_related_query_name_clash(
1495 target=models.ForeignKey("Another", models.CASCADE),
1496 relative=models.ManyToManyField(
1497 "Target", related_name=related_name, related_query_name="clash"
1498 ),
1499 )
1500
1501 def test_hidden_m2m_to_fk(self):
1502 self.test_m2m_to_fk(related_name="+")
1503
1504 def test_m2m_to_m2m(self, related_name=None):
1505 self._test_explicit_related_query_name_clash(
1506 target=models.ManyToManyField("Another"),
1507 relative=models.ManyToManyField(
1508 "Target",
1509 related_name=related_name,
1510 related_query_name="clash",
1511 ),
1512 )
1513
1514 def test_hidden_m2m_to_m2m(self):
1515 self.test_m2m_to_m2m(related_name="+")
1516
1517 def _test_explicit_related_query_name_clash(self, target, relative):
1518 class Another(models.Model):
1519 pass
1520
1521 class Target(models.Model):
1522 clash = target
1523
1524 class Model(models.Model):
1525 rel = relative
1526
1527 self.assertEqual(
1528 Model.check(),
1529 [
1530 Error(
1531 "Reverse query name for 'invalid_models_tests.Model.rel' "
1532 "clashes with field name 'invalid_models_tests.Target.clash'.",
1533 hint=(
1534 "Rename field 'invalid_models_tests.Target.clash', or "
1535 "add/change a related_name argument to the definition for "
1536 "field 'invalid_models_tests.Model.rel'."
1537 ),
1538 obj=Model._meta.get_field("rel"),
1539 id="fields.E303",
1540 ),
1541 ],
1542 )
1543
1544
1545 @isolate_apps("invalid_models_tests")
1546 class SelfReferentialM2MClashTests(SimpleTestCase):
1547 def test_clash_between_accessors(self):
1548 class Model(models.Model):
1549 first_m2m = models.ManyToManyField("self", symmetrical=False)
1550 second_m2m = models.ManyToManyField("self", symmetrical=False)
1551
1552 self.assertEqual(
1553 Model.check(),
1554 [
1555 Error(
1556 "Reverse accessor 'Model.model_set' for "
1557 "'invalid_models_tests.Model.first_m2m' clashes with reverse "
1558 "accessor for 'invalid_models_tests.Model.second_m2m'.",
1559 hint=(
1560 "Add or change a related_name argument to the definition "
1561 "for 'invalid_models_tests.Model.first_m2m' or "
1562 "'invalid_models_tests.Model.second_m2m'."
1563 ),
1564 obj=Model._meta.get_field("first_m2m"),
1565 id="fields.E304",
1566 ),
1567 Error(
1568 "Reverse accessor 'Model.model_set' for "
1569 "'invalid_models_tests.Model.second_m2m' clashes with reverse "
1570 "accessor for 'invalid_models_tests.Model.first_m2m'.",
1571 hint=(
1572 "Add or change a related_name argument to the definition "
1573 "for 'invalid_models_tests.Model.second_m2m' or "
1574 "'invalid_models_tests.Model.first_m2m'."
1575 ),
1576 obj=Model._meta.get_field("second_m2m"),
1577 id="fields.E304",
1578 ),
1579 ],
1580 )
1581
1582 def test_accessor_clash(self):
1583 class Model(models.Model):
1584 model_set = models.ManyToManyField("self", symmetrical=False)
1585
1586 self.assertEqual(
1587 Model.check(),
1588 [
1589 Error(
1590 "Reverse accessor 'Model.model_set' for "
1591 "'invalid_models_tests.Model.model_set' clashes with field "
1592 "name 'invalid_models_tests.Model.model_set'.",
1593 hint=(
1594 "Rename field 'invalid_models_tests.Model.model_set', or "
1595 "add/change a related_name argument to the definition for "
1596 "field 'invalid_models_tests.Model.model_set'."
1597 ),
1598 obj=Model._meta.get_field("model_set"),
1599 id="fields.E302",
1600 ),
1601 ],
1602 )
1603
1604 def test_reverse_query_name_clash(self):
1605 class Model(models.Model):
1606 model = models.ManyToManyField("self", symmetrical=False)
1607
1608 self.assertEqual(
1609 Model.check(),
1610 [
1611 Error(
1612 "Reverse query name for 'invalid_models_tests.Model.model' "
1613 "clashes with field name 'invalid_models_tests.Model.model'.",
1614 hint=(
1615 "Rename field 'invalid_models_tests.Model.model', or "
1616 "add/change a related_name argument to the definition for "
1617 "field 'invalid_models_tests.Model.model'."
1618 ),
1619 obj=Model._meta.get_field("model"),
1620 id="fields.E303",
1621 ),
1622 ],
1623 )
1624
1625 def test_clash_under_explicit_related_name(self):
1626 class Model(models.Model):
1627 clash = models.IntegerField()
1628 m2m = models.ManyToManyField(
1629 "self", symmetrical=False, related_name="clash"
1630 )
1631
1632 self.assertEqual(
1633 Model.check(),
1634 [
1635 Error(
1636 "Reverse accessor 'Model.clash' for "
1637 "'invalid_models_tests.Model.m2m' clashes with field name "
1638 "'invalid_models_tests.Model.clash'.",
1639 hint=(
1640 "Rename field 'invalid_models_tests.Model.clash', or "
1641 "add/change a related_name argument to the definition for "
1642 "field 'invalid_models_tests.Model.m2m'."
1643 ),
1644 obj=Model._meta.get_field("m2m"),
1645 id="fields.E302",
1646 ),
1647 Error(
1648 "Reverse query name for 'invalid_models_tests.Model.m2m' "
1649 "clashes with field name 'invalid_models_tests.Model.clash'.",
1650 hint=(
1651 "Rename field 'invalid_models_tests.Model.clash', or "
1652 "add/change a related_name argument to the definition for "
1653 "field 'invalid_models_tests.Model.m2m'."
1654 ),
1655 obj=Model._meta.get_field("m2m"),
1656 id="fields.E303",
1657 ),
1658 ],
1659 )
1660
1661 def test_valid_model(self):
1662 class Model(models.Model):
1663 first = models.ManyToManyField(
1664 "self", symmetrical=False, related_name="first_accessor"
1665 )
1666 second = models.ManyToManyField(
1667 "self", symmetrical=False, related_name="second_accessor"
1668 )
1669
1670 self.assertEqual(Model.check(), [])
1671
1672
1673 @isolate_apps("invalid_models_tests")
1674 class SelfReferentialFKClashTests(SimpleTestCase):
1675 def test_accessor_clash(self):
1676 class Model(models.Model):
1677 model_set = models.ForeignKey("Model", models.CASCADE)
1678
1679 self.assertEqual(
1680 Model.check(),
1681 [
1682 Error(
1683 "Reverse accessor 'Model.model_set' for "
1684 "'invalid_models_tests.Model.model_set' clashes with field "
1685 "name 'invalid_models_tests.Model.model_set'.",
1686 hint=(
1687 "Rename field 'invalid_models_tests.Model.model_set', or "
1688 "add/change a related_name argument to the definition for "
1689 "field 'invalid_models_tests.Model.model_set'."
1690 ),
1691 obj=Model._meta.get_field("model_set"),
1692 id="fields.E302",
1693 ),
1694 ],
1695 )
1696
1697 def test_reverse_query_name_clash(self):
1698 class Model(models.Model):
1699 model = models.ForeignKey("Model", models.CASCADE)
1700
1701 self.assertEqual(
1702 Model.check(),
1703 [
1704 Error(
1705 "Reverse query name for 'invalid_models_tests.Model.model' "
1706 "clashes with field name 'invalid_models_tests.Model.model'.",
1707 hint=(
1708 "Rename field 'invalid_models_tests.Model.model', or "
1709 "add/change a related_name argument to the definition for "
1710 "field 'invalid_models_tests.Model.model'."
1711 ),
1712 obj=Model._meta.get_field("model"),
1713 id="fields.E303",
1714 ),
1715 ],
1716 )
1717
1718 def test_clash_under_explicit_related_name(self):
1719 class Model(models.Model):
1720 clash = models.CharField(max_length=10)
1721 foreign = models.ForeignKey("Model", models.CASCADE, related_name="clash")
1722
1723 self.assertEqual(
1724 Model.check(),
1725 [
1726 Error(
1727 "Reverse accessor 'Model.clash' for "
1728 "'invalid_models_tests.Model.foreign' clashes with field name "
1729 "'invalid_models_tests.Model.clash'.",
1730 hint=(
1731 "Rename field 'invalid_models_tests.Model.clash', or "
1732 "add/change a related_name argument to the definition for "
1733 "field 'invalid_models_tests.Model.foreign'."
1734 ),
1735 obj=Model._meta.get_field("foreign"),
1736 id="fields.E302",
1737 ),
1738 Error(
1739 "Reverse query name for 'invalid_models_tests.Model.foreign' "
1740 "clashes with field name 'invalid_models_tests.Model.clash'.",
1741 hint=(
1742 "Rename field 'invalid_models_tests.Model.clash', or "
1743 "add/change a related_name argument to the definition for "
1744 "field 'invalid_models_tests.Model.foreign'."
1745 ),
1746 obj=Model._meta.get_field("foreign"),
1747 id="fields.E303",
1748 ),
1749 ],
1750 )
1751
1752
1753 @isolate_apps("invalid_models_tests")
1754 class ComplexClashTests(SimpleTestCase):
1755 # New tests should not be included here, because this is a single,
1756 # self-contained sanity check, not a test of everything.
1757 def test_complex_clash(self):
1758 class Target(models.Model):
1759 tgt_safe = models.CharField(max_length=10)
1760 clash = models.CharField(max_length=10)
1761 model = models.CharField(max_length=10)
1762
1763 clash1_set = models.CharField(max_length=10)
1764
1765 class Model(models.Model):
1766 src_safe = models.CharField(max_length=10)
1767
1768 foreign_1 = models.ForeignKey(Target, models.CASCADE, related_name="id")
1769 foreign_2 = models.ForeignKey(
1770 Target, models.CASCADE, related_name="src_safe"
1771 )
1772
1773 m2m_1 = models.ManyToManyField(Target, related_name="id")
1774 m2m_2 = models.ManyToManyField(Target, related_name="src_safe")
1775
1776 self.assertEqual(
1777 Model.check(),
1778 [
1779 Error(
1780 "Reverse accessor 'Target.id' for "
1781 "'invalid_models_tests.Model.foreign_1' clashes with field "
1782 "name 'invalid_models_tests.Target.id'.",
1783 hint=(
1784 "Rename field 'invalid_models_tests.Target.id', or "
1785 "add/change a related_name argument to the definition for "
1786 "field 'invalid_models_tests.Model.foreign_1'."
1787 ),
1788 obj=Model._meta.get_field("foreign_1"),
1789 id="fields.E302",
1790 ),
1791 Error(
1792 "Reverse query name for 'invalid_models_tests.Model.foreign_1' "
1793 "clashes with field name 'invalid_models_tests.Target.id'.",
1794 hint=(
1795 "Rename field 'invalid_models_tests.Target.id', or "
1796 "add/change a related_name argument to the definition for "
1797 "field 'invalid_models_tests.Model.foreign_1'."
1798 ),
1799 obj=Model._meta.get_field("foreign_1"),
1800 id="fields.E303",
1801 ),
1802 Error(
1803 "Reverse accessor 'Target.id' for "
1804 "'invalid_models_tests.Model.foreign_1' clashes with reverse "
1805 "accessor for 'invalid_models_tests.Model.m2m_1'.",
1806 hint=(
1807 "Add or change a related_name argument to the definition "
1808 "for 'invalid_models_tests.Model.foreign_1' or "
1809 "'invalid_models_tests.Model.m2m_1'."
1810 ),
1811 obj=Model._meta.get_field("foreign_1"),
1812 id="fields.E304",
1813 ),
1814 Error(
1815 "Reverse query name for 'invalid_models_tests.Model.foreign_1' "
1816 "clashes with reverse query name for "
1817 "'invalid_models_tests.Model.m2m_1'.",
1818 hint=(
1819 "Add or change a related_name argument to the definition "
1820 "for 'invalid_models_tests.Model.foreign_1' or "
1821 "'invalid_models_tests.Model.m2m_1'."
1822 ),
1823 obj=Model._meta.get_field("foreign_1"),
1824 id="fields.E305",
1825 ),
1826 Error(
1827 "Reverse accessor 'Target.src_safe' for "
1828 "'invalid_models_tests.Model.foreign_2' clashes with reverse "
1829 "accessor for 'invalid_models_tests.Model.m2m_2'.",
1830 hint=(
1831 "Add or change a related_name argument to the definition "
1832 "for 'invalid_models_tests.Model.foreign_2' or "
1833 "'invalid_models_tests.Model.m2m_2'."
1834 ),
1835 obj=Model._meta.get_field("foreign_2"),
1836 id="fields.E304",
1837 ),
1838 Error(
1839 "Reverse query name for 'invalid_models_tests.Model.foreign_2' "
1840 "clashes with reverse query name for "
1841 "'invalid_models_tests.Model.m2m_2'.",
1842 hint=(
1843 "Add or change a related_name argument to the definition "
1844 "for 'invalid_models_tests.Model.foreign_2' or "
1845 "'invalid_models_tests.Model.m2m_2'."
1846 ),
1847 obj=Model._meta.get_field("foreign_2"),
1848 id="fields.E305",
1849 ),
1850 Error(
1851 "Reverse accessor 'Target.id' for "
1852 "'invalid_models_tests.Model.m2m_1' clashes with field name "
1853 "'invalid_models_tests.Target.id'.",
1854 hint=(
1855 "Rename field 'invalid_models_tests.Target.id', or "
1856 "add/change a related_name argument to the definition for "
1857 "field 'invalid_models_tests.Model.m2m_1'."
1858 ),
1859 obj=Model._meta.get_field("m2m_1"),
1860 id="fields.E302",
1861 ),
1862 Error(
1863 "Reverse query name for 'invalid_models_tests.Model.m2m_1' "
1864 "clashes with field name 'invalid_models_tests.Target.id'.",
1865 hint=(
1866 "Rename field 'invalid_models_tests.Target.id', or "
1867 "add/change a related_name argument to the definition for "
1868 "field 'invalid_models_tests.Model.m2m_1'."
1869 ),
1870 obj=Model._meta.get_field("m2m_1"),
1871 id="fields.E303",
1872 ),
1873 Error(
1874 "Reverse accessor 'Target.id' for "
1875 "'invalid_models_tests.Model.m2m_1' clashes with reverse "
1876 "accessor for 'invalid_models_tests.Model.foreign_1'.",
1877 hint=(
1878 "Add or change a related_name argument to the definition "
1879 "for 'invalid_models_tests.Model.m2m_1' or "
1880 "'invalid_models_tests.Model.foreign_1'."
1881 ),
1882 obj=Model._meta.get_field("m2m_1"),
1883 id="fields.E304",
1884 ),
1885 Error(
1886 "Reverse query name for 'invalid_models_tests.Model.m2m_1' "
1887 "clashes with reverse query name for "
1888 "'invalid_models_tests.Model.foreign_1'.",
1889 hint=(
1890 "Add or change a related_name argument to the definition "
1891 "for 'invalid_models_tests.Model.m2m_1' or "
1892 "'invalid_models_tests.Model.foreign_1'."
1893 ),
1894 obj=Model._meta.get_field("m2m_1"),
1895 id="fields.E305",
1896 ),
1897 Error(
1898 "Reverse accessor 'Target.src_safe' for "
1899 "'invalid_models_tests.Model.m2m_2' clashes with reverse "
1900 "accessor for 'invalid_models_tests.Model.foreign_2'.",
1901 hint=(
1902 "Add or change a related_name argument to the definition "
1903 "for 'invalid_models_tests.Model.m2m_2' or "
1904 "'invalid_models_tests.Model.foreign_2'."
1905 ),
1906 obj=Model._meta.get_field("m2m_2"),
1907 id="fields.E304",
1908 ),
1909 Error(
1910 "Reverse query name for 'invalid_models_tests.Model.m2m_2' "
1911 "clashes with reverse query name for "
1912 "'invalid_models_tests.Model.foreign_2'.",
1913 hint=(
1914 "Add or change a related_name argument to the definition "
1915 "for 'invalid_models_tests.Model.m2m_2' or "
1916 "'invalid_models_tests.Model.foreign_2'."
1917 ),
1918 obj=Model._meta.get_field("m2m_2"),
1919 id="fields.E305",
1920 ),
1921 ],
1922 )
1923
1924 def test_clash_parent_link(self):
1925 class Parent(models.Model):
1926 pass
1927
1928 class Child(Parent):
1929 other_parent = models.OneToOneField(Parent, models.CASCADE)
1930
1931 errors = [
1932 (
1933 "fields.E304",
1934 "accessor",
1935 " 'Parent.child'",
1936 "parent_ptr",
1937 "other_parent",
1938 ),
1939 ("fields.E305", "query name", "", "parent_ptr", "other_parent"),
1940 (
1941 "fields.E304",
1942 "accessor",
1943 " 'Parent.child'",
1944 "other_parent",
1945 "parent_ptr",
1946 ),
1947 ("fields.E305", "query name", "", "other_parent", "parent_ptr"),
1948 ]
1949 self.assertEqual(
1950 Child.check(),
1951 [
1952 Error(
1953 "Reverse %s%s for 'invalid_models_tests.Child.%s' clashes with "
1954 "reverse %s for 'invalid_models_tests.Child.%s'."
1955 % (attr, rel_name, field_name, attr, clash_name),
1956 hint=(
1957 "Add or change a related_name argument to the definition "
1958 "for 'invalid_models_tests.Child.%s' or "
1959 "'invalid_models_tests.Child.%s'." % (field_name, clash_name)
1960 ),
1961 obj=Child._meta.get_field(field_name),
1962 id=error_id,
1963 )
1964 for error_id, attr, rel_name, field_name, clash_name in errors
1965 ],
1966 )
1967
1968
1969 @isolate_apps("invalid_models_tests")
1970 class M2mThroughFieldsTests(SimpleTestCase):
1971 def test_m2m_field_argument_validation(self):
1972 """
1973 ManyToManyField accepts the ``through_fields`` kwarg
1974 only if an intermediary table is specified.
1975 """
1976
1977 class Fan(models.Model):
1978 pass
1979
1980 with self.assertRaisesMessage(
1981 ValueError, "Cannot specify through_fields without a through model"
1982 ):
1983 models.ManyToManyField(Fan, through_fields=("f1", "f2"))
1984
1985 def test_invalid_order(self):
1986 """
1987 Mixing up the order of link fields to ManyToManyField.through_fields
1988 triggers validation errors.
1989 """
1990
1991 class Fan(models.Model):
1992 pass
1993
1994 class Event(models.Model):
1995 invitees = models.ManyToManyField(
1996 Fan, through="Invitation", through_fields=("invitee", "event")
1997 )
1998
1999 class Invitation(models.Model):
2000 event = models.ForeignKey(Event, models.CASCADE)
2001 invitee = models.ForeignKey(Fan, models.CASCADE)
2002 inviter = models.ForeignKey(Fan, models.CASCADE, related_name="+")
2003
2004 field = Event._meta.get_field("invitees")
2005 self.assertEqual(
2006 field.check(from_model=Event),
2007 [
2008 Error(
2009 "'Invitation.invitee' is not a foreign key to 'Event'.",
2010 hint=(
2011 "Did you mean one of the following foreign keys to 'Event': "
2012 "event?"
2013 ),
2014 obj=field,
2015 id="fields.E339",
2016 ),
2017 Error(
2018 "'Invitation.event' is not a foreign key to 'Fan'.",
2019 hint=(
2020 "Did you mean one of the following foreign keys to 'Fan': "
2021 "invitee, inviter?"
2022 ),
2023 obj=field,
2024 id="fields.E339",
2025 ),
2026 ],
2027 )
2028
2029 def test_invalid_field(self):
2030 """
2031 Providing invalid field names to ManyToManyField.through_fields
2032 triggers validation errors.
2033 """
2034
2035 class Fan(models.Model):
2036 pass
2037
2038 class Event(models.Model):
2039 invitees = models.ManyToManyField(
2040 Fan,
2041 through="Invitation",
2042 through_fields=("invalid_field_1", "invalid_field_2"),
2043 )
2044
2045 class Invitation(models.Model):
2046 event = models.ForeignKey(Event, models.CASCADE)
2047 invitee = models.ForeignKey(Fan, models.CASCADE)
2048 inviter = models.ForeignKey(Fan, models.CASCADE, related_name="+")
2049
2050 field = Event._meta.get_field("invitees")
2051 self.assertEqual(
2052 field.check(from_model=Event),
2053 [
2054 Error(
2055 "The intermediary model 'invalid_models_tests.Invitation' has no "
2056 "field 'invalid_field_1'.",
2057 hint=(
2058 "Did you mean one of the following foreign keys to 'Event': "
2059 "event?"
2060 ),
2061 obj=field,
2062 id="fields.E338",
2063 ),
2064 Error(
2065 "The intermediary model 'invalid_models_tests.Invitation' has no "
2066 "field 'invalid_field_2'.",
2067 hint=(
2068 "Did you mean one of the following foreign keys to 'Fan': "
2069 "invitee, inviter?"
2070 ),
2071 obj=field,
2072 id="fields.E338",
2073 ),
2074 ],
2075 )
2076
2077 def test_explicit_field_names(self):
2078 """
2079 If ``through_fields`` kwarg is given, it must specify both
2080 link fields of the intermediary table.
2081 """
2082
2083 class Fan(models.Model):
2084 pass
2085
2086 class Event(models.Model):
2087 invitees = models.ManyToManyField(
2088 Fan, through="Invitation", through_fields=(None, "invitee")
2089 )
2090
2091 class Invitation(models.Model):
2092 event = models.ForeignKey(Event, models.CASCADE)
2093 invitee = models.ForeignKey(Fan, models.CASCADE)
2094 inviter = models.ForeignKey(Fan, models.CASCADE, related_name="+")
2095
2096 field = Event._meta.get_field("invitees")
2097 self.assertEqual(
2098 field.check(from_model=Event),
2099 [
2100 Error(
2101 "Field specifies 'through_fields' but does not provide the names "
2102 "of the two link fields that should be used for the relation "
2103 "through model 'invalid_models_tests.Invitation'.",
2104 hint=(
2105 "Make sure you specify 'through_fields' as "
2106 "through_fields=('field1', 'field2')"
2107 ),
2108 obj=field,
2109 id="fields.E337",
2110 ),
2111 ],
2112 )
2113
2114 def test_superset_foreign_object(self):
2115 class Parent(models.Model):
2116 a = models.PositiveIntegerField()
2117 b = models.PositiveIntegerField()
2118 c = models.PositiveIntegerField()
2119
2120 class Meta:
2121 unique_together = (("a", "b", "c"),)
2122
2123 class Child(models.Model):
2124 a = models.PositiveIntegerField()
2125 b = models.PositiveIntegerField()
2126 value = models.CharField(max_length=255)
2127 parent = models.ForeignObject(
2128 Parent,
2129 on_delete=models.SET_NULL,
2130 from_fields=("a", "b"),
2131 to_fields=("a", "b"),
2132 related_name="children",
2133 )
2134
2135 field = Child._meta.get_field("parent")
2136 self.assertEqual(
2137 field.check(from_model=Child),
2138 [
2139 Error(
2140 "No subset of the fields 'a', 'b' on model 'Parent' is unique.",
2141 hint=(
2142 "Mark a single field as unique=True or add a set of "
2143 "fields to a unique constraint (via unique_together or a "
2144 "UniqueConstraint (without condition) in the model "
2145 "Meta.constraints)."
2146 ),
2147 obj=field,
2148 id="fields.E310",
2149 ),
2150 ],
2151 )
2152
2153 def test_intersection_foreign_object(self):
2154 class Parent(models.Model):
2155 a = models.PositiveIntegerField()
2156 b = models.PositiveIntegerField()
2157 c = models.PositiveIntegerField()
2158 d = models.PositiveIntegerField()
2159
2160 class Meta:
2161 unique_together = (("a", "b", "c"),)
2162
2163 class Child(models.Model):
2164 a = models.PositiveIntegerField()
2165 b = models.PositiveIntegerField()
2166 d = models.PositiveIntegerField()
2167 value = models.CharField(max_length=255)
2168 parent = models.ForeignObject(
2169 Parent,
2170 on_delete=models.SET_NULL,
2171 from_fields=("a", "b", "d"),
2172 to_fields=("a", "b", "d"),
2173 related_name="children",
2174 )
2175
2176 field = Child._meta.get_field("parent")
2177 self.assertEqual(
2178 field.check(from_model=Child),
2179 [
2180 Error(
2181 "No subset of the fields 'a', 'b', 'd' on model 'Parent' is "
2182 "unique.",
2183 hint=(
2184 "Mark a single field as unique=True or add a set of "
2185 "fields to a unique constraint (via unique_together or a "
2186 "UniqueConstraint (without condition) in the model "
2187 "Meta.constraints)."
2188 ),
2189 obj=field,
2190 id="fields.E310",
2191 ),
2192 ],
2193 )