diff options
Diffstat (limited to 'tests/model_fields/tests.py')
| -rw-r--r-- | tests/model_fields/tests.py | 197 |
1 files changed, 104 insertions, 93 deletions
diff --git a/tests/model_fields/tests.py b/tests/model_fields/tests.py index 86365989f0..eb21d436d8 100644 --- a/tests/model_fields/tests.py +++ b/tests/model_fields/tests.py @@ -7,8 +7,15 @@ from django.test import SimpleTestCase, TestCase from django.utils.functional import lazy from .models import ( - Bar, Choiceful, Foo, RenamedField, VerboseNameField, Whiz, WhizDelayed, - WhizIter, WhizIterEmpty, + Bar, + Choiceful, + Foo, + RenamedField, + VerboseNameField, + Whiz, + WhizDelayed, + WhizIter, + WhizIterEmpty, ) @@ -18,7 +25,6 @@ class Nested: class BasicFieldTests(SimpleTestCase): - def test_show_hidden_initial(self): """ Fields with choices respect show_hidden_initial as a kwarg to @@ -36,14 +42,14 @@ class BasicFieldTests(SimpleTestCase): """ __repr__() of a field displays its name. """ - f = Foo._meta.get_field('a') - self.assertEqual(repr(f), '<django.db.models.fields.CharField: a>') + f = Foo._meta.get_field("a") + self.assertEqual(repr(f), "<django.db.models.fields.CharField: a>") f = models.fields.CharField() - self.assertEqual(repr(f), '<django.db.models.fields.CharField>') + self.assertEqual(repr(f), "<django.db.models.fields.CharField>") def test_field_repr_nested(self): """__repr__() uses __qualname__ for nested class support.""" - self.assertEqual(repr(Nested.Field()), '<model_fields.tests.Nested.Field>') + self.assertEqual(repr(Nested.Field()), "<model_fields.tests.Nested.Field>") def test_field_name(self): """ @@ -51,34 +57,36 @@ class BasicFieldTests(SimpleTestCase): model's attribute name (modelname). """ instance = RenamedField() - self.assertTrue(hasattr(instance, 'get_fieldname_display')) - self.assertFalse(hasattr(instance, 'get_modelname_display')) + self.assertTrue(hasattr(instance, "get_fieldname_display")) + self.assertFalse(hasattr(instance, "get_modelname_display")) def test_field_verbose_name(self): m = VerboseNameField for i in range(1, 22): - self.assertEqual(m._meta.get_field('field%d' % i).verbose_name, 'verbose field%d' % i) + self.assertEqual( + m._meta.get_field("field%d" % i).verbose_name, "verbose field%d" % i + ) - self.assertEqual(m._meta.get_field('id').verbose_name, 'verbose pk') + self.assertEqual(m._meta.get_field("id").verbose_name, "verbose pk") def test_choices_form_class(self): """Can supply a custom choices form class to Field.formfield()""" - choices = [('a', 'a')] + choices = [("a", "a")] field = models.CharField(choices=choices) klass = forms.TypedMultipleChoiceField self.assertIsInstance(field.formfield(choices_form_class=klass), klass) def test_formfield_disabled(self): """Field.formfield() sets disabled for fields with choices.""" - field = models.CharField(choices=[('a', 'b')]) + field = models.CharField(choices=[("a", "b")]) form_field = field.formfield(disabled=True) self.assertIs(form_field.disabled, True) def test_field_str(self): f = models.Field() - self.assertEqual(str(f), '<django.db.models.fields.Field>') - f = Foo._meta.get_field('a') - self.assertEqual(str(f), 'model_fields.Foo.a') + self.assertEqual(str(f), "<django.db.models.fields.Field>") + f = Foo._meta.get_field("a") + self.assertEqual(str(f), "model_fields.Foo.a") def test_field_ordering(self): """Fields are ordered based on their creation.""" @@ -88,11 +96,11 @@ class BasicFieldTests(SimpleTestCase): self.assertLess(f2, f1) self.assertGreater(f3, f1) self.assertIsNotNone(f1) - self.assertNotIn(f2, (None, 1, '')) + self.assertNotIn(f2, (None, 1, "")) def test_field_instance_is_picklable(self): """Field instances can be pickled.""" - field = models.Field(max_length=100, default='a string') + field = models.Field(max_length=100, default="a string") # Must be picklable with this cached property populated (#28188). field._get_default pickle.dumps(field) @@ -100,10 +108,11 @@ class BasicFieldTests(SimpleTestCase): def test_deconstruct_nested_field(self): """deconstruct() uses __qualname__ for nested class support.""" name, path, args, kwargs = Nested.Field().deconstruct() - self.assertEqual(path, 'model_fields.tests.Nested.Field') + self.assertEqual(path, "model_fields.tests.Nested.Field") def test_abstract_inherited_fields(self): """Field instances from abstract models are not equal.""" + class AbstractModel(models.Model): field = models.IntegerField() @@ -116,9 +125,9 @@ class BasicFieldTests(SimpleTestCase): class InheritAbstractModel2(AbstractModel): pass - abstract_model_field = AbstractModel._meta.get_field('field') - inherit1_model_field = InheritAbstractModel1._meta.get_field('field') - inherit2_model_field = InheritAbstractModel2._meta.get_field('field') + abstract_model_field = AbstractModel._meta.get_field("field") + inherit1_model_field = InheritAbstractModel1._meta.get_field("field") + inherit2_model_field = InheritAbstractModel2._meta.get_field("field") self.assertNotEqual(abstract_model_field, inherit1_model_field) self.assertNotEqual(abstract_model_field, inherit2_model_field) @@ -139,25 +148,24 @@ class BasicFieldTests(SimpleTestCase): class ChoicesTests(SimpleTestCase): - @classmethod def setUpClass(cls): super().setUpClass() - cls.no_choices = Choiceful._meta.get_field('no_choices') - cls.empty_choices = Choiceful._meta.get_field('empty_choices') - cls.empty_choices_bool = Choiceful._meta.get_field('empty_choices_bool') - cls.empty_choices_text = Choiceful._meta.get_field('empty_choices_text') - cls.with_choices = Choiceful._meta.get_field('with_choices') + cls.no_choices = Choiceful._meta.get_field("no_choices") + cls.empty_choices = Choiceful._meta.get_field("empty_choices") + cls.empty_choices_bool = Choiceful._meta.get_field("empty_choices_bool") + cls.empty_choices_text = Choiceful._meta.get_field("empty_choices_text") + cls.with_choices = Choiceful._meta.get_field("with_choices") def test_choices(self): self.assertIsNone(self.no_choices.choices) self.assertEqual(self.empty_choices.choices, ()) - self.assertEqual(self.with_choices.choices, [(1, 'A')]) + self.assertEqual(self.with_choices.choices, [(1, "A")]) def test_flatchoices(self): self.assertEqual(self.no_choices.flatchoices, []) self.assertEqual(self.empty_choices.flatchoices, []) - self.assertEqual(self.with_choices.flatchoices, [(1, 'A')]) + self.assertEqual(self.with_choices.flatchoices, [(1, "A")]) def test_check(self): self.assertEqual(Choiceful.check(), []) @@ -175,7 +183,9 @@ class ChoicesTests(SimpleTestCase): no_choices_formfield = self.no_choices.formfield() self.assertIsInstance(no_choices_formfield, forms.IntegerField) fields = ( - self.empty_choices, self.with_choices, self.empty_choices_bool, + self.empty_choices, + self.with_choices, + self.empty_choices_bool, self.empty_choices_text, ) for field in fields: @@ -184,163 +194,164 @@ class ChoicesTests(SimpleTestCase): class GetFieldDisplayTests(SimpleTestCase): - def test_choices_and_field_display(self): """ get_choices() interacts with get_FIELD_display() to return the expected values. """ - self.assertEqual(Whiz(c=1).get_c_display(), 'First') # A nested value - self.assertEqual(Whiz(c=0).get_c_display(), 'Other') # A top level value - self.assertEqual(Whiz(c=9).get_c_display(), 9) # Invalid value - self.assertIsNone(Whiz(c=None).get_c_display()) # Blank value - self.assertEqual(Whiz(c='').get_c_display(), '') # Empty value - self.assertEqual(WhizDelayed(c=0).get_c_display(), 'Other') # Delayed choices + self.assertEqual(Whiz(c=1).get_c_display(), "First") # A nested value + self.assertEqual(Whiz(c=0).get_c_display(), "Other") # A top level value + self.assertEqual(Whiz(c=9).get_c_display(), 9) # Invalid value + self.assertIsNone(Whiz(c=None).get_c_display()) # Blank value + self.assertEqual(Whiz(c="").get_c_display(), "") # Empty value + self.assertEqual(WhizDelayed(c=0).get_c_display(), "Other") # Delayed choices def test_get_FIELD_display_translated(self): """A translated display value is coerced to str.""" val = Whiz(c=5).get_c_display() self.assertIsInstance(val, str) - self.assertEqual(val, 'translated') + self.assertEqual(val, "translated") def test_overriding_FIELD_display(self): class FooBar(models.Model): - foo_bar = models.IntegerField(choices=[(1, 'foo'), (2, 'bar')]) + foo_bar = models.IntegerField(choices=[(1, "foo"), (2, "bar")]) def get_foo_bar_display(self): - return 'something' + return "something" f = FooBar(foo_bar=1) - self.assertEqual(f.get_foo_bar_display(), 'something') + self.assertEqual(f.get_foo_bar_display(), "something") def test_overriding_inherited_FIELD_display(self): class Base(models.Model): - foo = models.CharField(max_length=254, choices=[('A', 'Base A')]) + foo = models.CharField(max_length=254, choices=[("A", "Base A")]) class Meta: abstract = True class Child(Base): - foo = models.CharField(max_length=254, choices=[('A', 'Child A'), ('B', 'Child B')]) + foo = models.CharField( + max_length=254, choices=[("A", "Child A"), ("B", "Child B")] + ) - self.assertEqual(Child(foo='A').get_foo_display(), 'Child A') - self.assertEqual(Child(foo='B').get_foo_display(), 'Child B') + self.assertEqual(Child(foo="A").get_foo_display(), "Child A") + self.assertEqual(Child(foo="B").get_foo_display(), "Child B") def test_iterator_choices(self): """ get_choices() works with Iterators. """ - self.assertEqual(WhizIter(c=1).c, 1) # A nested value - self.assertEqual(WhizIter(c=9).c, 9) # Invalid value - self.assertIsNone(WhizIter(c=None).c) # Blank value - self.assertEqual(WhizIter(c='').c, '') # Empty value + self.assertEqual(WhizIter(c=1).c, 1) # A nested value + self.assertEqual(WhizIter(c=9).c, 9) # Invalid value + self.assertIsNone(WhizIter(c=None).c) # Blank value + self.assertEqual(WhizIter(c="").c, "") # Empty value def test_empty_iterator_choices(self): """ get_choices() works with empty iterators. """ - self.assertEqual(WhizIterEmpty(c="a").c, "a") # A nested value - self.assertEqual(WhizIterEmpty(c="b").c, "b") # Invalid value - self.assertIsNone(WhizIterEmpty(c=None).c) # Blank value - self.assertEqual(WhizIterEmpty(c='').c, '') # Empty value + self.assertEqual(WhizIterEmpty(c="a").c, "a") # A nested value + self.assertEqual(WhizIterEmpty(c="b").c, "b") # Invalid value + self.assertIsNone(WhizIterEmpty(c=None).c) # Blank value + self.assertEqual(WhizIterEmpty(c="").c, "") # Empty value class GetChoicesTests(SimpleTestCase): - def test_empty_choices(self): choices = [] f = models.CharField(choices=choices) self.assertEqual(f.get_choices(include_blank=False), choices) def test_blank_in_choices(self): - choices = [('', '<><>'), ('a', 'A')] + choices = [("", "<><>"), ("a", "A")] f = models.CharField(choices=choices) self.assertEqual(f.get_choices(include_blank=True), choices) def test_blank_in_grouped_choices(self): choices = [ - ('f', 'Foo'), - ('b', 'Bar'), - ('Group', ( - ('', 'No Preference'), - ('fg', 'Foo'), - ('bg', 'Bar'), - )), + ("f", "Foo"), + ("b", "Bar"), + ( + "Group", + ( + ("", "No Preference"), + ("fg", "Foo"), + ("bg", "Bar"), + ), + ), ] f = models.CharField(choices=choices) self.assertEqual(f.get_choices(include_blank=True), choices) def test_lazy_strings_not_evaluated(self): lazy_func = lazy(lambda x: 0 / 0, int) # raises ZeroDivisionError if evaluated. - f = models.CharField(choices=[(lazy_func('group'), (('a', 'A'), ('b', 'B')))]) - self.assertEqual(f.get_choices(include_blank=True)[0], ('', '---------')) + f = models.CharField(choices=[(lazy_func("group"), (("a", "A"), ("b", "B")))]) + self.assertEqual(f.get_choices(include_blank=True)[0], ("", "---------")) class GetChoicesOrderingTests(TestCase): - @classmethod def setUpTestData(cls): - cls.foo1 = Foo.objects.create(a='a', d='12.35') - cls.foo2 = Foo.objects.create(a='b', d='12.34') - cls.bar1 = Bar.objects.create(a=cls.foo1, b='b') - cls.bar2 = Bar.objects.create(a=cls.foo2, b='a') - cls.field = Bar._meta.get_field('a') + cls.foo1 = Foo.objects.create(a="a", d="12.35") + cls.foo2 = Foo.objects.create(a="b", d="12.34") + cls.bar1 = Bar.objects.create(a=cls.foo1, b="b") + cls.bar2 = Bar.objects.create(a=cls.foo2, b="a") + cls.field = Bar._meta.get_field("a") def assertChoicesEqual(self, choices, objs): self.assertEqual(choices, [(obj.pk, str(obj)) for obj in objs]) def test_get_choices(self): self.assertChoicesEqual( - self.field.get_choices(include_blank=False, ordering=('a',)), - [self.foo1, self.foo2] + self.field.get_choices(include_blank=False, ordering=("a",)), + [self.foo1, self.foo2], ) self.assertChoicesEqual( - self.field.get_choices(include_blank=False, ordering=('-a',)), - [self.foo2, self.foo1] + self.field.get_choices(include_blank=False, ordering=("-a",)), + [self.foo2, self.foo1], ) def test_get_choices_default_ordering(self): - self.addCleanup(setattr, Foo._meta, 'ordering', Foo._meta.ordering) - Foo._meta.ordering = ('d',) + self.addCleanup(setattr, Foo._meta, "ordering", Foo._meta.ordering) + Foo._meta.ordering = ("d",) self.assertChoicesEqual( - self.field.get_choices(include_blank=False), - [self.foo2, self.foo1] + self.field.get_choices(include_blank=False), [self.foo2, self.foo1] ) def test_get_choices_reverse_related_field(self): self.assertChoicesEqual( - self.field.remote_field.get_choices(include_blank=False, ordering=('a',)), - [self.bar1, self.bar2] + self.field.remote_field.get_choices(include_blank=False, ordering=("a",)), + [self.bar1, self.bar2], ) self.assertChoicesEqual( - self.field.remote_field.get_choices(include_blank=False, ordering=('-a',)), - [self.bar2, self.bar1] + self.field.remote_field.get_choices(include_blank=False, ordering=("-a",)), + [self.bar2, self.bar1], ) def test_get_choices_reverse_related_field_default_ordering(self): - self.addCleanup(setattr, Bar._meta, 'ordering', Bar._meta.ordering) - Bar._meta.ordering = ('b',) + self.addCleanup(setattr, Bar._meta, "ordering", Bar._meta.ordering) + Bar._meta.ordering = ("b",) self.assertChoicesEqual( self.field.remote_field.get_choices(include_blank=False), - [self.bar2, self.bar1] + [self.bar2, self.bar1], ) class GetChoicesLimitChoicesToTests(TestCase): @classmethod def setUpTestData(cls): - cls.foo1 = Foo.objects.create(a='a', d='12.34') - cls.foo2 = Foo.objects.create(a='b', d='12.34') - cls.bar1 = Bar.objects.create(a=cls.foo1, b='b') - cls.bar2 = Bar.objects.create(a=cls.foo2, b='a') - cls.field = Bar._meta.get_field('a') + cls.foo1 = Foo.objects.create(a="a", d="12.34") + cls.foo2 = Foo.objects.create(a="b", d="12.34") + cls.bar1 = Bar.objects.create(a=cls.foo1, b="b") + cls.bar2 = Bar.objects.create(a=cls.foo2, b="a") + cls.field = Bar._meta.get_field("a") def assertChoicesEqual(self, choices, objs): self.assertEqual(choices, [(obj.pk, str(obj)) for obj in objs]) def test_get_choices(self): self.assertChoicesEqual( - self.field.get_choices(include_blank=False, limit_choices_to={'a': 'a'}), + self.field.get_choices(include_blank=False, limit_choices_to={"a": "a"}), [self.foo1], ) self.assertChoicesEqual( @@ -351,7 +362,7 @@ class GetChoicesLimitChoicesToTests(TestCase): def test_get_choices_reverse_related_field(self): field = self.field.remote_field self.assertChoicesEqual( - field.get_choices(include_blank=False, limit_choices_to={'b': 'b'}), + field.get_choices(include_blank=False, limit_choices_to={"b": "b"}), [self.bar1], ) self.assertChoicesEqual( |