Debian Codegraph @

tests/model_inheritance/test_abstract_inheritance.py

raw
1 from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
2 from django.contrib.contenttypes.models import ContentType
3 from django.core.checks import Error
4 from django.core.exceptions import FieldDoesNotExist, FieldError
5 from django.db import models
6 from django.test import SimpleTestCase
7 from django.test.utils import isolate_apps
8
9
10 @isolate_apps("model_inheritance")
11 class AbstractInheritanceTests(SimpleTestCase):
12 def test_single_parent(self):
13 class AbstractBase(models.Model):
14 name = models.CharField(max_length=30)
15
16 class Meta:
17 abstract = True
18
19 class AbstractDescendant(AbstractBase):
20 name = models.CharField(max_length=50)
21
22 class Meta:
23 abstract = True
24
25 class DerivedChild(AbstractBase):
26 name = models.CharField(max_length=50)
27
28 class DerivedGrandChild(AbstractDescendant):
29 pass
30
31 self.assertEqual(AbstractDescendant._meta.get_field("name").max_length, 50)
32 self.assertEqual(DerivedChild._meta.get_field("name").max_length, 50)
33 self.assertEqual(DerivedGrandChild._meta.get_field("name").max_length, 50)
34
35 def test_multiple_inheritance_allows_inherited_field(self):
36 """
37 Single layer multiple inheritance is as expected, deriving the
38 inherited field from the first base.
39 """
40
41 class ParentA(models.Model):
42 name = models.CharField(max_length=255)
43
44 class Meta:
45 abstract = True
46
47 class ParentB(models.Model):
48 name = models.IntegerField()
49
50 class Meta:
51 abstract = True
52
53 class Child(ParentA, ParentB):
54 pass
55
56 self.assertEqual(Child.check(), [])
57 inherited_field = Child._meta.get_field("name")
58 self.assertIsInstance(inherited_field, models.CharField)
59 self.assertEqual(inherited_field.max_length, 255)
60
61 def test_diamond_shaped_multiple_inheritance_is_depth_first(self):
62 """
63 In contrast to standard Python MRO, resolution of inherited fields is
64 strictly depth-first, rather than breadth-first in diamond-shaped cases.
65
66 This is because a copy of the parent field descriptor is placed onto
67 the model class in ModelBase.__new__(), rather than the attribute
68 lookup going via bases. (It only **looks** like inheritance.)
69
70 Here, Child inherits name from Root, rather than ParentB.
71 """
72
73 class Root(models.Model):
74 name = models.CharField(max_length=255)
75
76 class Meta:
77 abstract = True
78
79 class ParentA(Root):
80 class Meta:
81 abstract = True
82
83 class ParentB(Root):
84 name = models.IntegerField()
85
86 class Meta:
87 abstract = True
88
89 class Child(ParentA, ParentB):
90 pass
91
92 self.assertEqual(Child.check(), [])
93 inherited_field = Child._meta.get_field("name")
94 self.assertIsInstance(inherited_field, models.CharField)
95 self.assertEqual(inherited_field.max_length, 255)
96
97 def test_target_field_may_be_pushed_down(self):
98 """
99 Where the Child model needs to inherit a field from a different base
100 than that given by depth-first resolution, the target field can be
101 **pushed down** by being re-declared.
102 """
103
104 class Root(models.Model):
105 name = models.CharField(max_length=255)
106
107 class Meta:
108 abstract = True
109
110 class ParentA(Root):
111 class Meta:
112 abstract = True
113
114 class ParentB(Root):
115 name = models.IntegerField()
116
117 class Meta:
118 abstract = True
119
120 class Child(ParentA, ParentB):
121 name = models.IntegerField()
122
123 self.assertEqual(Child.check(), [])
124 inherited_field = Child._meta.get_field("name")
125 self.assertIsInstance(inherited_field, models.IntegerField)
126
127 def test_multiple_inheritance_cannot_shadow_concrete_inherited_field(self):
128 class ConcreteParent(models.Model):
129 name = models.CharField(max_length=255)
130
131 class AbstractParent(models.Model):
132 name = models.IntegerField()
133
134 class Meta:
135 abstract = True
136
137 class FirstChild(ConcreteParent, AbstractParent):
138 pass
139
140 class AnotherChild(AbstractParent, ConcreteParent):
141 pass
142
143 self.assertIsInstance(FirstChild._meta.get_field("name"), models.CharField)
144 self.assertEqual(
145 AnotherChild.check(),
146 [
147 Error(
148 "The field 'name' clashes with the field 'name' "
149 "from model 'model_inheritance.concreteparent'.",
150 obj=AnotherChild._meta.get_field("name"),
151 id="models.E006",
152 )
153 ],
154 )
155
156 def test_virtual_field(self):
157 class RelationModel(models.Model):
158 content_type = models.ForeignKey(ContentType, models.CASCADE)
159 object_id = models.PositiveIntegerField()
160 content_object = GenericForeignKey("content_type", "object_id")
161
162 class RelatedModelAbstract(models.Model):
163 field = GenericRelation(RelationModel)
164
165 class Meta:
166 abstract = True
167
168 class ModelAbstract(models.Model):
169 field = models.CharField(max_length=100)
170
171 class Meta:
172 abstract = True
173
174 class OverrideRelatedModelAbstract(RelatedModelAbstract):
175 field = models.CharField(max_length=100)
176
177 class ExtendModelAbstract(ModelAbstract):
178 field = GenericRelation(RelationModel)
179
180 self.assertIsInstance(
181 OverrideRelatedModelAbstract._meta.get_field("field"), models.CharField
182 )
183 self.assertIsInstance(
184 ExtendModelAbstract._meta.get_field("field"), GenericRelation
185 )
186
187 def test_cannot_override_indirect_abstract_field(self):
188 class AbstractBase(models.Model):
189 name = models.CharField(max_length=30)
190
191 class Meta:
192 abstract = True
193
194 class ConcreteDescendant(AbstractBase):
195 pass
196
197 msg = (
198 "Local field 'name' in class 'Descendant' clashes with field of "
199 "the same name from base class 'ConcreteDescendant'."
200 )
201 with self.assertRaisesMessage(FieldError, msg):
202
203 class Descendant(ConcreteDescendant):
204 name = models.IntegerField()
205
206 def test_override_field_with_attr(self):
207 class AbstractBase(models.Model):
208 first_name = models.CharField(max_length=50)
209 last_name = models.CharField(max_length=50)
210 middle_name = models.CharField(max_length=30)
211 full_name = models.CharField(max_length=150)
212
213 class Meta:
214 abstract = True
215
216 class Descendant(AbstractBase):
217 middle_name = None
218
219 def full_name(self):
220 return self.first_name + self.last_name
221
222 msg = "Descendant has no field named %r"
223 with self.assertRaisesMessage(FieldDoesNotExist, msg % "middle_name"):
224 Descendant._meta.get_field("middle_name")
225
226 with self.assertRaisesMessage(FieldDoesNotExist, msg % "full_name"):
227 Descendant._meta.get_field("full_name")
228
229 def test_overriding_field_removed_by_concrete_model(self):
230 class AbstractModel(models.Model):
231 foo = models.CharField(max_length=30)
232
233 class Meta:
234 abstract = True
235
236 class RemovedAbstractModelField(AbstractModel):
237 foo = None
238
239 class OverrideRemovedFieldByConcreteModel(RemovedAbstractModelField):
240 foo = models.CharField(max_length=50)
241
242 self.assertEqual(
243 OverrideRemovedFieldByConcreteModel._meta.get_field("foo").max_length, 50
244 )
245
246 def test_shadowed_fkey_id(self):
247 class Foo(models.Model):
248 pass
249
250 class AbstractBase(models.Model):
251 foo = models.ForeignKey(Foo, models.CASCADE)
252
253 class Meta:
254 abstract = True
255
256 class Descendant(AbstractBase):
257 foo_id = models.IntegerField()
258
259 self.assertEqual(
260 Descendant.check(),
261 [
262 Error(
263 "The field 'foo_id' clashes with the field 'foo' "
264 "from model 'model_inheritance.descendant'.",
265 obj=Descendant._meta.get_field("foo_id"),
266 id="models.E006",
267 )
268 ],
269 )
270
271 def test_shadow_related_name_when_set_to_none(self):
272 class AbstractBase(models.Model):
273 bar = models.IntegerField()
274
275 class Meta:
276 abstract = True
277
278 class Foo(AbstractBase):
279 bar = None
280 foo = models.IntegerField()
281
282 class Bar(models.Model):
283 bar = models.ForeignKey(Foo, models.CASCADE, related_name="bar")
284
285 self.assertEqual(Bar.check(), [])
286
287 def test_reverse_foreign_key(self):
288 class AbstractBase(models.Model):
289 foo = models.CharField(max_length=100)
290
291 class Meta:
292 abstract = True
293
294 class Descendant(AbstractBase):
295 pass
296
297 class Foo(models.Model):
298 foo = models.ForeignKey(Descendant, models.CASCADE, related_name="foo")
299
300 self.assertEqual(
301 Foo._meta.get_field("foo").check(),
302 [
303 Error(
304 "Reverse accessor 'Descendant.foo' for "
305 "'model_inheritance.Foo.foo' clashes with field name "
306 "'model_inheritance.Descendant.foo'.",
307 hint=(
308 "Rename field 'model_inheritance.Descendant.foo', or "
309 "add/change a related_name argument to the definition "
310 "for field 'model_inheritance.Foo.foo'."
311 ),
312 obj=Foo._meta.get_field("foo"),
313 id="fields.E302",
314 ),
315 Error(
316 "Reverse query name for 'model_inheritance.Foo.foo' "
317 "clashes with field name "
318 "'model_inheritance.Descendant.foo'.",
319 hint=(
320 "Rename field 'model_inheritance.Descendant.foo', or "
321 "add/change a related_name argument to the definition "
322 "for field 'model_inheritance.Foo.foo'."
323 ),
324 obj=Foo._meta.get_field("foo"),
325 id="fields.E303",
326 ),
327 ],
328 )
329
330 def test_multi_inheritance_field_clashes(self):
331 class AbstractBase(models.Model):
332 name = models.CharField(max_length=30)
333
334 class Meta:
335 abstract = True
336
337 class ConcreteBase(AbstractBase):
338 pass
339
340 class AbstractDescendant(ConcreteBase):
341 class Meta:
342 abstract = True
343
344 class ConcreteDescendant(AbstractDescendant):
345 name = models.CharField(max_length=100)
346
347 self.assertEqual(
348 ConcreteDescendant.check(),
349 [
350 Error(
351 "The field 'name' clashes with the field 'name' from "
352 "model 'model_inheritance.concretebase'.",
353 obj=ConcreteDescendant._meta.get_field("name"),
354 id="models.E006",
355 )
356 ],
357 )
358
359 def test_override_one2one_relation_auto_field_clashes(self):
360 class ConcreteParent(models.Model):
361 name = models.CharField(max_length=255)
362
363 class AbstractParent(models.Model):
364 name = models.IntegerField()
365
366 class Meta:
367 abstract = True
368
369 msg = (
370 "Auto-generated field 'concreteparent_ptr' in class 'Descendant' "
371 "for parent_link to base class 'ConcreteParent' clashes with "
372 "declared field of the same name."
373 )
374 with self.assertRaisesMessage(FieldError, msg):
375
376 class Descendant(ConcreteParent, AbstractParent):
377 concreteparent_ptr = models.CharField(max_length=30)
378
379 def test_abstract_model_with_regular_python_mixin_mro(self):
380 class AbstractModel(models.Model):
381 name = models.CharField(max_length=255)
382 age = models.IntegerField()
383
384 class Meta:
385 abstract = True
386
387 class Mixin:
388 age = None
389
390 class Mixin2:
391 age = 2
392
393 class DescendantMixin(Mixin):
394 pass
395
396 class ConcreteModel(models.Model):
397 foo = models.IntegerField()
398
399 class ConcreteModel2(ConcreteModel):
400 age = models.SmallIntegerField()
401
402 def fields(model):
403 if not hasattr(model, "_meta"):
404 return []
405 return [(f.name, f.__class__) for f in model._meta.get_fields()]
406
407 model_dict = {"__module__": "model_inheritance"}
408 model1 = type("Model1", (AbstractModel, Mixin), model_dict.copy())
409 model2 = type("Model2", (Mixin2, AbstractModel), model_dict.copy())
410 model3 = type("Model3", (DescendantMixin, AbstractModel), model_dict.copy())
411 model4 = type("Model4", (Mixin2, Mixin, AbstractModel), model_dict.copy())
412 model5 = type(
413 "Model5", (Mixin2, ConcreteModel2, Mixin, AbstractModel), model_dict.copy()
414 )
415
416 self.assertEqual(
417 fields(model1),
418 [
419 ("id", models.AutoField),
420 ("name", models.CharField),
421 ("age", models.IntegerField),
422 ],
423 )
424
425 self.assertEqual(
426 fields(model2), [("id", models.AutoField), ("name", models.CharField)]
427 )
428 self.assertEqual(getattr(model2, "age"), 2)
429
430 self.assertEqual(
431 fields(model3), [("id", models.AutoField), ("name", models.CharField)]
432 )
433
434 self.assertEqual(
435 fields(model4), [("id", models.AutoField), ("name", models.CharField)]
436 )
437 self.assertEqual(getattr(model4, "age"), 2)
438
439 self.assertEqual(
440 fields(model5),
441 [
442 ("id", models.AutoField),
443 ("foo", models.IntegerField),
444 ("concretemodel_ptr", models.OneToOneField),
445 ("age", models.SmallIntegerField),
446 ("concretemodel2_ptr", models.OneToOneField),
447 ("name", models.CharField),
448 ],
449 )