Split model_fields tests into different files. (3c1b572f) · Commits · Dom Sekotill / django

tests/model_fields/models.py

+1 −1

Original line number	Diff line number	Diff line
		@@ -121,7 +121,7 @@ class NullBooleanModel(models.Model):


		class BooleanModel(models.Model):
		bfield = models.BooleanField(default=None)
		bfield = models.BooleanField()
		string = models.CharField(max_length=10, default='abc')

tests/model_fields/test_binaryfield.py

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		from django.core.exceptions import ValidationError
		from django.test import TestCase
		from django.utils import six

		from .models import DataModel


		class BinaryFieldTests(TestCase):
		binary_data = b'\x00\x46\xFE'

		def test_set_and_retrieve(self):
		data_set = (self.binary_data, six.memoryview(self.binary_data))
		for bdata in data_set:
		dm = DataModel(data=bdata)
		dm.save()
		dm = DataModel.objects.get(pk=dm.pk)
		self.assertEqual(bytes(dm.data), bytes(bdata))
		# Resave (=update)
		dm.save()
		dm = DataModel.objects.get(pk=dm.pk)
		self.assertEqual(bytes(dm.data), bytes(bdata))
		# Test default value
		self.assertEqual(bytes(dm.short_data), b'\x08')

		def test_max_length(self):
		dm = DataModel(short_data=self.binary_data * 4)
		with self.assertRaises(ValidationError):
		dm.full_clean()

tests/model_fields/test_booleanfield.py

0 → 100644

+119 −0

Original line number	Diff line number	Diff line
		from django.core.exceptions import ValidationError
		from django.db import IntegrityError, connection, models, transaction
		from django.test import SimpleTestCase, TestCase

		from .models import BooleanModel, FksToBooleans, NullBooleanModel


		class BooleanFieldTests(TestCase):
		def _test_get_db_prep_lookup(self, f):
		self.assertEqual(f.get_db_prep_lookup('exact', True, connection=connection), [True])
		self.assertEqual(f.get_db_prep_lookup('exact', '1', connection=connection), [True])
		self.assertEqual(f.get_db_prep_lookup('exact', 1, connection=connection), [True])
		self.assertEqual(f.get_db_prep_lookup('exact', False, connection=connection), [False])
		self.assertEqual(f.get_db_prep_lookup('exact', '0', connection=connection), [False])
		self.assertEqual(f.get_db_prep_lookup('exact', 0, connection=connection), [False])
		self.assertEqual(f.get_db_prep_lookup('exact', None, connection=connection), [None])

		def _test_to_python(self, f):
		self.assertIs(f.to_python(1), True)
		self.assertIs(f.to_python(0), False)

		def test_booleanfield_get_db_prep_lookup(self):
		self._test_get_db_prep_lookup(models.BooleanField())

		def test_nullbooleanfield_get_db_prep_lookup(self):
		self._test_get_db_prep_lookup(models.NullBooleanField())

		def test_booleanfield_to_python(self):
		self._test_to_python(models.BooleanField())

		def test_nullbooleanfield_to_python(self):
		self._test_to_python(models.NullBooleanField())

		def test_booleanfield_choices_blank(self):
		"""
		BooleanField with choices and defaults doesn't generate a formfield
		with the blank option (#9640, #10549).
		"""
		choices = [(1, 'Si'), (2, 'No')]
		f = models.BooleanField(choices=choices, default=1, null=False)
		self.assertEqual(f.formfield().choices, choices)

		def test_return_type(self):
		b = BooleanModel.objects.create(bfield=True)
		b.refresh_from_db()
		self.assertEqual(b.bfield, True)

		b2 = BooleanModel.objects.create(bfield=False)
		b2.refresh_from_db()
		self.assertEqual(b2.bfield, False)

		b3 = NullBooleanModel.objects.create(nbfield=True)
		b3.refresh_from_db()
		self.assertEqual(b3.nbfield, True)

		b4 = NullBooleanModel.objects.create(nbfield=False)
		b4.refresh_from_db()
		self.assertEqual(b4.nbfield, False)

		# When an extra clause exists, the boolean conversions are applied with
		# an offset (#13293).
		b5 = BooleanModel.objects.all().extra(select={'string_col': 'string'})[0]
		self.assertNotIsInstance(b5.pk, bool)

		def test_select_related(self):
		"""
		Boolean fields retrieved via select_related() should return booleans.
		"""
		bmt = BooleanModel.objects.create(bfield=True)
		bmf = BooleanModel.objects.create(bfield=False)
		nbmt = NullBooleanModel.objects.create(nbfield=True)
		nbmf = NullBooleanModel.objects.create(nbfield=False)
		m1 = FksToBooleans.objects.create(bf=bmt, nbf=nbmt)
		m2 = FksToBooleans.objects.create(bf=bmf, nbf=nbmf)

		# select_related('fk_field_name')
		ma = FksToBooleans.objects.select_related('bf').get(pk=m1.id)
		self.assertEqual(ma.bf.bfield, True)
		self.assertEqual(ma.nbf.nbfield, True)

		# select_related()
		mb = FksToBooleans.objects.select_related().get(pk=m1.id)
		mc = FksToBooleans.objects.select_related().get(pk=m2.id)
		self.assertEqual(mb.bf.bfield, True)
		self.assertEqual(mb.nbf.nbfield, True)
		self.assertEqual(mc.bf.bfield, False)
		self.assertEqual(mc.nbf.nbfield, False)

		def test_null_default(self):
		"""
		A BooleanField defaults to None, which isn't a valid value (#15124).
		"""
		boolean_field = BooleanModel._meta.get_field('bfield')
		self.assertFalse(boolean_field.has_default())
		b = BooleanModel()
		self.assertIsNone(b.bfield)
		with transaction.atomic():
		with self.assertRaises(IntegrityError):
		b.save()

		nb = NullBooleanModel()
		self.assertIsNone(nb.nbfield)
		nb.save() # no error


		class ValidationTest(SimpleTestCase):

		def test_boolean_field_doesnt_accept_empty_input(self):
		f = models.BooleanField()
		with self.assertRaises(ValidationError):
		f.clean(None, None)

		def test_nullbooleanfield_blank(self):
		"""
		NullBooleanField shouldn't throw a validation error when given a value
		of None.
		"""
		nullboolean = NullBooleanModel(nbfield=None)
		nullboolean.full_clean()

