Tweaks to DecimalField

rest_framework/fields.py

@@ -521,20 +521,21 @@ class DecimalField(Field):
         return value
 
     def to_representation(self, value):
-        if isinstance(value, decimal.Decimal):
+        if value in (None, ''):
-            context = decimal.getcontext().copy()
+            return None
-            context.prec = self.max_digits
-            quantized = value.quantize(
-                decimal.Decimal('.1') ** self.decimal_places,
-                context=context
-            )
-            if not self.coerce_to_string:
-                return quantized
-            return '{0:f}'.format(quantized)
 
+        if not isinstance(value, decimal.Decimal):
+            value = decimal.Decimal(value)
+
+        context = decimal.getcontext().copy()
+        context.prec = self.max_digits
+        quantized = value.quantize(
+            decimal.Decimal('.1') ** self.decimal_places,
+            context=context
+        )
         if not self.coerce_to_string:
-            return value
+            return quantized
-        return '%.*f' % (self.max_decimal_places, value)
+        return '{0:f}'.format(quantized)
 
 
 # Date & time fields...

tests/test_fields.py

@@ -14,31 +14,35 @@ def get_items(mapping_or_list_of_two_tuples):
     return mapping_or_list_of_two_tuples
 
 
-class ValidAndInvalidValues:
+class FieldValues:
     """
     Base class for testing valid and invalid input values.
     """
-    def test_valid_values(self):
+    def test_valid_inputs(self):
         """
         Ensure that valid values return the expected validated data.
         """
-        for input_value, expected_output in get_items(self.valid_mappings):
+        for input_value, expected_output in get_items(self.valid_inputs):
             assert self.field.run_validation(input_value) == expected_output
 
-    def test_invalid_values(self):
+    def test_invalid_inputs(self):
         """
         Ensure that invalid values raise the expected validation error.
         """
-        for input_value, expected_failure in get_items(self.invalid_mappings):
+        for input_value, expected_failure in get_items(self.invalid_inputs):
             with pytest.raises(fields.ValidationError) as exc_info:
                 self.field.run_validation(input_value)
             assert exc_info.value.messages == expected_failure
 
+    def test_outputs(self):
+        for output_value, expected_output in get_items(self.outputs):
+            assert self.field.to_representation(output_value) == expected_output
+
 
 # Boolean types...
 
