1. import pickle

  2. 

  3. from django import forms

  4. from django.core.exceptions import ValidationError

  5. from django.db import models

  6. from django.test import SimpleTestCase, TestCase

  7. from django.utils.functional import lazy

  8. 

  9. from .models import (

  10.     Bar,

  11.     Choiceful,

  12.     Foo,

  13.     RenamedField,

  14.     VerboseNameField,

  15.     Whiz,

  16.     WhizDelayed,

  17.     WhizIter,

  18.     WhizIterEmpty,

  19. )

  20. 

  21. 

  22. class Nested:

  23.     class Field(models.Field):

  24.         pass

  25. 

  26. 

  27. class BasicFieldTests(SimpleTestCase):

  28.     def test_show_hidden_initial(self):

  29.         """

  30.         Fields with choices respect show_hidden_initial as a kwarg to

  31.         formfield().

  32.         """

  33.         choices = [(0, 0), (1, 1)]

  34.         model_field = models.Field(choices=choices)

  35.         form_field = model_field.formfield(show_hidden_initial=True)

  36.         self.assertTrue(form_field.show_hidden_initial)

  37. 

  38.         form_field = model_field.formfield(show_hidden_initial=False)

  39.         self.assertFalse(form_field.show_hidden_initial)

  40. 

  41.     def test_field_repr(self):

  42.         """

  43.         __repr__() of a field displays its name.

  44.         """

  45.         f = Foo._meta.get_field("a")

  46.         self.assertEqual(repr(f), "<django.db.models.fields.CharField: a>")

  47.         f = models.fields.CharField()

  48.         self.assertEqual(repr(f), "<django.db.models.fields.CharField>")

  49. 

  50.     def test_field_repr_nested(self):

  51.         """__repr__() uses __qualname__ for nested class support."""

  52.         self.assertEqual(repr(Nested.Field()), "<model_fields.tests.Nested.Field>")

  53. 

  54.     def test_field_name(self):

  55.         """

  56.         A defined field name (name="fieldname") is used instead of the model

  57.         model's attribute name (modelname).

  58.         """

  59.         instance = RenamedField()

  60.         self.assertTrue(hasattr(instance, "get_fieldname_display"))

  61.         self.assertFalse(hasattr(instance, "get_modelname_display"))

  62. 

  63.     def test_field_verbose_name(self):

  64.         m = VerboseNameField

  65.         for i in range(1, 22):

  66.             self.assertEqual(

  67.                 m._meta.get_field("field%d" % i).verbose_name, "verbose field%d" % i

  68.             )

  69. 

  70.         self.assertEqual(m._meta.get_field("id").verbose_name, "verbose pk")

  71. 

  72.     def test_choices_form_class(self):

  73.         """Can supply a custom choices form class to Field.formfield()"""

  74.         choices = [("a", "a")]

  75.         field = models.CharField(choices=choices)

  76.         klass = forms.TypedMultipleChoiceField

  77.         self.assertIsInstance(field.formfield(choices_form_class=klass), klass)

  78. 

  79.     def test_formfield_disabled(self):

  80.         """Field.formfield() sets disabled for fields with choices."""

  81.         field = models.CharField(choices=[("a", "b")])

  82.         form_field = field.formfield(disabled=True)

  83.         self.assertIs(form_field.disabled, True)

  84. 

  85.     def test_field_str(self):

  86.         f = models.Field()

  87.         self.assertEqual(str(f), "<django.db.models.fields.Field>")

  88.         f = Foo._meta.get_field("a")

  89.         self.assertEqual(str(f), "model_fields.Foo.a")

  90. 

  91.     def test_field_ordering(self):

  92.         """Fields are ordered based on their creation."""

  93.         f1 = models.Field()

  94.         f2 = models.Field(auto_created=True)

  95.         f3 = models.Field()

  96.         self.assertLess(f2, f1)

  97.         self.assertGreater(f3, f1)

  98.         self.assertIsNotNone(f1)

  99.         self.assertNotIn(f2, (None, 1, ""))

  100. 

  101.     def test_field_instance_is_picklable(self):

  102.         """Field instances can be pickled."""

  103.         field = models.Field(max_length=100, default="a string")

  104.         # Must be picklable with this cached property populated (#28188).

  105.         field._get_default

  106.         pickle.dumps(field)

  107. 

  108.     def test_deconstruct_nested_field(self):

  109.         """deconstruct() uses __qualname__ for nested class support."""

  110.         name, path, args, kwargs = Nested.Field().deconstruct()

  111.         self.assertEqual(path, "model_fields.tests.Nested.Field")

  112. 

  113.     def test_abstract_inherited_fields(self):

  114.         """Field instances from abstract models are not equal."""

  115. 

  116.         class AbstractModel(models.Model):

  117.             field = models.IntegerField()

  118. 

  119.             class Meta:

  120.                 abstract = True

  121. 

  122.         class InheritAbstractModel1(AbstractModel):

  123.             pass

  124. 

  125.         class InheritAbstractModel2(AbstractModel):

  126.             pass

  127. 

  128.         abstract_model_field = AbstractModel._meta.get_field("field")

  129.         inherit1_model_field = InheritAbstractModel1._meta.get_field("field")

  130.         inherit2_model_field = InheritAbstractModel2._meta.get_field("field")

  131. 

  132.         self.assertNotEqual(abstract_model_field, inherit1_model_field)

  133.         self.assertNotEqual(abstract_model_field, inherit2_model_field)

  134.         self.assertNotEqual(inherit1_model_field, inherit2_model_field)

  135. 

  136.         self.assertLess(abstract_model_field, inherit1_model_field)

  137.         self.assertLess(abstract_model_field, inherit2_model_field)

  138.         self.assertLess(inherit1_model_field, inherit2_model_field)

  139. 

  140.     def test_hash_immutability(self):

  141.         field = models.IntegerField()

  142.         field_hash = hash(field)

  143. 

  144.         class MyModel(models.Model):

  145.             rank = field

  146. 

  147.         self.assertEqual(field_hash, hash(field))

  148. 

  149. 

  150. class ChoicesTests(SimpleTestCase):

  151.     @classmethod

  152.     def setUpClass(cls):

  153.         super().setUpClass()

  154.         cls.no_choices = Choiceful._meta.get_field("no_choices")

  155.         cls.empty_choices = Choiceful._meta.get_field("empty_choices")

  156.         cls.empty_choices_bool = Choiceful._meta.get_field("empty_choices_bool")

  157.         cls.empty_choices_text = Choiceful._meta.get_field("empty_choices_text")

  158.         cls.with_choices = Choiceful._meta.get_field("with_choices")

  159. 

  160.     def test_choices(self):

  161.         self.assertIsNone(self.no_choices.choices)

  162.         self.assertEqual(self.empty_choices.choices, ())

  163.         self.assertEqual(self.with_choices.choices, [(1, "A")])

  164. 

  165.     def test_flatchoices(self):

  166.         self.assertEqual(self.no_choices.flatchoices, [])

  167.         self.assertEqual(self.empty_choices.flatchoices, [])

  168.         self.assertEqual(self.with_choices.flatchoices, [(1, "A")])

  169. 

  170.     def test_check(self):

  171.         self.assertEqual(Choiceful.check(), [])

  172. 

  173.     def test_invalid_choice(self):

  174.         model_instance = None  # Actual model instance not needed.

  175.         self.no_choices.validate(0, model_instance)

  176.         msg = "['Value 99 is not a valid choice.']"

  177.         with self.assertRaisesMessage(ValidationError, msg):

  178.             self.empty_choices.validate(99, model_instance)

  179.         with self.assertRaisesMessage(ValidationError, msg):

  180.             self.with_choices.validate(99, model_instance)

  181. 

  182.     def test_formfield(self):

  183.         no_choices_formfield = self.no_choices.formfield()

  184.         self.assertIsInstance(no_choices_formfield, forms.IntegerField)

  185.         fields = (

  186.             self.empty_choices,

  187.             self.with_choices,

  188.             self.empty_choices_bool,

  189.             self.empty_choices_text,

  190.         )

  191.         for field in fields:

  192.             with self.subTest(field=field):

  193.                 self.assertIsInstance(field.formfield(), forms.ChoiceField)

  194. 

  195. 

  196. class GetFieldDisplayTests(SimpleTestCase):

  197.     def test_choices_and_field_display(self):

  198.         """

  199.         get_choices() interacts with get_FIELD_display() to return the expected

  200.         values.

  201.         """

  202.         self.assertEqual(Whiz(c=1).get_c_display(), "First")  # A nested value

  203.         self.assertEqual(Whiz(c=0).get_c_display(), "Other")  # A top level value

  204.         self.assertEqual(Whiz(c=9).get_c_display(), 9)  # Invalid value

  205.         self.assertIsNone(Whiz(c=None).get_c_display())  # Blank value

  206.         self.assertEqual(Whiz(c="").get_c_display(), "")  # Empty value

  207.         self.assertEqual(WhizDelayed(c=0).get_c_display(), "Other")  # Delayed choices

  208. 

  209.     def test_get_FIELD_display_translated(self):

  210.         """A translated display value is coerced to str."""

  211.         val = Whiz(c=5).get_c_display()

  212.         self.assertIsInstance(val, str)

  213.         self.assertEqual(val, "translated")

  214. 

  215.     def test_overriding_FIELD_display(self):

  216.         class FooBar(models.Model):

  217.             foo_bar = models.IntegerField(choices=[(1, "foo"), (2, "bar")])

  218. 

  219.             def get_foo_bar_display(self):

  220.                 return "something"

  221. 

  222.         f = FooBar(foo_bar=1)

  223.         self.assertEqual(f.get_foo_bar_display(), "something")

  224. 

  225.     def test_overriding_inherited_FIELD_display(self):

  226.         class Base(models.Model):

  227.             foo = models.CharField(max_length=254, choices=[("A", "Base A")])

  228. 

  229.             class Meta:

  230.                 abstract = True

  231. 

  232.         class Child(Base):

  233.             foo = models.CharField(

  234.                 max_length=254, choices=[("A", "Child A"), ("B", "Child B")]

  235.             )

  236. 

  237.         self.assertEqual(Child(foo="A").get_foo_display(), "Child A")

  238.         self.assertEqual(Child(foo="B").get_foo_display(), "Child B")

  239. 

  240.     def test_iterator_choices(self):

  241.         """

  242.         get_choices() works with Iterators.

  243.         """

  244.         self.assertEqual(WhizIter(c=1).c, 1)  # A nested value

  245.         self.assertEqual(WhizIter(c=9).c, 9)  # Invalid value

  246.         self.assertIsNone(WhizIter(c=None).c)  # Blank value

  247.         self.assertEqual(WhizIter(c="").c, "")  # Empty value

  248. 

  249.     def test_empty_iterator_choices(self):

  250.         """

  251.         get_choices() works with empty iterators.

  252.         """

  253.         self.assertEqual(WhizIterEmpty(c="a").c, "a")  # A nested value

  254.         self.assertEqual(WhizIterEmpty(c="b").c, "b")  # Invalid value

  255.         self.assertIsNone(WhizIterEmpty(c=None).c)  # Blank value

  256.         self.assertEqual(WhizIterEmpty(c="").c, "")  # Empty value

  257. 

  258. 

  259. class GetChoicesTests(SimpleTestCase):

  260.     def test_empty_choices(self):

  261.         choices = []

  262.         f = models.CharField(choices=choices)

  263.         self.assertEqual(f.get_choices(include_blank=False), choices)

  264. 

  265.     def test_blank_in_choices(self):

  266.         choices = [("", "<><>"), ("a", "A")]

  267.         f = models.CharField(choices=choices)

  268.         self.assertEqual(f.get_choices(include_blank=True), choices)

  269. 

  270.     def test_blank_in_grouped_choices(self):

  271.         choices = [

  272.             ("f", "Foo"),

  273.             ("b", "Bar"),

  274.             (

  275.                 "Group",

  276.                 (

  277.                     ("", "No Preference"),

  278.                     ("fg", "Foo"),

  279.                     ("bg", "Bar"),

  280.                 ),

  281.             ),

  282.         ]

  283.         f = models.CharField(choices=choices)

  284.         self.assertEqual(f.get_choices(include_blank=True), choices)

  285. 

  286.     def test_lazy_strings_not_evaluated(self):

  287.         lazy_func = lazy(lambda x: 0 / 0, int)  # raises ZeroDivisionError if evaluated.

  288.         f = models.CharField(choices=[(lazy_func("group"), (("a", "A"), ("b", "B")))])

  289.         self.assertEqual(f.get_choices(include_blank=True)[0], ("", "---------"))

  290. 

  291. 

  292. class GetChoicesOrderingTests(TestCase):

  293.     @classmethod

  294.     def setUpTestData(cls):

  295.         cls.foo1 = Foo.objects.create(a="a", d="12.35")

  296.         cls.foo2 = Foo.objects.create(a="b", d="12.34")

  297.         cls.bar1 = Bar.objects.create(a=cls.foo1, b="b")

  298.         cls.bar2 = Bar.objects.create(a=cls.foo2, b="a")

  299.         cls.field = Bar._meta.get_field("a")

  300. 

  301.     def assertChoicesEqual(self, choices, objs):

  302.         self.assertEqual(choices, [(obj.pk, str(obj)) for obj in objs])

  303. 

  304.     def test_get_choices(self):

  305.         self.assertChoicesEqual(

  306.             self.field.get_choices(include_blank=False, ordering=("a",)),

  307.             [self.foo1, self.foo2],

  308.         )

  309.         self.assertChoicesEqual(

  310.             self.field.get_choices(include_blank=False, ordering=("-a",)),

  311.             [self.foo2, self.foo1],

  312.         )

  313. 

  314.     def test_get_choices_default_ordering(self):

  315.         self.addCleanup(setattr, Foo._meta, "ordering", Foo._meta.ordering)

  316.         Foo._meta.ordering = ("d",)

  317.         self.assertChoicesEqual(

  318.             self.field.get_choices(include_blank=False), [self.foo2, self.foo1]

  319.         )

  320. 

  321.     def test_get_choices_reverse_related_field(self):

  322.         self.assertChoicesEqual(

  323.             self.field.remote_field.get_choices(include_blank=False, ordering=("a",)),

  324.             [self.bar1, self.bar2],

  325.         )

  326.         self.assertChoicesEqual(

  327.             self.field.remote_field.get_choices(include_blank=False, ordering=("-a",)),

  328.             [self.bar2, self.bar1],

  329.         )

  330. 

  331.     def test_get_choices_reverse_related_field_default_ordering(self):

  332.         self.addCleanup(setattr, Bar._meta, "ordering", Bar._meta.ordering)

  333.         Bar._meta.ordering = ("b",)

  334.         self.assertChoicesEqual(

  335.             self.field.remote_field.get_choices(include_blank=False),

  336.             [self.bar2, self.bar1],

  337.         )

  338. 

  339. 

  340. class GetChoicesLimitChoicesToTests(TestCase):

  341.     @classmethod

  342.     def setUpTestData(cls):

  343.         cls.foo1 = Foo.objects.create(a="a", d="12.34")

  344.         cls.foo2 = Foo.objects.create(a="b", d="12.34")

  345.         cls.bar1 = Bar.objects.create(a=cls.foo1, b="b")

  346.         cls.bar2 = Bar.objects.create(a=cls.foo2, b="a")

  347.         cls.field = Bar._meta.get_field("a")

  348. 

  349.     def assertChoicesEqual(self, choices, objs):

  350.         self.assertCountEqual(choices, [(obj.pk, str(obj)) for obj in objs])

  351. 

  352.     def test_get_choices(self):

  353.         self.assertChoicesEqual(

  354.             self.field.get_choices(include_blank=False, limit_choices_to={"a": "a"}),

  355.             [self.foo1],

  356.         )

  357.         self.assertChoicesEqual(

  358.             self.field.get_choices(include_blank=False, limit_choices_to={}),

  359.             [self.foo1, self.foo2],

  360.         )

  361. 

  362.     def test_get_choices_reverse_related_field(self):

  363.         field = self.field.remote_field

  364.         self.assertChoicesEqual(

  365.             field.get_choices(include_blank=False, limit_choices_to={"b": "b"}),

  366.             [self.bar1],

  367.         )

  368.         self.assertChoicesEqual(

  369.             field.get_choices(include_blank=False, limit_choices_to={}),

  370.             [self.bar1, self.bar2],

  371.         )
About Sign Up Leave Feedback Contact