python/lib/django-1.2/tests/regressiontests/model_fields/tests.py

   1 import datetime
   2 import unittest
   3 from decimal import Decimal
   4
   5 import django.test
   6 from django import forms
   7 from django.db import models
   8 from django.core.exceptions import ValidationError
   9
  10 from models import Foo, Bar, Whiz, BigD, BigS, Image, BigInt, Post, NullBooleanModel, BooleanModel
  11
  12 # If PIL available, do these tests.
  13 if Image:
  14     from imagefield import \
  15             ImageFieldTests, \
  16             ImageFieldTwoDimensionsTests, \
  17             ImageFieldNoDimensionsTests, \
  18             ImageFieldOneDimensionTests, \
  19             ImageFieldDimensionsFirstTests, \
  20             ImageFieldUsingFileTests, \
  21             TwoImageFieldTests
  22
  23
  24 class BasicFieldTests(django.test.TestCase):
  25     def test_show_hidden_initial(self):
  26         """
  27         Regression test for #12913. Make sure fields with choices respect
  28         show_hidden_initial as a kwarg to models.Field.formfield()
  29         """
  30         choices = [(0, 0), (1, 1)]
  31         model_field = models.Field(choices=choices)
  32         form_field = model_field.formfield(show_hidden_initial=True)
  33         self.assertTrue(form_field.show_hidden_initial)
  34
  35         form_field = model_field.formfield(show_hidden_initial=False)
  36         self.assertFalse(form_field.show_hidden_initial)
  37
  38     def test_nullbooleanfield_blank(self):
  39         """
  40         Regression test for #13071: NullBooleanField should not throw
  41         a validation error when given a value of None.
  42
  43         """
  44         nullboolean = NullBooleanModel(nbfield=None)
  45         try:
  46             nullboolean.full_clean()
  47         except ValidationError, e:
  48             self.fail("NullBooleanField failed validation with value of None: %s" % e.messages)
  49
  50 class DecimalFieldTests(django.test.TestCase):
  51     def test_to_python(self):
  52         f = models.DecimalField(max_digits=4, decimal_places=2)
  53         self.assertEqual(f.to_python(3), Decimal("3"))
  54         self.assertEqual(f.to_python("3.14"), Decimal("3.14"))
  55         self.assertRaises(ValidationError, f.to_python, "abc")
  56
  57     def test_default(self):
  58         f = models.DecimalField(default=Decimal("0.00"))
  59         self.assertEqual(f.get_default(), Decimal("0.00"))
  60
  61     def test_format(self):
  62         f = models.DecimalField(max_digits=5, decimal_places=1)
  63         self.assertEqual(f._format(f.to_python(2)), u'2.0')
  64         self.assertEqual(f._format(f.to_python('2.6')), u'2.6')
  65         self.assertEqual(f._format(None), None)
  66
  67     def test_get_db_prep_lookup(self):
  68         from django.db import connection
  69         f = models.DecimalField(max_digits=5, decimal_places=1)
  70         self.assertEqual(f.get_db_prep_lookup('exact', None, connection=connection), [None])
  71
  72     def test_filter_with_strings(self):
  73         """
  74         We should be able to filter decimal fields using strings (#8023)
  75         """
  76         Foo.objects.create(id=1, a='abc', d=Decimal("12.34"))
  77         self.assertEqual(list(Foo.objects.filter(d=u'1.23')), [])
  78
  79     def test_save_without_float_conversion(self):
  80         """
  81         Ensure decimals don't go through a corrupting float conversion during
  82         save (#5079).
  83         """
  84         bd = BigD(d="12.9")
  85         bd.save()
  86         bd = BigD.objects.get(pk=bd.pk)
  87         self.assertEqual(bd.d, Decimal("12.9"))
  88
  89     def test_lookup_really_big_value(self):
  90         """
  91         Ensure that really big values can be used in a filter statement, even
  92         with older Python versions.
  93         """
  94         # This should not crash. That counts as a win for our purposes.
  95         Foo.objects.filter(d__gte=100000000000)
  96
  97 class ForeignKeyTests(django.test.TestCase):
  98     def test_callable_default(self):
  99         """Test the use of a lazy callable for ForeignKey.default"""
 100         a = Foo.objects.create(id=1, a='abc', d=Decimal("12.34"))
 101         b = Bar.objects.create(b="bcd")
 102         self.assertEqual(b.a, a)
 103
 104 class DateTimeFieldTests(unittest.TestCase):
 105     def test_datetimefield_to_python_usecs(self):
 106         """DateTimeField.to_python should support usecs"""
 107         f = models.DateTimeField()
 108         self.assertEqual(f.to_python('2001-01-02 03:04:05.000006'),
 109                          datetime.datetime(2001, 1, 2, 3, 4, 5, 6))
 110         self.assertEqual(f.to_python('2001-01-02 03:04:05.999999'),
 111                          datetime.datetime(2001, 1, 2, 3, 4, 5, 999999))
 112
 113     def test_timefield_to_python_usecs(self):
 114         """TimeField.to_python should support usecs"""
 115         f = models.TimeField()
 116         self.assertEqual(f.to_python('01:02:03.000004'),
 117                          datetime.time(1, 2, 3, 4))
 118         self.assertEqual(f.to_python('01:02:03.999999'),
 119                          datetime.time(1, 2, 3, 999999))
 120
 121 class BooleanFieldTests(unittest.TestCase):
 122     def _test_get_db_prep_lookup(self, f):
 123         from django.db import connection
 124         self.assertEqual(f.get_db_prep_lookup('exact', True, connection=connection), [True])
 125         self.assertEqual(f.get_db_prep_lookup('exact', '1', connection=connection), [True])
 126         self.assertEqual(f.get_db_prep_lookup('exact', 1, connection=connection), [True])
 127         self.assertEqual(f.get_db_prep_lookup('exact', False, connection=connection), [False])
 128         self.assertEqual(f.get_db_prep_lookup('exact', '0', connection=connection), [False])
 129         self.assertEqual(f.get_db_prep_lookup('exact', 0, connection=connection), [False])
 130         self.assertEqual(f.get_db_prep_lookup('exact', None, connection=connection), [None])
 131
 132     def _test_to_python(self, f):
 133         self.assertTrue(f.to_python(1) is True)
 134         self.assertTrue(f.to_python(0) is False)
 135
 136     def test_booleanfield_get_db_prep_lookup(self):
 137         self._test_get_db_prep_lookup(models.BooleanField())
 138
 139     def test_nullbooleanfield_get_db_prep_lookup(self):
 140         self._test_get_db_prep_lookup(models.NullBooleanField())
 141
 142     def test_booleanfield_to_python(self):
 143         self._test_to_python(models.BooleanField())
 144
 145     def test_nullbooleanfield_to_python(self):
 146         self._test_to_python(models.NullBooleanField())
 147
 148     def test_booleanfield_choices_blank(self):
 149         """
 150         Test that BooleanField with choices and defaults doesn't generate a
 151         formfield with the blank option (#9640, #10549).
 152         """
 153         choices = [(1, u'Si'), (2, 'No')]
 154         f = models.BooleanField(choices=choices, default=1, null=True)
 155         self.assertEqual(f.formfield().choices, [('', '---------')] + choices)
 156
 157         f = models.BooleanField(choices=choices, default=1, null=False)
 158         self.assertEqual(f.formfield().choices, choices)
 159
 160     def test_return_type(self):
 161         b = BooleanModel()
 162         b.bfield = True
 163         b.save()
 164         b2 = BooleanModel.objects.get(pk=b.pk)
 165         self.assertTrue(isinstance(b2.bfield, bool))
 166         self.assertEqual(b2.bfield, True)
 167
 168         b3 = BooleanModel()
 169         b3.bfield = False
 170         b3.save()
 171         b4 = BooleanModel.objects.get(pk=b3.pk)
 172         self.assertTrue(isinstance(b4.bfield, bool))
 173         self.assertEqual(b4.bfield, False)
 174
 175         b = NullBooleanModel()
 176         b.nbfield = True
 177         b.save()
 178         b2 = NullBooleanModel.objects.get(pk=b.pk)
 179         self.assertTrue(isinstance(b2.nbfield, bool))
 180         self.assertEqual(b2.nbfield, True)
 181
 182         b3 = NullBooleanModel()
 183         b3.nbfield = False
 184         b3.save()
 185         b4 = NullBooleanModel.objects.get(pk=b3.pk)
 186         self.assertTrue(isinstance(b4.nbfield, bool))
 187         self.assertEqual(b4.nbfield, False)
 188
 189         # http://code.djangoproject.com/ticket/13293
 190         # Verify that when an extra clause exists, the boolean
 191         # conversions are applied with an offset
 192         b5 = BooleanModel.objects.all().extra(
 193             select={'string_length': 'LENGTH(string)'})[0]
 194         self.assertFalse(isinstance(b5.pk, bool))
 195
 196 class ChoicesTests(django.test.TestCase):
 197     def test_choices_and_field_display(self):
 198         """
 199         Check that get_choices and get_flatchoices interact with
 200         get_FIELD_display to return the expected values (#7913).
 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.assertEqual(Whiz(c=None).get_c_display(), None)    # Blank value
 206         self.assertEqual(Whiz(c='').get_c_display(), '')        # Empty value
 207
 208 class SlugFieldTests(django.test.TestCase):
 209     def test_slugfield_max_length(self):
 210         """
 211         Make sure SlugField honors max_length (#9706)
 212         """
 213         bs = BigS.objects.create(s = 'slug'*50)
 214         bs = BigS.objects.get(pk=bs.pk)
 215         self.assertEqual(bs.s, 'slug'*50)
 216
 217
 218 class ValidationTest(django.test.TestCase):
 219     def test_charfield_raises_error_on_empty_string(self):
 220         f = models.CharField()
 221         self.assertRaises(ValidationError, f.clean, "", None)
 222
 223     def test_charfield_cleans_empty_string_when_blank_true(self):
 224         f = models.CharField(blank=True)
 225         self.assertEqual('', f.clean('', None))
 226
 227     def test_integerfield_cleans_valid_string(self):
 228         f = models.IntegerField()
 229         self.assertEqual(2, f.clean('2', None))
 230
 231     def test_integerfield_raises_error_on_invalid_intput(self):
 232         f = models.IntegerField()
 233         self.assertRaises(ValidationError, f.clean, "a", None)
 234
 235     def test_charfield_with_choices_cleans_valid_choice(self):
 236         f = models.CharField(max_length=1, choices=[('a','A'), ('b','B')])
 237         self.assertEqual('a', f.clean('a', None))
 238
 239     def test_charfield_with_choices_raises_error_on_invalid_choice(self):
 240         f = models.CharField(choices=[('a','A'), ('b','B')])
 241         self.assertRaises(ValidationError, f.clean, "not a", None)
 242
 243     def test_choices_validation_supports_named_groups(self):
 244         f = models.IntegerField(choices=(('group',((10,'A'),(20,'B'))),(30,'C')))
 245         self.assertEqual(10, f.clean(10, None))
 246
 247     def test_nullable_integerfield_raises_error_with_blank_false(self):
 248         f = models.IntegerField(null=True, blank=False)
 249         self.assertRaises(ValidationError, f.clean, None, None)
 250
 251     def test_nullable_integerfield_cleans_none_on_null_and_blank_true(self):
 252         f = models.IntegerField(null=True, blank=True)
 253         self.assertEqual(None, f.clean(None, None))
 254
 255     def test_integerfield_raises_error_on_empty_input(self):
 256         f = models.IntegerField(null=False)
 257         self.assertRaises(ValidationError, f.clean, None, None)
 258         self.assertRaises(ValidationError, f.clean, '', None)
 259
 260     def test_charfield_raises_error_on_empty_input(self):
 261         f = models.CharField(null=False)
 262         self.assertRaises(ValidationError, f.clean, None, None)
 263
 264     def test_datefield_cleans_date(self):
 265         f = models.DateField()
 266         self.assertEqual(datetime.date(2008, 10, 10), f.clean('2008-10-10', None))
 267
 268     def test_boolean_field_doesnt_accept_empty_input(self):
 269         f = models.BooleanField()
 270         self.assertRaises(ValidationError, f.clean, None, None)
 271
 272
 273 class BigIntegerFieldTests(django.test.TestCase):
 274     def test_limits(self):
 275         # Ensure that values that are right at the limits can be saved
 276         # and then retrieved without corruption.
 277         maxval = 9223372036854775807
 278         minval = -maxval - 1
 279         BigInt.objects.create(value=maxval)
 280         qs = BigInt.objects.filter(value__gte=maxval)
 281         self.assertEqual(qs.count(), 1)
 282         self.assertEqual(qs[0].value, maxval)
 283         BigInt.objects.create(value=minval)
 284         qs = BigInt.objects.filter(value__lte=minval)
 285         self.assertEqual(qs.count(), 1)
 286         self.assertEqual(qs[0].value, minval)
 287
 288     def test_types(self):
 289         b = BigInt(value = 0)
 290         self.assertTrue(isinstance(b.value, (int, long)))
 291         b.save()
 292         self.assertTrue(isinstance(b.value, (int, long)))
 293         b = BigInt.objects.all()[0]
 294         self.assertTrue(isinstance(b.value, (int, long)))
 295
 296     def test_coercing(self):
 297         BigInt.objects.create(value ='10')
 298         b = BigInt.objects.get(value = '10')
 299         self.assertEqual(b.value, 10)
 300
 301 class TypeCoercionTests(django.test.TestCase):
 302     """
 303     Test that database lookups can accept the wrong types and convert
 304     them with no error: especially on Postgres 8.3+ which does not do
 305     automatic casting at the DB level. See #10015.
 306
 307     """
 308     def test_lookup_integer_in_charfield(self):
 309         self.assertEquals(Post.objects.filter(title=9).count(), 0)
 310
 311     def test_lookup_integer_in_textfield(self):
 312         self.assertEquals(Post.objects.filter(body=24).count(), 0)
 313