Converted model_fields regression tests into unittests.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@10499 bcc190cf-cafb-0310-a4f2-bffc1f526a37

tests/regressiontests/model_fields/models.py

@@ -1,4 +1,3 @@
-
 from django.db import models
 
 try:
@@ -37,64 +36,4 @@ class BigD(models.Model):
     d = models.DecimalField(max_digits=38, decimal_places=30)
 
 class BigS(models.Model):
-    s = models.SlugField(max_length=255)
+    s = models.SlugField(max_length=255)
-
-__test__ = {'API_TESTS':"""
-# Create a couple of Places.
->>> f = Foo.objects.create(a='abc', d=decimal.Decimal("12.34"))
->>> f.id
-1
->>> b = Bar(b = "bcd")
->>> b.a
-<Foo: Foo object>
->>> b.save()
-
-# Regression tests for #7913
-# Check that get_choices and get_flatchoices interact with
-# get_FIELD_display to return the expected values.
-
-# Test a nested value
->>> w = Whiz(c=1)
->>> w.save()
->>> w.get_c_display()
-u'First'
-
-# Test a top level value
->>> w.c = 0
->>> w.get_c_display()
-u'Other'
-
-# Test an invalid data value
->>> w.c = 9
->>> w.get_c_display()
-9
-
-# Test a blank data value
->>> w.c = None
->>> print w.get_c_display()
-None
-
-# Test an empty data value
->>> w.c = ''
->>> w.get_c_display()
-u''
-
-# Regression test for #8023: should be able to filter decimal fields using
-# strings (which is what gets passed through from, e.g., the admin interface).
->>> Foo.objects.filter(d=u'1.23')
-[]
-
-# Regression test for #5079 -- ensure decimals don't go through a corrupting
-# float conversion during save.  
->>> bd = BigD(d="12.9")
->>> bd.save()
->>> bd = BigD.objects.get(pk=bd.pk)
->>> bd.d == decimal.Decimal("12.9")
-True
-
-# Regression test for #9706: ensure SlugField honors max_length.
->>> bs = BigS.objects.create(s = 'slug' * 50)
->>> bs = BigS.objects.get(pk=bs.pk)
->>> bs.s == 'slug' * 50
-True
-"""}

tests/regressiontests/model_fields/tests.py

