Debian Codegraph @

tests/postgres_tests/test_ranges.py

raw
1 import datetime
2 import json
3 from decimal import Decimal
4
5 from django import forms
6 from django.core import exceptions, serializers
7 from django.db.models import DateField, DateTimeField, F, Func, Value
8 from django.http import QueryDict
9 from django.test import override_settings
10 from django.test.utils import isolate_apps
11 from django.utils import timezone
12
13 from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase
14 from .models import (
15 BigAutoFieldModel,
16 PostgreSQLModel,
17 RangeLookupsModel,
18 RangesModel,
19 SmallAutoFieldModel,
20 )
21
22 try:
23 from django.contrib.postgres import fields as pg_fields
24 from django.contrib.postgres import forms as pg_forms
25 from django.contrib.postgres.validators import (
26 RangeMaxValueValidator,
27 RangeMinValueValidator,
28 )
29 from django.db.backends.postgresql.psycopg_any import (
30 DateRange,
31 DateTimeTZRange,
32 NumericRange,
33 )
34 except ImportError:
35 pass
36
37
38 @isolate_apps("postgres_tests")
39 class BasicTests(PostgreSQLSimpleTestCase):
40 def test_get_field_display(self):
41 class Model(PostgreSQLModel):
42 field = pg_fields.IntegerRangeField(
43 choices=[
44 ["1-50", [((1, 25), "1-25"), ([26, 50], "26-50")]],
45 ((51, 100), "51-100"),
46 ],
47 )
48
49 tests = (
50 ((1, 25), "1-25"),
51 ([26, 50], "26-50"),
52 ((51, 100), "51-100"),
53 ((1, 2), "(1, 2)"),
54 ([1, 2], "[1, 2]"),
55 )
56 for value, display in tests:
57 with self.subTest(value=value, display=display):
58 instance = Model(field=value)
59 self.assertEqual(instance.get_field_display(), display)
60
61 def test_discrete_range_fields_unsupported_default_bounds(self):
62 discrete_range_types = [
63 pg_fields.BigIntegerRangeField,
64 pg_fields.IntegerRangeField,
65 pg_fields.DateRangeField,
66 ]
67 for field_type in discrete_range_types:
68 msg = f"Cannot use 'default_bounds' with {field_type.__name__}."
69 with self.assertRaisesMessage(TypeError, msg):
70 field_type(choices=[((51, 100), "51-100")], default_bounds="[]")
71
72 def test_continuous_range_fields_default_bounds(self):
73 continuous_range_types = [
74 pg_fields.DecimalRangeField,
75 pg_fields.DateTimeRangeField,
76 ]
77 for field_type in continuous_range_types:
78 field = field_type(choices=[((51, 100), "51-100")], default_bounds="[]")
79 self.assertEqual(field.default_bounds, "[]")
80
81 def test_invalid_default_bounds(self):
82 tests = [")]", ")[", "](", "])", "([", "[(", "x", "", None]
83 msg = "default_bounds must be one of '[)', '(]', '()', or '[]'."
84 for invalid_bounds in tests:
85 with self.assertRaisesMessage(ValueError, msg):
86 pg_fields.DecimalRangeField(default_bounds=invalid_bounds)
87
88 def test_deconstruct(self):
89 field = pg_fields.DecimalRangeField()
90 *_, kwargs = field.deconstruct()
91 self.assertEqual(kwargs, {})
92 field = pg_fields.DecimalRangeField(default_bounds="[]")
93 *_, kwargs = field.deconstruct()
94 self.assertEqual(kwargs, {"default_bounds": "[]"})
95
96
97 class TestSaveLoad(PostgreSQLTestCase):
98 def test_all_fields(self):
99 now = timezone.now()
100 instance = RangesModel(
101 ints=NumericRange(0, 10),
102 bigints=NumericRange(10, 20),
103 decimals=NumericRange(20, 30),
104 timestamps=DateTimeTZRange(now - datetime.timedelta(hours=1), now),
105 dates=DateRange(now.date() - datetime.timedelta(days=1), now.date()),
106 )
107 instance.save()
108 loaded = RangesModel.objects.get()
109 self.assertEqual(instance.ints, loaded.ints)
110 self.assertEqual(instance.bigints, loaded.bigints)
111 self.assertEqual(instance.decimals, loaded.decimals)
112 self.assertEqual(instance.timestamps, loaded.timestamps)
113 self.assertEqual(instance.dates, loaded.dates)
114
115 def test_range_object(self):
116 r = NumericRange(0, 10)
117 instance = RangesModel(ints=r)
118 instance.save()
119 loaded = RangesModel.objects.get()
120 self.assertEqual(r, loaded.ints)
121
122 def test_tuple(self):
123 instance = RangesModel(ints=(0, 10))
124 instance.save()
125 loaded = RangesModel.objects.get()
126 self.assertEqual(NumericRange(0, 10), loaded.ints)
127
128 def test_tuple_range_with_default_bounds(self):
129 range_ = (timezone.now(), timezone.now() + datetime.timedelta(hours=1))
130 RangesModel.objects.create(timestamps_closed_bounds=range_, timestamps=range_)
131 loaded = RangesModel.objects.get()
132 self.assertEqual(
133 loaded.timestamps_closed_bounds,
134 DateTimeTZRange(range_[0], range_[1], "[]"),
135 )
136 self.assertEqual(
137 loaded.timestamps,
138 DateTimeTZRange(range_[0], range_[1], "[)"),
139 )
140
141 def test_range_object_boundaries(self):
142 r = NumericRange(0, 10, "[]")
143 instance = RangesModel(decimals=r)
144 instance.save()
145 loaded = RangesModel.objects.get()
146 self.assertEqual(r, loaded.decimals)
147 self.assertIn(10, loaded.decimals)
148
149 def test_range_object_boundaries_range_with_default_bounds(self):
150 range_ = DateTimeTZRange(
151 timezone.now(),
152 timezone.now() + datetime.timedelta(hours=1),
153 bounds="()",
154 )
155 RangesModel.objects.create(timestamps_closed_bounds=range_)
156 loaded = RangesModel.objects.get()
157 self.assertEqual(loaded.timestamps_closed_bounds, range_)
158
159 def test_unbounded(self):
160 r = NumericRange(None, None, "()")
161 instance = RangesModel(decimals=r)
162 instance.save()
163 loaded = RangesModel.objects.get()
164 self.assertEqual(r, loaded.decimals)
165
166 def test_empty(self):
167 r = NumericRange(empty=True)
168 instance = RangesModel(ints=r)
169 instance.save()
170 loaded = RangesModel.objects.get()
171 self.assertEqual(r, loaded.ints)
172
173 def test_null(self):
174 instance = RangesModel(ints=None)
175 instance.save()
176 loaded = RangesModel.objects.get()
177 self.assertIsNone(loaded.ints)
178
179 def test_model_set_on_base_field(self):
180 instance = RangesModel()
181 field = instance._meta.get_field("ints")
182 self.assertEqual(field.model, RangesModel)
183 self.assertEqual(field.base_field.model, RangesModel)
184
185
186 class TestRangeContainsLookup(PostgreSQLTestCase):
187 @classmethod
188 def setUpTestData(cls):
189 cls.timestamps = [
190 datetime.datetime(year=2016, month=1, day=1),
191 datetime.datetime(year=2016, month=1, day=2, hour=1),
192 datetime.datetime(year=2016, month=1, day=2, hour=12),
193 datetime.datetime(year=2016, month=1, day=3),
194 datetime.datetime(year=2016, month=1, day=3, hour=1),
195 datetime.datetime(year=2016, month=2, day=2),
196 ]
197 cls.aware_timestamps = [
198 timezone.make_aware(timestamp) for timestamp in cls.timestamps
199 ]
200 cls.dates = [
201 datetime.date(year=2016, month=1, day=1),
202 datetime.date(year=2016, month=1, day=2),
203 datetime.date(year=2016, month=1, day=3),
204 datetime.date(year=2016, month=1, day=4),
205 datetime.date(year=2016, month=2, day=2),
206 datetime.date(year=2016, month=2, day=3),
207 ]
208 cls.obj = RangesModel.objects.create(
209 dates=(cls.dates[0], cls.dates[3]),
210 dates_inner=(cls.dates[1], cls.dates[2]),
211 timestamps=(cls.timestamps[0], cls.timestamps[3]),
212 timestamps_inner=(cls.timestamps[1], cls.timestamps[2]),
213 )
214 cls.aware_obj = RangesModel.objects.create(
215 dates=(cls.dates[0], cls.dates[3]),
216 dates_inner=(cls.dates[1], cls.dates[2]),
217 timestamps=(cls.aware_timestamps[0], cls.aware_timestamps[3]),
218 timestamps_inner=(cls.timestamps[1], cls.timestamps[2]),
219 )
220 # Objects that don't match any queries.
221 for i in range(3, 4):
222 RangesModel.objects.create(
223 dates=(cls.dates[i], cls.dates[i + 1]),
224 timestamps=(cls.timestamps[i], cls.timestamps[i + 1]),
225 )
226 RangesModel.objects.create(
227 dates=(cls.dates[i], cls.dates[i + 1]),
228 timestamps=(cls.aware_timestamps[i], cls.aware_timestamps[i + 1]),
229 )
230
231 def test_datetime_range_contains(self):
232 filter_args = (
233 self.timestamps[1],
234 self.aware_timestamps[1],
235 (self.timestamps[1], self.timestamps[2]),
236 (self.aware_timestamps[1], self.aware_timestamps[2]),
237 Value(self.dates[0]),
238 Func(F("dates"), function="lower", output_field=DateTimeField()),
239 F("timestamps_inner"),
240 )
241 for filter_arg in filter_args:
242 with self.subTest(filter_arg=filter_arg):
243 self.assertCountEqual(
244 RangesModel.objects.filter(**{"timestamps__contains": filter_arg}),
245 [self.obj, self.aware_obj],
246 )
247
248 def test_date_range_contains(self):
249 filter_args = (
250 self.timestamps[1],
251 (self.dates[1], self.dates[2]),
252 Value(self.dates[0], output_field=DateField()),
253 Func(F("timestamps"), function="lower", output_field=DateField()),
254 F("dates_inner"),
255 )
256 for filter_arg in filter_args:
257 with self.subTest(filter_arg=filter_arg):
258 self.assertCountEqual(
259 RangesModel.objects.filter(**{"dates__contains": filter_arg}),
260 [self.obj, self.aware_obj],
261 )
262
263
264 class TestQuerying(PostgreSQLTestCase):
265 @classmethod
266 def setUpTestData(cls):
267 cls.objs = RangesModel.objects.bulk_create(
268 [
269 RangesModel(ints=NumericRange(0, 10)),
270 RangesModel(ints=NumericRange(5, 15)),
271 RangesModel(ints=NumericRange(None, 0)),
272 RangesModel(ints=NumericRange(empty=True)),
273 RangesModel(ints=None),
274 ]
275 )
276
277 def test_exact(self):
278 self.assertSequenceEqual(
279 RangesModel.objects.filter(ints__exact=NumericRange(0, 10)),
280 [self.objs[0]],
281 )
282
283 def test_isnull(self):
284 self.assertSequenceEqual(
285 RangesModel.objects.filter(ints__isnull=True),
286 [self.objs[4]],
287 )
288
289 def test_isempty(self):
290 self.assertSequenceEqual(
291 RangesModel.objects.filter(ints__isempty=True),
292 [self.objs[3]],
293 )
294
295 def test_contains(self):
296 self.assertSequenceEqual(
297 RangesModel.objects.filter(ints__contains=8),
298 [self.objs[0], self.objs[1]],
299 )
300
301 def test_contains_range(self):
302 self.assertSequenceEqual(
303 RangesModel.objects.filter(ints__contains=NumericRange(3, 8)),
304 [self.objs[0]],
305 )
306
307 def test_contained_by(self):
308 self.assertSequenceEqual(
309 RangesModel.objects.filter(ints__contained_by=NumericRange(0, 20)),
310 [self.objs[0], self.objs[1], self.objs[3]],
311 )
312
313 def test_overlap(self):
314 self.assertSequenceEqual(
315 RangesModel.objects.filter(ints__overlap=NumericRange(3, 8)),
316 [self.objs[0], self.objs[1]],
317 )
318
319 def test_fully_lt(self):
320 self.assertSequenceEqual(
321 RangesModel.objects.filter(ints__fully_lt=NumericRange(5, 10)),
322 [self.objs[2]],
323 )
324
325 def test_fully_gt(self):
326 self.assertSequenceEqual(
327 RangesModel.objects.filter(ints__fully_gt=NumericRange(5, 10)),
328 [],
329 )
330
331 def test_not_lt(self):
332 self.assertSequenceEqual(
333 RangesModel.objects.filter(ints__not_lt=NumericRange(5, 10)),
334 [self.objs[1]],
335 )
336
337 def test_not_gt(self):
338 self.assertSequenceEqual(
339 RangesModel.objects.filter(ints__not_gt=NumericRange(5, 10)),
340 [self.objs[0], self.objs[2]],
341 )
342
343 def test_adjacent_to(self):
344 self.assertSequenceEqual(
345 RangesModel.objects.filter(ints__adjacent_to=NumericRange(0, 5)),
346 [self.objs[1], self.objs[2]],
347 )
348
349 def test_startswith(self):
350 self.assertSequenceEqual(
351 RangesModel.objects.filter(ints__startswith=0),
352 [self.objs[0]],
353 )
354
355 def test_endswith(self):
356 self.assertSequenceEqual(
357 RangesModel.objects.filter(ints__endswith=0),
358 [self.objs[2]],
359 )
360
361 def test_startswith_chaining(self):
362 self.assertSequenceEqual(
363 RangesModel.objects.filter(ints__startswith__gte=0),
364 [self.objs[0], self.objs[1]],
365 )
366
367 def test_bound_type(self):
368 decimals = RangesModel.objects.bulk_create(
369 [
370 RangesModel(decimals=NumericRange(None, 10)),
371 RangesModel(decimals=NumericRange(10, None)),
372 RangesModel(decimals=NumericRange(5, 15)),
373 RangesModel(decimals=NumericRange(5, 15, "(]")),
374 ]
375 )
376 tests = [
377 ("lower_inc", True, [decimals[1], decimals[2]]),
378 ("lower_inc", False, [decimals[0], decimals[3]]),
379 ("lower_inf", True, [decimals[0]]),
380 ("lower_inf", False, [decimals[1], decimals[2], decimals[3]]),
381 ("upper_inc", True, [decimals[3]]),
382 ("upper_inc", False, [decimals[0], decimals[1], decimals[2]]),
383 ("upper_inf", True, [decimals[1]]),
384 ("upper_inf", False, [decimals[0], decimals[2], decimals[3]]),
385 ]
386 for lookup, filter_arg, excepted_result in tests:
387 with self.subTest(lookup=lookup, filter_arg=filter_arg):
388 self.assertSequenceEqual(
389 RangesModel.objects.filter(**{"decimals__%s" % lookup: filter_arg}),
390 excepted_result,
391 )
392
393
394 class TestQueryingWithRanges(PostgreSQLTestCase):
395 def test_date_range(self):
396 objs = [
397 RangeLookupsModel.objects.create(date="2015-01-01"),
398 RangeLookupsModel.objects.create(date="2015-05-05"),
399 ]
400 self.assertSequenceEqual(
401 RangeLookupsModel.objects.filter(
402 date__contained_by=DateRange("2015-01-01", "2015-05-04")
403 ),
404 [objs[0]],
405 )
406
407 def test_date_range_datetime_field(self):
408 objs = [
409 RangeLookupsModel.objects.create(timestamp="2015-01-01"),
410 RangeLookupsModel.objects.create(timestamp="2015-05-05"),
411 ]
412 self.assertSequenceEqual(
413 RangeLookupsModel.objects.filter(
414 timestamp__date__contained_by=DateRange("2015-01-01", "2015-05-04")
415 ),
416 [objs[0]],
417 )
418
419 def test_datetime_range(self):
420 objs = [
421 RangeLookupsModel.objects.create(timestamp="2015-01-01T09:00:00"),
422 RangeLookupsModel.objects.create(timestamp="2015-05-05T17:00:00"),
423 ]
424 self.assertSequenceEqual(
425 RangeLookupsModel.objects.filter(
426 timestamp__contained_by=DateTimeTZRange(
427 "2015-01-01T09:00", "2015-05-04T23:55"
428 )
429 ),
430 [objs[0]],
431 )
432
433 def test_small_integer_field_contained_by(self):
434 objs = [
435 RangeLookupsModel.objects.create(small_integer=8),
436 RangeLookupsModel.objects.create(small_integer=4),
437 RangeLookupsModel.objects.create(small_integer=-1),
438 ]
439 self.assertSequenceEqual(
440 RangeLookupsModel.objects.filter(
441 small_integer__contained_by=NumericRange(4, 6)
442 ),
443 [objs[1]],
444 )
445
446 def test_integer_range(self):
447 objs = [
448 RangeLookupsModel.objects.create(integer=5),
449 RangeLookupsModel.objects.create(integer=99),
450 RangeLookupsModel.objects.create(integer=-1),
451 ]
452 self.assertSequenceEqual(
453 RangeLookupsModel.objects.filter(integer__contained_by=NumericRange(1, 98)),
454 [objs[0]],
455 )
456
457 def test_biginteger_range(self):
458 objs = [
459 RangeLookupsModel.objects.create(big_integer=5),
460 RangeLookupsModel.objects.create(big_integer=99),
461 RangeLookupsModel.objects.create(big_integer=-1),
462 ]
463 self.assertSequenceEqual(
464 RangeLookupsModel.objects.filter(
465 big_integer__contained_by=NumericRange(1, 98)
466 ),
467 [objs[0]],
468 )
469
470 def test_decimal_field_contained_by(self):
471 objs = [
472 RangeLookupsModel.objects.create(decimal_field=Decimal("1.33")),
473 RangeLookupsModel.objects.create(decimal_field=Decimal("2.88")),
474 RangeLookupsModel.objects.create(decimal_field=Decimal("99.17")),
475 ]
476 self.assertSequenceEqual(
477 RangeLookupsModel.objects.filter(
478 decimal_field__contained_by=NumericRange(
479 Decimal("1.89"), Decimal("7.91")
480 ),
481 ),
482 [objs[1]],
483 )
484
485 def test_float_range(self):
486 objs = [
487 RangeLookupsModel.objects.create(float=5),
488 RangeLookupsModel.objects.create(float=99),
489 RangeLookupsModel.objects.create(float=-1),
490 ]
491 self.assertSequenceEqual(
492 RangeLookupsModel.objects.filter(float__contained_by=NumericRange(1, 98)),
493 [objs[0]],
494 )
495
496 def test_small_auto_field_contained_by(self):
497 objs = SmallAutoFieldModel.objects.bulk_create(
498 [SmallAutoFieldModel() for i in range(1, 5)]
499 )
500 self.assertSequenceEqual(
501 SmallAutoFieldModel.objects.filter(
502 id__contained_by=NumericRange(objs[1].pk, objs[3].pk),
503 ),
504 objs[1:3],
505 )
506
507 def test_auto_field_contained_by(self):
508 objs = RangeLookupsModel.objects.bulk_create(
509 [RangeLookupsModel() for i in range(1, 5)]
510 )
511 self.assertSequenceEqual(
512 RangeLookupsModel.objects.filter(
513 id__contained_by=NumericRange(objs[1].pk, objs[3].pk),
514 ),
515 objs[1:3],
516 )
517
518 def test_big_auto_field_contained_by(self):
519 objs = BigAutoFieldModel.objects.bulk_create(
520 [BigAutoFieldModel() for i in range(1, 5)]
521 )
522 self.assertSequenceEqual(
523 BigAutoFieldModel.objects.filter(
524 id__contained_by=NumericRange(objs[1].pk, objs[3].pk),
525 ),
526 objs[1:3],
527 )
528
529 def test_f_ranges(self):
530 parent = RangesModel.objects.create(decimals=NumericRange(0, 10))
531 objs = [
532 RangeLookupsModel.objects.create(float=5, parent=parent),
533 RangeLookupsModel.objects.create(float=99, parent=parent),
534 ]
535 self.assertSequenceEqual(
536 RangeLookupsModel.objects.filter(float__contained_by=F("parent__decimals")),
537 [objs[0]],
538 )
539
540 def test_exclude(self):
541 objs = [
542 RangeLookupsModel.objects.create(float=5),
543 RangeLookupsModel.objects.create(float=99),
544 RangeLookupsModel.objects.create(float=-1),
545 ]
546 self.assertSequenceEqual(
547 RangeLookupsModel.objects.exclude(float__contained_by=NumericRange(0, 100)),
548 [objs[2]],
549 )
550
551
552 class TestSerialization(PostgreSQLSimpleTestCase):
553 test_data = (
554 '[{"fields": {"ints": "{\\"upper\\": \\"10\\", \\"lower\\": \\"0\\", '
555 '\\"bounds\\": \\"[)\\"}", "decimals": "{\\"empty\\": true}", '
556 '"bigints": null, "timestamps": '
557 '"{\\"upper\\": \\"2014-02-02T12:12:12+00:00\\", '
558 '\\"lower\\": \\"2014-01-01T00:00:00+00:00\\", \\"bounds\\": \\"[)\\"}", '
559 '"timestamps_inner": null, '
560 '"timestamps_closed_bounds": "{\\"upper\\": \\"2014-02-02T12:12:12+00:00\\", '
561 '\\"lower\\": \\"2014-01-01T00:00:00+00:00\\", \\"bounds\\": \\"()\\"}", '
562 '"dates": "{\\"upper\\": \\"2014-02-02\\", \\"lower\\": \\"2014-01-01\\", '
563 '\\"bounds\\": \\"[)\\"}", "dates_inner": null }, '
564 '"model": "postgres_tests.rangesmodel", "pk": null}]'
565 )
566
567 lower_date = datetime.date(2014, 1, 1)
568 upper_date = datetime.date(2014, 2, 2)
569 lower_dt = datetime.datetime(2014, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
570 upper_dt = datetime.datetime(2014, 2, 2, 12, 12, 12, tzinfo=datetime.timezone.utc)
571
572 def test_dumping(self):
573 instance = RangesModel(
574 ints=NumericRange(0, 10),
575 decimals=NumericRange(empty=True),
576 timestamps=DateTimeTZRange(self.lower_dt, self.upper_dt),
577 timestamps_closed_bounds=DateTimeTZRange(
578 self.lower_dt,
579 self.upper_dt,
580 bounds="()",
581 ),
582 dates=DateRange(self.lower_date, self.upper_date),
583 )
584 data = serializers.serialize("json", [instance])
585 dumped = json.loads(data)
586 for field in ("ints", "dates", "timestamps", "timestamps_closed_bounds"):
587 dumped[0]["fields"][field] = json.loads(dumped[0]["fields"][field])
588 check = json.loads(self.test_data)
589 for field in ("ints", "dates", "timestamps", "timestamps_closed_bounds"):
590 check[0]["fields"][field] = json.loads(check[0]["fields"][field])
591
592 self.assertEqual(dumped, check)
593
594 def test_loading(self):
595 instance = list(serializers.deserialize("json", self.test_data))[0].object
596 self.assertEqual(instance.ints, NumericRange(0, 10))
597 self.assertEqual(instance.decimals, NumericRange(empty=True))
598 self.assertIsNone(instance.bigints)
599 self.assertEqual(instance.dates, DateRange(self.lower_date, self.upper_date))
600 self.assertEqual(
601 instance.timestamps, DateTimeTZRange(self.lower_dt, self.upper_dt)
602 )
603 self.assertEqual(
604 instance.timestamps_closed_bounds,
605 DateTimeTZRange(self.lower_dt, self.upper_dt, bounds="()"),
606 )
607
608 def test_serialize_range_with_null(self):
609 instance = RangesModel(ints=NumericRange(None, 10))
610 data = serializers.serialize("json", [instance])
611 new_instance = list(serializers.deserialize("json", data))[0].object
612 self.assertEqual(new_instance.ints, NumericRange(None, 10))
613
614 instance = RangesModel(ints=NumericRange(10, None))
615 data = serializers.serialize("json", [instance])
616 new_instance = list(serializers.deserialize("json", data))[0].object
617 self.assertEqual(new_instance.ints, NumericRange(10, None))
618
619
620 class TestChecks(PostgreSQLSimpleTestCase):
621 def test_choices_tuple_list(self):
622 class Model(PostgreSQLModel):
623 field = pg_fields.IntegerRangeField(
624 choices=[
625 ["1-50", [((1, 25), "1-25"), ([26, 50], "26-50")]],
626 ((51, 100), "51-100"),
627 ],
628 )
629
630 self.assertEqual(Model._meta.get_field("field").check(), [])
631
632
633 class TestValidators(PostgreSQLSimpleTestCase):
634 def test_max(self):
635 validator = RangeMaxValueValidator(5)
636 validator(NumericRange(0, 5))
637 msg = "Ensure that the upper bound of the range is not greater than 5."
638 with self.assertRaises(exceptions.ValidationError) as cm:
639 validator(NumericRange(0, 10))
640 self.assertEqual(cm.exception.messages[0], msg)
641 self.assertEqual(cm.exception.code, "max_value")
642 with self.assertRaisesMessage(exceptions.ValidationError, msg):
643 validator(NumericRange(0, None)) # an unbound range
644
645 def test_min(self):
646 validator = RangeMinValueValidator(5)
647 validator(NumericRange(10, 15))
648 msg = "Ensure that the lower bound of the range is not less than 5."
649 with self.assertRaises(exceptions.ValidationError) as cm:
650 validator(NumericRange(0, 10))
651 self.assertEqual(cm.exception.messages[0], msg)
652 self.assertEqual(cm.exception.code, "min_value")
653 with self.assertRaisesMessage(exceptions.ValidationError, msg):
654 validator(NumericRange(None, 10)) # an unbound range
655
656
657 class TestFormField(PostgreSQLSimpleTestCase):
658 def test_valid_integer(self):
659 field = pg_forms.IntegerRangeField()
660 value = field.clean(["1", "2"])
661 self.assertEqual(value, NumericRange(1, 2))
662
663 def test_valid_decimal(self):
664 field = pg_forms.DecimalRangeField()
665 value = field.clean(["1.12345", "2.001"])
666 self.assertEqual(value, NumericRange(Decimal("1.12345"), Decimal("2.001")))
667
668 def test_valid_timestamps(self):
669 field = pg_forms.DateTimeRangeField()
670 value = field.clean(["01/01/2014 00:00:00", "02/02/2014 12:12:12"])
671 lower = datetime.datetime(2014, 1, 1, 0, 0, 0)
672 upper = datetime.datetime(2014, 2, 2, 12, 12, 12)
673 self.assertEqual(value, DateTimeTZRange(lower, upper))
674
675 def test_valid_dates(self):
676 field = pg_forms.DateRangeField()
677 value = field.clean(["01/01/2014", "02/02/2014"])
678 lower = datetime.date(2014, 1, 1)
679 upper = datetime.date(2014, 2, 2)
680 self.assertEqual(value, DateRange(lower, upper))
681
682 def test_using_split_datetime_widget(self):
683 class SplitDateTimeRangeField(pg_forms.DateTimeRangeField):
684 base_field = forms.SplitDateTimeField
685
686 class SplitForm(forms.Form):
687 field = SplitDateTimeRangeField()
688
689 form = SplitForm()
690 self.assertHTMLEqual(
691 str(form),
692 """
693 <div>
694 <fieldset>
695 <legend>Field:</legend>
696 <input id="id_field_0_0" name="field_0_0" type="text">
697 <input id="id_field_0_1" name="field_0_1" type="text">
698 <input id="id_field_1_0" name="field_1_0" type="text">
699 <input id="id_field_1_1" name="field_1_1" type="text">
700 </fieldset>
701 </div>
702 """,
703 )
704 form = SplitForm(
705 {
706 "field_0_0": "01/01/2014",
707 "field_0_1": "00:00:00",
708 "field_1_0": "02/02/2014",
709 "field_1_1": "12:12:12",
710 }
711 )
712 self.assertTrue(form.is_valid())
713 lower = datetime.datetime(2014, 1, 1, 0, 0, 0)
714 upper = datetime.datetime(2014, 2, 2, 12, 12, 12)
715 self.assertEqual(form.cleaned_data["field"], DateTimeTZRange(lower, upper))
716
717 def test_none(self):
718 field = pg_forms.IntegerRangeField(required=False)
719 value = field.clean(["", ""])
720 self.assertIsNone(value)
721
722 def test_datetime_form_as_table(self):
723 class DateTimeRangeForm(forms.Form):
724 datetime_field = pg_forms.DateTimeRangeField(show_hidden_initial=True)
725
726 form = DateTimeRangeForm()
727 self.assertHTMLEqual(
728 form.as_table(),
729 """
730 <tr><th>
731 <label>Datetime field:</label>
732 </th><td>
733 <input type="text" name="datetime_field_0" id="id_datetime_field_0">
734 <input type="text" name="datetime_field_1" id="id_datetime_field_1">
735 <input type="hidden" name="initial-datetime_field_0"
736 id="initial-id_datetime_field_0">
737 <input type="hidden" name="initial-datetime_field_1"
738 id="initial-id_datetime_field_1">
739 </td></tr>
740 """,
741 )
742 form = DateTimeRangeForm(
743 {
744 "datetime_field_0": "2010-01-01 11:13:00",
745 "datetime_field_1": "2020-12-12 16:59:00",
746 }
747 )
748 self.assertHTMLEqual(
749 form.as_table(),
750 """
751 <tr><th>
752 <label>Datetime field:</label>
753 </th><td>
754 <input type="text" name="datetime_field_0"
755 value="2010-01-01 11:13:00" id="id_datetime_field_0">
756 <input type="text" name="datetime_field_1"
757 value="2020-12-12 16:59:00" id="id_datetime_field_1">
758 <input type="hidden" name="initial-datetime_field_0"
759 value="2010-01-01 11:13:00" id="initial-id_datetime_field_0">
760 <input type="hidden" name="initial-datetime_field_1"
761 value="2020-12-12 16:59:00" id="initial-id_datetime_field_1"></td></tr>
762 """,
763 )
764
765 def test_datetime_form_initial_data(self):
766 class DateTimeRangeForm(forms.Form):
767 datetime_field = pg_forms.DateTimeRangeField(show_hidden_initial=True)
768
769 data = QueryDict(mutable=True)
770 data.update(
771 {
772 "datetime_field_0": "2010-01-01 11:13:00",
773 "datetime_field_1": "",
774 "initial-datetime_field_0": "2010-01-01 10:12:00",
775 "initial-datetime_field_1": "",
776 }
777 )
778 form = DateTimeRangeForm(data=data)
779 self.assertTrue(form.has_changed())
780
781 data["initial-datetime_field_0"] = "2010-01-01 11:13:00"
782 form = DateTimeRangeForm(data=data)
783 self.assertFalse(form.has_changed())
784
785 def test_rendering(self):
786 class RangeForm(forms.Form):
787 ints = pg_forms.IntegerRangeField()
788
789 self.assertHTMLEqual(
790 str(RangeForm()),
791 """
792 <div>
793 <fieldset>
794 <legend>Ints:</legend>
795 <input id="id_ints_0" name="ints_0" type="number">
796 <input id="id_ints_1" name="ints_1" type="number">
797 </fieldset>
798 </div>
799 """,
800 )
801
802 def test_integer_lower_bound_higher(self):
803 field = pg_forms.IntegerRangeField()
804 with self.assertRaises(exceptions.ValidationError) as cm:
805 field.clean(["10", "2"])
806 self.assertEqual(
807 cm.exception.messages[0],
808 "The start of the range must not exceed the end of the range.",
809 )
810 self.assertEqual(cm.exception.code, "bound_ordering")
811
812 def test_integer_open(self):
813 field = pg_forms.IntegerRangeField()
814 value = field.clean(["", "0"])
815 self.assertEqual(value, NumericRange(None, 0))
816
817 def test_integer_incorrect_data_type(self):
818 field = pg_forms.IntegerRangeField()
819 with self.assertRaises(exceptions.ValidationError) as cm:
820 field.clean("1")
821 self.assertEqual(cm.exception.messages[0], "Enter two whole numbers.")
822 self.assertEqual(cm.exception.code, "invalid")
823
824 def test_integer_invalid_lower(self):
825 field = pg_forms.IntegerRangeField()
826 with self.assertRaises(exceptions.ValidationError) as cm:
827 field.clean(["a", "2"])
828 self.assertEqual(cm.exception.messages[0], "Enter a whole number.")
829
830 def test_integer_invalid_upper(self):
831 field = pg_forms.IntegerRangeField()
832 with self.assertRaises(exceptions.ValidationError) as cm:
833 field.clean(["1", "b"])
834 self.assertEqual(cm.exception.messages[0], "Enter a whole number.")
835
836 def test_integer_required(self):
837 field = pg_forms.IntegerRangeField(required=True)
838 with self.assertRaises(exceptions.ValidationError) as cm:
839 field.clean(["", ""])
840 self.assertEqual(cm.exception.messages[0], "This field is required.")
841 value = field.clean([1, ""])
842 self.assertEqual(value, NumericRange(1, None))
843
844 def test_decimal_lower_bound_higher(self):
845 field = pg_forms.DecimalRangeField()
846 with self.assertRaises(exceptions.ValidationError) as cm:
847 field.clean(["1.8", "1.6"])
848 self.assertEqual(
849 cm.exception.messages[0],
850 "The start of the range must not exceed the end of the range.",
851 )
852 self.assertEqual(cm.exception.code, "bound_ordering")
853
854 def test_decimal_open(self):
855 field = pg_forms.DecimalRangeField()
856 value = field.clean(["", "3.1415926"])
857 self.assertEqual(value, NumericRange(None, Decimal("3.1415926")))
858
859 def test_decimal_incorrect_data_type(self):
860 field = pg_forms.DecimalRangeField()
861 with self.assertRaises(exceptions.ValidationError) as cm:
862 field.clean("1.6")
863 self.assertEqual(cm.exception.messages[0], "Enter two numbers.")
864 self.assertEqual(cm.exception.code, "invalid")
865
866 def test_decimal_invalid_lower(self):
867 field = pg_forms.DecimalRangeField()
868 with self.assertRaises(exceptions.ValidationError) as cm:
869 field.clean(["a", "3.1415926"])
870 self.assertEqual(cm.exception.messages[0], "Enter a number.")
871
872 def test_decimal_invalid_upper(self):
873 field = pg_forms.DecimalRangeField()
874 with self.assertRaises(exceptions.ValidationError) as cm:
875 field.clean(["1.61803399", "b"])
876 self.assertEqual(cm.exception.messages[0], "Enter a number.")
877
878 def test_decimal_required(self):
879 field = pg_forms.DecimalRangeField(required=True)
880 with self.assertRaises(exceptions.ValidationError) as cm:
881 field.clean(["", ""])
882 self.assertEqual(cm.exception.messages[0], "This field is required.")
883 value = field.clean(["1.61803399", ""])
884 self.assertEqual(value, NumericRange(Decimal("1.61803399"), None))
885
886 def test_date_lower_bound_higher(self):
887 field = pg_forms.DateRangeField()
888 with self.assertRaises(exceptions.ValidationError) as cm:
889 field.clean(["2013-04-09", "1976-04-16"])
890 self.assertEqual(
891 cm.exception.messages[0],
892 "The start of the range must not exceed the end of the range.",
893 )
894 self.assertEqual(cm.exception.code, "bound_ordering")
895
896 def test_date_open(self):
897 field = pg_forms.DateRangeField()
898 value = field.clean(["", "2013-04-09"])
899 self.assertEqual(value, DateRange(None, datetime.date(2013, 4, 9)))
900
901 def test_date_incorrect_data_type(self):
902 field = pg_forms.DateRangeField()
903 with self.assertRaises(exceptions.ValidationError) as cm:
904 field.clean("1")
905 self.assertEqual(cm.exception.messages[0], "Enter two valid dates.")
906 self.assertEqual(cm.exception.code, "invalid")
907
908 def test_date_invalid_lower(self):
909 field = pg_forms.DateRangeField()
910 with self.assertRaises(exceptions.ValidationError) as cm:
911 field.clean(["a", "2013-04-09"])
912 self.assertEqual(cm.exception.messages[0], "Enter a valid date.")
913
914 def test_date_invalid_upper(self):
915 field = pg_forms.DateRangeField()
916 with self.assertRaises(exceptions.ValidationError) as cm:
917 field.clean(["2013-04-09", "b"])
918 self.assertEqual(cm.exception.messages[0], "Enter a valid date.")
919
920 def test_date_required(self):
921 field = pg_forms.DateRangeField(required=True)
922 with self.assertRaises(exceptions.ValidationError) as cm:
923 field.clean(["", ""])
924 self.assertEqual(cm.exception.messages[0], "This field is required.")
925 value = field.clean(["1976-04-16", ""])
926 self.assertEqual(value, DateRange(datetime.date(1976, 4, 16), None))
927
928 def test_date_has_changed_first(self):
929 self.assertTrue(
930 pg_forms.DateRangeField().has_changed(
931 ["2010-01-01", "2020-12-12"],
932 ["2010-01-31", "2020-12-12"],
933 )
934 )
935
936 def test_date_has_changed_last(self):
937 self.assertTrue(
938 pg_forms.DateRangeField().has_changed(
939 ["2010-01-01", "2020-12-12"],
940 ["2010-01-01", "2020-12-31"],
941 )
942 )
943
944 def test_datetime_lower_bound_higher(self):
945 field = pg_forms.DateTimeRangeField()
946 with self.assertRaises(exceptions.ValidationError) as cm:
947 field.clean(["2006-10-25 14:59", "2006-10-25 14:58"])
948 self.assertEqual(
949 cm.exception.messages[0],
950 "The start of the range must not exceed the end of the range.",
951 )
952 self.assertEqual(cm.exception.code, "bound_ordering")
953
954 def test_datetime_open(self):
955 field = pg_forms.DateTimeRangeField()
956 value = field.clean(["", "2013-04-09 11:45"])
957 self.assertEqual(
958 value, DateTimeTZRange(None, datetime.datetime(2013, 4, 9, 11, 45))
959 )
960
961 def test_datetime_incorrect_data_type(self):
962 field = pg_forms.DateTimeRangeField()
963 with self.assertRaises(exceptions.ValidationError) as cm:
964 field.clean("2013-04-09 11:45")
965 self.assertEqual(cm.exception.messages[0], "Enter two valid date/times.")
966 self.assertEqual(cm.exception.code, "invalid")
967
968 def test_datetime_invalid_lower(self):
969 field = pg_forms.DateTimeRangeField()
970 with self.assertRaises(exceptions.ValidationError) as cm:
971 field.clean(["45", "2013-04-09 11:45"])
972 self.assertEqual(cm.exception.messages[0], "Enter a valid date/time.")
973
974 def test_datetime_invalid_upper(self):
975 field = pg_forms.DateTimeRangeField()
976 with self.assertRaises(exceptions.ValidationError) as cm:
977 field.clean(["2013-04-09 11:45", "sweet pickles"])
978 self.assertEqual(cm.exception.messages[0], "Enter a valid date/time.")
979
980 def test_datetime_required(self):
981 field = pg_forms.DateTimeRangeField(required=True)
982 with self.assertRaises(exceptions.ValidationError) as cm:
983 field.clean(["", ""])
984 self.assertEqual(cm.exception.messages[0], "This field is required.")
985 value = field.clean(["2013-04-09 11:45", ""])
986 self.assertEqual(
987 value, DateTimeTZRange(datetime.datetime(2013, 4, 9, 11, 45), None)
988 )
989
990 @override_settings(USE_TZ=True, TIME_ZONE="Africa/Johannesburg")
991 def test_datetime_prepare_value(self):
992 field = pg_forms.DateTimeRangeField()
993 value = field.prepare_value(
994 DateTimeTZRange(
995 datetime.datetime(2015, 5, 22, 16, 6, 33, tzinfo=datetime.timezone.utc),
996 None,
997 )
998 )
999 self.assertEqual(value, [datetime.datetime(2015, 5, 22, 18, 6, 33), None])
1000
1001 def test_datetime_has_changed_first(self):
1002 self.assertTrue(
1003 pg_forms.DateTimeRangeField().has_changed(
1004 ["2010-01-01 00:00", "2020-12-12 00:00"],
1005 ["2010-01-31 23:00", "2020-12-12 00:00"],
1006 )
1007 )
1008
1009 def test_datetime_has_changed_last(self):
1010 self.assertTrue(
1011 pg_forms.DateTimeRangeField().has_changed(
1012 ["2010-01-01 00:00", "2020-12-12 00:00"],
1013 ["2010-01-01 00:00", "2020-12-31 23:00"],
1014 )
1015 )
1016
1017 def test_model_field_formfield_integer(self):
1018 model_field = pg_fields.IntegerRangeField()
1019 form_field = model_field.formfield()
1020 self.assertIsInstance(form_field, pg_forms.IntegerRangeField)
1021 self.assertEqual(form_field.range_kwargs, {})
1022
1023 def test_model_field_formfield_biginteger(self):
1024 model_field = pg_fields.BigIntegerRangeField()
1025 form_field = model_field.formfield()
1026 self.assertIsInstance(form_field, pg_forms.IntegerRangeField)
1027 self.assertEqual(form_field.range_kwargs, {})
1028
1029 def test_model_field_formfield_float(self):
1030 model_field = pg_fields.DecimalRangeField(default_bounds="()")
1031 form_field = model_field.formfield()
1032 self.assertIsInstance(form_field, pg_forms.DecimalRangeField)
1033 self.assertEqual(form_field.range_kwargs, {"bounds": "()"})
1034
1035 def test_model_field_formfield_date(self):
1036 model_field = pg_fields.DateRangeField()
1037 form_field = model_field.formfield()
1038 self.assertIsInstance(form_field, pg_forms.DateRangeField)
1039 self.assertEqual(form_field.range_kwargs, {})
1040
1041 def test_model_field_formfield_datetime(self):
1042 model_field = pg_fields.DateTimeRangeField()
1043 form_field = model_field.formfield()
1044 self.assertIsInstance(form_field, pg_forms.DateTimeRangeField)
1045 self.assertEqual(
1046 form_field.range_kwargs,
1047 {"bounds": pg_fields.ranges.CANONICAL_RANGE_BOUNDS},
1048 )
1049
1050 def test_model_field_formfield_datetime_default_bounds(self):
1051 model_field = pg_fields.DateTimeRangeField(default_bounds="[]")
1052 form_field = model_field.formfield()
1053 self.assertIsInstance(form_field, pg_forms.DateTimeRangeField)
1054 self.assertEqual(form_field.range_kwargs, {"bounds": "[]"})
1055
1056 def test_model_field_with_default_bounds(self):
1057 field = pg_forms.DateTimeRangeField(default_bounds="[]")
1058 value = field.clean(["2014-01-01 00:00:00", "2014-02-03 12:13:14"])
1059 lower = datetime.datetime(2014, 1, 1, 0, 0, 0)
1060 upper = datetime.datetime(2014, 2, 3, 12, 13, 14)
1061 self.assertEqual(value, DateTimeTZRange(lower, upper, "[]"))
1062
1063 def test_has_changed(self):
1064 for field, value in (
1065 (pg_forms.DateRangeField(), ["2010-01-01", "2020-12-12"]),
1066 (pg_forms.DateTimeRangeField(), ["2010-01-01 11:13", "2020-12-12 14:52"]),
1067 (pg_forms.IntegerRangeField(), [1, 2]),
1068 (pg_forms.DecimalRangeField(), ["1.12345", "2.001"]),
1069 ):
1070 with self.subTest(field=field.__class__.__name__):
1071 self.assertTrue(field.has_changed(None, value))
1072 self.assertTrue(field.has_changed([value[0], ""], value))
1073 self.assertTrue(field.has_changed(["", value[1]], value))
1074 self.assertFalse(field.has_changed(value, value))
1075
1076
1077 class TestWidget(PostgreSQLSimpleTestCase):
1078 def test_range_widget(self):
1079 f = pg_forms.ranges.DateTimeRangeField()
1080 self.assertHTMLEqual(
1081 f.widget.render("datetimerange", ""),
1082 '<input type="text" name="datetimerange_0">'
1083 '<input type="text" name="datetimerange_1">',
1084 )
1085 self.assertHTMLEqual(
1086 f.widget.render("datetimerange", None),
1087 '<input type="text" name="datetimerange_0">'
1088 '<input type="text" name="datetimerange_1">',
1089 )
1090 dt_range = DateTimeTZRange(
1091 datetime.datetime(2006, 1, 10, 7, 30), datetime.datetime(2006, 2, 12, 9, 50)
1092 )
1093 self.assertHTMLEqual(
1094 f.widget.render("datetimerange", dt_range),
1095 '<input type="text" name="datetimerange_0" value="2006-01-10 07:30:00">'
1096 '<input type="text" name="datetimerange_1" value="2006-02-12 09:50:00">',
1097 )
1098
1099 def test_range_widget_render_tuple_value(self):
1100 field = pg_forms.ranges.DateTimeRangeField()
1101 dt_range_tuple = (
1102 datetime.datetime(2022, 4, 22, 10, 24),
1103 datetime.datetime(2022, 5, 12, 9, 25),
1104 )
1105 self.assertHTMLEqual(
1106 field.widget.render("datetimerange", dt_range_tuple),
1107 '<input type="text" name="datetimerange_0" value="2022-04-22 10:24:00">'
1108 '<input type="text" name="datetimerange_1" value="2022-05-12 09:25:00">',
1109 )