diff options
Diffstat (limited to 'tests/postgres_tests/test_ranges.py')
| -rw-r--r-- | tests/postgres_tests/test_ranges.py | 534 |
1 files changed, 296 insertions, 238 deletions
diff --git a/tests/postgres_tests/test_ranges.py b/tests/postgres_tests/test_ranges.py index c2f9d443dd..7563b4ffff 100644 --- a/tests/postgres_tests/test_ranges.py +++ b/tests/postgres_tests/test_ranges.py @@ -12,38 +12,43 @@ from django.utils import timezone from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase from .models import ( - BigAutoFieldModel, PostgreSQLModel, RangeLookupsModel, RangesModel, + BigAutoFieldModel, + PostgreSQLModel, + RangeLookupsModel, + RangesModel, SmallAutoFieldModel, ) try: from psycopg2.extras import DateRange, DateTimeTZRange, NumericRange - from django.contrib.postgres import fields as pg_fields, forms as pg_forms + from django.contrib.postgres import fields as pg_fields + from django.contrib.postgres import forms as pg_forms from django.contrib.postgres.validators import ( - RangeMaxValueValidator, RangeMinValueValidator, + RangeMaxValueValidator, + RangeMinValueValidator, ) except ImportError: pass -@isolate_apps('postgres_tests') +@isolate_apps("postgres_tests") class BasicTests(PostgreSQLSimpleTestCase): def test_get_field_display(self): class Model(PostgreSQLModel): field = pg_fields.IntegerRangeField( choices=[ - ['1-50', [((1, 25), '1-25'), ([26, 50], '26-50')]], - ((51, 100), '51-100'), + ["1-50", [((1, 25), "1-25"), ([26, 50], "26-50")]], + ((51, 100), "51-100"), ], ) tests = ( - ((1, 25), '1-25'), - ([26, 50], '26-50'), - ((51, 100), '51-100'), - ((1, 2), '(1, 2)'), - ([1, 2], '[1, 2]'), + ((1, 25), "1-25"), + ([26, 50], "26-50"), + ((51, 100), "51-100"), + ((1, 2), "(1, 2)"), + ([1, 2], "[1, 2]"), ) for value, display in tests: with self.subTest(value=value, display=display): @@ -59,7 +64,7 @@ class BasicTests(PostgreSQLSimpleTestCase): for field_type in discrete_range_types: msg = f"Cannot use 'default_bounds' with {field_type.__name__}." with self.assertRaisesMessage(TypeError, msg): - field_type(choices=[((51, 100), '51-100')], default_bounds='[]') + field_type(choices=[((51, 100), "51-100")], default_bounds="[]") def test_continuous_range_fields_default_bounds(self): continuous_range_types = [ @@ -67,11 +72,11 @@ class BasicTests(PostgreSQLSimpleTestCase): pg_fields.DateTimeRangeField, ] for field_type in continuous_range_types: - field = field_type(choices=[((51, 100), '51-100')], default_bounds='[]') - self.assertEqual(field.default_bounds, '[]') + field = field_type(choices=[((51, 100), "51-100")], default_bounds="[]") + self.assertEqual(field.default_bounds, "[]") def test_invalid_default_bounds(self): - tests = [')]', ')[', '](', '])', '([', '[(', 'x', '', None] + tests = [")]", ")[", "](", "])", "([", "[(", "x", "", None] msg = "default_bounds must be one of '[)', '(]', '()', or '[]'." for invalid_bounds in tests: with self.assertRaisesMessage(ValueError, msg): @@ -81,13 +86,12 @@ class BasicTests(PostgreSQLSimpleTestCase): field = pg_fields.DecimalRangeField() *_, kwargs = field.deconstruct() self.assertEqual(kwargs, {}) - field = pg_fields.DecimalRangeField(default_bounds='[]') + field = pg_fields.DecimalRangeField(default_bounds="[]") *_, kwargs = field.deconstruct() - self.assertEqual(kwargs, {'default_bounds': '[]'}) + self.assertEqual(kwargs, {"default_bounds": "[]"}) class TestSaveLoad(PostgreSQLTestCase): - def test_all_fields(self): now = timezone.now() instance = RangesModel( @@ -124,15 +128,15 @@ class TestSaveLoad(PostgreSQLTestCase): loaded = RangesModel.objects.get() self.assertEqual( loaded.timestamps_closed_bounds, - DateTimeTZRange(range_[0], range_[1], '[]'), + DateTimeTZRange(range_[0], range_[1], "[]"), ) self.assertEqual( loaded.timestamps, - DateTimeTZRange(range_[0], range_[1], '[)'), + DateTimeTZRange(range_[0], range_[1], "[)"), ) def test_range_object_boundaries(self): - r = NumericRange(0, 10, '[]') + r = NumericRange(0, 10, "[]") instance = RangesModel(decimals=r) instance.save() loaded = RangesModel.objects.get() @@ -143,14 +147,14 @@ class TestSaveLoad(PostgreSQLTestCase): range_ = DateTimeTZRange( timezone.now(), timezone.now() + datetime.timedelta(hours=1), - bounds='()', + bounds="()", ) RangesModel.objects.create(timestamps_closed_bounds=range_) loaded = RangesModel.objects.get() self.assertEqual(loaded.timestamps_closed_bounds, range_) def test_unbounded(self): - r = NumericRange(None, None, '()') + r = NumericRange(None, None, "()") instance = RangesModel(decimals=r) instance.save() loaded = RangesModel.objects.get() @@ -171,13 +175,12 @@ class TestSaveLoad(PostgreSQLTestCase): def test_model_set_on_base_field(self): instance = RangesModel() - field = instance._meta.get_field('ints') + field = instance._meta.get_field("ints") self.assertEqual(field.model, RangesModel) self.assertEqual(field.base_field.model, RangesModel) class TestRangeContainsLookup(PostgreSQLTestCase): - @classmethod def setUpTestData(cls): cls.timestamps = [ @@ -189,8 +192,7 @@ class TestRangeContainsLookup(PostgreSQLTestCase): datetime.datetime(year=2016, month=2, day=2), ] cls.aware_timestamps = [ - timezone.make_aware(timestamp) - for timestamp in cls.timestamps + timezone.make_aware(timestamp) for timestamp in cls.timestamps ] cls.dates = [ datetime.date(year=2016, month=1, day=1), @@ -230,13 +232,13 @@ class TestRangeContainsLookup(PostgreSQLTestCase): (self.timestamps[1], self.timestamps[2]), (self.aware_timestamps[1], self.aware_timestamps[2]), Value(self.dates[0]), - Func(F('dates'), function='lower', output_field=DateTimeField()), - F('timestamps_inner'), + Func(F("dates"), function="lower", output_field=DateTimeField()), + F("timestamps_inner"), ) for filter_arg in filter_args: with self.subTest(filter_arg=filter_arg): self.assertCountEqual( - RangesModel.objects.filter(**{'timestamps__contains': filter_arg}), + RangesModel.objects.filter(**{"timestamps__contains": filter_arg}), [self.obj, self.aware_obj], ) @@ -245,28 +247,29 @@ class TestRangeContainsLookup(PostgreSQLTestCase): self.timestamps[1], (self.dates[1], self.dates[2]), Value(self.dates[0], output_field=DateField()), - Func(F('timestamps'), function='lower', output_field=DateField()), - F('dates_inner'), + Func(F("timestamps"), function="lower", output_field=DateField()), + F("dates_inner"), ) for filter_arg in filter_args: with self.subTest(filter_arg=filter_arg): self.assertCountEqual( - RangesModel.objects.filter(**{'dates__contains': filter_arg}), + RangesModel.objects.filter(**{"dates__contains": filter_arg}), [self.obj, self.aware_obj], ) class TestQuerying(PostgreSQLTestCase): - @classmethod def setUpTestData(cls): - cls.objs = RangesModel.objects.bulk_create([ - RangesModel(ints=NumericRange(0, 10)), - RangesModel(ints=NumericRange(5, 15)), - RangesModel(ints=NumericRange(None, 0)), - RangesModel(ints=NumericRange(empty=True)), - RangesModel(ints=None), - ]) + cls.objs = RangesModel.objects.bulk_create( + [ + RangesModel(ints=NumericRange(0, 10)), + RangesModel(ints=NumericRange(5, 15)), + RangesModel(ints=NumericRange(None, 0)), + RangesModel(ints=NumericRange(empty=True)), + RangesModel(ints=None), + ] + ) def test_exact(self): self.assertSequenceEqual( @@ -359,26 +362,28 @@ class TestQuerying(PostgreSQLTestCase): ) def test_bound_type(self): - decimals = RangesModel.objects.bulk_create([ - RangesModel(decimals=NumericRange(None, 10)), - RangesModel(decimals=NumericRange(10, None)), - RangesModel(decimals=NumericRange(5, 15)), - RangesModel(decimals=NumericRange(5, 15, '(]')), - ]) + decimals = RangesModel.objects.bulk_create( + [ + RangesModel(decimals=NumericRange(None, 10)), + RangesModel(decimals=NumericRange(10, None)), + RangesModel(decimals=NumericRange(5, 15)), + RangesModel(decimals=NumericRange(5, 15, "(]")), + ] + ) tests = [ - ('lower_inc', True, [decimals[1], decimals[2]]), - ('lower_inc', False, [decimals[0], decimals[3]]), - ('lower_inf', True, [decimals[0]]), - ('lower_inf', False, [decimals[1], decimals[2], decimals[3]]), - ('upper_inc', True, [decimals[3]]), - ('upper_inc', False, [decimals[0], decimals[1], decimals[2]]), - ('upper_inf', True, [decimals[1]]), - ('upper_inf', False, [decimals[0], decimals[2], decimals[3]]), + ("lower_inc", True, [decimals[1], decimals[2]]), + ("lower_inc", False, [decimals[0], decimals[3]]), + ("lower_inf", True, [decimals[0]]), + ("lower_inf", False, [decimals[1], decimals[2], decimals[3]]), + ("upper_inc", True, [decimals[3]]), + ("upper_inc", False, [decimals[0], decimals[1], decimals[2]]), + ("upper_inf", True, [decimals[1]]), + ("upper_inf", False, [decimals[0], decimals[2], decimals[3]]), ] for lookup, filter_arg, excepted_result in tests: with self.subTest(lookup=lookup, filter_arg=filter_arg): self.assertSequenceEqual( - RangesModel.objects.filter(**{'decimals__%s' % lookup: filter_arg}), + RangesModel.objects.filter(**{"decimals__%s" % lookup: filter_arg}), excepted_result, ) @@ -386,32 +391,38 @@ class TestQuerying(PostgreSQLTestCase): class TestQueryingWithRanges(PostgreSQLTestCase): def test_date_range(self): objs = [ - RangeLookupsModel.objects.create(date='2015-01-01'), - RangeLookupsModel.objects.create(date='2015-05-05'), + RangeLookupsModel.objects.create(date="2015-01-01"), + RangeLookupsModel.objects.create(date="2015-05-05"), ] self.assertSequenceEqual( - RangeLookupsModel.objects.filter(date__contained_by=DateRange('2015-01-01', '2015-05-04')), + RangeLookupsModel.objects.filter( + date__contained_by=DateRange("2015-01-01", "2015-05-04") + ), [objs[0]], ) def test_date_range_datetime_field(self): objs = [ - RangeLookupsModel.objects.create(timestamp='2015-01-01'), - RangeLookupsModel.objects.create(timestamp='2015-05-05'), + RangeLookupsModel.objects.create(timestamp="2015-01-01"), + RangeLookupsModel.objects.create(timestamp="2015-05-05"), ] self.assertSequenceEqual( - RangeLookupsModel.objects.filter(timestamp__date__contained_by=DateRange('2015-01-01', '2015-05-04')), + RangeLookupsModel.objects.filter( + timestamp__date__contained_by=DateRange("2015-01-01", "2015-05-04") + ), [objs[0]], ) def test_datetime_range(self): objs = [ - RangeLookupsModel.objects.create(timestamp='2015-01-01T09:00:00'), - RangeLookupsModel.objects.create(timestamp='2015-05-05T17:00:00'), + RangeLookupsModel.objects.create(timestamp="2015-01-01T09:00:00"), + RangeLookupsModel.objects.create(timestamp="2015-05-05T17:00:00"), ] self.assertSequenceEqual( RangeLookupsModel.objects.filter( - timestamp__contained_by=DateTimeTZRange('2015-01-01T09:00', '2015-05-04T23:55') + timestamp__contained_by=DateTimeTZRange( + "2015-01-01T09:00", "2015-05-04T23:55" + ) ), [objs[0]], ) @@ -423,7 +434,9 @@ class TestQueryingWithRanges(PostgreSQLTestCase): RangeLookupsModel.objects.create(small_integer=-1), ] self.assertSequenceEqual( - RangeLookupsModel.objects.filter(small_integer__contained_by=NumericRange(4, 6)), + RangeLookupsModel.objects.filter( + small_integer__contained_by=NumericRange(4, 6) + ), [objs[1]], ) @@ -435,7 +448,7 @@ class TestQueryingWithRanges(PostgreSQLTestCase): ] self.assertSequenceEqual( RangeLookupsModel.objects.filter(integer__contained_by=NumericRange(1, 98)), - [objs[0]] + [objs[0]], ) def test_biginteger_range(self): @@ -445,19 +458,23 @@ class TestQueryingWithRanges(PostgreSQLTestCase): RangeLookupsModel.objects.create(big_integer=-1), ] self.assertSequenceEqual( - RangeLookupsModel.objects.filter(big_integer__contained_by=NumericRange(1, 98)), - [objs[0]] + RangeLookupsModel.objects.filter( + big_integer__contained_by=NumericRange(1, 98) + ), + [objs[0]], ) def test_decimal_field_contained_by(self): objs = [ - RangeLookupsModel.objects.create(decimal_field=Decimal('1.33')), - RangeLookupsModel.objects.create(decimal_field=Decimal('2.88')), - RangeLookupsModel.objects.create(decimal_field=Decimal('99.17')), + RangeLookupsModel.objects.create(decimal_field=Decimal("1.33")), + RangeLookupsModel.objects.create(decimal_field=Decimal("2.88")), + RangeLookupsModel.objects.create(decimal_field=Decimal("99.17")), ] self.assertSequenceEqual( RangeLookupsModel.objects.filter( - decimal_field__contained_by=NumericRange(Decimal('1.89'), Decimal('7.91')), + decimal_field__contained_by=NumericRange( + Decimal("1.89"), Decimal("7.91") + ), ), [objs[1]], ) @@ -470,13 +487,13 @@ class TestQueryingWithRanges(PostgreSQLTestCase): ] self.assertSequenceEqual( RangeLookupsModel.objects.filter(float__contained_by=NumericRange(1, 98)), - [objs[0]] + [objs[0]], ) def test_small_auto_field_contained_by(self): - objs = SmallAutoFieldModel.objects.bulk_create([ - SmallAutoFieldModel() for i in range(1, 5) - ]) + objs = SmallAutoFieldModel.objects.bulk_create( + [SmallAutoFieldModel() for i in range(1, 5)] + ) self.assertSequenceEqual( SmallAutoFieldModel.objects.filter( id__contained_by=NumericRange(objs[1].pk, objs[3].pk), @@ -485,9 +502,9 @@ class TestQueryingWithRanges(PostgreSQLTestCase): ) def test_auto_field_contained_by(self): - objs = RangeLookupsModel.objects.bulk_create([ - RangeLookupsModel() for i in range(1, 5) - ]) + objs = RangeLookupsModel.objects.bulk_create( + [RangeLookupsModel() for i in range(1, 5)] + ) self.assertSequenceEqual( RangeLookupsModel.objects.filter( id__contained_by=NumericRange(objs[1].pk, objs[3].pk), @@ -496,9 +513,9 @@ class TestQueryingWithRanges(PostgreSQLTestCase): ) def test_big_auto_field_contained_by(self): - objs = BigAutoFieldModel.objects.bulk_create([ - BigAutoFieldModel() for i in range(1, 5) - ]) + objs = BigAutoFieldModel.objects.bulk_create( + [BigAutoFieldModel() for i in range(1, 5)] + ) self.assertSequenceEqual( BigAutoFieldModel.objects.filter( id__contained_by=NumericRange(objs[1].pk, objs[3].pk), @@ -513,8 +530,8 @@ class TestQueryingWithRanges(PostgreSQLTestCase): RangeLookupsModel.objects.create(float=99, parent=parent), ] self.assertSequenceEqual( - RangeLookupsModel.objects.filter(float__contained_by=F('parent__decimals')), - [objs[0]] + RangeLookupsModel.objects.filter(float__contained_by=F("parent__decimals")), + [objs[0]], ) def test_exclude(self): @@ -525,7 +542,7 @@ class TestQueryingWithRanges(PostgreSQLTestCase): ] self.assertSequenceEqual( RangeLookupsModel.objects.exclude(float__contained_by=NumericRange(0, 100)), - [objs[2]] + [objs[2]], ) @@ -550,44 +567,49 @@ class TestSerialization(PostgreSQLSimpleTestCase): def test_dumping(self): instance = RangesModel( - ints=NumericRange(0, 10), decimals=NumericRange(empty=True), + ints=NumericRange(0, 10), + decimals=NumericRange(empty=True), timestamps=DateTimeTZRange(self.lower_dt, self.upper_dt), timestamps_closed_bounds=DateTimeTZRange( - self.lower_dt, self.upper_dt, bounds='()', + self.lower_dt, + self.upper_dt, + bounds="()", ), dates=DateRange(self.lower_date, self.upper_date), ) - data = serializers.serialize('json', [instance]) + data = serializers.serialize("json", [instance]) dumped = json.loads(data) - for field in ('ints', 'dates', 'timestamps', 'timestamps_closed_bounds'): - dumped[0]['fields'][field] = json.loads(dumped[0]['fields'][field]) + for field in ("ints", "dates", "timestamps", "timestamps_closed_bounds"): + dumped[0]["fields"][field] = json.loads(dumped[0]["fields"][field]) check = json.loads(self.test_data) - for field in ('ints', 'dates', 'timestamps', 'timestamps_closed_bounds'): - check[0]['fields'][field] = json.loads(check[0]['fields'][field]) + for field in ("ints", "dates", "timestamps", "timestamps_closed_bounds"): + check[0]["fields"][field] = json.loads(check[0]["fields"][field]) self.assertEqual(dumped, check) def test_loading(self): - instance = list(serializers.deserialize('json', self.test_data))[0].object + instance = list(serializers.deserialize("json", self.test_data))[0].object self.assertEqual(instance.ints, NumericRange(0, 10)) self.assertEqual(instance.decimals, NumericRange(empty=True)) self.assertIsNone(instance.bigints) self.assertEqual(instance.dates, DateRange(self.lower_date, self.upper_date)) - self.assertEqual(instance.timestamps, DateTimeTZRange(self.lower_dt, self.upper_dt)) + self.assertEqual( + instance.timestamps, DateTimeTZRange(self.lower_dt, self.upper_dt) + ) self.assertEqual( instance.timestamps_closed_bounds, - DateTimeTZRange(self.lower_dt, self.upper_dt, bounds='()'), + DateTimeTZRange(self.lower_dt, self.upper_dt, bounds="()"), ) def test_serialize_range_with_null(self): instance = RangesModel(ints=NumericRange(None, 10)) - data = serializers.serialize('json', [instance]) - new_instance = list(serializers.deserialize('json', data))[0].object + data = serializers.serialize("json", [instance]) + new_instance = list(serializers.deserialize("json", data))[0].object self.assertEqual(new_instance.ints, NumericRange(None, 10)) instance = RangesModel(ints=NumericRange(10, None)) - data = serializers.serialize('json', [instance]) - new_instance = list(serializers.deserialize('json', data))[0].object + data = serializers.serialize("json", [instance]) + new_instance = list(serializers.deserialize("json", data))[0].object self.assertEqual(new_instance.ints, NumericRange(10, None)) @@ -596,60 +618,59 @@ class TestChecks(PostgreSQLSimpleTestCase): class Model(PostgreSQLModel): field = pg_fields.IntegerRangeField( choices=[ - ['1-50', [((1, 25), '1-25'), ([26, 50], '26-50')]], - ((51, 100), '51-100'), + ["1-50", [((1, 25), "1-25"), ([26, 50], "26-50")]], + ((51, 100), "51-100"), ], ) - self.assertEqual(Model._meta.get_field('field').check(), []) + self.assertEqual(Model._meta.get_field("field").check(), []) -class TestValidators(PostgreSQLSimpleTestCase): +class TestValidators(PostgreSQLSimpleTestCase): def test_max(self): validator = RangeMaxValueValidator(5) validator(NumericRange(0, 5)) - msg = 'Ensure that this range is completely less than or equal to 5.' + msg = "Ensure that this range is completely less than or equal to 5." with self.assertRaises(exceptions.ValidationError) as cm: validator(NumericRange(0, 10)) self.assertEqual(cm.exception.messages[0], msg) - self.assertEqual(cm.exception.code, 'max_value') + self.assertEqual(cm.exception.code, "max_value") with self.assertRaisesMessage(exceptions.ValidationError, msg): validator(NumericRange(0, None)) # an unbound range def test_min(self): validator = RangeMinValueValidator(5) validator(NumericRange(10, 15)) - msg = 'Ensure that this range is completely greater than or equal to 5.' + msg = "Ensure that this range is completely greater than or equal to 5." with self.assertRaises(exceptions.ValidationError) as cm: validator(NumericRange(0, 10)) self.assertEqual(cm.exception.messages[0], msg) - self.assertEqual(cm.exception.code, 'min_value') + self.assertEqual(cm.exception.code, "min_value") with self.assertRaisesMessage(exceptions.ValidationError, msg): validator(NumericRange(None, 10)) # an unbound range class TestFormField(PostgreSQLSimpleTestCase): - def test_valid_integer(self): field = pg_forms.IntegerRangeField() - value = field.clean(['1', '2']) + value = field.clean(["1", "2"]) self.assertEqual(value, NumericRange(1, 2)) def test_valid_decimal(self): field = pg_forms.DecimalRangeField() - value = field.clean(['1.12345', '2.001']) - self.assertEqual(value, NumericRange(Decimal('1.12345'), Decimal('2.001'))) + value = field.clean(["1.12345", "2.001"]) + self.assertEqual(value, NumericRange(Decimal("1.12345"), Decimal("2.001"))) def test_valid_timestamps(self): field = pg_forms.DateTimeRangeField() - value = field.clean(['01/01/2014 00:00:00', '02/02/2014 12:12:12']) + value = field.clean(["01/01/2014 00:00:00", "02/02/2014 12:12:12"]) lower = datetime.datetime(2014, 1, 1, 0, 0, 0) upper = datetime.datetime(2014, 2, 2, 12, 12, 12) self.assertEqual(value, DateTimeTZRange(lower, upper)) def test_valid_dates(self): field = pg_forms.DateRangeField() - value = field.clean(['01/01/2014', '02/02/2014']) + value = field.clean(["01/01/2014", "02/02/2014"]) lower = datetime.date(2014, 1, 1) upper = datetime.date(2014, 2, 2) self.assertEqual(value, DateRange(lower, upper)) @@ -662,7 +683,9 @@ class TestFormField(PostgreSQLSimpleTestCase): field = SplitDateTimeRangeField() form = SplitForm() - self.assertHTMLEqual(str(form), ''' + self.assertHTMLEqual( + str(form), + """ <tr> <th> <label>Field:</label> @@ -674,21 +697,24 @@ class TestFormField(PostgreSQLSimpleTestCase): <input id="id_field_1_1" name="field_1_1" type="text"> </td> </tr> - ''') - form = SplitForm({ - 'field_0_0': '01/01/2014', - 'field_0_1': '00:00:00', - 'field_1_0': '02/02/2014', - 'field_1_1': '12:12:12', - }) + """, + ) + form = SplitForm( + { + "field_0_0": "01/01/2014", + "field_0_1": "00:00:00", + "field_1_0": "02/02/2014", + "field_1_1": "12:12:12", + } + ) self.assertTrue(form.is_valid()) lower = datetime.datetime(2014, 1, 1, 0, 0, 0) upper = datetime.datetime(2014, 2, 2, 12, 12, 12) - self.assertEqual(form.cleaned_data['field'], DateTimeTZRange(lower, upper)) + self.assertEqual(form.cleaned_data["field"], DateTimeTZRange(lower, upper)) def test_none(self): field = pg_forms.IntegerRangeField(required=False) - value = field.clean(['', '']) + value = field.clean(["", ""]) self.assertIsNone(value) def test_datetime_form_as_table(self): @@ -707,12 +733,14 @@ class TestFormField(PostgreSQLSimpleTestCase): <input type="hidden" name="initial-datetime_field_0" id="initial-id_datetime_field_0"> <input type="hidden" name="initial-datetime_field_1" id="initial-id_datetime_field_1"> </td></tr> - """ + """, + ) + form = DateTimeRangeForm( + { + "datetime_field_0": "2010-01-01 11:13:00", + "datetime_field_1": "2020-12-12 16:59:00", + } ) - form = DateTimeRangeForm({ - 'datetime_field_0': '2010-01-01 11:13:00', - 'datetime_field_1': '2020-12-12 16:59:00', - }) self.assertHTMLEqual( form.as_table(), """ @@ -727,7 +755,7 @@ class TestFormField(PostgreSQLSimpleTestCase): id="initial-id_datetime_field_0"> <input type="hidden" name="initial-datetime_field_1" value="2020-12-12 16:59:00" id="initial-id_datetime_field_1"></td></tr> - """ + """, ) def test_datetime_form_initial_data(self): @@ -735,16 +763,18 @@ class TestFormField(PostgreSQLSimpleTestCase): datetime_field = pg_forms.DateTimeRangeField(show_hidden_initial=True) data = QueryDict(mutable=True) - data.update({ - 'datetime_field_0': '2010-01-01 11:13:00', - 'datetime_field_1': '', - 'initial-datetime_field_0': '2010-01-01 10:12:00', - 'initial-datetime_field_1': '', - }) + data.update( + { + "datetime_field_0": "2010-01-01 11:13:00", + "datetime_field_1": "", + "initial-datetime_field_0": "2010-01-01 10:12:00", + "initial-datetime_field_1": "", + } + ) form = DateTimeRangeForm(data=data) self.assertTrue(form.has_changed()) - data['initial-datetime_field_0'] = '2010-01-01 11:13:00' + data["initial-datetime_field_0"] = "2010-01-01 11:13:00" form = DateTimeRangeForm(data=data) self.assertFalse(form.has_changed()) @@ -752,7 +782,9 @@ class TestFormField(PostgreSQLSimpleTestCase): class RangeForm(forms.Form): ints = pg_forms.IntegerRangeField() - self.assertHTMLEqual(str(RangeForm()), ''' + self.assertHTMLEqual( + str(RangeForm()), + """ <tr> <th><label>Ints:</label></th> <td> @@ -760,195 +792,222 @@ class TestFormField(PostgreSQLSimpleTestCase): <input id="id_ints_1" name="ints_1" type="number"> </td> </tr> - ''') + """, + ) def test_integer_lower_bound_higher(self): field = pg_forms.IntegerRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['10', '2']) - self.assertEqual(cm.exception.messages[0], 'The start of the range must not exceed the end of the range.') - self.assertEqual(cm.exception.code, 'bound_ordering') + field.clean(["10", "2"]) + self.assertEqual( + cm.exception.messages[0], + "The start of the range must not exceed the end of the range.", + ) + self.assertEqual(cm.exception.code, "bound_ordering") def test_integer_open(self): field = pg_forms.IntegerRangeField() - value = field.clean(['', '0']) + value = field.clean(["", "0"]) self.assertEqual(value, NumericRange(None, 0)) def test_integer_incorrect_data_type(self): field = pg_forms.IntegerRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean('1') - self.assertEqual(cm.exception.messages[0], 'Enter two whole numbers.') - self.assertEqual(cm.exception.code, 'invalid') + field.clean("1") + self.assertEqual(cm.exception.messages[0], "Enter two whole numbers.") + self.assertEqual(cm.exception.code, "invalid") def test_integer_invalid_lower(self): field = pg_forms.IntegerRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['a', '2']) - self.assertEqual(cm.exception.messages[0], 'Enter a whole number.') + field.clean(["a", "2"]) + self.assertEqual(cm.exception.messages[0], "Enter a whole number.") def test_integer_invalid_upper(self): field = pg_forms.IntegerRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['1', 'b']) - self.assertEqual(cm.exception.messages[0], 'Enter a whole number.') + field.clean(["1", "b"]) + self.assertEqual(cm.exception.messages[0], "Enter a whole number.") def test_integer_required(self): field = pg_forms.IntegerRangeField(required=True) with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['', '']) - self.assertEqual(cm.exception.messages[0], 'This field is required.') - value = field.clean([1, '']) + field.clean(["", ""]) + self.assertEqual(cm.exception.messages[0], "This field is required.") + value = field.clean([1, ""]) self.assertEqual(value, NumericRange(1, None)) def test_decimal_lower_bound_higher(self): field = pg_forms.DecimalRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['1.8', '1.6']) - self.assertEqual(cm.exception.messages[0], 'The start of the range must not exceed the end of the range.') - self.assertEqual(cm.exception.code, 'bound_ordering') + field.clean(["1.8", "1.6"]) + self.assertEqual( + cm.exception.messages[0], + "The start of the range must not exceed the end of the range.", + ) + self.assertEqual(cm.exception.code, "bound_ordering") def test_decimal_open(self): field = pg_forms.DecimalRangeField() - value = field.clean(['', '3.1415926']) - self.assertEqual(value, NumericRange(None, Decimal('3.1415926'))) + value = field.clean(["", "3.1415926"]) + self.assertEqual(value, NumericRange(None, Decimal("3.1415926"))) def test_decimal_incorrect_data_type(self): field = pg_forms.DecimalRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean('1.6') - self.assertEqual(cm.exception.messages[0], 'Enter two numbers.') - self.assertEqual(cm.exception.code, 'invalid') + field.clean("1.6") + self.assertEqual(cm.exception.messages[0], "Enter two numbers.") + self.assertEqual(cm.exception.code, "invalid") def test_decimal_invalid_lower(self): field = pg_forms.DecimalRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['a', '3.1415926']) - self.assertEqual(cm.exception.messages[0], 'Enter a number.') + field.clean(["a", "3.1415926"]) + self.assertEqual(cm.exception.messages[0], "Enter a number.") def test_decimal_invalid_upper(self): field = pg_forms.DecimalRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['1.61803399', 'b']) - self.assertEqual(cm.exception.messages[0], 'Enter a number.') + field.clean(["1.61803399", "b"]) + self.assertEqual(cm.exception.messages[0], "Enter a number.") def test_decimal_required(self): field = pg_forms.DecimalRangeField(required=True) with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['', '']) - self.assertEqual(cm.exception.messages[0], 'This field is required.') - value = field.clean(['1.61803399', '']) - self.assertEqual(value, NumericRange(Decimal('1.61803399'), None)) + field.clean(["", ""]) + self.assertEqual(cm.exception.messages[0], "This field is required.") + value = field.clean(["1.61803399", ""]) + self.assertEqual(value, NumericRange(Decimal("1.61803399"), None)) def test_date_lower_bound_higher(self): field = pg_forms.DateRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['2013-04-09', '1976-04-16']) - self.assertEqual(cm.exception.messages[0], 'The start of the range must not exceed the end of the range.') - self.assertEqual(cm.exception.code, 'bound_ordering') + field.clean(["2013-04-09", "1976-04-16"]) + self.assertEqual( + cm.exception.messages[0], + "The start of the range must not exceed the end of the range.", + ) + self.assertEqual(cm.exception.code, "bound_ordering") def test_date_open(self): field = pg_forms.DateRangeField() - value = field.clean(['', '2013-04-09']) + value = field.clean(["", "2013-04-09"]) self.assertEqual(value, DateRange(None, datetime.date(2013, 4, 9))) def test_date_incorrect_data_type(self): field = pg_forms.DateRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean('1') - self.assertEqual(cm.exception.messages[0], 'Enter two valid dates.') - self.assertEqual(cm.exception.code, 'invalid') + field.clean("1") + self.assertEqual(cm.exception.messages[0], "Enter two valid dates.") + self.assertEqual(cm.exception.code, "invalid") def test_date_invalid_lower(self): field = pg_forms.DateRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['a', '2013-04-09']) - self.assertEqual(cm.exception.messages[0], 'Enter a valid date.') + field.clean(["a", "2013-04-09"]) + self.assertEqual(cm.exception.messages[0], "Enter a valid date.") def test_date_invalid_upper(self): field = pg_forms.DateRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['2013-04-09', 'b']) - self.assertEqual(cm.exception.messages[0], 'Enter a valid date.') + field.clean(["2013-04-09", "b"]) + self.assertEqual(cm.exception.messages[0], "Enter a valid date.") def test_date_required(self): field = pg_forms.DateRangeField(required=True) with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['', '']) - self.assertEqual(cm.exception.messages[0], 'This field is required.') - value = field.clean(['1976-04-16', '']) + field.clean(["", ""]) + self.assertEqual(cm.exception.messages[0], "This field is required.") + value = field.clean(["1976-04-16", ""]) self.assertEqual(value, DateRange(datetime.date(1976, 4, 16), None)) def test_date_has_changed_first(self): - self.assertTrue(pg_forms.DateRangeField().has_changed( - ['2010-01-01', '2020-12-12'], - ['2010-01-31', '2020-12-12'], - )) + self.assertTrue( + pg_forms.DateRangeField().has_changed( + ["2010-01-01", "2020-12-12"], + ["2010-01-31", "2020-12-12"], + ) + ) def test_date_has_changed_last(self): - self.assertTrue(pg_forms.DateRangeField().has_changed( - ['2010-01-01', '2020-12-12'], - ['2010-01-01', '2020-12-31'], - )) + self.assertTrue( + pg_forms.DateRangeField().has_changed( + ["2010-01-01", "2020-12-12"], + ["2010-01-01", "2020-12-31"], + ) + ) def test_datetime_lower_bound_higher(self): field = pg_forms.DateTimeRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['2006-10-25 14:59', '2006-10-25 14:58']) - self.assertEqual(cm.exception.messages[0], 'The start of the range must not exceed the end of the range.') - self.assertEqual(cm.exception.code, 'bound_ordering') + field.clean(["2006-10-25 14:59", "2006-10-25 14:58"]) + self.assertEqual( + cm.exception.messages[0], + "The start of the range must not exceed the end of the range.", + ) + self.assertEqual(cm.exception.code, "bound_ordering") def test_datetime_open(self): field = pg_forms.DateTimeRangeField() - value = field.clean(['', '2013-04-09 11:45']) - self.assertEqual(value, DateTimeTZRange(None, datetime.datetime(2013, 4, 9, 11, 45))) + value = field.clean(["", "2013-04-09 11:45"]) + self.assertEqual( + value, DateTimeTZRange(None, datetime.datetime(2013, 4, 9, 11, 45)) + ) def test_datetime_incorrect_data_type(self): field = pg_forms.DateTimeRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean('2013-04-09 11:45') - self.assertEqual(cm.exception.messages[0], 'Enter two valid date/times.') - self.assertEqual(cm.exception.code, 'invalid') + field.clean("2013-04-09 11:45") + self.assertEqual(cm.exception.messages[0], "Enter two valid date/times.") + self.assertEqual(cm.exception.code, "invalid") def test_datetime_invalid_lower(self): field = pg_forms.DateTimeRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['45', '2013-04-09 11:45']) - self.assertEqual(cm.exception.messages[0], 'Enter a valid date/time.') + field.clean(["45", "2013-04-09 11:45"]) + self.assertEqual(cm.exception.messages[0], "Enter a valid date/time.") def test_datetime_invalid_upper(self): field = pg_forms.DateTimeRangeField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['2013-04-09 11:45', 'sweet pickles']) - self.assertEqual(cm.exception.messages[0], 'Enter a valid date/time.') + field.clean(["2013-04-09 11:45", "sweet pickles"]) + self.assertEqual(cm.exception.messages[0], "Enter a valid date/time.") def test_datetime_required(self): field = pg_forms.DateTimeRangeField(required=True) with self.assertRaises(exceptions.ValidationError) as cm: - field.clean(['', '']) - self.assertEqual(cm.exception.messages[0], 'This field is required.') - value = field.clean(['2013-04-09 11:45', '']) - self.assertEqual(value, DateTimeTZRange(datetime.datetime(2013, 4, 9, 11, 45), None)) + field.clean(["", ""]) + self.assertEqual(cm.exception.messages[0], "This field is required.") + value = field.clean(["2013-04-09 11:45", ""]) + self.assertEqual( + value, DateTimeTZRange(datetime.datetime(2013, 4, 9, 11, 45), None) + ) - @override_settings(USE_TZ=True, TIME_ZONE='Africa/Johannesburg') + @override_settings(USE_TZ=True, TIME_ZONE="Africa/Johannesburg") def test_datetime_prepare_value(self): field = pg_forms.DateTimeRangeField() value = field.prepare_value( - DateTimeTZRange(datetime.datetime(2015, 5, 22, 16, 6, 33, tzinfo=timezone.utc), None) + DateTimeTZRange( + datetime.datetime(2015, 5, 22, 16, 6, 33, tzinfo=timezone.utc), None + ) ) self.assertEqual(value, [datetime.datetime(2015, 5, 22, 18, 6, 33), None]) def test_datetime_has_changed_first(self): - self.assertTrue(pg_forms.DateTimeRangeField().has_changed( - ['2010-01-01 00:00', '2020-12-12 00:00'], - ['2010-01-31 23:00', '2020-12-12 00:00'], - )) + self.assertTrue( + pg_forms.DateTimeRangeField().has_changed( + ["2010-01-01 00:00", "2020-12-12 00:00"], + ["2010-01-31 23:00", "2020-12-12 00:00"], + ) + ) def test_datetime_has_changed_last(self): - self.assertTrue(pg_forms.DateTimeRangeField().has_changed( - ['2010-01-01 00:00', '2020-12-12 00:00'], - ['2010-01-01 00:00', '2020-12-31 23:00'], - )) + self.assertTrue( + pg_forms.DateTimeRangeField().has_changed( + ["2010-01-01 00:00", "2020-12-12 00:00"], + ["2010-01-01 00:00", "2020-12-31 23:00"], + ) + ) def test_model_field_formfield_integer(self): model_field = pg_fields.IntegerRangeField() @@ -963,10 +1022,10 @@ class TestFormField(PostgreSQLSimpleTestCase): self.assertEqual(form_field.range_kwargs, {}) def test_model_field_formfield_float(self): - model_field = pg_fields.DecimalRangeField(default_bounds='()') + model_field = pg_fields.DecimalRangeField(default_bounds="()") form_field = model_field.formfield() self.assertIsInstance(form_field, pg_forms.DecimalRangeField) - self.assertEqual(form_field.range_kwargs, {'bounds': '()'}) + self.assertEqual(form_field.range_kwargs, {"bounds": "()"}) def test_model_field_formfield_date(self): model_field = pg_fields.DateRangeField() @@ -980,33 +1039,33 @@ class TestFormField(PostgreSQLSimpleTestCase): self.assertIsInstance(form_field, pg_forms.DateTimeRangeField) self.assertEqual( form_field.range_kwargs, - {'bounds': pg_fields.ranges.CANONICAL_RANGE_BOUNDS}, + {"bounds": pg_fields.ranges.CANONICAL_RANGE_BOUNDS}, ) def test_model_field_formfield_datetime_default_bounds(self): - model_field = pg_fields.DateTimeRangeField(default_bounds='[]') + model_field = pg_fields.DateTimeRangeField(default_bounds="[]") form_field = model_field.formfield() self.assertIsInstance(form_field, pg_forms.DateTimeRangeField) - self.assertEqual(form_field.range_kwargs, {'bounds': '[]'}) + self.assertEqual(form_field.range_kwargs, {"bounds": "[]"}) def test_model_field_with_default_bounds(self): - field = pg_forms.DateTimeRangeField(default_bounds='[]') - value = field.clean(['2014-01-01 00:00:00', '2014-02-03 12:13:14']) + field = pg_forms.DateTimeRangeField(default_bounds="[]") + value = field.clean(["2014-01-01 00:00:00", "2014-02-03 12:13:14"]) lower = datetime.datetime(2014, 1, 1, 0, 0, 0) upper = datetime.datetime(2014, 2, 3, 12, 13, 14) - self.assertEqual(value, DateTimeTZRange(lower, upper, '[]')) + self.assertEqual(value, DateTimeTZRange(lower, upper, "[]")) def test_has_changed(self): for field, value in ( - (pg_forms.DateRangeField(), ['2010-01-01', '2020-12-12']), - (pg_forms.DateTimeRangeField(), ['2010-01-01 11:13', '2020-12-12 14:52']), + (pg_forms.DateRangeField(), ["2010-01-01", "2020-12-12"]), + (pg_forms.DateTimeRangeField(), ["2010-01-01 11:13", "2020-12-12 14:52"]), (pg_forms.IntegerRangeField(), [1, 2]), - (pg_forms.DecimalRangeField(), ['1.12345', '2.001']), + (pg_forms.DecimalRangeField(), ["1.12345", "2.001"]), ): with self.subTest(field=field.__class__.__name__): self.assertTrue(field.has_changed(None, value)) - self.assertTrue(field.has_changed([value[0], ''], value)) - self.assertTrue(field.has_changed(['', value[1]], value)) + self.assertTrue(field.has_changed([value[0], ""], value)) + self.assertTrue(field.has_changed(["", value[1]], value)) self.assertFalse(field.has_changed(value, value)) @@ -1014,19 +1073,18 @@ class TestWidget(PostgreSQLSimpleTestCase): def test_range_widget(self): f = pg_forms.ranges.DateTimeRangeField() self.assertHTMLEqual( - f.widget.render('datetimerange', ''), - '<input type="text" name="datetimerange_0"><input type="text" name="datetimerange_1">' + f.widget.render("datetimerange", ""), + '<input type="text" name="datetimerange_0"><input type="text" name="datetimerange_1">', ) self.assertHTMLEqual( - f.widget.render('datetimerange', None), - '<input type="text" name="datetimerange_0"><input type="text" name="datetimerange_1">' + f.widget.render("datetimerange", None), + '<input type="text" name="datetimerange_0"><input type="text" name="datetimerange_1">', ) dt_range = DateTimeTZRange( - datetime.datetime(2006, 1, 10, 7, 30), - datetime.datetime(2006, 2, 12, 9, 50) + datetime.datetime(2006, 1, 10, 7, 30), datetime.datetime(2006, 2, 12, 9, 50) ) self.assertHTMLEqual( - f.widget.render('datetimerange', dt_range), + f.widget.render("datetimerange", dt_range), '<input type="text" name="datetimerange_0" value="2006-01-10 07:30:00">' - '<input type="text" name="datetimerange_1" value="2006-02-12 09:50:00">' + '<input type="text" name="datetimerange_1" value="2006-02-12 09:50:00">', ) |