-class TestBooleanField(ValidAndInvalidValues):
+class TestBooleanField(FieldValues):
-    valid_mappings = {
+    valid_inputs = {
         'true': True,
         'false': False,
         '1': True,
@@ -48,73 +52,92 @@ class TestBooleanField(ValidAndInvalidValues):
         True: True,
         False: False,
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'foo': ['`foo` is not a valid boolean.']
     }
+    outputs = {
+        'true': True,
+        'false': False,
+        '1': True,
+        '0': False,
+        1: True,
+        0: False,
+        True: True,
+        False: False,
+        'other': True
+    }
     field = fields.BooleanField()
 
 
 # String types...
 
-class TestCharField(ValidAndInvalidValues):
+class TestCharField(FieldValues):
-    valid_mappings = {
+    valid_inputs = {
         1: '1',
         'abc': 'abc'
     }
-    invalid_mappings = {
+    invalid_inputs = {
         '': ['This field may not be blank.']
     }
+    outputs = {
+        1: '1',
+        'abc': 'abc'
+    }
     field = fields.CharField()
 
 
-class TestEmailField(ValidAndInvalidValues):
+class TestEmailField(FieldValues):
-    valid_mappings = {
+    valid_inputs = {
         'example@example.com': 'example@example.com',
         ' example@example.com ': 'example@example.com',
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'example.com': ['Enter a valid email address.']
     }
+    outputs = {}
     field = fields.EmailField()
 
 
-class TestRegexField(ValidAndInvalidValues):
+class TestRegexField(FieldValues):
-    valid_mappings = {
+    valid_inputs = {
         'a9': 'a9',
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'A9': ["This value does not match the required pattern."]
     }
+    outputs = {}
     field = fields.RegexField(regex='[a-z][0-9]')
 
 
-class TestSlugField(ValidAndInvalidValues):
+class TestSlugField(FieldValues):
-    valid_mappings = {
+    valid_inputs = {
         'slug-99': 'slug-99',
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'slug 99': ["Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens."]
     }
+    outputs = {}
     field = fields.SlugField()
 
 
-class TestURLField(ValidAndInvalidValues):
+class TestURLField(FieldValues):
-    valid_mappings = {
+    valid_inputs = {
         'http://example.com': 'http://example.com',
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'example.com': ['Enter a valid URL.']
     }
+    outputs = {}
     field = fields.URLField()
 
 
 # Number types...
 
-class TestIntegerField(ValidAndInvalidValues):
+class TestIntegerField(FieldValues):
     """
     Valid and invalid values for `IntegerField`.
     """
-    valid_mappings = {
+    valid_inputs = {
         '1': 1,
         '0': 0,
         1: 1,
@@ -122,36 +145,45 @@ class TestIntegerField(ValidAndInvalidValues):
         1.0: 1,
         0.0: 0
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'abc': ['A valid integer is required.']
     }
+    outputs = {
+        '1': 1,
+        '0': 0,
+        1: 1,
+        0: 0,
+        1.0: 1,
+        0.0: 0
+    }
     field = fields.IntegerField()
 
 
-class TestMinMaxIntegerField(ValidAndInvalidValues):
+class TestMinMaxIntegerField(FieldValues):
     """
     Valid and invalid values for `IntegerField` with min and max limits.
     """
-    valid_mappings = {
+    valid_inputs = {
         '1': 1,
         '3': 3,
         1: 1,
         3: 3,
     }
-    invalid_mappings = {
+    invalid_inputs = {
         0: ['Ensure this value is greater than or equal to 1.'],
         4: ['Ensure this value is less than or equal to 3.'],
         '0': ['Ensure this value is greater than or equal to 1.'],
         '4': ['Ensure this value is less than or equal to 3.'],
     }
+    outputs = {}
     field = fields.IntegerField(min_value=1, max_value=3)
 
 
-class TestFloatField(ValidAndInvalidValues):
+class TestFloatField(FieldValues):
     """
     Valid and invalid values for `FloatField`.
     """
-    valid_mappings = {
+    valid_inputs = {
         '1': 1.0,
         '0': 0.0,
         1: 1.0,
@@ -159,17 +191,25 @@ class TestFloatField(ValidAndInvalidValues):
         1.0: 1.0,
         0.0: 0.0,
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'abc': ["A valid number is required."]
     }
+    outputs = {
+        '1': 1.0,
+        '0': 0.0,
+        1: 1.0,
+        0: 0.0,
+        1.0: 1.0,
+        0.0: 0.0,
+    }
     field = fields.FloatField()
 
 
-class TestMinMaxFloatField(ValidAndInvalidValues):
+class TestMinMaxFloatField(FieldValues):
     """
     Valid and invalid values for `FloatField` with min and max limits.
     """
-    valid_mappings = {
+    valid_inputs = {
         '1': 1,
         '3': 3,
         1: 1,
@@ -177,20 +217,21 @@ class TestMinMaxFloatField(ValidAndInvalidValues):
         1.0: 1.0,
         3.0: 3.0,
     }
-    invalid_mappings = {
+    invalid_inputs = {
         0.9: ['Ensure this value is greater than or equal to 1.'],
         3.1: ['Ensure this value is less than or equal to 3.'],
         '0.0': ['Ensure this value is greater than or equal to 1.'],
         '3.1': ['Ensure this value is less than or equal to 3.'],
     }
+    outputs = {}
     field = fields.FloatField(min_value=1, max_value=3)
 
 
-class TestDecimalField(ValidAndInvalidValues):
+class TestDecimalField(FieldValues):
     """
     Valid and invalid values for `DecimalField`.
     """
-    valid_mappings = {
+    valid_inputs = {
         '12.3': Decimal('12.3'),
         '0.1': Decimal('0.1'),
         10: Decimal('10'),
@@ -198,7 +239,7 @@ class TestDecimalField(ValidAndInvalidValues):
         12.3: Decimal('12.3'),
         0.1: Decimal('0.1'),
     }
-    invalid_mappings = (
+    invalid_inputs = (
         ('abc', ["A valid number is required."]),
         (Decimal('Nan'), ["A valid number is required."]),
         (Decimal('Inf'), ["A valid number is required."]),
@@ -206,63 +247,98 @@ class TestDecimalField(ValidAndInvalidValues):
         ('0.01', ["Ensure that there are no more than 1 decimal places."]),
         (123, ["Ensure that there are no more than 2 digits before the decimal point."])
     )
+    outputs = {
+        '1': '1.0',
+        '0': '0.0',
+        '1.09': '1.1',
+        '0.04': '0.0',
+        1: '1.0',
+        0: '0.0',
+        Decimal('1.0'): '1.0',
+        Decimal('0.0'): '0.0',
+        Decimal('1.09'): '1.1',
+        Decimal('0.04'): '0.0',
+    }
     field = fields.DecimalField(max_digits=3, decimal_places=1)
 
 
-class TestMinMaxDecimalField(ValidAndInvalidValues):
+class TestMinMaxDecimalField(FieldValues):
     """
     Valid and invalid values for `DecimalField` with min and max limits.
     """
-    valid_mappings = {
+    valid_inputs = {
         '10.0': 10.0,
         '20.0': 20.0,
     }
-    invalid_mappings = {
+    invalid_inputs = {
         '9.9': ['Ensure this value is greater than or equal to 10.'],
         '20.1': ['Ensure this value is less than or equal to 20.'],
     }
+    outputs = {}
     field = fields.DecimalField(
         max_digits=3, decimal_places=1,
         min_value=10, max_value=20
     )
 
 
+class TestNoStringCoercionDecimalField(FieldValues):
+    """
+    Output values for `DecimalField` with `coerce_to_string=False`.
+    """
+    valid_inputs = {}
+    invalid_inputs = {}
+    outputs = {
+        1.09: Decimal('1.1'),
+        0.04: Decimal('0.0'),
+        '1.09': Decimal('1.1'),
+        '0.04': Decimal('0.0'),
+        Decimal('1.09'): Decimal('1.1'),
+        Decimal('0.04'): Decimal('0.0'),
+    }
+    field = fields.DecimalField(
+        max_digits=3, decimal_places=1,
+        coerce_to_string=False
+    )
+
+
 # Date & time fields...
 
-class TestDateField(ValidAndInvalidValues):
+class TestDateField(FieldValues):
     """
     Valid and invalid values for `DateField`.
     """
-    valid_mappings = {
+    valid_inputs = {
         '2001-01-01': datetime.date(2001, 1, 1),
         datetime.date(2001, 1, 1): datetime.date(2001, 1, 1),
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'abc': ['Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]'],
         '2001-99-99': ['Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]'],
         datetime.datetime(2001, 1, 1, 12, 00): ['Expected a date but got a datetime.'],
     }
+    outputs = {}
     field = fields.DateField()
 
 
-class TestCustomInputFormatDateField(ValidAndInvalidValues):
+class TestCustomInputFormatDateField(FieldValues):
     """
     Valid and invalid values for `DateField` with a cutom input format.
     """
-    valid_mappings = {
+    valid_inputs = {
         '1 Jan 2001': datetime.date(2001, 1, 1),
     }
-    invalid_mappings = {
+    invalid_inputs = {
         '2001-01-01': ['Date has wrong format. Use one of these formats instead: DD [Jan-Dec] YYYY']
     }
+    outputs = {}
     field = fields.DateField(input_formats=['%d %b %Y'])
 
 
-class TestDateTimeField(ValidAndInvalidValues):
+class TestDateTimeField(FieldValues):
     """
     Valid and invalid values for `DateTimeField`.
     """
-    valid_mappings = {
+    valid_inputs = {
         '2001-01-01 13:00': datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
         '2001-01-01T13:00': datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
         '2001-01-01T13:00Z': datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
@@ -270,81 +346,87 @@ class TestDateTimeField(ValidAndInvalidValues):
         datetime.datetime(2001, 1, 1, 13, 00): datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
         datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'abc': ['Datetime has wrong format. Use one of these formats instead: YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]'],
         '2001-99-99T99:00': ['Datetime has wrong format. Use one of these formats instead: YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]'],
         datetime.date(2001, 1, 1): ['Expected a datetime but got a date.'],
     }
+    outputs = {}
     field = fields.DateTimeField(default_timezone=timezone.UTC())
 
 
-class TestCustomInputFormatDateTimeField(ValidAndInvalidValues):
+class TestCustomInputFormatDateTimeField(FieldValues):
     """
     Valid and invalid values for `DateTimeField` with a cutom input format.
     """
-    valid_mappings = {
+    valid_inputs = {
         '1:35pm, 1 Jan 2001': datetime.datetime(2001, 1, 1, 13, 35, tzinfo=timezone.UTC()),
     }
-    invalid_mappings = {
+    invalid_inputs = {
         '2001-01-01T20:50': ['Datetime has wrong format. Use one of these formats instead: hh:mm[AM|PM], DD [Jan-Dec] YYYY']
     }
+    outputs = {}
     field = fields.DateTimeField(default_timezone=timezone.UTC(), input_formats=['%I:%M%p, %d %b %Y'])
 
 
-class TestNaiveDateTimeField(ValidAndInvalidValues):
+class TestNaiveDateTimeField(FieldValues):
     """
     Valid and invalid values for `DateTimeField` with naive datetimes.
     """
-    valid_mappings = {
+    valid_inputs = {
         datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): datetime.datetime(2001, 1, 1, 13, 00),
         '2001-01-01 13:00': datetime.datetime(2001, 1, 1, 13, 00),
     }
-    invalid_mappings = {}
+    invalid_inputs = {}
+    outputs = {}
     field = fields.DateTimeField(default_timezone=None)
 
 
-class TestTimeField(ValidAndInvalidValues):
+class TestTimeField(FieldValues):
     """
     Valid and invalid values for `TimeField`.
     """
-    valid_mappings = {
+    valid_inputs = {
         '13:00': datetime.time(13, 00),
         datetime.time(13, 00): datetime.time(13, 00),
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'abc': ['Time has wrong format. Use one of these formats instead: hh:mm[:ss[.uuuuuu]]'],
         '99:99': ['Time has wrong format. Use one of these formats instead: hh:mm[:ss[.uuuuuu]]'],
     }
+    outputs = {}
     field = fields.TimeField()
 
 
-class TestCustomInputFormatTimeField(ValidAndInvalidValues):
+class TestCustomInputFormatTimeField(FieldValues):
     """
     Valid and invalid values for `TimeField` with a custom input format.
     """
-    valid_mappings = {
+    valid_inputs = {
         '1:00pm': datetime.time(13, 00),
     }
-    invalid_mappings = {
+    invalid_inputs = {
         '13:00': ['Time has wrong format. Use one of these formats instead: hh:mm[AM|PM]'],
     }
+    outputs = {}
     field = fields.TimeField(input_formats=['%I:%M%p'])
 
 
 # Choice types...
 
-class TestChoiceField(ValidAndInvalidValues):
+class TestChoiceField(FieldValues):
     """
     Valid and invalid values for `ChoiceField`.
     """
-    valid_mappings = {
+    valid_inputs = {
         'poor': 'poor',
         'medium': 'medium',
         'good': 'good',
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'awful': ['`awful` is not a valid choice.']
     }
+    outputs = {}
     field = fields.ChoiceField(
         choices=[
             ('poor', 'Poor quality'),
@@ -354,19 +436,20 @@ class TestChoiceField(ValidAndInvalidValues):
     )
 
 
-class TestChoiceFieldWithType(ValidAndInvalidValues):
+class TestChoiceFieldWithType(FieldValues):
     """
     Valid and invalid values for a `Choice` field that uses an integer type,
     instead of a char type.
     """
-    valid_mappings = {
+    valid_inputs = {
         '1': 1,
         3: 3,
     }
-    invalid_mappings = {
+    invalid_inputs = {
         5: ['`5` is not a valid choice.'],
         'abc': ['`abc` is not a valid choice.']
     }
+    outputs = {}
     field = fields.ChoiceField(
         choices=[
             (1, 'Poor quality'),
@@ -376,35 +459,37 @@ class TestChoiceFieldWithType(ValidAndInvalidValues):
     )
 
 
-class TestChoiceFieldWithListChoices(ValidAndInvalidValues):
+class TestChoiceFieldWithListChoices(FieldValues):
     """
     Valid and invalid values for a `Choice` field that uses a flat list for the
     choices, rather than a list of pairs of (`value`, `description`).
     """
-    valid_mappings = {
+    valid_inputs = {
         'poor': 'poor',
         'medium': 'medium',
         'good': 'good',
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'awful': ['`awful` is not a valid choice.']
     }
+    outputs = {}
     field = fields.ChoiceField(choices=('poor', 'medium', 'good'))
 
 
-class TestMultipleChoiceField(ValidAndInvalidValues):
+class TestMultipleChoiceField(FieldValues):
     """
     Valid and invalid values for `MultipleChoiceField`.
     """
-    valid_mappings = {
+    valid_inputs = {
         (): set(),
         ('aircon',): set(['aircon']),
         ('aircon', 'manual'): set(['aircon', 'manual']),
     }
-    invalid_mappings = {
+    invalid_inputs = {
         'abc': ['Expected a list of items but got type `str`'],
         ('aircon', 'incorrect'): ['`incorrect` is not a valid choice.']
     }
+    outputs = {}
     field = fields.MultipleChoiceField(
         choices=[
             ('aircon', 'AirCon'),