Merge branch 'hotfix/mashony/decimal-int-overflow-error-handling' into 'master'

Fix precision check for DecimalIntegerType

See merge request !42

schematics/types/custom.py

@@ -42,8 +42,7 @@ class DecimalIntegerType(NumberType):
     def convert(self, value, context=None):
         if not isinstance(value, (int, float)):
             raise ValidationError(f'Require int or float type, but {type(value).__name__} found')
-        precision = self.__get_value_precision(value)
-        if precision > self.strict:
+        if not self.is_precision_valid(value):
             raise ValidationError(f"Value should have less than or equal to {self.strict} numbers after decimal point")
         return super().convert(value, context)
 
@@ -52,10 +51,12 @@ class DecimalIntegerType(NumberType):
             return round(value * self.get_strict())
         return value
 
-    def __get_value_precision(self, value):
-        # todo: find more correct way to calculate this
-        decimal_number = "{:.15f}".format(float(value)).strip("0").split(".")[1]
-        return len(decimal_number)
+    def is_precision_valid(self, value):
+        """
+        Check if value has less than `strict` decimal numbers
+        works with numbers less than .9999999999996 decimal part
+        """
+        return round(value * self.get_strict()) == round(value * self.get_strict(), 10)
 
     def validate_range(self, value, context=None):
         """

tests/custom_types/test_decimal_integer_type.py

@@ -129,19 +129,15 @@ class TestDecimalIntegerType:
         assert isinstance(amount_field, types.DecimalIntegerType)
         assert 'exclusiveMinimum' in amount_field.metadata
 
-    @pytest.mark.parametrize("value, expected_precision", [
-        (10, 0),
-        (10., 0),
-        (10.0, 0),
-        (10.000, 0),
-        (10.1, 1),
-        (10.01, 2),
-        (10.000000000001, 12),
-        (3.55, 2),
+    @pytest.mark.parametrize("value, strict", [
+        [-655.31, 2],
+        [0.31, 2],
+        [5 ** (10*100), 2],
+        [0.9999999999996, 2],
     ])
-    def test_value_precision(self, value, expected_precision):
-        test_field = types.DecimalIntegerType()
-        assert test_field._DecimalIntegerType__get_value_precision(value) == expected_precision
+    def test_value_precision(self, value, strict):
+        test_field = types.DecimalIntegerType(strict=strict)
+        assert test_field.is_precision_valid(value)
 
     @pytest.mark.parametrize("value, strict, expectation", [
         (10, 2, does_not_raise()),  # default
@@ -151,9 +147,16 @@ class TestDecimalIntegerType:
         (10.1, 2, does_not_raise()),
         (10.001, 2, pytest.raises(exceptions.ValidationError)),
         (10.009, 2, pytest.raises(exceptions.ValidationError)),
+        (10.9999999999, 2, pytest.raises(exceptions.ValidationError)),
+        (10.9999999999995, 2, pytest.raises(exceptions.ValidationError)),
         (3.55, 2, does_not_raise()),
         (3., 0, does_not_raise()),
         (3.0, 0, does_not_raise()),
+        (92.1, 2, does_not_raise()),
+        (5 ** (10*100), 0, does_not_raise()),
+        (-(5 ** (10*100)), 0, does_not_raise()),
+        (types.DecimalIntegerType._max_int, 0, does_not_raise()),
+        (-types.DecimalIntegerType._max_int, 0, does_not_raise()),
     ])
     def test_precision_validation(self, value, strict, expectation):
         test_field = types.DecimalIntegerType(strict=strict)