tests/model_fields/test_charfield.py

0 → 100644

+59 −0

Original line number	Diff line number	Diff line
		from django.core.exceptions import ValidationError
		from django.db import models
		from django.test import SimpleTestCase, TestCase
		from django.utils.functional import lazy

		from .models import Post


		class TestCharField(TestCase):

		def test_max_length_passed_to_formfield(self):
		"""
		CharField passes its max_length attribute to form fields created using
		the formfield() method.
		"""
		cf1 = models.CharField()
		cf2 = models.CharField(max_length=1234)
		self.assertIsNone(cf1.formfield().max_length)
		self.assertEqual(1234, cf2.formfield().max_length)

		def test_lookup_integer_in_charfield(self):
		self.assertEqual(Post.objects.filter(title=9).count(), 0)


		class ValidationTests(SimpleTestCase):

		def test_charfield_raises_error_on_empty_string(self):
		f = models.CharField()
		with self.assertRaises(ValidationError):
		f.clean('', None)

		def test_charfield_cleans_empty_string_when_blank_true(self):
		f = models.CharField(blank=True)
		self.assertEqual('', f.clean('', None))

		def test_charfield_with_choices_cleans_valid_choice(self):
		f = models.CharField(max_length=1, choices=[('a', 'A'), ('b', 'B')])
		self.assertEqual('a', f.clean('a', None))

		def test_charfield_with_choices_raises_error_on_invalid_choice(self):
		f = models.CharField(choices=[('a', 'A'), ('b', 'B')])
		with self.assertRaises(ValidationError):
		f.clean('not a', None)

		def test_charfield_get_choices_with_blank_defined(self):
		f = models.CharField(choices=[('', '<><>'), ('a', 'A')])
		self.assertEqual(f.get_choices(True), [('', '<><>'), ('a', 'A')])

		def test_charfield_get_choices_doesnt_evaluate_lazy_strings(self):
		# Regression test for #23098
		# Will raise ZeroDivisionError if lazy is evaluated
		lazy_func = lazy(lambda x: 0 / 0, int)
		f = models.CharField(choices=[(lazy_func('group'), (('a', 'A'), ('b', 'B')))])
		self.assertEqual(f.get_choices(True)[0], ('', '---------'))

		def test_charfield_raises_error_on_empty_input(self):
		f = models.CharField(null=False)
		with self.assertRaises(ValidationError):
		f.clean(None, None)

tests/model_fields/test_custom_fields.py

0 → 100644

+22 −0

Original line number	Diff line number	Diff line
		from django.db import connection, models
		from django.test import SimpleTestCase


		class CustomFieldTests(SimpleTestCase):

		def test_get_prep_value_count(self):
		"""
		Field values are not prepared twice in get_db_prep_lookup() (#14786).
		"""
		class NoopField(models.TextField):
		def __init__(self, args, *kwargs):
		self.prep_value_count = 0
		super(NoopField, self).__init__(args, *kwargs)

		def get_prep_value(self, value):
		self.prep_value_count += 1
		return super(NoopField, self).get_prep_value(value)

		field = NoopField()
		field.get_db_prep_lookup('exact', 'TEST', connection=connection, prepared=False)
		self.assertEqual(field.prep_value_count, 1)