# -*- encoding: utf-8 -*- from __future__ import unicode_literals from django.core.checks import Error from django.db import models from django.test.utils import override_settings from django.test.testcases import skipIfDBFeature from .base import IsolatedModelsTestCase class RelativeFieldTests(IsolatedModelsTestCase): def test_valid_foreign_key_without_accessor(self): class Target(models.Model): # There would be a clash if Model.field installed an accessor. model = models.IntegerField() class Model(models.Model): field = models.ForeignKey(Target, related_name='+') field = Model._meta.get_field('field') errors = field.check() self.assertEqual(errors, []) def test_foreign_key_to_missing_model(self): # Model names are resolved when a model is being created, so we cannot # test relative fields in isolation and we need to attach them to a # model. class Model(models.Model): foreign_key = models.ForeignKey('Rel1') field = Model._meta.get_field('foreign_key') errors = field.check() expected = [ Error( ('The field has a relation with model Rel1, ' 'which has either not been installed or is abstract.'), hint=('Ensure that you did not misspell the model name and ' 'the model is not abstract. Does your INSTALLED_APPS ' 'setting contain the app where Rel1 is defined?'), obj=field, id='E030', ), ] self.assertEqual(errors, expected) def test_many_to_many_to_missing_model(self): class Model(models.Model): m2m = models.ManyToManyField("Rel2") field = Model._meta.get_field('m2m') errors = field.check(from_model=Model) expected = [ Error( ('The field has a relation with model Rel2, ' 'which has either not been installed or is abstract.'), hint=('Ensure that you did not misspell the model name and ' 'the model is not abstract. Does your INSTALLED_APPS ' 'setting contain the app where Rel2 is defined?'), obj=field, id='E030', ), ] self.assertEqual(errors, expected) def test_ambiguous_relationship_model(self): class Person(models.Model): pass class Group(models.Model): field = models.ManyToManyField('Person', through="AmbiguousRelationship", related_name='tertiary') class AmbiguousRelationship(models.Model): # Too much foreign keys to Person. first_person = models.ForeignKey(Person, related_name="first") second_person = models.ForeignKey(Person, related_name="second") second_model = models.ForeignKey(Group) field = Group._meta.get_field('field') errors = field.check(from_model=Group) expected = [ Error( ('The model is used as an intermediary model by ' 'invalid_models_tests.Group.field, but it has more than one ' 'foreign key to Person, ' 'which is ambiguous and is not permitted.'), hint=('If you want to create a recursive relationship, use ' 'ForeignKey("self", symmetrical=False, ' 'through="AmbiguousRelationship").'), obj=field, id='E027', ), ] self.assertEqual(errors, expected) def test_relationship_model_with_foreign_key_to_wrong_model(self): class WrongModel(models.Model): pass class Person(models.Model): pass class Group(models.Model): members = models.ManyToManyField('Person', through="InvalidRelationship") class InvalidRelationship(models.Model): person = models.ForeignKey(Person) wrong_foreign_key = models.ForeignKey(WrongModel) # The last foreign key should point to Group model. field = Group._meta.get_field('members') errors = field.check(from_model=Group) expected = [ Error( ('The model is used as an intermediary model by ' 'invalid_models_tests.Group.members, but it misses ' 'a foreign key to Group or Person.'), hint=None, obj=InvalidRelationship, id='E028', ), ] self.assertEqual(errors, expected) def test_relationship_model_missing_foreign_key(self): class Person(models.Model): pass class Group(models.Model): members = models.ManyToManyField('Person', through="InvalidRelationship") class InvalidRelationship(models.Model): group = models.ForeignKey(Group) # No foreign key to Person field = Group._meta.get_field('members') errors = field.check(from_model=Group) expected = [ Error( ('The model is used as an intermediary model by ' 'invalid_models_tests.Group.members, but it misses ' 'a foreign key to Group or Person.'), hint=None, obj=InvalidRelationship, id='E028', ), ] self.assertEqual(errors, expected) def test_missing_relationship_model(self): class Person(models.Model): pass class Group(models.Model): members = models.ManyToManyField('Person', through="MissingM2MModel") field = Group._meta.get_field('members') errors = field.check(from_model=Group) expected = [ Error( ('The field specifies a many-to-many relation through model ' 'MissingM2MModel, which has not been installed.'), hint=('Ensure that you did not misspell the model name and ' 'the model is not abstract. Does your INSTALLED_APPS ' 'setting contain the app where MissingM2MModel is defined?'), obj=field, id='E023', ), ] self.assertEqual(errors, expected) def test_symmetrical_self_referential_field(self): class Person(models.Model): # Implicit symmetrical=False. friends = models.ManyToManyField('self', through="Relationship") class Relationship(models.Model): first = models.ForeignKey(Person, related_name="rel_from_set") second = models.ForeignKey(Person, related_name="rel_to_set") field = Person._meta.get_field('friends') errors = field.check(from_model=Person) expected = [ Error( 'Many-to-many fields with intermediate tables must not be symmetrical.', hint=None, obj=field, id='E024', ), ] self.assertEqual(errors, expected) def test_too_many_foreign_keys_in_self_referential_model(self): class Person(models.Model): friends = models.ManyToManyField('self', through="InvalidRelationship", symmetrical=False) class InvalidRelationship(models.Model): first = models.ForeignKey(Person, related_name="rel_from_set_2") second = models.ForeignKey(Person, related_name="rel_to_set_2") third = models.ForeignKey(Person, related_name="too_many_by_far") field = Person._meta.get_field('friends') errors = field.check(from_model=Person) expected = [ Error( ('The model is used as an intermediary model by ' 'invalid_models_tests.Person.friends, but it has more than two ' 'foreign keys to Person, which is ambiguous and ' 'is not permitted.'), hint=None, obj=InvalidRelationship, id='E025', ), ] self.assertEqual(errors, expected) def test_symmetric_self_reference_with_intermediate_table(self): class Person(models.Model): # Explicit symmetrical=True. friends = models.ManyToManyField('self', through="Relationship", symmetrical=True) class Relationship(models.Model): first = models.ForeignKey(Person, related_name="rel_from_set") second = models.ForeignKey(Person, related_name="rel_to_set") field = Person._meta.get_field('friends') errors = field.check(from_model=Person) expected = [ Error( 'Many-to-many fields with intermediate tables must not be symmetrical.', hint=None, obj=field, id='E024', ), ] self.assertEqual(errors, expected) def test_foreign_key_to_abstract_model(self): class Model(models.Model): foreign_key = models.ForeignKey('AbstractModel') class AbstractModel(models.Model): class Meta: abstract = True field = Model._meta.get_field('foreign_key') errors = field.check() expected = [ Error( ('The field has a relation with model AbstractModel, ' 'which has either not been installed or is abstract.'), hint=('Ensure that you did not misspell the model name and ' 'the model is not abstract. Does your INSTALLED_APPS ' 'setting contain the app where AbstractModel is defined?'), obj=field, id='E030', ), ] self.assertEqual(errors, expected) def test_m2m_to_abstract_model(self): class AbstractModel(models.Model): class Meta: abstract = True class Model(models.Model): m2m = models.ManyToManyField('AbstractModel') field = Model._meta.get_field('m2m') errors = field.check(from_model=Model) expected = [ Error( ('The field has a relation with model AbstractModel, ' 'which has either not been installed or is abstract.'), hint=('Ensure that you did not misspell the model name and ' 'the model is not abstract. Does your INSTALLED_APPS ' 'setting contain the app where AbstractModel is defined?'), obj=field, id='E030', ), ] self.assertEqual(errors, expected) def test_unique_m2m(self): class Person(models.Model): name = models.CharField(max_length=5) class Group(models.Model): members = models.ManyToManyField('Person', unique=True) field = Group._meta.get_field('members') errors = field.check(from_model=Group) expected = [ Error( 'ManyToManyFields must not be unique.', hint=None, obj=field, id='E022', ), ] self.assertEqual(errors, expected) def test_foreign_key_to_non_unique_field(self): class Target(models.Model): bad = models.IntegerField() # No unique=True class Model(models.Model): foreign_key = models.ForeignKey('Target', to_field='bad') field = Model._meta.get_field('foreign_key') errors = field.check() expected = [ Error( 'Target.bad must have unique=True because it is referenced by a foreign key.', hint=None, obj=field, id='E019', ), ] self.assertEqual(errors, expected) def test_foreign_key_to_non_unique_field_under_explicit_model(self): class Target(models.Model): bad = models.IntegerField() class Model(models.Model): field = models.ForeignKey(Target, to_field='bad') field = Model._meta.get_field('field') errors = field.check() expected = [ Error( 'Target.bad must have unique=True because it is referenced by a foreign key.', hint=None, obj=field, id='E019', ), ] self.assertEqual(errors, expected) def test_foreign_object_to_non_unique_fields(self): class Person(models.Model): # Note that both fields are not unique. country_id = models.IntegerField() city_id = models.IntegerField() class MMembership(models.Model): person_country_id = models.IntegerField() person_city_id = models.IntegerField() person = models.ForeignObject(Person, from_fields=['person_country_id', 'person_city_id'], to_fields=['country_id', 'city_id']) field = MMembership._meta.get_field('person') errors = field.check() expected = [ Error( ('No unique=True constraint on field combination ' '"country_id,city_id" under model Person.'), hint=('Set unique=True argument on any of the fields ' '"country_id,city_id" under model Person.'), obj=field, id='E018', ) ] self.assertEqual(errors, expected) def test_on_delete_set_null_on_non_nullable_field(self): class Person(models.Model): pass class Model(models.Model): foreign_key = models.ForeignKey('Person', on_delete=models.SET_NULL) field = Model._meta.get_field('foreign_key') errors = field.check() expected = [ Error( 'The field specifies on_delete=SET_NULL, but cannot be null.', hint='Set null=True argument on the field.', obj=field, id='E020', ), ] self.assertEqual(errors, expected) def test_on_delete_set_default_without_default_value(self): class Person(models.Model): pass class Model(models.Model): foreign_key = models.ForeignKey('Person', on_delete=models.SET_DEFAULT) field = Model._meta.get_field('foreign_key') errors = field.check() expected = [ Error( 'The field specifies on_delete=SET_DEFAULT, but has no default value.', hint=None, obj=field, id='E021', ), ] self.assertEqual(errors, expected) @skipIfDBFeature('interprets_empty_strings_as_nulls') def test_nullable_primary_key(self): class Model(models.Model): field = models.IntegerField(primary_key=True, null=True) field = Model._meta.get_field('field') errors = field.check() expected = [ Error( 'Primary keys must not have null=True.', hint='Set null=False on the field or remove primary_key=True argument.', obj=field, id='E036', ), ] self.assertEqual(errors, expected) def test_not_swapped_model(self): class SwappableModel(models.Model): # A model that can be, but isn't swapped out. References to this # model should *not* raise any validation error. class Meta: swappable = 'TEST_SWAPPABLE_MODEL' class Model(models.Model): explicit_fk = models.ForeignKey(SwappableModel, related_name='explicit_fk') implicit_fk = models.ForeignKey('invalid_models_tests.SwappableModel', related_name='implicit_fk') explicit_m2m = models.ManyToManyField(SwappableModel, related_name='explicit_m2m') implicit_m2m = models.ManyToManyField( 'invalid_models_tests.SwappableModel', related_name='implicit_m2m') explicit_fk = Model._meta.get_field('explicit_fk') self.assertEqual(explicit_fk.check(), []) implicit_fk = Model._meta.get_field('implicit_fk') self.assertEqual(implicit_fk.check(), []) explicit_m2m = Model._meta.get_field('explicit_m2m') self.assertEqual(explicit_m2m.check(from_model=Model), []) implicit_m2m = Model._meta.get_field('implicit_m2m') self.assertEqual(implicit_m2m.check(from_model=Model), []) @override_settings(TEST_SWAPPED_MODEL='invalid_models_tests.Replacement') def test_referencing_to_swapped_model(self): class Replacement(models.Model): pass class SwappedModel(models.Model): class Meta: swappable = 'TEST_SWAPPED_MODEL' class Model(models.Model): explicit_fk = models.ForeignKey(SwappedModel, related_name='explicit_fk') implicit_fk = models.ForeignKey('invalid_models_tests.SwappedModel', related_name='implicit_fk') explicit_m2m = models.ManyToManyField(SwappedModel, related_name='explicit_m2m') implicit_m2m = models.ManyToManyField( 'invalid_models_tests.SwappedModel', related_name='implicit_m2m') fields = [ Model._meta.get_field('explicit_fk'), Model._meta.get_field('implicit_fk'), Model._meta.get_field('explicit_m2m'), Model._meta.get_field('implicit_m2m'), ] expected_error = Error( ('The field defines a relation with the model ' 'invalid_models_tests.SwappedModel, which has been swapped out.'), hint='Update the relation to point at settings.TEST_SWAPPED_MODEL', id='E029', ) for field in fields: expected_error.obj = field errors = field.check(from_model=Model) self.assertEqual(errors, [expected_error]) class AccessorClashTests(IsolatedModelsTestCase): def test_fk_to_integer(self): self._test_accessor_clash( target=models.IntegerField(), relative=models.ForeignKey('Target')) def test_fk_to_fk(self): self._test_accessor_clash( target=models.ForeignKey('Another'), relative=models.ForeignKey('Target')) def test_fk_to_m2m(self): self._test_accessor_clash( target=models.ManyToManyField('Another'), relative=models.ForeignKey('Target')) def test_m2m_to_integer(self): self._test_accessor_clash( target=models.IntegerField(), relative=models.ManyToManyField('Target')) def test_m2m_to_fk(self): self._test_accessor_clash( target=models.ForeignKey('Another'), relative=models.ManyToManyField('Target')) def test_m2m_to_m2m(self): self._test_accessor_clash( target=models.ManyToManyField('Another'), relative=models.ManyToManyField('Target')) def _test_accessor_clash(self, target, relative): class Another(models.Model): pass class Target(models.Model): model_set = target class Model(models.Model): rel = relative errors = Model.check() expected = [ Error( 'Accessor for field Model.rel clashes with field Target.model_set.', hint=('Rename field Target.model_set or add/change ' 'a related_name argument to the definition ' 'for field Model.rel.'), obj=Model._meta.get_field('rel'), id='E014', ), ] self.assertEqual(errors, expected) def test_clash_between_accessors(self): class Target(models.Model): pass class Model(models.Model): foreign = models.ForeignKey(Target) m2m = models.ManyToManyField(Target) errors = Model.check() expected = [ Error( 'Clash between accessors for Model.foreign and Model.m2m.', hint=('Add or change a related_name argument to the definition ' 'for Model.foreign or Model.m2m.'), obj=Model._meta.get_field('foreign'), id='E016', ), Error( 'Clash between accessors for Model.m2m and Model.foreign.', hint=('Add or change a related_name argument to the definition ' 'for Model.m2m or Model.foreign.'), obj=Model._meta.get_field('m2m'), id='E016', ), ] self.assertEqual(errors, expected) def test_m2m_to_m2m_with_inheritance(self): """ Ref #22047. """ class Target(models.Model): pass class Model(models.Model): children = models.ManyToManyField('Child', related_name="m2m_clash", related_query_name="no_clash") class Parent(models.Model): m2m_clash = models.ManyToManyField('Target') class Child(Parent): pass errors = Model.check() expected = [ Error( 'Accessor for field Model.children clashes with field Child.m2m_clash.', hint=('Rename field Child.m2m_clash or add/change ' 'a related_name argument to the definition ' 'for field Model.children.'), obj=Model._meta.get_field('children'), id='E014', ) ] self.assertEqual(errors, expected) class ReverseQueryNameClashTests(IsolatedModelsTestCase): def test_fk_to_integer(self): self._test_reverse_query_name_clash( target=models.IntegerField(), relative=models.ForeignKey('Target')) def test_fk_to_fk(self): self._test_reverse_query_name_clash( target=models.ForeignKey('Another'), relative=models.ForeignKey('Target')) def test_fk_to_m2m(self): self._test_reverse_query_name_clash( target=models.ManyToManyField('Another'), relative=models.ForeignKey('Target')) def test_m2m_to_integer(self): self._test_reverse_query_name_clash( target=models.IntegerField(), relative=models.ManyToManyField('Target')) def test_m2m_to_fk(self): self._test_reverse_query_name_clash( target=models.ForeignKey('Another'), relative=models.ManyToManyField('Target')) def test_m2m_to_m2m(self): self._test_reverse_query_name_clash( target=models.ManyToManyField('Another'), relative=models.ManyToManyField('Target')) def _test_reverse_query_name_clash(self, target, relative): class Another(models.Model): pass class Target(models.Model): model = target class Model(models.Model): rel = relative errors = Model.check() expected = [ Error( 'Reverse query name for field Model.rel clashes with field Target.model.', hint=('Rename field Target.model or add/change ' 'a related_name argument to the definition ' 'for field Model.rel.'), obj=Model._meta.get_field('rel'), id='E015', ), ] self.assertEqual(errors, expected) class ExplicitRelatedNameClashTests(IsolatedModelsTestCase): def test_fk_to_integer(self): self._test_explicit_related_name_clash( target=models.IntegerField(), relative=models.ForeignKey('Target', related_name='clash')) def test_fk_to_fk(self): self._test_explicit_related_name_clash( target=models.ForeignKey('Another'), relative=models.ForeignKey('Target', related_name='clash')) def test_fk_to_m2m(self): self._test_explicit_related_name_clash( target=models.ManyToManyField('Another'), relative=models.ForeignKey('Target', related_name='clash')) def test_m2m_to_integer(self): self._test_explicit_related_name_clash( target=models.IntegerField(), relative=models.ManyToManyField('Target', related_name='clash')) def test_m2m_to_fk(self): self._test_explicit_related_name_clash( target=models.ForeignKey('Another'), relative=models.ManyToManyField('Target', related_name='clash')) def test_m2m_to_m2m(self): self._test_explicit_related_name_clash( target=models.ManyToManyField('Another'), relative=models.ManyToManyField('Target', related_name='clash')) def _test_explicit_related_name_clash(self, target, relative): class Another(models.Model): pass class Target(models.Model): clash = target class Model(models.Model): rel = relative errors = Model.check() expected = [ Error( 'Accessor for field Model.rel clashes with field Target.clash.', hint=('Rename field Target.clash or add/change ' 'a related_name argument to the definition ' 'for field Model.rel.'), obj=Model._meta.get_field('rel'), id='E014', ), Error( 'Reverse query name for field Model.rel clashes with field Target.clash.', hint=('Rename field Target.clash or add/change ' 'a related_name argument to the definition ' 'for field Model.rel.'), obj=Model._meta.get_field('rel'), id='E015', ), ] self.assertEqual(errors, expected) class ExplicitRelatedQueryNameClashTests(IsolatedModelsTestCase): def test_fk_to_integer(self): self._test_explicit_related_query_name_clash( target=models.IntegerField(), relative=models.ForeignKey('Target', related_query_name='clash')) def test_fk_to_fk(self): self._test_explicit_related_query_name_clash( target=models.ForeignKey('Another'), relative=models.ForeignKey('Target', related_query_name='clash')) def test_fk_to_m2m(self): self._test_explicit_related_query_name_clash( target=models.ManyToManyField('Another'), relative=models.ForeignKey('Target', related_query_name='clash')) def test_m2m_to_integer(self): self._test_explicit_related_query_name_clash( target=models.IntegerField(), relative=models.ManyToManyField('Target', related_query_name='clash')) def test_m2m_to_fk(self): self._test_explicit_related_query_name_clash( target=models.ForeignKey('Another'), relative=models.ManyToManyField('Target', related_query_name='clash')) def test_m2m_to_m2m(self): self._test_explicit_related_query_name_clash( target=models.ManyToManyField('Another'), relative=models.ManyToManyField('Target', related_query_name='clash')) def _test_explicit_related_query_name_clash(self, target, relative): class Another(models.Model): pass class Target(models.Model): clash = target class Model(models.Model): rel = relative errors = Model.check() expected = [ Error( 'Reverse query name for field Model.rel clashes with field Target.clash.', hint=('Rename field Target.clash or add/change a related_name ' 'argument to the definition for field Model.rel.'), obj=Model._meta.get_field('rel'), id='E015', ), ] self.assertEqual(errors, expected) class SelfReferentialM2MClashTests(IsolatedModelsTestCase): def test_clash_between_accessors(self): class Model(models.Model): first_m2m = models.ManyToManyField('self', symmetrical=False) second_m2m = models.ManyToManyField('self', symmetrical=False) errors = Model.check() expected = [ Error( 'Clash between accessors for Model.first_m2m and Model.second_m2m.', hint=('Add or change a related_name argument to the definition ' 'for Model.first_m2m or Model.second_m2m.'), obj=Model._meta.get_field('first_m2m'), id='E016', ), Error( 'Clash between accessors for Model.second_m2m and Model.first_m2m.', hint=('Add or change a related_name argument to the definition ' 'for Model.second_m2m or Model.first_m2m.'), obj=Model._meta.get_field('second_m2m'), id='E016', ), ] self.assertEqual(errors, expected) def test_accessor_clash(self): class Model(models.Model): model_set = models.ManyToManyField("self", symmetrical=False) errors = Model.check() expected = [ Error( 'Accessor for field Model.model_set clashes with field Model.model_set.', hint=('Rename field Model.model_set or add/change ' 'a related_name argument to the definition ' 'for field Model.model_set.'), obj=Model._meta.get_field('model_set'), id='E014', ), ] self.assertEqual(errors, expected) def test_reverse_query_name_clash(self): class Model(models.Model): model = models.ManyToManyField("self", symmetrical=False) errors = Model.check() expected = [ Error( 'Reverse query name for field Model.model clashes with field Model.model.', hint=('Rename field Model.model or add/change a related_name ' 'argument to the definition for field Model.model.'), obj=Model._meta.get_field('model'), id='E015', ), ] self.assertEqual(errors, expected) def test_clash_under_explicit_related_name(self): class Model(models.Model): clash = models.IntegerField() m2m = models.ManyToManyField("self", symmetrical=False, related_name='clash') errors = Model.check() expected = [ Error( 'Accessor for field Model.m2m clashes with field Model.clash.', hint=('Rename field Model.clash or add/change a related_name ' 'argument to the definition for field Model.m2m.'), obj=Model._meta.get_field('m2m'), id='E014', ), Error( 'Reverse query name for field Model.m2m clashes with field Model.clash.', hint=('Rename field Model.clash or add/change a related_name ' 'argument to the definition for field Model.m2m.'), obj=Model._meta.get_field('m2m'), id='E015', ), ] self.assertEqual(errors, expected) def test_valid_model(self): class Model(models.Model): first = models.ManyToManyField("self", symmetrical=False, related_name='first_accessor') second = models.ManyToManyField("self", symmetrical=False, related_name='second_accessor') errors = Model.check() self.assertEqual(errors, []) class SelfReferentialFKClashTests(IsolatedModelsTestCase): def test_accessor_clash(self): class Model(models.Model): model_set = models.ForeignKey("Model") errors = Model.check() expected = [ Error( 'Accessor for field Model.model_set clashes with field Model.model_set.', hint=('Rename field Model.model_set or add/change ' 'a related_name argument to the definition ' 'for field Model.model_set.'), obj=Model._meta.get_field('model_set'), id='E014', ), ] self.assertEqual(errors, expected) def test_reverse_query_name_clash(self): class Model(models.Model): model = models.ForeignKey("Model") errors = Model.check() expected = [ Error( 'Reverse query name for field Model.model clashes with field Model.model.', hint=('Rename field Model.model or add/change ' 'a related_name argument to the definition ' 'for field Model.model.'), obj=Model._meta.get_field('model'), id='E015', ), ] self.assertEqual(errors, expected) def test_clash_under_explicit_related_name(self): class Model(models.Model): clash = models.CharField(max_length=10) foreign = models.ForeignKey("Model", related_name='clash') errors = Model.check() expected = [ Error( 'Accessor for field Model.foreign clashes with field Model.clash.', hint=('Rename field Model.clash or add/change ' 'a related_name argument to the definition ' 'for field Model.foreign.'), obj=Model._meta.get_field('foreign'), id='E014', ), Error( 'Reverse query name for field Model.foreign clashes with field Model.clash.', hint=('Rename field Model.clash or add/change ' 'a related_name argument to the definition ' 'for field Model.foreign.'), obj=Model._meta.get_field('foreign'), id='E015', ), ] self.assertEqual(errors, expected) class ComplexClashTests(IsolatedModelsTestCase): # New tests should not be included here, because this is a single, # self-contained sanity check, not a test of everything. def test_complex_clash(self): class Target(models.Model): tgt_safe = models.CharField(max_length=10) clash = models.CharField(max_length=10) model = models.CharField(max_length=10) clash1_set = models.CharField(max_length=10) class Model(models.Model): src_safe = models.CharField(max_length=10) foreign_1 = models.ForeignKey(Target, related_name='id') foreign_2 = models.ForeignKey(Target, related_name='src_safe') m2m_1 = models.ManyToManyField(Target, related_name='id') m2m_2 = models.ManyToManyField(Target, related_name='src_safe') errors = Model.check() expected = [ Error( 'Accessor for field Model.foreign_1 clashes with field Target.id.', hint=('Rename field Target.id or add/change a related_name ' 'argument to the definition for field Model.foreign_1.'), obj=Model._meta.get_field('foreign_1'), id='E014', ), Error( 'Reverse query name for field Model.foreign_1 clashes with field Target.id.', hint=('Rename field Target.id or add/change a related_name ' 'argument to the definition for field Model.foreign_1.'), obj=Model._meta.get_field('foreign_1'), id='E015', ), Error( 'Clash between accessors for Model.foreign_1 and Model.m2m_1.', hint=('Add or change a related_name argument to ' 'the definition for Model.foreign_1 or Model.m2m_1.'), obj=Model._meta.get_field('foreign_1'), id='E016', ), Error( 'Clash between reverse query names for Model.foreign_1 and Model.m2m_1.', hint=('Add or change a related_name argument to ' 'the definition for Model.foreign_1 or Model.m2m_1.'), obj=Model._meta.get_field('foreign_1'), id='E017', ), Error( 'Clash between accessors for Model.foreign_2 and Model.m2m_2.', hint=('Add or change a related_name argument ' 'to the definition for Model.foreign_2 or Model.m2m_2.'), obj=Model._meta.get_field('foreign_2'), id='E016', ), Error( 'Clash between reverse query names for Model.foreign_2 and Model.m2m_2.', hint=('Add or change a related_name argument to ' 'the definition for Model.foreign_2 or Model.m2m_2.'), obj=Model._meta.get_field('foreign_2'), id='E017', ), Error( 'Accessor for field Model.m2m_1 clashes with field Target.id.', hint=('Rename field Target.id or add/change a related_name ' 'argument to the definition for field Model.m2m_1.'), obj=Model._meta.get_field('m2m_1'), id='E014', ), Error( 'Reverse query name for field Model.m2m_1 clashes with field Target.id.', hint=('Rename field Target.id or add/change a related_name ' 'argument to the definition for field Model.m2m_1.'), obj=Model._meta.get_field('m2m_1'), id='E015', ), Error( 'Clash between accessors for Model.m2m_1 and Model.foreign_1.', hint=('Add or change a related_name argument to the definition ' 'for Model.m2m_1 or Model.foreign_1.'), obj=Model._meta.get_field('m2m_1'), id='E016', ), Error( 'Clash between reverse query names for Model.m2m_1 and Model.foreign_1.', hint=('Add or change a related_name argument to ' 'the definition for Model.m2m_1 or Model.foreign_1.'), obj=Model._meta.get_field('m2m_1'), id='E017', ), Error( 'Clash between accessors for Model.m2m_2 and Model.foreign_2.', hint=('Add or change a related_name argument to the definition ' 'for Model.m2m_2 or Model.foreign_2.'), obj=Model._meta.get_field('m2m_2'), id='E016', ), Error( 'Clash between reverse query names for Model.m2m_2 and Model.foreign_2.', hint=('Add or change a related_name argument to the definition ' 'for Model.m2m_2 or Model.foreign_2.'), obj=Model._meta.get_field('m2m_2'), id='E017', ), ] self.assertEqual(errors, expected)