1. import math

  2. from decimal import Decimal

  3. 

  4. from django.core import validators

  5. from django.core.exceptions import ValidationError

  6. from django.db import models

  7. from django.test import TestCase

  8. 

  9. from .models import BigD, Foo

  10. 

  11. 

  12. class DecimalFieldTests(TestCase):

  13.     def test_to_python(self):

  14.         f = models.DecimalField(max_digits=4, decimal_places=2)

  15.         self.assertEqual(f.to_python(3), Decimal("3"))

  16.         self.assertEqual(f.to_python("3.14"), Decimal("3.14"))

  17.         # to_python() converts floats and honors max_digits.

  18.         self.assertEqual(f.to_python(3.1415926535897), Decimal("3.142"))

  19.         self.assertEqual(f.to_python(2.4), Decimal("2.400"))

  20.         # Uses default rounding of ROUND_HALF_EVEN.

  21.         self.assertEqual(f.to_python(2.0625), Decimal("2.062"))

  22.         self.assertEqual(f.to_python(2.1875), Decimal("2.188"))

  23. 

  24.     def test_invalid_value(self):

  25.         field = models.DecimalField(max_digits=4, decimal_places=2)

  26.         msg = "“%s” value must be a decimal number."

  27.         tests = [

  28.             (),

  29.             [],

  30.             {},

  31.             set(),

  32.             object(),

  33.             complex(),

  34.             "non-numeric string",

  35.             b"non-numeric byte-string",

  36.         ]

  37.         for value in tests:

  38.             with self.subTest(value):

  39.                 with self.assertRaisesMessage(ValidationError, msg % (value,)):

  40.                     field.clean(value, None)

  41. 

  42.     def test_default(self):

  43.         f = models.DecimalField(default=Decimal("0.00"))

  44.         self.assertEqual(f.get_default(), Decimal("0.00"))

  45. 

  46.     def test_get_prep_value(self):

  47.         f = models.DecimalField(max_digits=5, decimal_places=1)

  48.         self.assertIsNone(f.get_prep_value(None))

  49.         self.assertEqual(f.get_prep_value("2.4"), Decimal("2.4"))

  50. 

  51.     def test_filter_with_strings(self):

  52.         """

  53.         Should be able to filter decimal fields using strings (#8023).

  54.         """

  55.         foo = Foo.objects.create(a="abc", d=Decimal("12.34"))

  56.         self.assertEqual(list(Foo.objects.filter(d="12.34")), [foo])

  57. 

  58.     def test_save_without_float_conversion(self):

  59.         """

  60.         Ensure decimals don't go through a corrupting float conversion during

  61.         save (#5079).

  62.         """

  63.         bd = BigD(d="12.9")

  64.         bd.save()

  65.         bd = BigD.objects.get(pk=bd.pk)

  66.         self.assertEqual(bd.d, Decimal("12.9"))

  67. 

  68.     def test_save_nan_invalid(self):

  69.         msg = "“nan” value must be a decimal number."

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

  71.             BigD.objects.create(d=float("nan"))

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

  73.             BigD.objects.create(d=math.nan)

  74. 

  75.     def test_fetch_from_db_without_float_rounding(self):

  76.         big_decimal = BigD.objects.create(d=Decimal(".100000000000000000000000000005"))

  77.         big_decimal.refresh_from_db()

  78.         self.assertEqual(big_decimal.d, Decimal(".100000000000000000000000000005"))

  79. 

  80.     def test_lookup_really_big_value(self):

  81.         """

  82.         Really big values can be used in a filter statement.

  83.         """

  84.         # This should not crash.

  85.         Foo.objects.filter(d__gte=100000000000)

  86. 

  87.     def test_max_digits_validation(self):

  88.         field = models.DecimalField(max_digits=2)

  89.         expected_message = validators.DecimalValidator.messages["max_digits"] % {

  90.             "max": 2

  91.         }

  92.         with self.assertRaisesMessage(ValidationError, expected_message):

  93.             field.clean(100, None)

  94. 

  95.     def test_max_decimal_places_validation(self):

  96.         field = models.DecimalField(decimal_places=1)

  97.         expected_message = validators.DecimalValidator.messages[

  98.             "max_decimal_places"

  99.         ] % {"max": 1}

  100.         with self.assertRaisesMessage(ValidationError, expected_message):

  101.             field.clean(Decimal("0.99"), None)

  102. 

  103.     def test_max_whole_digits_validation(self):

  104.         field = models.DecimalField(max_digits=3, decimal_places=1)

  105.         expected_message = validators.DecimalValidator.messages["max_whole_digits"] % {

  106.             "max": 2

  107.         }

  108.         with self.assertRaisesMessage(ValidationError, expected_message):

  109.             field.clean(Decimal("999"), None)

  110. 

  111.     def test_roundtrip_with_trailing_zeros(self):

  112.         """Trailing zeros in the fractional part aren't truncated."""

  113.         obj = Foo.objects.create(a="bar", d=Decimal("8.320"))

  114.         obj.refresh_from_db()

  115.         self.assertEqual(obj.d.compare_total(Decimal("8.320")), Decimal("0"))
About Sign Up Leave Feedback Contact