diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 5fb99a42f..db7ceabb1 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -521,20 +521,21 @@ class DecimalField(Field): return value def to_representation(self, value): - if isinstance(value, decimal.Decimal): - 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 quantized - return '{0:f}'.format(quantized) + if value in (None, ''): + return None + 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 '%.*f' % (self.max_decimal_places, value) + return quantized + return '{0:f}'.format(quantized) # Date & time fields... diff --git a/tests/test_fields.py b/tests/test_fields.py index e03ece544..0f445d415 100644 --- a/tests/test_fields.py +++ b/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): - valid_mappings = { +class TestBooleanField(FieldValues): + 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): - valid_mappings = { +class TestCharField(FieldValues): + 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): - valid_mappings = { +class TestEmailField(FieldValues): + 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): - valid_mappings = { +class TestRegexField(FieldValues): + 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): - valid_mappings = { +class TestSlugField(FieldValues): + 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): - valid_mappings = { +class TestURLField(FieldValues): + 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'),