Debian Codegraph @

tests/check_framework/test_model_checks.py

raw
1 from unittest import mock
2
3 from django.core import checks
4 from django.core.checks import Error, Warning
5 from django.db import models
6 from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature
7 from django.test.utils import (
8 isolate_apps,
9 modify_settings,
10 override_settings,
11 override_system_checks,
12 )
13
14
15 class EmptyRouter:
16 pass
17
18
19 @isolate_apps("check_framework", attr_name="apps")
20 @override_system_checks([checks.model_checks.check_all_models])
21 class DuplicateDBTableTests(SimpleTestCase):
22 def test_collision_in_same_app(self):
23 class Model1(models.Model):
24 class Meta:
25 db_table = "test_table"
26
27 class Model2(models.Model):
28 class Meta:
29 db_table = "test_table"
30
31 self.assertEqual(
32 checks.run_checks(app_configs=self.apps.get_app_configs()),
33 [
34 Error(
35 "db_table 'test_table' is used by multiple models: "
36 "check_framework.Model1, check_framework.Model2.",
37 obj="test_table",
38 id="models.E028",
39 )
40 ],
41 )
42
43 @override_settings(
44 DATABASE_ROUTERS=["check_framework.test_model_checks.EmptyRouter"]
45 )
46 def test_collision_in_same_app_database_routers_installed(self):
47 class Model1(models.Model):
48 class Meta:
49 db_table = "test_table"
50
51 class Model2(models.Model):
52 class Meta:
53 db_table = "test_table"
54
55 self.assertEqual(
56 checks.run_checks(app_configs=self.apps.get_app_configs()),
57 [
58 Warning(
59 "db_table 'test_table' is used by multiple models: "
60 "check_framework.Model1, check_framework.Model2.",
61 hint=(
62 "You have configured settings.DATABASE_ROUTERS. Verify "
63 "that check_framework.Model1, check_framework.Model2 are "
64 "correctly routed to separate databases."
65 ),
66 obj="test_table",
67 id="models.W035",
68 )
69 ],
70 )
71
72 @modify_settings(INSTALLED_APPS={"append": "basic"})
73 @isolate_apps("basic", "check_framework", kwarg_name="apps")
74 def test_collision_across_apps(self, apps):
75 class Model1(models.Model):
76 class Meta:
77 app_label = "basic"
78 db_table = "test_table"
79
80 class Model2(models.Model):
81 class Meta:
82 app_label = "check_framework"
83 db_table = "test_table"
84
85 self.assertEqual(
86 checks.run_checks(app_configs=apps.get_app_configs()),
87 [
88 Error(
89 "db_table 'test_table' is used by multiple models: "
90 "basic.Model1, check_framework.Model2.",
91 obj="test_table",
92 id="models.E028",
93 )
94 ],
95 )
96
97 @modify_settings(INSTALLED_APPS={"append": "basic"})
98 @override_settings(
99 DATABASE_ROUTERS=["check_framework.test_model_checks.EmptyRouter"]
100 )
101 @isolate_apps("basic", "check_framework", kwarg_name="apps")
102 def test_collision_across_apps_database_routers_installed(self, apps):
103 class Model1(models.Model):
104 class Meta:
105 app_label = "basic"
106 db_table = "test_table"
107
108 class Model2(models.Model):
109 class Meta:
110 app_label = "check_framework"
111 db_table = "test_table"
112
113 self.assertEqual(
114 checks.run_checks(app_configs=apps.get_app_configs()),
115 [
116 Warning(
117 "db_table 'test_table' is used by multiple models: "
118 "basic.Model1, check_framework.Model2.",
119 hint=(
120 "You have configured settings.DATABASE_ROUTERS. Verify "
121 "that basic.Model1, check_framework.Model2 are correctly "
122 "routed to separate databases."
123 ),
124 obj="test_table",
125 id="models.W035",
126 )
127 ],
128 )
129
130 def test_no_collision_for_unmanaged_models(self):
131 class Unmanaged(models.Model):
132 class Meta:
133 db_table = "test_table"
134 managed = False
135
136 class Managed(models.Model):
137 class Meta:
138 db_table = "test_table"
139
140 self.assertEqual(checks.run_checks(app_configs=self.apps.get_app_configs()), [])
141
142 def test_no_collision_for_proxy_models(self):
143 class Model(models.Model):
144 class Meta:
145 db_table = "test_table"
146
147 class ProxyModel(Model):
148 class Meta:
149 proxy = True
150
151 self.assertEqual(Model._meta.db_table, ProxyModel._meta.db_table)
152 self.assertEqual(checks.run_checks(app_configs=self.apps.get_app_configs()), [])
153
154
155 @isolate_apps("check_framework", attr_name="apps")
156 @override_system_checks([checks.model_checks.check_all_models])
157 class IndexNameTests(SimpleTestCase):
158 def test_collision_in_same_model(self):
159 index = models.Index(fields=["id"], name="foo")
160
161 class Model(models.Model):
162 class Meta:
163 indexes = [index, index]
164
165 self.assertEqual(
166 checks.run_checks(app_configs=self.apps.get_app_configs()),
167 [
168 Error(
169 "index name 'foo' is not unique for model check_framework.Model.",
170 id="models.E029",
171 ),
172 ],
173 )
174
175 def test_collision_in_different_models(self):
176 index = models.Index(fields=["id"], name="foo")
177
178 class Model1(models.Model):
179 class Meta:
180 indexes = [index]
181
182 class Model2(models.Model):
183 class Meta:
184 indexes = [index]
185
186 self.assertEqual(
187 checks.run_checks(app_configs=self.apps.get_app_configs()),
188 [
189 Error(
190 "index name 'foo' is not unique among models: "
191 "check_framework.Model1, check_framework.Model2.",
192 id="models.E030",
193 ),
194 ],
195 )
196
197 def test_collision_abstract_model(self):
198 class AbstractModel(models.Model):
199 class Meta:
200 indexes = [models.Index(fields=["id"], name="foo")]
201 abstract = True
202
203 class Model1(AbstractModel):
204 pass
205
206 class Model2(AbstractModel):
207 pass
208
209 self.assertEqual(
210 checks.run_checks(app_configs=self.apps.get_app_configs()),
211 [
212 Error(
213 "index name 'foo' is not unique among models: "
214 "check_framework.Model1, check_framework.Model2.",
215 id="models.E030",
216 ),
217 ],
218 )
219
220 def test_no_collision_abstract_model_interpolation(self):
221 class AbstractModel(models.Model):
222 name = models.CharField(max_length=20)
223
224 class Meta:
225 indexes = [
226 models.Index(fields=["name"], name="%(app_label)s_%(class)s_foo")
227 ]
228 abstract = True
229
230 class Model1(AbstractModel):
231 pass
232
233 class Model2(AbstractModel):
234 pass
235
236 self.assertEqual(checks.run_checks(app_configs=self.apps.get_app_configs()), [])
237
238 @modify_settings(INSTALLED_APPS={"append": "basic"})
239 @isolate_apps("basic", "check_framework", kwarg_name="apps")
240 def test_collision_across_apps(self, apps):
241 index = models.Index(fields=["id"], name="foo")
242
243 class Model1(models.Model):
244 class Meta:
245 app_label = "basic"
246 indexes = [index]
247
248 class Model2(models.Model):
249 class Meta:
250 app_label = "check_framework"
251 indexes = [index]
252
253 self.assertEqual(
254 checks.run_checks(app_configs=apps.get_app_configs()),
255 [
256 Error(
257 "index name 'foo' is not unique among models: basic.Model1, "
258 "check_framework.Model2.",
259 id="models.E030",
260 ),
261 ],
262 )
263
264 @modify_settings(INSTALLED_APPS={"append": "basic"})
265 @isolate_apps("basic", "check_framework", kwarg_name="apps")
266 def test_no_collision_across_apps_interpolation(self, apps):
267 index = models.Index(fields=["id"], name="%(app_label)s_%(class)s_foo")
268
269 class Model1(models.Model):
270 class Meta:
271 app_label = "basic"
272 constraints = [index]
273
274 class Model2(models.Model):
275 class Meta:
276 app_label = "check_framework"
277 constraints = [index]
278
279 self.assertEqual(checks.run_checks(app_configs=apps.get_app_configs()), [])
280
281
282 @isolate_apps("check_framework", attr_name="apps")
283 @override_system_checks([checks.model_checks.check_all_models])
284 @skipUnlessDBFeature("supports_table_check_constraints")
285 class ConstraintNameTests(TestCase):
286 def test_collision_in_same_model(self):
287 class Model(models.Model):
288 class Meta:
289 constraints = [
290 models.CheckConstraint(condition=models.Q(id__gt=0), name="foo"),
291 models.CheckConstraint(condition=models.Q(id__lt=100), name="foo"),
292 ]
293
294 self.assertEqual(
295 checks.run_checks(app_configs=self.apps.get_app_configs()),
296 [
297 Error(
298 "constraint name 'foo' is not unique for model "
299 "check_framework.Model.",
300 id="models.E031",
301 ),
302 ],
303 )
304
305 def test_collision_in_different_models(self):
306 constraint = models.CheckConstraint(condition=models.Q(id__gt=0), name="foo")
307
308 class Model1(models.Model):
309 class Meta:
310 constraints = [constraint]
311
312 class Model2(models.Model):
313 class Meta:
314 constraints = [constraint]
315
316 self.assertEqual(
317 checks.run_checks(app_configs=self.apps.get_app_configs()),
318 [
319 Error(
320 "constraint name 'foo' is not unique among models: "
321 "check_framework.Model1, check_framework.Model2.",
322 id="models.E032",
323 ),
324 ],
325 )
326
327 def test_collision_abstract_model(self):
328 class AbstractModel(models.Model):
329 class Meta:
330 constraints = [
331 models.CheckConstraint(condition=models.Q(id__gt=0), name="foo")
332 ]
333 abstract = True
334
335 class Model1(AbstractModel):
336 pass
337
338 class Model2(AbstractModel):
339 pass
340
341 self.assertEqual(
342 checks.run_checks(app_configs=self.apps.get_app_configs()),
343 [
344 Error(
345 "constraint name 'foo' is not unique among models: "
346 "check_framework.Model1, check_framework.Model2.",
347 id="models.E032",
348 ),
349 ],
350 )
351
352 def test_no_collision_abstract_model_interpolation(self):
353 class AbstractModel(models.Model):
354 class Meta:
355 constraints = [
356 models.CheckConstraint(
357 condition=models.Q(id__gt=0), name="%(app_label)s_%(class)s_foo"
358 ),
359 ]
360 abstract = True
361
362 class Model1(AbstractModel):
363 pass
364
365 class Model2(AbstractModel):
366 pass
367
368 self.assertEqual(checks.run_checks(app_configs=self.apps.get_app_configs()), [])
369
370 @modify_settings(INSTALLED_APPS={"append": "basic"})
371 @isolate_apps("basic", "check_framework", kwarg_name="apps")
372 def test_collision_across_apps(self, apps):
373 constraint = models.CheckConstraint(condition=models.Q(id__gt=0), name="foo")
374
375 class Model1(models.Model):
376 class Meta:
377 app_label = "basic"
378 constraints = [constraint]
379
380 class Model2(models.Model):
381 class Meta:
382 app_label = "check_framework"
383 constraints = [constraint]
384
385 self.assertEqual(
386 checks.run_checks(app_configs=apps.get_app_configs()),
387 [
388 Error(
389 "constraint name 'foo' is not unique among models: "
390 "basic.Model1, check_framework.Model2.",
391 id="models.E032",
392 ),
393 ],
394 )
395
396 @modify_settings(INSTALLED_APPS={"append": "basic"})
397 @isolate_apps("basic", "check_framework", kwarg_name="apps")
398 def test_no_collision_across_apps_interpolation(self, apps):
399 constraint = models.CheckConstraint(
400 condition=models.Q(id__gt=0), name="%(app_label)s_%(class)s_foo"
401 )
402
403 class Model1(models.Model):
404 class Meta:
405 app_label = "basic"
406 constraints = [constraint]
407
408 class Model2(models.Model):
409 class Meta:
410 app_label = "check_framework"
411 constraints = [constraint]
412
413 self.assertEqual(checks.run_checks(app_configs=apps.get_app_configs()), [])
414
415
416 def mocked_is_overridden(self, setting):
417 # Force treating DEFAULT_AUTO_FIELD = 'django.db.models.AutoField' as a not
418 # overridden setting.
419 return (
420 setting != "DEFAULT_AUTO_FIELD"
421 or self.DEFAULT_AUTO_FIELD != "django.db.models.AutoField"
422 )
423
424
425 @mock.patch("django.conf.UserSettingsHolder.is_overridden", mocked_is_overridden)
426 @override_settings(DEFAULT_AUTO_FIELD="django.db.models.AutoField")
427 @isolate_apps("check_framework.apps.CheckDefaultPKConfig", attr_name="apps")
428 @override_system_checks([checks.model_checks.check_all_models])
429 class ModelDefaultAutoFieldTests(SimpleTestCase):
430 msg = (
431 "Auto-created primary key used when not defining a primary key type, "
432 "by default 'django.db.models.AutoField'."
433 )
434 hint = (
435 "Configure the DEFAULT_AUTO_FIELD setting or the "
436 "CheckDefaultPKConfig.default_auto_field attribute to point to a "
437 "subclass of AutoField, e.g. 'django.db.models.BigAutoField'."
438 )
439
440 def test_auto_created_pk(self):
441 class Model(models.Model):
442 pass
443
444 self.assertEqual(
445 checks.run_checks(app_configs=self.apps.get_app_configs()),
446 [
447 Warning(self.msg, hint=self.hint, obj=Model, id="models.W042"),
448 ],
449 )
450
451 def test_explicit_inherited_pk(self):
452 class Parent(models.Model):
453 id = models.AutoField(primary_key=True)
454
455 class Child(Parent):
456 pass
457
458 self.assertEqual(checks.run_checks(app_configs=self.apps.get_app_configs()), [])
459
460 def test_skipped_on_model_with_invalid_app_label(self):
461 class Model(models.Model):
462 class Meta:
463 app_label = "invalid_app_label"
464
465 self.assertEqual(Model.check(), [])
466
467 def test_skipped_on_abstract_model(self):
468 class Abstract(models.Model):
469 class Meta:
470 abstract = True
471
472 # Call .check() because abstract models are not registered.
473 self.assertEqual(Abstract.check(), [])
474
475 def test_explicit_inherited_parent_link(self):
476 class Parent(models.Model):
477 id = models.AutoField(primary_key=True)
478
479 class Child(Parent):
480 parent_ptr = models.OneToOneField(Parent, models.CASCADE, parent_link=True)
481
482 self.assertEqual(checks.run_checks(app_configs=self.apps.get_app_configs()), [])
483
484 def test_auto_created_inherited_pk(self):
485 class Parent(models.Model):
486 pass
487
488 class Child(Parent):
489 pass
490
491 self.assertEqual(
492 checks.run_checks(app_configs=self.apps.get_app_configs()),
493 [
494 Warning(self.msg, hint=self.hint, obj=Parent, id="models.W042"),
495 ],
496 )
497
498 def test_auto_created_inherited_parent_link(self):
499 class Parent(models.Model):
500 pass
501
502 class Child(Parent):
503 parent_ptr = models.OneToOneField(Parent, models.CASCADE, parent_link=True)
504
505 self.assertEqual(
506 checks.run_checks(app_configs=self.apps.get_app_configs()),
507 [
508 Warning(self.msg, hint=self.hint, obj=Parent, id="models.W042"),
509 ],
510 )
511
512 def test_auto_created_pk_inherited_abstract_parent(self):
513 class Parent(models.Model):
514 class Meta:
515 abstract = True
516
517 class Child(Parent):
518 pass
519
520 self.assertEqual(
521 checks.run_checks(app_configs=self.apps.get_app_configs()),
522 [
523 Warning(self.msg, hint=self.hint, obj=Child, id="models.W042"),
524 ],
525 )
526
527 @override_settings(DEFAULT_AUTO_FIELD="django.db.models.BigAutoField")
528 def test_default_auto_field_setting(self):
529 class Model(models.Model):
530 pass
531
532 self.assertEqual(checks.run_checks(app_configs=self.apps.get_app_configs()), [])
533
534 def test_explicit_pk(self):
535 class Model(models.Model):
536 id = models.BigAutoField(primary_key=True)
537
538 self.assertEqual(checks.run_checks(app_configs=self.apps.get_app_configs()), [])
539
540 @isolate_apps("check_framework.apps.CheckPKConfig", kwarg_name="apps")
541 def test_app_default_auto_field(self, apps):
542 class ModelWithPkViaAppConfig(models.Model):
543 class Meta:
544 app_label = "check_framework.apps.CheckPKConfig"
545
546 self.assertEqual(checks.run_checks(app_configs=apps.get_app_configs()), [])