@@ -1,79 +1,109 @@
-"""
+import datetime
->>> from django.db.models.fields import *
+import unittest
->>> try:
+import django.test
-...     from decimal import Decimal
+from django.db import models
-... except ImportError:
+from django.core.exceptions import ValidationError
-...     from django.utils._decimal import Decimal
+from models import Foo, Bar, Whiz, BigD, BigS
+try:
+    from decimal import Decimal
+except ImportError:
+    from django.utils._decimal import Decimal
+    
+class DecimalFieldTests(django.test.TestCase):
+    def test_to_python(self):
+        f = models.DecimalField(max_digits=4, decimal_places=2)
+        self.assertEqual(f.to_python(3), Decimal("3"))
+        self.assertEqual(f.to_python("3.14"), Decimal("3.14"))
+        self.assertRaises(ValidationError, f.to_python, "abc")
+    
+    def test_default(self):
+        f = models.DecimalField(default=Decimal("0.00"))
+        self.assertEqual(f.get_default(), Decimal("0.00"))
+    
+    def test_format(self):
+        f = models.DecimalField(max_digits=5, decimal_places=1)
+        self.assertEqual(f._format(f.to_python(2)), u'2.0')
+        self.assertEqual(f._format(f.to_python('2.6')), u'2.6')
+        self.assertEqual(f._format(None), None)
+    
+    def test_get_db_prep_lookup(self):
+        f = models.DecimalField(max_digits=5, decimal_places=1)
+        self.assertEqual(f.get_db_prep_lookup('exact', None), [None])
 
-# DecimalField
+    def test_filter_with_strings(self):
+        """
+        We should be able to filter decimal fields using strings (#8023)
+        """
+        Foo.objects.create(id=1, a='abc', d=Decimal("12.34"))
+        self.assertEqual(list(Foo.objects.filter(d=u'1.23')), [])
 
->>> f = DecimalField(max_digits=4, decimal_places=2)
+    def test_save_wihout_float_conversion(self):
+        """
+        Ensure decimals don't go through a corrupting float conversion during
+        save (#5079).
+        """
+        bd = BigD(d="12.9")
+        bd.save()
+        bd = BigD.objects.get(pk=bd.pk)
+        self.assertEqual(bd.d, Decimal("12.9"))
 
->>> f.to_python(3) == Decimal("3")
+class ForeignKeyTests(django.test.TestCase):
-True
+    def test_callable_default(self):
+        """Test the use of a lazy callable for ForeignKey.default"""
+        a = Foo.objects.create(id=1, a='abc', d=Decimal("12.34"))
+        b = Bar.objects.create(b="bcd")
+        self.assertEqual(b.a, a)
 
->>> f.to_python("3.14") == Decimal("3.14")
+class DateTimeFieldTests(unittest.TestCase):
-True
+    def test_datetimefield_to_python_usecs(self):
+        """DateTimeField.to_python should support usecs"""
+        f = models.DateTimeField()
+        self.assertEqual(f.to_python('2001-01-02 03:04:05.000006'),
+                         datetime.datetime(2001, 1, 2, 3, 4, 5, 6))
+        self.assertEqual(f.to_python('2001-01-02 03:04:05.999999'),
+                         datetime.datetime(2001, 1, 2, 3, 4, 5, 999999))
+        
+    def test_timefield_to_python_usecs(self):
+        """TimeField.to_python should support usecs"""
+        f = models.TimeField()
+        self.assertEqual(f.to_python('01:02:03.000004'), 
+                         datetime.time(1, 2, 3, 4))
+        self.assertEqual(f.to_python('01:02:03.999999'),
+                         datetime.time(1, 2, 3, 999999))
 
->>> f.to_python("abc")
+class BooleanFieldTests(unittest.TestCase):
-Traceback (most recent call last):
+    def _test_get_db_prep_lookup(self, f):
-...
+        self.assertEqual(f.get_db_prep_lookup('exact', True), [True])
-ValidationError: This value must be a decimal number.
+        self.assertEqual(f.get_db_prep_lookup('exact', '1'), [True])
+        self.assertEqual(f.get_db_prep_lookup('exact', 1), [True])
+        self.assertEqual(f.get_db_prep_lookup('exact', False), [False])
+        self.assertEqual(f.get_db_prep_lookup('exact', '0'), [False])
+        self.assertEqual(f.get_db_prep_lookup('exact', 0), [False])
+        self.assertEqual(f.get_db_prep_lookup('exact', None), [None])
 
->>> f = DecimalField(default=Decimal("0.00"))
+    def test_booleanfield_get_db_prep_lookup(self):
->>> f.get_default()
+        self._test_get_db_prep_lookup(models.BooleanField())
-Decimal("0.00")
+        
+    def test_nullbooleanfield_get_db_prep_lookup(self):
+        self._test_get_db_prep_lookup(models.NullBooleanField())
 
->>> f = DecimalField(max_digits=5, decimal_places=1)
+class ChoicesTests(django.test.TestCase):
->>> x = f.to_python(2)
+    def test_choices_and_field_display(self):
->>> y = f.to_python('2.6')
+        """
-
+        Check that get_choices and get_flatchoices interact with
->>> f._format(x)
+        get_FIELD_display to return the expected values (#7913).
-u'2.0'
+        """
->>> f._format(y)
+        self.assertEqual(Whiz(c=1).get_c_display(), 'First')    # A nested value
-u'2.6'
+        self.assertEqual(Whiz(c=0).get_c_display(), 'Other')    # A top level value
->>> f._format(None)
+        self.assertEqual(Whiz(c=9).get_c_display(), 9)          # Invalid value
->>> f.get_db_prep_lookup('exact', None)
+        self.assertEqual(Whiz(c=None).get_c_display(), None)    # Blank value
-[None]
+        self.assertEqual(Whiz(c='').get_c_display(), '')        # Empty value
-
+        
-# DateTimeField and TimeField to_python should support usecs:
+class SlugFieldTests(django.test.TestCase):
->>> f = DateTimeField()
+    def test_slugfield_max_length(self):
->>> f.to_python('2001-01-02 03:04:05.000006')
+        """
-datetime.datetime(2001, 1, 2, 3, 4, 5, 6)
+        Make sure SlugField honors max_length (#9706)
->>> f.to_python('2001-01-02 03:04:05.999999')
+        """
-datetime.datetime(2001, 1, 2, 3, 4, 5, 999999)
+        bs = BigS.objects.create(s = 'slug'*50)
-
+        bs = BigS.objects.get(pk=bs.pk)
->>> f = TimeField()
+        self.assertEqual(bs.s, 'slug'*50)
->>> f.to_python('01:02:03.000004')
-datetime.time(1, 2, 3, 4)
->>> f.to_python('01:02:03.999999')
-datetime.time(1, 2, 3, 999999)
-
-# Boolean and null boolean fields
->>> f = BooleanField()
->>> for val in (True, '1', 1):
-...     f.get_db_prep_lookup('exact', val)
-[True]
-[True]
-[True]
->>> for val in (False, '0', 0):
-...     f.get_db_prep_lookup('exact', val)
-[False]
-[False]
-[False]
-
->>> f = NullBooleanField()
->>> for val in (True, '1', 1):
-...     f.get_db_prep_lookup('exact', val)
-[True]
-[True]
-[True]
->>> for val in (False, '0', 0):
-...     f.get_db_prep_lookup('exact', val)
-[False]
-[False]
-[False]
->>> f.get_db_prep_lookup('exact', None)
-[None]
-
-"""