Debian Codegraph @

tests/invalid_models_tests/test_ordinary_fields.py

raw
1 import unittest
2 import uuid
3
4 from django.core.checks import Error
5 from django.core.checks import Warning as DjangoWarning
6 from django.db import connection, models
7 from django.db.models.functions import Coalesce, LPad, Pi
8 from django.test import SimpleTestCase, TestCase, skipIfDBFeature, skipUnlessDBFeature
9 from django.test.utils import isolate_apps, override_settings
10 from django.utils.functional import lazy
11 from django.utils.timezone import now
12 from django.utils.translation import gettext_lazy as _
13 from django.utils.version import get_docs_version
14
15
16 @isolate_apps("invalid_models_tests")
17 class AutoFieldTests(SimpleTestCase):
18 def test_valid_case(self):
19 class Model(models.Model):
20 id = models.AutoField(primary_key=True)
21
22 field = Model._meta.get_field("id")
23 self.assertEqual(field.check(), [])
24
25 def test_primary_key(self):
26 # primary_key must be True. Refs #12467.
27 class Model(models.Model):
28 field = models.AutoField(primary_key=False)
29
30 # Prevent Django from autocreating `id` AutoField, which would
31 # result in an error, because a model must have exactly one
32 # AutoField.
33 another = models.IntegerField(primary_key=True)
34
35 field = Model._meta.get_field("field")
36 self.assertEqual(
37 field.check(),
38 [
39 Error(
40 "AutoFields must set primary_key=True.",
41 obj=field,
42 id="fields.E100",
43 ),
44 ],
45 )
46
47 def test_max_length_warning(self):
48 class Model(models.Model):
49 auto = models.AutoField(primary_key=True, max_length=2)
50
51 field = Model._meta.get_field("auto")
52 self.assertEqual(
53 field.check(),
54 [
55 DjangoWarning(
56 "'max_length' is ignored when used with %s."
57 % field.__class__.__name__,
58 hint="Remove 'max_length' from field",
59 obj=field,
60 id="fields.W122",
61 ),
62 ],
63 )
64
65
66 @isolate_apps("invalid_models_tests")
67 class BinaryFieldTests(SimpleTestCase):
68 def test_valid_default_value(self):
69 class Model(models.Model):
70 field1 = models.BinaryField(default=b"test")
71 field2 = models.BinaryField(default=None)
72
73 for field_name in ("field1", "field2"):
74 field = Model._meta.get_field(field_name)
75 self.assertEqual(field.check(), [])
76
77 def test_str_default_value(self):
78 class Model(models.Model):
79 field = models.BinaryField(default="test")
80
81 field = Model._meta.get_field("field")
82 self.assertEqual(
83 field.check(),
84 [
85 Error(
86 "BinaryField's default cannot be a string. Use bytes content "
87 "instead.",
88 obj=field,
89 id="fields.E170",
90 ),
91 ],
92 )
93
94
95 @isolate_apps("invalid_models_tests")
96 class CharFieldTests(TestCase):
97 def test_valid_field(self):
98 class Model(models.Model):
99 field = models.CharField(
100 max_length=255,
101 choices=[
102 ("1", "item1"),
103 ("2", "item2"),
104 ],
105 db_index=True,
106 )
107
108 field = Model._meta.get_field("field")
109 self.assertEqual(field.check(), [])
110
111 def test_missing_max_length(self):
112 class Model(models.Model):
113 field = models.CharField()
114
115 field = Model._meta.get_field("field")
116 expected = (
117 []
118 if connection.features.supports_unlimited_charfield
119 else [
120 Error(
121 "CharFields must define a 'max_length' attribute.",
122 obj=field,
123 id="fields.E120",
124 ),
125 ]
126 )
127 self.assertEqual(field.check(), expected)
128
129 def test_negative_max_length(self):
130 class Model(models.Model):
131 field = models.CharField(max_length=-1)
132
133 field = Model._meta.get_field("field")
134 self.assertEqual(
135 field.check(),
136 [
137 Error(
138 "'max_length' must be a positive integer.",
139 obj=field,
140 id="fields.E121",
141 ),
142 ],
143 )
144
145 def test_bad_max_length_value(self):
146 class Model(models.Model):
147 field = models.CharField(max_length="bad")
148
149 field = Model._meta.get_field("field")
150 self.assertEqual(
151 field.check(),
152 [
153 Error(
154 "'max_length' must be a positive integer.",
155 obj=field,
156 id="fields.E121",
157 ),
158 ],
159 )
160
161 def test_str_max_length_value(self):
162 class Model(models.Model):
163 field = models.CharField(max_length="20")
164
165 field = Model._meta.get_field("field")
166 self.assertEqual(
167 field.check(),
168 [
169 Error(
170 "'max_length' must be a positive integer.",
171 obj=field,
172 id="fields.E121",
173 ),
174 ],
175 )
176
177 def test_str_max_length_type(self):
178 class Model(models.Model):
179 field = models.CharField(max_length=True)
180
181 field = Model._meta.get_field("field")
182 self.assertEqual(
183 field.check(),
184 [
185 Error(
186 "'max_length' must be a positive integer.",
187 obj=field,
188 id="fields.E121",
189 ),
190 ],
191 )
192
193 def test_non_iterable_choices(self):
194 class Model(models.Model):
195 field = models.CharField(max_length=10, choices="bad")
196
197 field = Model._meta.get_field("field")
198 self.assertEqual(
199 field.check(),
200 [
201 Error(
202 "'choices' must be a mapping (e.g. a dictionary) or an iterable "
203 "(e.g. a list or tuple).",
204 obj=field,
205 id="fields.E004",
206 ),
207 ],
208 )
209
210 def test_non_iterable_choices_two_letters(self):
211 """Two letters isn't a valid choice pair."""
212
213 class Model(models.Model):
214 field = models.CharField(max_length=10, choices=["ab"])
215
216 field = Model._meta.get_field("field")
217 self.assertEqual(
218 field.check(),
219 [
220 Error(
221 "'choices' must be a mapping of actual values to human readable "
222 "names or an iterable containing (actual value, human readable "
223 "name) tuples.",
224 obj=field,
225 id="fields.E005",
226 ),
227 ],
228 )
229
230 def test_iterable_of_iterable_choices(self):
231 class ThingItem:
232 def __init__(self, value, display):
233 self.value = value
234 self.display = display
235
236 def __iter__(self):
237 return iter((self.value, self.display))
238
239 def __len__(self):
240 return 2
241
242 class Things:
243 def __iter__(self):
244 return iter((ThingItem(1, 2), ThingItem(3, 4)))
245
246 class ThingWithIterableChoices(models.Model):
247 thing = models.CharField(max_length=100, blank=True, choices=Things())
248
249 self.assertEqual(ThingWithIterableChoices._meta.get_field("thing").check(), [])
250
251 def test_choices_containing_non_pairs(self):
252 class Model(models.Model):
253 field = models.CharField(max_length=10, choices=[(1, 2, 3), (1, 2, 3)])
254
255 class Model2(models.Model):
256 field = models.IntegerField(choices=[0])
257
258 for model in (Model, Model2):
259 with self.subTest(model.__name__):
260 field = model._meta.get_field("field")
261 self.assertEqual(
262 field.check(),
263 [
264 Error(
265 "'choices' must be a mapping of actual values to human "
266 "readable names or an iterable containing (actual value, "
267 "human readable name) tuples.",
268 obj=field,
269 id="fields.E005",
270 ),
271 ],
272 )
273
274 def test_choices_containing_lazy(self):
275 class Model(models.Model):
276 field = models.CharField(
277 max_length=10, choices=[["1", _("1")], ["2", _("2")]]
278 )
279
280 self.assertEqual(Model._meta.get_field("field").check(), [])
281
282 def test_lazy_choices(self):
283 class Model(models.Model):
284 field = models.CharField(
285 max_length=10, choices=lazy(lambda: [[1, "1"], [2, "2"]], tuple)()
286 )
287
288 self.assertEqual(Model._meta.get_field("field").check(), [])
289
290 def test_choices_named_group(self):
291 class Model(models.Model):
292 field = models.CharField(
293 max_length=10,
294 choices=[
295 ["knights", [["L", "Lancelot"], ["G", "Galahad"]]],
296 ["wizards", [["T", "Tim the Enchanter"]]],
297 ["R", "Random character"],
298 ],
299 )
300
301 self.assertEqual(Model._meta.get_field("field").check(), [])
302
303 def test_choices_named_group_non_pairs(self):
304 class Model(models.Model):
305 field = models.CharField(
306 max_length=10,
307 choices=[["knights", [["L", "Lancelot", "Du Lac"]]]],
308 )
309
310 field = Model._meta.get_field("field")
311 self.assertEqual(
312 field.check(),
313 [
314 Error(
315 "'choices' must be a mapping of actual values to human readable "
316 "names or an iterable containing (actual value, human readable "
317 "name) tuples.",
318 obj=field,
319 id="fields.E005",
320 ),
321 ],
322 )
323
324 def test_choices_named_group_bad_structure(self):
325 class Model(models.Model):
326 field = models.CharField(
327 max_length=10,
328 choices=[
329 [
330 "knights",
331 [
332 ["Noble", [["G", "Galahad"]]],
333 ["Combative", [["L", "Lancelot"]]],
334 ],
335 ],
336 ],
337 )
338
339 field = Model._meta.get_field("field")
340 self.assertEqual(
341 field.check(),
342 [
343 Error(
344 "'choices' must be a mapping of actual values to human readable "
345 "names or an iterable containing (actual value, human readable "
346 "name) tuples.",
347 obj=field,
348 id="fields.E005",
349 ),
350 ],
351 )
352
353 def test_choices_named_group_lazy(self):
354 class Model(models.Model):
355 field = models.CharField(
356 max_length=10,
357 choices=[
358 [_("knights"), [["L", _("Lancelot")], ["G", _("Galahad")]]],
359 ["R", _("Random character")],
360 ],
361 )
362
363 self.assertEqual(Model._meta.get_field("field").check(), [])
364
365 def test_choices_in_max_length(self):
366 class Model(models.Model):
367 field = models.CharField(
368 max_length=2,
369 choices=[("ABC", "Value Too Long!"), ("OK", "Good")],
370 )
371 group = models.CharField(
372 max_length=2,
373 choices=[
374 ("Nested", [("OK", "Good"), ("Longer", "Longer")]),
375 ("Grouped", [("Bad", "Bad")]),
376 ],
377 )
378
379 for name, choice_max_length in (("field", 3), ("group", 6)):
380 with self.subTest(name):
381 field = Model._meta.get_field(name)
382 self.assertEqual(
383 field.check(),
384 [
385 Error(
386 "'max_length' is too small to fit the longest value "
387 "in 'choices' (%d characters)." % choice_max_length,
388 obj=field,
389 id="fields.E009",
390 ),
391 ],
392 )
393
394 def test_bad_db_index_value(self):
395 class Model(models.Model):
396 field = models.CharField(max_length=10, db_index="bad")
397
398 field = Model._meta.get_field("field")
399 self.assertEqual(
400 field.check(),
401 [
402 Error(
403 "'db_index' must be None, True or False.",
404 obj=field,
405 id="fields.E006",
406 ),
407 ],
408 )
409
410 def test_bad_validators(self):
411 class Model(models.Model):
412 field = models.CharField(max_length=10, validators=[True])
413
414 field = Model._meta.get_field("field")
415 self.assertEqual(
416 field.check(),
417 [
418 Error(
419 "All 'validators' must be callable.",
420 hint=(
421 "validators[0] (True) isn't a function or instance of a "
422 "validator class."
423 ),
424 obj=field,
425 id="fields.E008",
426 ),
427 ],
428 )
429
430 @unittest.skipUnless(connection.vendor == "mysql", "Test valid only for MySQL")
431 def test_too_long_char_field_under_mysql(self):
432 from django.db.backends.mysql.validation import DatabaseValidation
433
434 class Model(models.Model):
435 field = models.CharField(unique=True, max_length=256)
436
437 field = Model._meta.get_field("field")
438 validator = DatabaseValidation(connection=connection)
439 self.assertEqual(
440 validator.check_field(field),
441 [
442 DjangoWarning(
443 "%s may not allow unique CharFields to have a max_length > "
444 "255." % connection.display_name,
445 hint=(
446 "See: https://docs.djangoproject.com/en/%s/ref/databases/"
447 "#mysql-character-fields" % get_docs_version()
448 ),
449 obj=field,
450 id="mysql.W003",
451 )
452 ],
453 )
454
455 def test_db_collation(self):
456 class Model(models.Model):
457 field = models.CharField(max_length=100, db_collation="anything")
458
459 field = Model._meta.get_field("field")
460 error = Error(
461 "%s does not support a database collation on CharFields."
462 % connection.display_name,
463 id="fields.E190",
464 obj=field,
465 )
466 expected = (
467 [] if connection.features.supports_collation_on_charfield else [error]
468 )
469 self.assertEqual(field.check(databases=self.databases), expected)
470
471 def test_db_collation_required_db_features(self):
472 class Model(models.Model):
473 field = models.CharField(max_length=100, db_collation="anything")
474
475 class Meta:
476 required_db_features = {"supports_collation_on_charfield"}
477
478 field = Model._meta.get_field("field")
479 self.assertEqual(field.check(databases=self.databases), [])
480
481
482 @isolate_apps("invalid_models_tests")
483 class DateFieldTests(SimpleTestCase):
484 maxDiff = None
485
486 def test_auto_now_and_auto_now_add_raise_error(self):
487 class Model(models.Model):
488 field0 = models.DateTimeField(auto_now=True, auto_now_add=True, default=now)
489 field1 = models.DateTimeField(
490 auto_now=True, auto_now_add=False, default=now
491 )
492 field2 = models.DateTimeField(
493 auto_now=False, auto_now_add=True, default=now
494 )
495 field3 = models.DateTimeField(
496 auto_now=True, auto_now_add=True, default=None
497 )
498
499 expected = []
500 checks = []
501 for i in range(4):
502 field = Model._meta.get_field("field%d" % i)
503 expected.append(
504 Error(
505 "The options auto_now, auto_now_add, and default "
506 "are mutually exclusive. Only one of these options "
507 "may be present.",
508 obj=field,
509 id="fields.E160",
510 )
511 )
512 checks.extend(field.check())
513 self.assertEqual(checks, expected)
514
515 def test_fix_default_value(self):
516 class Model(models.Model):
517 field_dt = models.DateField(default=now())
518 field_d = models.DateField(default=now().date())
519 field_now = models.DateField(default=now)
520
521 field_dt = Model._meta.get_field("field_dt")
522 field_d = Model._meta.get_field("field_d")
523 field_now = Model._meta.get_field("field_now")
524 errors = field_dt.check()
525 errors.extend(field_d.check())
526 errors.extend(field_now.check()) # doesn't raise a warning
527 self.assertEqual(
528 errors,
529 [
530 DjangoWarning(
531 "Fixed default value provided.",
532 hint="It seems you set a fixed date / time / datetime "
533 "value as default for this field. This may not be "
534 "what you want. If you want to have the current date "
535 "as default, use `django.utils.timezone.now`",
536 obj=field_dt,
537 id="fields.W161",
538 ),
539 DjangoWarning(
540 "Fixed default value provided.",
541 hint="It seems you set a fixed date / time / datetime "
542 "value as default for this field. This may not be "
543 "what you want. If you want to have the current date "
544 "as default, use `django.utils.timezone.now`",
545 obj=field_d,
546 id="fields.W161",
547 ),
548 ],
549 )
550
551 @override_settings(USE_TZ=True)
552 def test_fix_default_value_tz(self):
553 self.test_fix_default_value()
554
555
556 @isolate_apps("invalid_models_tests")
557 class DateTimeFieldTests(SimpleTestCase):
558 maxDiff = None
559
560 def test_fix_default_value(self):
561 class Model(models.Model):
562 field_dt = models.DateTimeField(default=now())
563 field_d = models.DateTimeField(default=now().date())
564 field_now = models.DateTimeField(default=now)
565
566 field_dt = Model._meta.get_field("field_dt")
567 field_d = Model._meta.get_field("field_d")
568 field_now = Model._meta.get_field("field_now")
569 errors = field_dt.check()
570 errors.extend(field_d.check())
571 errors.extend(field_now.check()) # doesn't raise a warning
572 self.assertEqual(
573 errors,
574 [
575 DjangoWarning(
576 "Fixed default value provided.",
577 hint="It seems you set a fixed date / time / datetime "
578 "value as default for this field. This may not be "
579 "what you want. If you want to have the current date "
580 "as default, use `django.utils.timezone.now`",
581 obj=field_dt,
582 id="fields.W161",
583 ),
584 DjangoWarning(
585 "Fixed default value provided.",
586 hint="It seems you set a fixed date / time / datetime "
587 "value as default for this field. This may not be "
588 "what you want. If you want to have the current date "
589 "as default, use `django.utils.timezone.now`",
590 obj=field_d,
591 id="fields.W161",
592 ),
593 ],
594 )
595
596 @override_settings(USE_TZ=True)
597 def test_fix_default_value_tz(self):
598 self.test_fix_default_value()
599
600
601 @isolate_apps("invalid_models_tests")
602 class DecimalFieldTests(SimpleTestCase):
603 def test_required_attributes(self):
604 class Model(models.Model):
605 field = models.DecimalField()
606
607 field = Model._meta.get_field("field")
608 self.assertEqual(
609 field.check(),
610 [
611 Error(
612 "DecimalFields must define a 'decimal_places' attribute.",
613 obj=field,
614 id="fields.E130",
615 ),
616 Error(
617 "DecimalFields must define a 'max_digits' attribute.",
618 obj=field,
619 id="fields.E132",
620 ),
621 ],
622 )
623
624 def test_negative_max_digits_and_decimal_places(self):
625 class Model(models.Model):
626 field = models.DecimalField(max_digits=-1, decimal_places=-1)
627
628 field = Model._meta.get_field("field")
629 self.assertEqual(
630 field.check(),
631 [
632 Error(
633 "'decimal_places' must be a non-negative integer.",
634 obj=field,
635 id="fields.E131",
636 ),
637 Error(
638 "'max_digits' must be a positive integer.",
639 obj=field,
640 id="fields.E133",
641 ),
642 ],
643 )
644
645 def test_bad_values_of_max_digits_and_decimal_places(self):
646 class Model(models.Model):
647 field = models.DecimalField(max_digits="bad", decimal_places="bad")
648
649 field = Model._meta.get_field("field")
650 self.assertEqual(
651 field.check(),
652 [
653 Error(
654 "'decimal_places' must be a non-negative integer.",
655 obj=field,
656 id="fields.E131",
657 ),
658 Error(
659 "'max_digits' must be a positive integer.",
660 obj=field,
661 id="fields.E133",
662 ),
663 ],
664 )
665
666 def test_decimal_places_greater_than_max_digits(self):
667 class Model(models.Model):
668 field = models.DecimalField(max_digits=9, decimal_places=10)
669
670 field = Model._meta.get_field("field")
671 self.assertEqual(
672 field.check(),
673 [
674 Error(
675 "'max_digits' must be greater or equal to 'decimal_places'.",
676 obj=field,
677 id="fields.E134",
678 ),
679 ],
680 )
681
682 def test_valid_field(self):
683 class Model(models.Model):
684 field = models.DecimalField(max_digits=10, decimal_places=10)
685
686 field = Model._meta.get_field("field")
687 self.assertEqual(field.check(), [])
688
689
690 @isolate_apps("invalid_models_tests")
691 class FileFieldTests(SimpleTestCase):
692 def test_valid_default_case(self):
693 class Model(models.Model):
694 field = models.FileField()
695
696 self.assertEqual(Model._meta.get_field("field").check(), [])
697
698 def test_valid_case(self):
699 class Model(models.Model):
700 field = models.FileField(upload_to="somewhere")
701
702 field = Model._meta.get_field("field")
703 self.assertEqual(field.check(), [])
704
705 def test_primary_key(self):
706 class Model(models.Model):
707 field = models.FileField(primary_key=False, upload_to="somewhere")
708
709 field = Model._meta.get_field("field")
710 self.assertEqual(
711 field.check(),
712 [
713 Error(
714 "'primary_key' is not a valid argument for a FileField.",
715 obj=field,
716 id="fields.E201",
717 )
718 ],
719 )
720
721 def test_upload_to_starts_with_slash(self):
722 class Model(models.Model):
723 field = models.FileField(upload_to="/somewhere")
724
725 field = Model._meta.get_field("field")
726 self.assertEqual(
727 field.check(),
728 [
729 Error(
730 "FileField's 'upload_to' argument must be a relative path, not "
731 "an absolute path.",
732 obj=field,
733 id="fields.E202",
734 hint="Remove the leading slash.",
735 )
736 ],
737 )
738
739 def test_upload_to_callable_not_checked(self):
740 def callable(instance, filename):
741 return "/" + filename
742
743 class Model(models.Model):
744 field = models.FileField(upload_to=callable)
745
746 field = Model._meta.get_field("field")
747 self.assertEqual(field.check(), [])
748
749
750 @isolate_apps("invalid_models_tests")
751 class FilePathFieldTests(SimpleTestCase):
752 def test_forbidden_files_and_folders(self):
753 class Model(models.Model):
754 field = models.FilePathField(allow_files=False, allow_folders=False)
755
756 field = Model._meta.get_field("field")
757 self.assertEqual(
758 field.check(),
759 [
760 Error(
761 "FilePathFields must have either 'allow_files' or 'allow_folders' "
762 "set to True.",
763 obj=field,
764 id="fields.E140",
765 ),
766 ],
767 )
768
769
770 @isolate_apps("invalid_models_tests")
771 class GenericIPAddressFieldTests(SimpleTestCase):
772 def test_non_nullable_blank(self):
773 class Model(models.Model):
774 field = models.GenericIPAddressField(null=False, blank=True)
775
776 field = Model._meta.get_field("field")
777 self.assertEqual(
778 field.check(),
779 [
780 Error(
781 (
782 "GenericIPAddressFields cannot have blank=True if null=False, "
783 "as blank values are stored as nulls."
784 ),
785 obj=field,
786 id="fields.E150",
787 ),
788 ],
789 )
790
791
792 @isolate_apps("invalid_models_tests")
793 class ImageFieldTests(SimpleTestCase):
794 def test_pillow_installed(self):
795 try:
796 from PIL import Image # NOQA
797 except ImportError:
798 pillow_installed = False
799 else:
800 pillow_installed = True
801
802 class Model(models.Model):
803 field = models.ImageField(upload_to="somewhere")
804
805 field = Model._meta.get_field("field")
806 errors = field.check()
807 expected = (
808 []
809 if pillow_installed
810 else [
811 Error(
812 "Cannot use ImageField because Pillow is not installed.",
813 hint=(
814 "Get Pillow at https://pypi.org/project/Pillow/ "
815 'or run command "python -m pip install Pillow".'
816 ),
817 obj=field,
818 id="fields.E210",
819 ),
820 ]
821 )
822 self.assertEqual(errors, expected)
823
824
825 @isolate_apps("invalid_models_tests")
826 class IntegerFieldTests(SimpleTestCase):
827 def test_max_length_warning(self):
828 class Model(models.Model):
829 integer = models.IntegerField(max_length=2)
830 biginteger = models.BigIntegerField(max_length=2)
831 smallinteger = models.SmallIntegerField(max_length=2)
832 positiveinteger = models.PositiveIntegerField(max_length=2)
833 positivebiginteger = models.PositiveBigIntegerField(max_length=2)
834 positivesmallinteger = models.PositiveSmallIntegerField(max_length=2)
835
836 for field in Model._meta.get_fields():
837 if field.auto_created:
838 continue
839 with self.subTest(name=field.name):
840 self.assertEqual(
841 field.check(),
842 [
843 DjangoWarning(
844 "'max_length' is ignored when used with %s."
845 % field.__class__.__name__,
846 hint="Remove 'max_length' from field",
847 obj=field,
848 id="fields.W122",
849 )
850 ],
851 )
852
853 def test_non_iterable_choices(self):
854 class Model(models.Model):
855 field = models.IntegerField(choices=123)
856
857 field = Model._meta.get_field("field")
858 self.assertEqual(
859 field.check(),
860 [
861 Error(
862 "'choices' must be a mapping (e.g. a dictionary) or an iterable "
863 "(e.g. a list or tuple).",
864 obj=field,
865 id="fields.E004",
866 ),
867 ],
868 )
869
870 def test_non_iterable_choices_number(self):
871 """An integer isn't a valid choice pair."""
872
873 class Model(models.Model):
874 field = models.IntegerField(choices=[123])
875
876 field = Model._meta.get_field("field")
877 self.assertEqual(
878 field.check(),
879 [
880 Error(
881 "'choices' must be a mapping of actual values to human readable "
882 "names or an iterable containing (actual value, human readable "
883 "name) tuples.",
884 obj=field,
885 id="fields.E005",
886 ),
887 ],
888 )
889
890
891 @isolate_apps("invalid_models_tests")
892 class TimeFieldTests(SimpleTestCase):
893 maxDiff = None
894
895 def test_fix_default_value(self):
896 class Model(models.Model):
897 field_dt = models.TimeField(default=now())
898 field_t = models.TimeField(default=now().time())
899 # Timezone-aware time object (when USE_TZ=True).
900 field_tz = models.TimeField(default=now().timetz())
901 field_now = models.DateField(default=now)
902
903 names = ["field_dt", "field_t", "field_tz", "field_now"]
904 fields = [Model._meta.get_field(name) for name in names]
905 errors = []
906 for field in fields:
907 errors.extend(field.check())
908
909 self.assertEqual(
910 errors,
911 [
912 DjangoWarning(
913 "Fixed default value provided.",
914 hint="It seems you set a fixed date / time / datetime "
915 "value as default for this field. This may not be "
916 "what you want. If you want to have the current date "
917 "as default, use `django.utils.timezone.now`",
918 obj=fields[0],
919 id="fields.W161",
920 ),
921 DjangoWarning(
922 "Fixed default value provided.",
923 hint="It seems you set a fixed date / time / datetime "
924 "value as default for this field. This may not be "
925 "what you want. If you want to have the current date "
926 "as default, use `django.utils.timezone.now`",
927 obj=fields[1],
928 id="fields.W161",
929 ),
930 DjangoWarning(
931 "Fixed default value provided.",
932 hint=(
933 "It seems you set a fixed date / time / datetime value as "
934 "default for this field. This may not be what you want. "
935 "If you want to have the current date as default, use "
936 "`django.utils.timezone.now`"
937 ),
938 obj=fields[2],
939 id="fields.W161",
940 ),
941 # field_now doesn't raise a warning.
942 ],
943 )
944
945 @override_settings(USE_TZ=True)
946 def test_fix_default_value_tz(self):
947 self.test_fix_default_value()
948
949
950 @isolate_apps("invalid_models_tests")
951 class TextFieldTests(TestCase):
952 @skipIfDBFeature("supports_index_on_text_field")
953 def test_max_length_warning(self):
954 class Model(models.Model):
955 value = models.TextField(db_index=True)
956
957 field = Model._meta.get_field("value")
958 field_type = field.db_type(connection)
959 self.assertEqual(
960 field.check(databases=self.databases),
961 [
962 DjangoWarning(
963 "%s does not support a database index on %s columns."
964 % (connection.display_name, field_type),
965 hint=(
966 "An index won't be created. Silence this warning if you "
967 "don't care about it."
968 ),
969 obj=field,
970 id="fields.W162",
971 )
972 ],
973 )
974
975 def test_db_collation(self):
976 class Model(models.Model):
977 field = models.TextField(db_collation="anything")
978
979 field = Model._meta.get_field("field")
980 error = Error(
981 "%s does not support a database collation on TextFields."
982 % connection.display_name,
983 id="fields.E190",
984 obj=field,
985 )
986 expected = (
987 [] if connection.features.supports_collation_on_textfield else [error]
988 )
989 self.assertEqual(field.check(databases=self.databases), expected)
990
991 def test_db_collation_required_db_features(self):
992 class Model(models.Model):
993 field = models.TextField(db_collation="anything")
994
995 class Meta:
996 required_db_features = {"supports_collation_on_textfield"}
997
998 field = Model._meta.get_field("field")
999 self.assertEqual(field.check(databases=self.databases), [])
1000
1001
1002 @isolate_apps("invalid_models_tests")
1003 class UUIDFieldTests(TestCase):
1004 def test_choices_named_group(self):
1005 class Model(models.Model):
1006 field = models.UUIDField(
1007 choices=[
1008 [
1009 "knights",
1010 [
1011 [
1012 uuid.UUID("5c859437-d061-4847-b3f7-e6b78852f8c8"),
1013 "Lancelot",
1014 ],
1015 [
1016 uuid.UUID("c7853ec1-2ea3-4359-b02d-b54e8f1bcee2"),
1017 "Galahad",
1018 ],
1019 ],
1020 ],
1021 [uuid.UUID("25d405be-4895-4d50-9b2e-d6695359ce47"), "Other"],
1022 ],
1023 )
1024
1025 self.assertEqual(Model._meta.get_field("field").check(), [])
1026
1027
1028 @isolate_apps("invalid_models_tests")
1029 @skipUnlessDBFeature("supports_json_field")
1030 class JSONFieldTests(TestCase):
1031 def test_invalid_default(self):
1032 class Model(models.Model):
1033 field = models.JSONField(default={})
1034
1035 self.assertEqual(
1036 Model._meta.get_field("field").check(),
1037 [
1038 DjangoWarning(
1039 msg=(
1040 "JSONField default should be a callable instead of an "
1041 "instance so that it's not shared between all field "
1042 "instances."
1043 ),
1044 hint=("Use a callable instead, e.g., use `dict` instead of `{}`."),
1045 obj=Model._meta.get_field("field"),
1046 id="fields.E010",
1047 )
1048 ],
1049 )
1050
1051 def test_valid_default(self):
1052 class Model(models.Model):
1053 field = models.JSONField(default=dict)
1054
1055 self.assertEqual(Model._meta.get_field("field").check(), [])
1056
1057 def test_valid_default_none(self):
1058 class Model(models.Model):
1059 field = models.JSONField(default=None)
1060
1061 self.assertEqual(Model._meta.get_field("field").check(), [])
1062
1063 def test_valid_callable_default(self):
1064 def callable_default():
1065 return {"it": "works"}
1066
1067 class Model(models.Model):
1068 field = models.JSONField(default=callable_default)
1069
1070 self.assertEqual(Model._meta.get_field("field").check(), [])
1071
1072
1073 @isolate_apps("invalid_models_tests")
1074 class DbCommentTests(TestCase):
1075 def test_db_comment(self):
1076 class Model(models.Model):
1077 field = models.IntegerField(db_comment="Column comment")
1078
1079 errors = Model._meta.get_field("field").check(databases=self.databases)
1080 expected = (
1081 []
1082 if connection.features.supports_comments
1083 else [
1084 DjangoWarning(
1085 f"{connection.display_name} does not support comments on columns "
1086 f"(db_comment).",
1087 obj=Model._meta.get_field("field"),
1088 id="fields.W163",
1089 ),
1090 ]
1091 )
1092 self.assertEqual(errors, expected)
1093
1094 def test_db_comment_required_db_features(self):
1095 class Model(models.Model):
1096 field = models.IntegerField(db_comment="Column comment")
1097
1098 class Meta:
1099 required_db_features = {"supports_comments"}
1100
1101 errors = Model._meta.get_field("field").check(databases=self.databases)
1102 self.assertEqual(errors, [])
1103
1104
1105 @isolate_apps("invalid_models_tests")
1106 class InvalidDBDefaultTests(TestCase):
1107 def test_db_default(self):
1108 class Model(models.Model):
1109 field = models.FloatField(db_default=Pi())
1110
1111 field = Model._meta.get_field("field")
1112 errors = field.check(databases=self.databases)
1113
1114 if connection.features.supports_expression_defaults:
1115 expected_errors = []
1116 else:
1117 msg = (
1118 f"{connection.display_name} does not support default database values "
1119 "with expressions (db_default)."
1120 )
1121 expected_errors = [Error(msg=msg, obj=field, id="fields.E011")]
1122 self.assertEqual(errors, expected_errors)
1123
1124 def test_db_default_literal(self):
1125 class Model(models.Model):
1126 field = models.IntegerField(db_default=1)
1127
1128 field = Model._meta.get_field("field")
1129 errors = field.check(databases=self.databases)
1130 self.assertEqual(errors, [])
1131
1132 def test_db_default_required_db_features(self):
1133 class Model(models.Model):
1134 field = models.FloatField(db_default=Pi())
1135
1136 class Meta:
1137 required_db_features = {"supports_expression_defaults"}
1138
1139 field = Model._meta.get_field("field")
1140 errors = field.check(databases=self.databases)
1141 self.assertEqual(errors, [])
1142
1143 def test_db_default_expression_invalid(self):
1144 expression = models.F("field_name")
1145
1146 class Model(models.Model):
1147 field = models.FloatField(db_default=expression)
1148
1149 field = Model._meta.get_field("field")
1150 errors = field.check(databases=self.databases)
1151
1152 if connection.features.supports_expression_defaults:
1153 msg = f"{expression} cannot be used in db_default."
1154 expected_errors = [Error(msg=msg, obj=field, id="fields.E012")]
1155 else:
1156 msg = (
1157 f"{connection.display_name} does not support default database values "
1158 "with expressions (db_default)."
1159 )
1160 expected_errors = [Error(msg=msg, obj=field, id="fields.E011")]
1161 self.assertEqual(errors, expected_errors)
1162
1163 def test_db_default_expression_required_db_features(self):
1164 expression = models.F("field_name")
1165
1166 class Model(models.Model):
1167 field = models.FloatField(db_default=expression)
1168
1169 class Meta:
1170 required_db_features = {"supports_expression_defaults"}
1171
1172 field = Model._meta.get_field("field")
1173 errors = field.check(databases=self.databases)
1174
1175 if connection.features.supports_expression_defaults:
1176 msg = f"{expression} cannot be used in db_default."
1177 expected_errors = [Error(msg=msg, obj=field, id="fields.E012")]
1178 else:
1179 expected_errors = []
1180 self.assertEqual(errors, expected_errors)
1181
1182 @skipUnlessDBFeature("supports_expression_defaults")
1183 def test_db_default_combined_invalid(self):
1184 expression = models.Value(4.5) + models.F("field_name")
1185
1186 class Model(models.Model):
1187 field = models.FloatField(db_default=expression)
1188
1189 field = Model._meta.get_field("field")
1190 errors = field.check(databases=self.databases)
1191
1192 msg = f"{expression} cannot be used in db_default."
1193 expected_error = Error(msg=msg, obj=field, id="fields.E012")
1194 self.assertEqual(errors, [expected_error])
1195
1196 @skipUnlessDBFeature("supports_expression_defaults")
1197 def test_db_default_function_arguments_invalid(self):
1198 expression = Coalesce(models.Value(4.5), models.F("field_name"))
1199
1200 class Model(models.Model):
1201 field = models.FloatField(db_default=expression)
1202
1203 field = Model._meta.get_field("field")
1204 errors = field.check(databases=self.databases)
1205
1206 msg = f"{expression} cannot be used in db_default."
1207 expected_error = Error(msg=msg, obj=field, id="fields.E012")
1208 self.assertEqual(errors, [expected_error])
1209
1210 def test_literals_not_treated_as_expressions(self):
1211 """
1212 DatabaseFeatures.supports_expression_defaults = False shouldn't
1213 prevent non-expression literals (integer, float, boolean, etc.) from
1214 being used as database defaults.
1215 """
1216
1217 class Model(models.Model):
1218 field = models.FloatField(db_default=1.0)
1219
1220 field = Model._meta.get_field("field")
1221 with unittest.mock.patch.object(
1222 connection.features, "supports_expression_defaults", False
1223 ):
1224 errors = field.check(databases=self.databases)
1225 self.assertEqual(errors, [])
1226
1227
1228 @isolate_apps("invalid_models_tests")
1229 class GeneratedFieldTests(TestCase):
1230 def test_not_supported(self):
1231 db_persist = connection.features.supports_stored_generated_columns
1232
1233 class Model(models.Model):
1234 name = models.IntegerField()
1235 field = models.GeneratedField(
1236 expression=models.F("name"),
1237 output_field=models.IntegerField(),
1238 db_persist=db_persist,
1239 )
1240
1241 expected_errors = []
1242 if (
1243 not connection.features.supports_stored_generated_columns
1244 and not connection.features.supports_virtual_generated_columns
1245 ):
1246 expected_errors.append(
1247 Error(
1248 f"{connection.display_name} does not support GeneratedFields.",
1249 obj=Model._meta.get_field("field"),
1250 id="fields.E220",
1251 )
1252 )
1253 if (
1254 not db_persist
1255 and not connection.features.supports_virtual_generated_columns
1256 ):
1257 expected_errors.append(
1258 Error(
1259 f"{connection.display_name} does not support non-persisted "
1260 "GeneratedFields.",
1261 obj=Model._meta.get_field("field"),
1262 id="fields.E221",
1263 hint="Set db_persist=True on the field.",
1264 ),
1265 )
1266 self.assertEqual(
1267 Model._meta.get_field("field").check(databases={"default"}),
1268 expected_errors,
1269 )
1270
1271 def test_not_supported_stored_required_db_features(self):
1272 class Model(models.Model):
1273 name = models.IntegerField()
1274 field = models.GeneratedField(
1275 expression=models.F("name"),
1276 output_field=models.IntegerField(),
1277 db_persist=True,
1278 )
1279
1280 class Meta:
1281 required_db_features = {"supports_stored_generated_columns"}
1282
1283 self.assertEqual(Model.check(databases=self.databases), [])
1284
1285 def test_not_supported_virtual_required_db_features(self):
1286 class Model(models.Model):
1287 name = models.IntegerField()
1288 field = models.GeneratedField(
1289 expression=models.F("name"),
1290 output_field=models.IntegerField(),
1291 db_persist=False,
1292 )
1293
1294 class Meta:
1295 required_db_features = {"supports_virtual_generated_columns"}
1296
1297 self.assertEqual(Model.check(databases=self.databases), [])
1298
1299 @skipUnlessDBFeature("supports_stored_generated_columns")
1300 def test_not_supported_virtual(self):
1301 class Model(models.Model):
1302 name = models.IntegerField()
1303 field = models.GeneratedField(
1304 expression=models.F("name"),
1305 output_field=models.IntegerField(),
1306 db_persist=False,
1307 )
1308 a = models.TextField()
1309
1310 excepted_errors = (
1311 []
1312 if connection.features.supports_virtual_generated_columns
1313 else [
1314 Error(
1315 f"{connection.display_name} does not support non-persisted "
1316 "GeneratedFields.",
1317 obj=Model._meta.get_field("field"),
1318 id="fields.E221",
1319 hint="Set db_persist=True on the field.",
1320 ),
1321 ]
1322 )
1323 self.assertEqual(
1324 Model._meta.get_field("field").check(databases={"default"}),
1325 excepted_errors,
1326 )
1327
1328 @skipUnlessDBFeature("supports_virtual_generated_columns")
1329 def test_not_supported_stored(self):
1330 class Model(models.Model):
1331 name = models.IntegerField()
1332 field = models.GeneratedField(
1333 expression=models.F("name"),
1334 output_field=models.IntegerField(),
1335 db_persist=True,
1336 )
1337 a = models.TextField()
1338
1339 expected_errors = (
1340 []
1341 if connection.features.supports_stored_generated_columns
1342 else [
1343 Error(
1344 f"{connection.display_name} does not support persisted "
1345 "GeneratedFields.",
1346 obj=Model._meta.get_field("field"),
1347 id="fields.E222",
1348 hint="Set db_persist=False on the field.",
1349 ),
1350 ]
1351 )
1352 self.assertEqual(
1353 Model._meta.get_field("field").check(databases={"default"}),
1354 expected_errors,
1355 )
1356
1357 @skipUnlessDBFeature("supports_stored_generated_columns")
1358 def test_output_field_check_error(self):
1359 class Model(models.Model):
1360 value = models.DecimalField(max_digits=5, decimal_places=2)
1361 field = models.GeneratedField(
1362 expression=models.F("value") * 2,
1363 output_field=models.DecimalField(max_digits=-1, decimal_places=-1),
1364 db_persist=True,
1365 )
1366
1367 expected_errors = [
1368 Error(
1369 "GeneratedField.output_field has errors:"
1370 "\n 'decimal_places' must be a non-negative integer. (fields.E131)"
1371 "\n 'max_digits' must be a positive integer. (fields.E133)",
1372 obj=Model._meta.get_field("field"),
1373 id="fields.E223",
1374 ),
1375 ]
1376 self.assertEqual(
1377 Model._meta.get_field("field").check(databases={"default"}),
1378 expected_errors,
1379 )
1380
1381 @skipUnlessDBFeature("supports_stored_generated_columns")
1382 def test_output_field_charfield_unlimited_error(self):
1383 class Model(models.Model):
1384 name = models.CharField(max_length=255)
1385 field = models.GeneratedField(
1386 expression=LPad("name", 7, models.Value("xy")),
1387 output_field=models.CharField(),
1388 db_persist=True,
1389 )
1390
1391 expected_errors = (
1392 []
1393 if connection.features.supports_unlimited_charfield
1394 else [
1395 Error(
1396 "GeneratedField.output_field has errors:"
1397 "\n CharFields must define a 'max_length' attribute. "
1398 "(fields.E120)",
1399 obj=Model._meta.get_field("field"),
1400 id="fields.E223",
1401 ),
1402 ]
1403 )
1404 self.assertEqual(
1405 Model._meta.get_field("field").check(databases={"default"}),
1406 expected_errors,
1407 )
1408
1409 @skipUnlessDBFeature("supports_stored_generated_columns")
1410 def test_output_field_check_warning(self):
1411 class Model(models.Model):
1412 value = models.IntegerField()
1413 field = models.GeneratedField(
1414 expression=models.F("value") * 2,
1415 output_field=models.IntegerField(max_length=40),
1416 db_persist=True,
1417 )
1418
1419 expected_warnings = [
1420 DjangoWarning(
1421 "GeneratedField.output_field has warnings:"
1422 "\n 'max_length' is ignored when used with IntegerField. "
1423 "(fields.W122)",
1424 obj=Model._meta.get_field("field"),
1425 id="fields.W224",
1426 ),
1427 ]
1428 self.assertEqual(
1429 Model._meta.get_field("field").check(databases={"default"}),
1430 expected_warnings,
1431 )