Debian Codegraph @

tests/postgres_tests/test_array.py

raw
1 import decimal
2 import enum
3 import json
4 import unittest
5 import uuid
6
7 from django import forms
8 from django.contrib.admin.utils import display_for_field
9 from django.core import checks, exceptions, serializers, validators
10 from django.core.exceptions import FieldError
11 from django.core.management import call_command
12 from django.db import IntegrityError, connection, models
13 from django.db.models.expressions import Exists, F, OuterRef, RawSQL, Value
14 from django.db.models.functions import Cast, JSONObject, Upper
15 from django.test import TransactionTestCase, override_settings, skipUnlessDBFeature
16 from django.test.utils import isolate_apps
17 from django.utils import timezone
18
19 from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase, PostgreSQLWidgetTestCase
20 from .models import (
21 ArrayEnumModel,
22 ArrayFieldSubclass,
23 CharArrayModel,
24 DateTimeArrayModel,
25 IntegerArrayModel,
26 NestedIntegerArrayModel,
27 NullableIntegerArrayModel,
28 OtherTypesArrayModel,
29 PostgreSQLModel,
30 Tag,
31 WithSizeArrayModel,
32 )
33
34 try:
35 from django.contrib.postgres.aggregates import ArrayAgg
36 from django.contrib.postgres.expressions import ArraySubquery
37 from django.contrib.postgres.fields import ArrayField
38 from django.contrib.postgres.fields.array import IndexTransform, SliceTransform
39 from django.contrib.postgres.forms import (
40 SimpleArrayField,
41 SplitArrayField,
42 SplitArrayWidget,
43 )
44 from django.db.backends.postgresql.psycopg_any import NumericRange
45 except ImportError:
46 pass
47
48
49 @isolate_apps("postgres_tests")
50 class BasicTests(PostgreSQLSimpleTestCase):
51 def test_get_field_display(self):
52 class MyModel(PostgreSQLModel):
53 field = ArrayField(
54 models.CharField(max_length=16),
55 choices=[
56 ["Media", [(["vinyl", "cd"], "Audio")]],
57 (("mp3", "mp4"), "Digital"),
58 ],
59 )
60
61 tests = (
62 (["vinyl", "cd"], "Audio"),
63 (("mp3", "mp4"), "Digital"),
64 (("a", "b"), "('a', 'b')"),
65 (["c", "d"], "['c', 'd']"),
66 )
67 for value, display in tests:
68 with self.subTest(value=value, display=display):
69 instance = MyModel(field=value)
70 self.assertEqual(instance.get_field_display(), display)
71
72 def test_get_field_display_nested_array(self):
73 class MyModel(PostgreSQLModel):
74 field = ArrayField(
75 ArrayField(models.CharField(max_length=16)),
76 choices=[
77 [
78 "Media",
79 [([["vinyl", "cd"], ("x",)], "Audio")],
80 ],
81 ((["mp3"], ("mp4",)), "Digital"),
82 ],
83 )
84
85 tests = (
86 ([["vinyl", "cd"], ("x",)], "Audio"),
87 ((["mp3"], ("mp4",)), "Digital"),
88 ((("a", "b"), ("c",)), "(('a', 'b'), ('c',))"),
89 ([["a", "b"], ["c"]], "[['a', 'b'], ['c']]"),
90 )
91 for value, display in tests:
92 with self.subTest(value=value, display=display):
93 instance = MyModel(field=value)
94 self.assertEqual(instance.get_field_display(), display)
95
96
97 class TestSaveLoad(PostgreSQLTestCase):
98 def test_integer(self):
99 instance = IntegerArrayModel(field=[1, 2, 3])
100 instance.save()
101 loaded = IntegerArrayModel.objects.get()
102 self.assertEqual(instance.field, loaded.field)
103
104 def test_char(self):
105 instance = CharArrayModel(field=["hello", "goodbye"])
106 instance.save()
107 loaded = CharArrayModel.objects.get()
108 self.assertEqual(instance.field, loaded.field)
109
110 def test_dates(self):
111 instance = DateTimeArrayModel(
112 datetimes=[timezone.now()],
113 dates=[timezone.now().date()],
114 times=[timezone.now().time()],
115 )
116 instance.save()
117 loaded = DateTimeArrayModel.objects.get()
118 self.assertEqual(instance.datetimes, loaded.datetimes)
119 self.assertEqual(instance.dates, loaded.dates)
120 self.assertEqual(instance.times, loaded.times)
121
122 def test_tuples(self):
123 instance = IntegerArrayModel(field=(1,))
124 instance.save()
125 loaded = IntegerArrayModel.objects.get()
126 self.assertSequenceEqual(instance.field, loaded.field)
127
128 def test_integers_passed_as_strings(self):
129 # This checks that get_prep_value is deferred properly
130 instance = IntegerArrayModel(field=["1"])
131 instance.save()
132 loaded = IntegerArrayModel.objects.get()
133 self.assertEqual(loaded.field, [1])
134
135 def test_default_null(self):
136 instance = NullableIntegerArrayModel()
137 instance.save()
138 loaded = NullableIntegerArrayModel.objects.get(pk=instance.pk)
139 self.assertIsNone(loaded.field)
140 self.assertEqual(instance.field, loaded.field)
141
142 def test_null_handling(self):
143 instance = NullableIntegerArrayModel(field=None)
144 instance.save()
145 loaded = NullableIntegerArrayModel.objects.get()
146 self.assertEqual(instance.field, loaded.field)
147
148 instance = IntegerArrayModel(field=None)
149 with self.assertRaises(IntegrityError):
150 instance.save()
151
152 def test_nested(self):
153 instance = NestedIntegerArrayModel(field=[[1, 2], [3, 4]])
154 instance.save()
155 loaded = NestedIntegerArrayModel.objects.get()
156 self.assertEqual(instance.field, loaded.field)
157
158 def test_other_array_types(self):
159 instance = OtherTypesArrayModel(
160 ips=["192.168.0.1", "::1"],
161 uuids=[uuid.uuid4()],
162 decimals=[decimal.Decimal(1.25), 1.75],
163 tags=[Tag(1), Tag(2), Tag(3)],
164 json=[{"a": 1}, {"b": 2}],
165 int_ranges=[NumericRange(10, 20), NumericRange(30, 40)],
166 bigint_ranges=[
167 NumericRange(7000000000, 10000000000),
168 NumericRange(50000000000, 70000000000),
169 ],
170 )
171 instance.save()
172 loaded = OtherTypesArrayModel.objects.get()
173 self.assertEqual(instance.ips, loaded.ips)
174 self.assertEqual(instance.uuids, loaded.uuids)
175 self.assertEqual(instance.decimals, loaded.decimals)
176 self.assertEqual(instance.tags, loaded.tags)
177 self.assertEqual(instance.json, loaded.json)
178 self.assertEqual(instance.int_ranges, loaded.int_ranges)
179 self.assertEqual(instance.bigint_ranges, loaded.bigint_ranges)
180
181 def test_null_from_db_value_handling(self):
182 instance = OtherTypesArrayModel.objects.create(
183 ips=["192.168.0.1", "::1"],
184 uuids=[uuid.uuid4()],
185 decimals=[decimal.Decimal(1.25), 1.75],
186 tags=None,
187 )
188 instance.refresh_from_db()
189 self.assertIsNone(instance.tags)
190 self.assertEqual(instance.json, [])
191 self.assertIsNone(instance.int_ranges)
192 self.assertIsNone(instance.bigint_ranges)
193
194 def test_model_set_on_base_field(self):
195 instance = IntegerArrayModel()
196 field = instance._meta.get_field("field")
197 self.assertEqual(field.model, IntegerArrayModel)
198 self.assertEqual(field.base_field.model, IntegerArrayModel)
199
200 def test_nested_nullable_base_field(self):
201 instance = NullableIntegerArrayModel.objects.create(
202 field_nested=[[None, None], [None, None]],
203 )
204 self.assertEqual(instance.field_nested, [[None, None], [None, None]])
205
206
207 class TestQuerying(PostgreSQLTestCase):
208 @classmethod
209 def setUpTestData(cls):
210 cls.objs = NullableIntegerArrayModel.objects.bulk_create(
211 [
212 NullableIntegerArrayModel(order=1, field=[1]),
213 NullableIntegerArrayModel(order=2, field=[2]),
214 NullableIntegerArrayModel(order=3, field=[2, 3]),
215 NullableIntegerArrayModel(order=4, field=[20, 30, 40]),
216 NullableIntegerArrayModel(order=5, field=None),
217 ]
218 )
219
220 def test_bulk_create_with_sized_arrayfield(self):
221 objs = WithSizeArrayModel.objects.bulk_create(
222 [
223 WithSizeArrayModel(field=[1, 2]),
224 WithSizeArrayModel(field=[3, 4]),
225 ]
226 )
227 self.assertEqual(objs[0].field, [1, 2])
228 self.assertEqual(objs[1].field, [3, 4])
229
230 def test_empty_list(self):
231 NullableIntegerArrayModel.objects.create(field=[])
232 obj = (
233 NullableIntegerArrayModel.objects.annotate(
234 empty_array=models.Value(
235 [], output_field=ArrayField(models.IntegerField())
236 ),
237 )
238 .filter(field=models.F("empty_array"))
239 .get()
240 )
241 self.assertEqual(obj.field, [])
242 self.assertEqual(obj.empty_array, [])
243
244 def test_exact(self):
245 self.assertSequenceEqual(
246 NullableIntegerArrayModel.objects.filter(field__exact=[1]), self.objs[:1]
247 )
248
249 def test_exact_null_only_array(self):
250 obj = NullableIntegerArrayModel.objects.create(
251 field=[None], field_nested=[None, None]
252 )
253 self.assertSequenceEqual(
254 NullableIntegerArrayModel.objects.filter(field__exact=[None]), [obj]
255 )
256 self.assertSequenceEqual(
257 NullableIntegerArrayModel.objects.filter(field_nested__exact=[None, None]),
258 [obj],
259 )
260
261 def test_exact_null_only_nested_array(self):
262 obj1 = NullableIntegerArrayModel.objects.create(field_nested=[[None, None]])
263 obj2 = NullableIntegerArrayModel.objects.create(
264 field_nested=[[None, None], [None, None]],
265 )
266 self.assertSequenceEqual(
267 NullableIntegerArrayModel.objects.filter(
268 field_nested__exact=[[None, None]],
269 ),
270 [obj1],
271 )
272 self.assertSequenceEqual(
273 NullableIntegerArrayModel.objects.filter(
274 field_nested__exact=[[None, None], [None, None]],
275 ),
276 [obj2],
277 )
278
279 def test_exact_with_expression(self):
280 self.assertSequenceEqual(
281 NullableIntegerArrayModel.objects.filter(field__exact=[Value(1)]),
282 self.objs[:1],
283 )
284
285 def test_exact_charfield(self):
286 instance = CharArrayModel.objects.create(field=["text"])
287 self.assertSequenceEqual(
288 CharArrayModel.objects.filter(field=["text"]), [instance]
289 )
290
291 def test_exact_nested(self):
292 instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
293 self.assertSequenceEqual(
294 NestedIntegerArrayModel.objects.filter(field=[[1, 2], [3, 4]]), [instance]
295 )
296
297 def test_isnull(self):
298 self.assertSequenceEqual(
299 NullableIntegerArrayModel.objects.filter(field__isnull=True), self.objs[-1:]
300 )
301
302 def test_gt(self):
303 self.assertSequenceEqual(
304 NullableIntegerArrayModel.objects.filter(field__gt=[0]), self.objs[:4]
305 )
306
307 def test_lt(self):
308 self.assertSequenceEqual(
309 NullableIntegerArrayModel.objects.filter(field__lt=[2]), self.objs[:1]
310 )
311
312 def test_in(self):
313 self.assertSequenceEqual(
314 NullableIntegerArrayModel.objects.filter(field__in=[[1], [2]]),
315 self.objs[:2],
316 )
317
318 def test_in_subquery(self):
319 IntegerArrayModel.objects.create(field=[2, 3])
320 self.assertSequenceEqual(
321 NullableIntegerArrayModel.objects.filter(
322 field__in=IntegerArrayModel.objects.values_list("field", flat=True)
323 ),
324 self.objs[2:3],
325 )
326
327 @unittest.expectedFailure
328 def test_in_including_F_object(self):
329 # This test asserts that Array objects passed to filters can be
330 # constructed to contain F objects. This currently doesn't work as the
331 # psycopg mogrify method that generates the ARRAY() syntax is
332 # expecting literals, not column references (#27095).
333 self.assertSequenceEqual(
334 NullableIntegerArrayModel.objects.filter(field__in=[[models.F("id")]]),
335 self.objs[:2],
336 )
337
338 def test_in_as_F_object(self):
339 self.assertSequenceEqual(
340 NullableIntegerArrayModel.objects.filter(field__in=[models.F("field")]),
341 self.objs[:4],
342 )
343
344 def test_contained_by(self):
345 self.assertSequenceEqual(
346 NullableIntegerArrayModel.objects.filter(field__contained_by=[1, 2]),
347 self.objs[:2],
348 )
349
350 def test_contained_by_including_F_object(self):
351 self.assertSequenceEqual(
352 NullableIntegerArrayModel.objects.filter(
353 field__contained_by=[models.F("order"), 2]
354 ),
355 self.objs[:3],
356 )
357
358 def test_contains(self):
359 self.assertSequenceEqual(
360 NullableIntegerArrayModel.objects.filter(field__contains=[2]),
361 self.objs[1:3],
362 )
363
364 def test_contains_subquery(self):
365 IntegerArrayModel.objects.create(field=[2, 3])
366 inner_qs = IntegerArrayModel.objects.values_list("field", flat=True)
367 self.assertSequenceEqual(
368 NullableIntegerArrayModel.objects.filter(field__contains=inner_qs[:1]),
369 self.objs[2:3],
370 )
371 inner_qs = IntegerArrayModel.objects.filter(field__contains=OuterRef("field"))
372 self.assertSequenceEqual(
373 NullableIntegerArrayModel.objects.filter(Exists(inner_qs)),
374 self.objs[1:3],
375 )
376
377 def test_contains_including_expression(self):
378 self.assertSequenceEqual(
379 NullableIntegerArrayModel.objects.filter(
380 field__contains=[2, Value(6) / Value(2)],
381 ),
382 self.objs[2:3],
383 )
384
385 def test_icontains(self):
386 # Using the __icontains lookup with ArrayField is inefficient.
387 instance = CharArrayModel.objects.create(field=["FoO"])
388 self.assertSequenceEqual(
389 CharArrayModel.objects.filter(field__icontains="foo"), [instance]
390 )
391
392 def test_contains_charfield(self):
393 # Regression for #22907
394 self.assertSequenceEqual(
395 CharArrayModel.objects.filter(field__contains=["text"]), []
396 )
397
398 def test_contained_by_charfield(self):
399 self.assertSequenceEqual(
400 CharArrayModel.objects.filter(field__contained_by=["text"]), []
401 )
402
403 def test_overlap_charfield(self):
404 self.assertSequenceEqual(
405 CharArrayModel.objects.filter(field__overlap=["text"]), []
406 )
407
408 def test_overlap_charfield_including_expression(self):
409 obj_1 = CharArrayModel.objects.create(field=["TEXT", "lower text"])
410 obj_2 = CharArrayModel.objects.create(field=["lower text", "TEXT"])
411 CharArrayModel.objects.create(field=["lower text", "text"])
412 self.assertSequenceEqual(
413 CharArrayModel.objects.filter(
414 field__overlap=[
415 Upper(Value("text")),
416 "other",
417 ]
418 ),
419 [obj_1, obj_2],
420 )
421
422 def test_overlap_values(self):
423 qs = NullableIntegerArrayModel.objects.filter(order__lt=3)
424 self.assertCountEqual(
425 NullableIntegerArrayModel.objects.filter(
426 field__overlap=qs.values_list("field"),
427 ),
428 self.objs[:3],
429 )
430 self.assertCountEqual(
431 NullableIntegerArrayModel.objects.filter(
432 field__overlap=qs.values("field"),
433 ),
434 self.objs[:3],
435 )
436
437 def test_lookups_autofield_array(self):
438 qs = (
439 NullableIntegerArrayModel.objects.filter(
440 field__0__isnull=False,
441 )
442 .values("field__0")
443 .annotate(
444 arrayagg=ArrayAgg("id"),
445 )
446 .order_by("field__0")
447 )
448 tests = (
449 ("contained_by", [self.objs[1].pk, self.objs[2].pk, 0], [2]),
450 ("contains", [self.objs[2].pk], [2]),
451 ("exact", [self.objs[3].pk], [20]),
452 ("overlap", [self.objs[1].pk, self.objs[3].pk], [2, 20]),
453 )
454 for lookup, value, expected in tests:
455 with self.subTest(lookup=lookup):
456 self.assertSequenceEqual(
457 qs.filter(
458 **{"arrayagg__" + lookup: value},
459 ).values_list("field__0", flat=True),
460 expected,
461 )
462
463 @skipUnlessDBFeature("allows_group_by_select_index")
464 def test_group_by_order_by_select_index(self):
465 with self.assertNumQueries(1) as ctx:
466 self.assertSequenceEqual(
467 NullableIntegerArrayModel.objects.filter(
468 field__0__isnull=False,
469 )
470 .values("field__0")
471 .annotate(arrayagg=ArrayAgg("id"))
472 .order_by("field__0"),
473 [
474 {"field__0": 1, "arrayagg": [self.objs[0].pk]},
475 {"field__0": 2, "arrayagg": [self.objs[1].pk, self.objs[2].pk]},
476 {"field__0": 20, "arrayagg": [self.objs[3].pk]},
477 ],
478 )
479 sql = ctx[0]["sql"]
480 self.assertIn("GROUP BY 1", sql)
481 self.assertIn("ORDER BY 1", sql)
482
483 def test_order_by_arrayagg_index(self):
484 qs = (
485 NullableIntegerArrayModel.objects.values("order")
486 .annotate(ids=ArrayAgg("id"))
487 .order_by("-ids__0")
488 )
489 self.assertQuerySetEqual(
490 qs, [{"order": obj.order, "ids": [obj.id]} for obj in reversed(self.objs)]
491 )
492
493 def test_index(self):
494 self.assertSequenceEqual(
495 NullableIntegerArrayModel.objects.filter(field__0=2), self.objs[1:3]
496 )
497
498 def test_index_chained(self):
499 self.assertSequenceEqual(
500 NullableIntegerArrayModel.objects.filter(field__0__lt=3), self.objs[0:3]
501 )
502
503 def test_index_nested(self):
504 instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
505 self.assertSequenceEqual(
506 NestedIntegerArrayModel.objects.filter(field__0__0=1), [instance]
507 )
508
509 @unittest.expectedFailure
510 def test_index_used_on_nested_data(self):
511 instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
512 self.assertSequenceEqual(
513 NestedIntegerArrayModel.objects.filter(field__0=[1, 2]), [instance]
514 )
515
516 def test_index_transform_expression(self):
517 expr = RawSQL("string_to_array(%s, ';')", ["1;2"])
518 self.assertSequenceEqual(
519 NullableIntegerArrayModel.objects.filter(
520 field__0=Cast(
521 IndexTransform(1, models.IntegerField, expr),
522 output_field=models.IntegerField(),
523 ),
524 ),
525 self.objs[:1],
526 )
527
528 def test_index_annotation(self):
529 qs = NullableIntegerArrayModel.objects.annotate(second=models.F("field__1"))
530 self.assertCountEqual(
531 qs.values_list("second", flat=True),
532 [None, None, None, 3, 30],
533 )
534
535 def test_overlap(self):
536 self.assertSequenceEqual(
537 NullableIntegerArrayModel.objects.filter(field__overlap=[1, 2]),
538 self.objs[0:3],
539 )
540
541 def test_len(self):
542 self.assertSequenceEqual(
543 NullableIntegerArrayModel.objects.filter(field__len__lte=2), self.objs[0:3]
544 )
545
546 def test_len_empty_array(self):
547 obj = NullableIntegerArrayModel.objects.create(field=[])
548 self.assertSequenceEqual(
549 NullableIntegerArrayModel.objects.filter(field__len=0), [obj]
550 )
551
552 def test_slice(self):
553 self.assertSequenceEqual(
554 NullableIntegerArrayModel.objects.filter(field__0_1=[2]), self.objs[1:3]
555 )
556
557 self.assertSequenceEqual(
558 NullableIntegerArrayModel.objects.filter(field__0_2=[2, 3]), self.objs[2:3]
559 )
560
561 def test_order_by_index(self):
562 more_objs = (
563 NullableIntegerArrayModel.objects.create(field=[1, 637]),
564 NullableIntegerArrayModel.objects.create(field=[2, 1]),
565 NullableIntegerArrayModel.objects.create(field=[3, -98123]),
566 NullableIntegerArrayModel.objects.create(field=[4, 2]),
567 )
568 self.assertSequenceEqual(
569 NullableIntegerArrayModel.objects.order_by("field__1"),
570 [
571 more_objs[2],
572 more_objs[1],
573 more_objs[3],
574 self.objs[2],
575 self.objs[3],
576 more_objs[0],
577 self.objs[4],
578 self.objs[1],
579 self.objs[0],
580 ],
581 )
582
583 @unittest.expectedFailure
584 def test_slice_nested(self):
585 instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
586 self.assertSequenceEqual(
587 NestedIntegerArrayModel.objects.filter(field__0__0_1=[1]), [instance]
588 )
589
590 def test_slice_transform_expression(self):
591 expr = RawSQL("string_to_array(%s, ';')", ["9;2;3"])
592 self.assertSequenceEqual(
593 NullableIntegerArrayModel.objects.filter(
594 field__0_2=SliceTransform(2, 3, expr)
595 ),
596 self.objs[2:3],
597 )
598
599 def test_slice_annotation(self):
600 qs = NullableIntegerArrayModel.objects.annotate(
601 first_two=models.F("field__0_2"),
602 )
603 self.assertCountEqual(
604 qs.values_list("first_two", flat=True),
605 [None, [1], [2], [2, 3], [20, 30]],
606 )
607
608 def test_slicing_of_f_expressions(self):
609 tests = [
610 (F("field")[:2], [1, 2]),
611 (F("field")[2:], [3, 4]),
612 (F("field")[1:3], [2, 3]),
613 (F("field")[3], [4]),
614 (F("field")[:3][1:], [2, 3]), # Nested slicing.
615 (F("field")[:3][1], [2]), # Slice then index.
616 ]
617 for expression, expected in tests:
618 with self.subTest(expression=expression, expected=expected):
619 instance = IntegerArrayModel.objects.create(field=[1, 2, 3, 4])
620 instance.field = expression
621 instance.save()
622 instance.refresh_from_db()
623 self.assertEqual(instance.field, expected)
624
625 def test_slicing_of_f_expressions_with_annotate(self):
626 IntegerArrayModel.objects.create(field=[1, 2, 3])
627 annotated = IntegerArrayModel.objects.annotate(
628 first_two=F("field")[:2],
629 after_two=F("field")[2:],
630 random_two=F("field")[1:3],
631 ).get()
632 self.assertEqual(annotated.first_two, [1, 2])
633 self.assertEqual(annotated.after_two, [3])
634 self.assertEqual(annotated.random_two, [2, 3])
635
636 def test_slicing_of_f_expressions_with_len(self):
637 queryset = NullableIntegerArrayModel.objects.annotate(
638 subarray=F("field")[:1]
639 ).filter(field__len=F("subarray__len"))
640 self.assertSequenceEqual(queryset, self.objs[:2])
641
642 def test_usage_in_subquery(self):
643 self.assertSequenceEqual(
644 NullableIntegerArrayModel.objects.filter(
645 id__in=NullableIntegerArrayModel.objects.filter(field__len=3)
646 ),
647 [self.objs[3]],
648 )
649
650 def test_enum_lookup(self):
651 class TestEnum(enum.Enum):
652 VALUE_1 = "value_1"
653
654 instance = ArrayEnumModel.objects.create(array_of_enums=[TestEnum.VALUE_1])
655 self.assertSequenceEqual(
656 ArrayEnumModel.objects.filter(array_of_enums__contains=[TestEnum.VALUE_1]),
657 [instance],
658 )
659
660 def test_unsupported_lookup(self):
661 msg = (
662 "Unsupported lookup '0_bar' for ArrayField or join on the field not "
663 "permitted."
664 )
665 with self.assertRaisesMessage(FieldError, msg):
666 list(NullableIntegerArrayModel.objects.filter(field__0_bar=[2]))
667
668 msg = (
669 "Unsupported lookup '0bar' for ArrayField or join on the field not "
670 "permitted."
671 )
672 with self.assertRaisesMessage(FieldError, msg):
673 list(NullableIntegerArrayModel.objects.filter(field__0bar=[2]))
674
675 def test_grouping_by_annotations_with_array_field_param(self):
676 value = models.Value([1], output_field=ArrayField(models.IntegerField()))
677 self.assertEqual(
678 NullableIntegerArrayModel.objects.annotate(
679 array_length=models.Func(
680 value,
681 1,
682 function="ARRAY_LENGTH",
683 output_field=models.IntegerField(),
684 ),
685 )
686 .values("array_length")
687 .annotate(
688 count=models.Count("pk"),
689 )
690 .get()["array_length"],
691 1,
692 )
693
694 def test_filter_by_array_subquery(self):
695 inner_qs = NullableIntegerArrayModel.objects.filter(
696 field__len=models.OuterRef("field__len"),
697 ).values("field")
698 self.assertSequenceEqual(
699 NullableIntegerArrayModel.objects.alias(
700 same_sized_fields=ArraySubquery(inner_qs),
701 ).filter(same_sized_fields__len__gt=1),
702 self.objs[0:2],
703 )
704
705 def test_annotated_array_subquery(self):
706 inner_qs = NullableIntegerArrayModel.objects.exclude(
707 pk=models.OuterRef("pk")
708 ).values("order")
709 self.assertSequenceEqual(
710 NullableIntegerArrayModel.objects.annotate(
711 sibling_ids=ArraySubquery(inner_qs),
712 )
713 .get(order=1)
714 .sibling_ids,
715 [2, 3, 4, 5],
716 )
717
718 def test_group_by_with_annotated_array_subquery(self):
719 inner_qs = NullableIntegerArrayModel.objects.exclude(
720 pk=models.OuterRef("pk")
721 ).values("order")
722 self.assertSequenceEqual(
723 NullableIntegerArrayModel.objects.annotate(
724 sibling_ids=ArraySubquery(inner_qs),
725 sibling_count=models.Max("sibling_ids__len"),
726 ).values_list("sibling_count", flat=True),
727 [len(self.objs) - 1] * len(self.objs),
728 )
729
730 def test_annotated_ordered_array_subquery(self):
731 inner_qs = NullableIntegerArrayModel.objects.order_by("-order").values("order")
732 self.assertSequenceEqual(
733 NullableIntegerArrayModel.objects.annotate(
734 ids=ArraySubquery(inner_qs),
735 )
736 .first()
737 .ids,
738 [5, 4, 3, 2, 1],
739 )
740
741 def test_annotated_array_subquery_with_json_objects(self):
742 inner_qs = NullableIntegerArrayModel.objects.exclude(
743 pk=models.OuterRef("pk")
744 ).values(json=JSONObject(order="order", field="field"))
745 siblings_json = (
746 NullableIntegerArrayModel.objects.annotate(
747 siblings_json=ArraySubquery(inner_qs),
748 )
749 .values_list("siblings_json", flat=True)
750 .get(order=1)
751 )
752 self.assertSequenceEqual(
753 siblings_json,
754 [
755 {"field": [2], "order": 2},
756 {"field": [2, 3], "order": 3},
757 {"field": [20, 30, 40], "order": 4},
758 {"field": None, "order": 5},
759 ],
760 )
761
762
763 class TestDateTimeExactQuerying(PostgreSQLTestCase):
764 @classmethod
765 def setUpTestData(cls):
766 now = timezone.now()
767 cls.datetimes = [now]
768 cls.dates = [now.date()]
769 cls.times = [now.time()]
770 cls.objs = [
771 DateTimeArrayModel.objects.create(
772 datetimes=cls.datetimes, dates=cls.dates, times=cls.times
773 ),
774 ]
775
776 def test_exact_datetimes(self):
777 self.assertSequenceEqual(
778 DateTimeArrayModel.objects.filter(datetimes=self.datetimes), self.objs
779 )
780
781 def test_exact_dates(self):
782 self.assertSequenceEqual(
783 DateTimeArrayModel.objects.filter(dates=self.dates), self.objs
784 )
785
786 def test_exact_times(self):
787 self.assertSequenceEqual(
788 DateTimeArrayModel.objects.filter(times=self.times), self.objs
789 )
790
791
792 class TestOtherTypesExactQuerying(PostgreSQLTestCase):
793 @classmethod
794 def setUpTestData(cls):
795 cls.ips = ["192.168.0.1", "::1"]
796 cls.uuids = [uuid.uuid4()]
797 cls.decimals = [decimal.Decimal(1.25), 1.75]
798 cls.tags = [Tag(1), Tag(2), Tag(3)]
799 cls.objs = [
800 OtherTypesArrayModel.objects.create(
801 ips=cls.ips,
802 uuids=cls.uuids,
803 decimals=cls.decimals,
804 tags=cls.tags,
805 )
806 ]
807
808 def test_exact_ip_addresses(self):
809 self.assertSequenceEqual(
810 OtherTypesArrayModel.objects.filter(ips=self.ips), self.objs
811 )
812
813 def test_exact_uuids(self):
814 self.assertSequenceEqual(
815 OtherTypesArrayModel.objects.filter(uuids=self.uuids), self.objs
816 )
817
818 def test_exact_decimals(self):
819 self.assertSequenceEqual(
820 OtherTypesArrayModel.objects.filter(decimals=self.decimals), self.objs
821 )
822
823 def test_exact_tags(self):
824 self.assertSequenceEqual(
825 OtherTypesArrayModel.objects.filter(tags=self.tags), self.objs
826 )
827
828
829 @isolate_apps("postgres_tests")
830 class TestChecks(PostgreSQLSimpleTestCase):
831 def test_field_checks(self):
832 class MyModel(PostgreSQLModel):
833 field = ArrayField(models.CharField(max_length=-1))
834
835 model = MyModel()
836 errors = model.check()
837 self.assertEqual(len(errors), 1)
838 # The inner CharField has a non-positive max_length.
839 self.assertEqual(errors[0].id, "postgres.E001")
840 self.assertIn("max_length", errors[0].msg)
841
842 def test_invalid_base_fields(self):
843 class MyModel(PostgreSQLModel):
844 field = ArrayField(
845 models.ManyToManyField("postgres_tests.IntegerArrayModel")
846 )
847
848 model = MyModel()
849 errors = model.check()
850 self.assertEqual(len(errors), 1)
851 self.assertEqual(errors[0].id, "postgres.E002")
852
853 def test_invalid_default(self):
854 class MyModel(PostgreSQLModel):
855 field = ArrayField(models.IntegerField(), default=[])
856
857 model = MyModel()
858 self.assertEqual(
859 model.check(),
860 [
861 checks.Warning(
862 msg=(
863 "ArrayField default should be a callable instead of an "
864 "instance so that it's not shared between all field "
865 "instances."
866 ),
867 hint="Use a callable instead, e.g., use `list` instead of `[]`.",
868 obj=MyModel._meta.get_field("field"),
869 id="fields.E010",
870 )
871 ],
872 )
873
874 def test_valid_default(self):
875 class MyModel(PostgreSQLModel):
876 field = ArrayField(models.IntegerField(), default=list)
877
878 model = MyModel()
879 self.assertEqual(model.check(), [])
880
881 def test_valid_default_none(self):
882 class MyModel(PostgreSQLModel):
883 field = ArrayField(models.IntegerField(), default=None)
884
885 model = MyModel()
886 self.assertEqual(model.check(), [])
887
888 def test_nested_field_checks(self):
889 """
890 Nested ArrayFields are permitted.
891 """
892
893 class MyModel(PostgreSQLModel):
894 field = ArrayField(ArrayField(models.CharField(max_length=-1)))
895
896 model = MyModel()
897 errors = model.check()
898 self.assertEqual(len(errors), 1)
899 # The inner CharField has a non-positive max_length.
900 self.assertEqual(errors[0].id, "postgres.E001")
901 self.assertIn("max_length", errors[0].msg)
902
903 def test_choices_tuple_list(self):
904 class MyModel(PostgreSQLModel):
905 field = ArrayField(
906 models.CharField(max_length=16),
907 choices=[
908 [
909 "Media",
910 [(["vinyl", "cd"], "Audio"), (("vhs", "dvd"), "Video")],
911 ],
912 (["mp3", "mp4"], "Digital"),
913 ],
914 )
915
916 self.assertEqual(MyModel._meta.get_field("field").check(), [])
917
918
919 @unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests")
920 class TestMigrations(TransactionTestCase):
921 available_apps = ["postgres_tests"]
922
923 def test_deconstruct(self):
924 field = ArrayField(models.IntegerField())
925 name, path, args, kwargs = field.deconstruct()
926 new = ArrayField(*args, **kwargs)
927 self.assertEqual(type(new.base_field), type(field.base_field))
928 self.assertIsNot(new.base_field, field.base_field)
929
930 def test_deconstruct_with_size(self):
931 field = ArrayField(models.IntegerField(), size=3)
932 name, path, args, kwargs = field.deconstruct()
933 new = ArrayField(*args, **kwargs)
934 self.assertEqual(new.size, field.size)
935
936 def test_deconstruct_args(self):
937 field = ArrayField(models.CharField(max_length=20))
938 name, path, args, kwargs = field.deconstruct()
939 new = ArrayField(*args, **kwargs)
940 self.assertEqual(new.base_field.max_length, field.base_field.max_length)
941
942 def test_subclass_deconstruct(self):
943 field = ArrayField(models.IntegerField())
944 name, path, args, kwargs = field.deconstruct()
945 self.assertEqual(path, "django.contrib.postgres.fields.ArrayField")
946
947 field = ArrayFieldSubclass()
948 name, path, args, kwargs = field.deconstruct()
949 self.assertEqual(path, "postgres_tests.models.ArrayFieldSubclass")
950
951 @override_settings(
952 MIGRATION_MODULES={
953 "postgres_tests": "postgres_tests.array_default_migrations",
954 }
955 )
956 def test_adding_field_with_default(self):
957 # See #22962
958 table_name = "postgres_tests_integerarraydefaultmodel"
959 with connection.cursor() as cursor:
960 self.assertNotIn(table_name, connection.introspection.table_names(cursor))
961 call_command("migrate", "postgres_tests", verbosity=0)
962 with connection.cursor() as cursor:
963 self.assertIn(table_name, connection.introspection.table_names(cursor))
964 call_command("migrate", "postgres_tests", "zero", verbosity=0)
965 with connection.cursor() as cursor:
966 self.assertNotIn(table_name, connection.introspection.table_names(cursor))
967
968 @override_settings(
969 MIGRATION_MODULES={
970 "postgres_tests": "postgres_tests.array_index_migrations",
971 }
972 )
973 def test_adding_arrayfield_with_index(self):
974 """
975 ArrayField shouldn't have varchar_patterns_ops or text_patterns_ops indexes.
976 """
977 table_name = "postgres_tests_chartextarrayindexmodel"
978 call_command("migrate", "postgres_tests", verbosity=0)
979 with connection.cursor() as cursor:
980 like_constraint_columns_list = [
981 v["columns"]
982 for k, v in list(
983 connection.introspection.get_constraints(cursor, table_name).items()
984 )
985 if k.endswith("_like")
986 ]
987 # Only the CharField should have a LIKE index.
988 self.assertEqual(like_constraint_columns_list, [["char2"]])
989 # All fields should have regular indexes.
990 with connection.cursor() as cursor:
991 indexes = [
992 c["columns"][0]
993 for c in connection.introspection.get_constraints(
994 cursor, table_name
995 ).values()
996 if c["index"] and len(c["columns"]) == 1
997 ]
998 self.assertIn("char", indexes)
999 self.assertIn("char2", indexes)
1000 self.assertIn("text", indexes)
1001 call_command("migrate", "postgres_tests", "zero", verbosity=0)
1002 with connection.cursor() as cursor:
1003 self.assertNotIn(table_name, connection.introspection.table_names(cursor))
1004
1005
1006 class TestSerialization(PostgreSQLSimpleTestCase):
1007 test_data = (
1008 '[{"fields": {"field": "[\\"1\\", \\"2\\", null]"}, '
1009 '"model": "postgres_tests.integerarraymodel", "pk": null}]'
1010 )
1011
1012 def test_dumping(self):
1013 instance = IntegerArrayModel(field=[1, 2, None])
1014 data = serializers.serialize("json", [instance])
1015 self.assertEqual(json.loads(data), json.loads(self.test_data))
1016
1017 def test_loading(self):
1018 instance = list(serializers.deserialize("json", self.test_data))[0].object
1019 self.assertEqual(instance.field, [1, 2, None])
1020
1021
1022 class TestStringSerialization(PostgreSQLSimpleTestCase):
1023 field_values = [["Django", "Python", None], ["Джанго", "פייתון", None, "król"]]
1024
1025 @staticmethod
1026 def create_json_data(array_field_value):
1027 fields = {"field": json.dumps(array_field_value, ensure_ascii=False)}
1028 return json.dumps(
1029 [{"model": "postgres_tests.chararraymodel", "pk": None, "fields": fields}]
1030 )
1031
1032 def test_encode(self):
1033 for field_value in self.field_values:
1034 with self.subTest(field_value=field_value):
1035 instance = CharArrayModel(field=field_value)
1036 data = serializers.serialize("json", [instance])
1037 json_data = self.create_json_data(field_value)
1038 self.assertEqual(json.loads(data), json.loads(json_data))
1039
1040 def test_decode(self):
1041 for field_value in self.field_values:
1042 with self.subTest(field_value=field_value):
1043 json_data = self.create_json_data(field_value)
1044 instance = list(serializers.deserialize("json", json_data))[0].object
1045 self.assertEqual(instance.field, field_value)
1046
1047
1048 class TestValidation(PostgreSQLSimpleTestCase):
1049 def test_unbounded(self):
1050 field = ArrayField(models.IntegerField())
1051 with self.assertRaises(exceptions.ValidationError) as cm:
1052 field.clean([1, None], None)
1053 self.assertEqual(cm.exception.code, "item_invalid")
1054 self.assertEqual(
1055 cm.exception.message % cm.exception.params,
1056 "Item 2 in the array did not validate: This field cannot be null.",
1057 )
1058
1059 def test_blank_true(self):
1060 field = ArrayField(models.IntegerField(blank=True, null=True))
1061 # This should not raise a validation error
1062 field.clean([1, None], None)
1063
1064 def test_with_size(self):
1065 field = ArrayField(models.IntegerField(), size=3)
1066 field.clean([1, 2, 3], None)
1067 with self.assertRaises(exceptions.ValidationError) as cm:
1068 field.clean([1, 2, 3, 4], None)
1069 self.assertEqual(
1070 cm.exception.messages[0],
1071 "List contains 4 items, it should contain no more than 3.",
1072 )
1073
1074 def test_with_size_singular(self):
1075 field = ArrayField(models.IntegerField(), size=1)
1076 field.clean([1], None)
1077 msg = "List contains 2 items, it should contain no more than 1."
1078 with self.assertRaisesMessage(exceptions.ValidationError, msg):
1079 field.clean([1, 2], None)
1080
1081 def test_nested_array_mismatch(self):
1082 field = ArrayField(ArrayField(models.IntegerField()))
1083 field.clean([[1, 2], [3, 4]], None)
1084 with self.assertRaises(exceptions.ValidationError) as cm:
1085 field.clean([[1, 2], [3, 4, 5]], None)
1086 self.assertEqual(cm.exception.code, "nested_array_mismatch")
1087 self.assertEqual(
1088 cm.exception.messages[0], "Nested arrays must have the same length."
1089 )
1090
1091 def test_with_base_field_error_params(self):
1092 field = ArrayField(models.CharField(max_length=2))
1093 with self.assertRaises(exceptions.ValidationError) as cm:
1094 field.clean(["abc"], None)
1095 self.assertEqual(len(cm.exception.error_list), 1)
1096 exception = cm.exception.error_list[0]
1097 self.assertEqual(
1098 exception.message,
1099 "Item 1 in the array did not validate: Ensure this value has at most 2 "
1100 "characters (it has 3).",
1101 )
1102 self.assertEqual(exception.code, "item_invalid")
1103 self.assertEqual(
1104 exception.params,
1105 {"nth": 1, "value": "abc", "limit_value": 2, "show_value": 3},
1106 )
1107
1108 def test_with_validators(self):
1109 field = ArrayField(
1110 models.IntegerField(validators=[validators.MinValueValidator(1)])
1111 )
1112 field.clean([1, 2], None)
1113 with self.assertRaises(exceptions.ValidationError) as cm:
1114 field.clean([0], None)
1115 self.assertEqual(len(cm.exception.error_list), 1)
1116 exception = cm.exception.error_list[0]
1117 self.assertEqual(
1118 exception.message,
1119 "Item 1 in the array did not validate: Ensure this value is greater than "
1120 "or equal to 1.",
1121 )
1122 self.assertEqual(exception.code, "item_invalid")
1123 self.assertEqual(
1124 exception.params, {"nth": 1, "value": 0, "limit_value": 1, "show_value": 0}
1125 )
1126
1127
1128 class TestSimpleFormField(PostgreSQLSimpleTestCase):
1129 def test_valid(self):
1130 field = SimpleArrayField(forms.CharField())
1131 value = field.clean("a,b,c")
1132 self.assertEqual(value, ["a", "b", "c"])
1133
1134 def test_to_python_fail(self):
1135 field = SimpleArrayField(forms.IntegerField())
1136 with self.assertRaises(exceptions.ValidationError) as cm:
1137 field.clean("a,b,9")
1138 self.assertEqual(
1139 cm.exception.messages[0],
1140 "Item 1 in the array did not validate: Enter a whole number.",
1141 )
1142
1143 def test_validate_fail(self):
1144 field = SimpleArrayField(forms.CharField(required=True))
1145 with self.assertRaises(exceptions.ValidationError) as cm:
1146 field.clean("a,b,")
1147 self.assertEqual(
1148 cm.exception.messages[0],
1149 "Item 3 in the array did not validate: This field is required.",
1150 )
1151
1152 def test_validate_fail_base_field_error_params(self):
1153 field = SimpleArrayField(forms.CharField(max_length=2))
1154 with self.assertRaises(exceptions.ValidationError) as cm:
1155 field.clean("abc,c,defg")
1156 errors = cm.exception.error_list
1157 self.assertEqual(len(errors), 2)
1158 first_error = errors[0]
1159 self.assertEqual(
1160 first_error.message,
1161 "Item 1 in the array did not validate: Ensure this value has at most 2 "
1162 "characters (it has 3).",
1163 )
1164 self.assertEqual(first_error.code, "item_invalid")
1165 self.assertEqual(
1166 first_error.params,
1167 {"nth": 1, "value": "abc", "limit_value": 2, "show_value": 3},
1168 )
1169 second_error = errors[1]
1170 self.assertEqual(
1171 second_error.message,
1172 "Item 3 in the array did not validate: Ensure this value has at most 2 "
1173 "characters (it has 4).",
1174 )
1175 self.assertEqual(second_error.code, "item_invalid")
1176 self.assertEqual(
1177 second_error.params,
1178 {"nth": 3, "value": "defg", "limit_value": 2, "show_value": 4},
1179 )
1180
1181 def test_validators_fail(self):
1182 field = SimpleArrayField(forms.RegexField("[a-e]{2}"))
1183 with self.assertRaises(exceptions.ValidationError) as cm:
1184 field.clean("a,bc,de")
1185 self.assertEqual(
1186 cm.exception.messages[0],
1187 "Item 1 in the array did not validate: Enter a valid value.",
1188 )
1189
1190 def test_delimiter(self):
1191 field = SimpleArrayField(forms.CharField(), delimiter="|")
1192 value = field.clean("a|b|c")
1193 self.assertEqual(value, ["a", "b", "c"])
1194
1195 def test_delimiter_with_nesting(self):
1196 field = SimpleArrayField(SimpleArrayField(forms.CharField()), delimiter="|")
1197 value = field.clean("a,b|c,d")
1198 self.assertEqual(value, [["a", "b"], ["c", "d"]])
1199
1200 def test_prepare_value(self):
1201 field = SimpleArrayField(forms.CharField())
1202 value = field.prepare_value(["a", "b", "c"])
1203 self.assertEqual(value, "a,b,c")
1204
1205 def test_max_length(self):
1206 field = SimpleArrayField(forms.CharField(), max_length=2)
1207 with self.assertRaises(exceptions.ValidationError) as cm:
1208 field.clean("a,b,c")
1209 self.assertEqual(
1210 cm.exception.messages[0],
1211 "List contains 3 items, it should contain no more than 2.",
1212 )
1213
1214 def test_min_length(self):
1215 field = SimpleArrayField(forms.CharField(), min_length=4)
1216 with self.assertRaises(exceptions.ValidationError) as cm:
1217 field.clean("a,b,c")
1218 self.assertEqual(
1219 cm.exception.messages[0],
1220 "List contains 3 items, it should contain no fewer than 4.",
1221 )
1222
1223 def test_min_length_singular(self):
1224 field = SimpleArrayField(forms.IntegerField(), min_length=2)
1225 field.clean([1, 2])
1226 msg = "List contains 1 item, it should contain no fewer than 2."
1227 with self.assertRaisesMessage(exceptions.ValidationError, msg):
1228 field.clean([1])
1229
1230 def test_required(self):
1231 field = SimpleArrayField(forms.CharField(), required=True)
1232 with self.assertRaises(exceptions.ValidationError) as cm:
1233 field.clean("")
1234 self.assertEqual(cm.exception.messages[0], "This field is required.")
1235
1236 def test_model_field_formfield(self):
1237 model_field = ArrayField(models.CharField(max_length=27))
1238 form_field = model_field.formfield()
1239 self.assertIsInstance(form_field, SimpleArrayField)
1240 self.assertIsInstance(form_field.base_field, forms.CharField)
1241 self.assertEqual(form_field.base_field.max_length, 27)
1242
1243 def test_model_field_formfield_size(self):
1244 model_field = ArrayField(models.CharField(max_length=27), size=4)
1245 form_field = model_field.formfield()
1246 self.assertIsInstance(form_field, SimpleArrayField)
1247 self.assertEqual(form_field.max_length, 4)
1248
1249 def test_model_field_choices(self):
1250 model_field = ArrayField(models.IntegerField(choices=((1, "A"), (2, "B"))))
1251 form_field = model_field.formfield()
1252 self.assertEqual(form_field.clean("1,2"), [1, 2])
1253
1254 def test_already_converted_value(self):
1255 field = SimpleArrayField(forms.CharField())
1256 vals = ["a", "b", "c"]
1257 self.assertEqual(field.clean(vals), vals)
1258
1259 def test_has_changed(self):
1260 field = SimpleArrayField(forms.IntegerField())
1261 self.assertIs(field.has_changed([1, 2], [1, 2]), False)
1262 self.assertIs(field.has_changed([1, 2], "1,2"), False)
1263 self.assertIs(field.has_changed([1, 2], "1,2,3"), True)
1264 self.assertIs(field.has_changed([1, 2], "a,b"), True)
1265
1266 def test_has_changed_empty(self):
1267 field = SimpleArrayField(forms.CharField())
1268 self.assertIs(field.has_changed(None, None), False)
1269 self.assertIs(field.has_changed(None, ""), False)
1270 self.assertIs(field.has_changed(None, []), False)
1271 self.assertIs(field.has_changed([], None), False)
1272 self.assertIs(field.has_changed([], ""), False)
1273
1274
1275 class TestSplitFormField(PostgreSQLSimpleTestCase):
1276 def test_valid(self):
1277 class SplitForm(forms.Form):
1278 array = SplitArrayField(forms.CharField(), size=3)
1279
1280 data = {"array_0": "a", "array_1": "b", "array_2": "c"}
1281 form = SplitForm(data)
1282 self.assertTrue(form.is_valid())
1283 self.assertEqual(form.cleaned_data, {"array": ["a", "b", "c"]})
1284
1285 def test_required(self):
1286 class SplitForm(forms.Form):
1287 array = SplitArrayField(forms.CharField(), required=True, size=3)
1288
1289 data = {"array_0": "", "array_1": "", "array_2": ""}
1290 form = SplitForm(data)
1291 self.assertFalse(form.is_valid())
1292 self.assertEqual(form.errors, {"array": ["This field is required."]})
1293
1294 def test_remove_trailing_nulls(self):
1295 class SplitForm(forms.Form):
1296 array = SplitArrayField(
1297 forms.CharField(required=False), size=5, remove_trailing_nulls=True
1298 )
1299
1300 data = {
1301 "array_0": "a",
1302 "array_1": "",
1303 "array_2": "b",
1304 "array_3": "",
1305 "array_4": "",
1306 }
1307 form = SplitForm(data)
1308 self.assertTrue(form.is_valid(), form.errors)
1309 self.assertEqual(form.cleaned_data, {"array": ["a", "", "b"]})
1310
1311 def test_remove_trailing_nulls_not_required(self):
1312 class SplitForm(forms.Form):
1313 array = SplitArrayField(
1314 forms.CharField(required=False),
1315 size=2,
1316 remove_trailing_nulls=True,
1317 required=False,
1318 )
1319
1320 data = {"array_0": "", "array_1": ""}
1321 form = SplitForm(data)
1322 self.assertTrue(form.is_valid())
1323 self.assertEqual(form.cleaned_data, {"array": []})
1324
1325 def test_required_field(self):
1326 class SplitForm(forms.Form):
1327 array = SplitArrayField(forms.CharField(), size=3)
1328
1329 data = {"array_0": "a", "array_1": "b", "array_2": ""}
1330 form = SplitForm(data)
1331 self.assertFalse(form.is_valid())
1332 self.assertEqual(
1333 form.errors,
1334 {
1335 "array": [
1336 "Item 3 in the array did not validate: This field is required."
1337 ]
1338 },
1339 )
1340
1341 def test_invalid_integer(self):
1342 msg = (
1343 "Item 2 in the array did not validate: Ensure this value is less than or "
1344 "equal to 100."
1345 )
1346 with self.assertRaisesMessage(exceptions.ValidationError, msg):
1347 SplitArrayField(forms.IntegerField(max_value=100), size=2).clean([0, 101])
1348
1349 def test_rendering(self):
1350 class SplitForm(forms.Form):
1351 array = SplitArrayField(forms.CharField(), size=3)
1352
1353 self.assertHTMLEqual(
1354 str(SplitForm()),
1355 """
1356 <div>
1357 <label for="id_array_0">Array:</label>
1358 <input id="id_array_0" name="array_0" type="text" required>
1359 <input id="id_array_1" name="array_1" type="text" required>
1360 <input id="id_array_2" name="array_2" type="text" required>
1361 </div>
1362 """,
1363 )
1364
1365 def test_invalid_char_length(self):
1366 field = SplitArrayField(forms.CharField(max_length=2), size=3)
1367 with self.assertRaises(exceptions.ValidationError) as cm:
1368 field.clean(["abc", "c", "defg"])
1369 self.assertEqual(
1370 cm.exception.messages,
1371 [
1372 "Item 1 in the array did not validate: Ensure this value has at most 2 "
1373 "characters (it has 3).",
1374 "Item 3 in the array did not validate: Ensure this value has at most 2 "
1375 "characters (it has 4).",
1376 ],
1377 )
1378
1379 def test_invalid_char_length_with_remove_trailing_nulls(self):
1380 field = SplitArrayField(
1381 forms.CharField(max_length=2, required=False),
1382 size=3,
1383 remove_trailing_nulls=True,
1384 )
1385 with self.assertRaises(exceptions.ValidationError) as cm:
1386 field.clean(["abc", "", ""])
1387 self.assertEqual(
1388 cm.exception.messages,
1389 [
1390 "Item 1 in the array did not validate: Ensure this value has at most 2 "
1391 "characters (it has 3).",
1392 ],
1393 )
1394
1395 def test_splitarraywidget_value_omitted_from_data(self):
1396 class Form(forms.ModelForm):
1397 field = SplitArrayField(forms.IntegerField(), required=False, size=2)
1398
1399 class Meta:
1400 model = IntegerArrayModel
1401 fields = ("field",)
1402
1403 form = Form({"field_0": "1", "field_1": "2"})
1404 self.assertEqual(form.errors, {})
1405 obj = form.save(commit=False)
1406 self.assertEqual(obj.field, [1, 2])
1407
1408 def test_splitarrayfield_has_changed(self):
1409 class Form(forms.ModelForm):
1410 field = SplitArrayField(forms.IntegerField(), required=False, size=2)
1411
1412 class Meta:
1413 model = IntegerArrayModel
1414 fields = ("field",)
1415
1416 tests = [
1417 ({}, {"field_0": "", "field_1": ""}, True),
1418 ({"field": None}, {"field_0": "", "field_1": ""}, True),
1419 ({"field": [1]}, {"field_0": "", "field_1": ""}, True),
1420 ({"field": [1]}, {"field_0": "1", "field_1": "0"}, True),
1421 ({"field": [1, 2]}, {"field_0": "1", "field_1": "2"}, False),
1422 ({"field": [1, 2]}, {"field_0": "a", "field_1": "b"}, True),
1423 ]
1424 for initial, data, expected_result in tests:
1425 with self.subTest(initial=initial, data=data):
1426 obj = IntegerArrayModel(**initial)
1427 form = Form(data, instance=obj)
1428 self.assertIs(form.has_changed(), expected_result)
1429
1430 def test_splitarrayfield_remove_trailing_nulls_has_changed(self):
1431 class Form(forms.ModelForm):
1432 field = SplitArrayField(
1433 forms.IntegerField(), required=False, size=2, remove_trailing_nulls=True
1434 )
1435
1436 class Meta:
1437 model = IntegerArrayModel
1438 fields = ("field",)
1439
1440 tests = [
1441 ({}, {"field_0": "", "field_1": ""}, False),
1442 ({"field": None}, {"field_0": "", "field_1": ""}, False),
1443 ({"field": []}, {"field_0": "", "field_1": ""}, False),
1444 ({"field": [1]}, {"field_0": "1", "field_1": ""}, False),
1445 ]
1446 for initial, data, expected_result in tests:
1447 with self.subTest(initial=initial, data=data):
1448 obj = IntegerArrayModel(**initial)
1449 form = Form(data, instance=obj)
1450 self.assertIs(form.has_changed(), expected_result)
1451
1452
1453 class TestSplitFormWidget(PostgreSQLWidgetTestCase):
1454 def test_get_context(self):
1455 self.assertEqual(
1456 SplitArrayWidget(forms.TextInput(), size=2).get_context(
1457 "name", ["val1", "val2"]
1458 ),
1459 {
1460 "widget": {
1461 "name": "name",
1462 "is_hidden": False,
1463 "required": False,
1464 "value": "['val1', 'val2']",
1465 "attrs": {},
1466 "template_name": "postgres/widgets/split_array.html",
1467 "subwidgets": [
1468 {
1469 "name": "name_0",
1470 "is_hidden": False,
1471 "required": False,
1472 "value": "val1",
1473 "attrs": {},
1474 "template_name": "django/forms/widgets/text.html",
1475 "type": "text",
1476 },
1477 {
1478 "name": "name_1",
1479 "is_hidden": False,
1480 "required": False,
1481 "value": "val2",
1482 "attrs": {},
1483 "template_name": "django/forms/widgets/text.html",
1484 "type": "text",
1485 },
1486 ],
1487 }
1488 },
1489 )
1490
1491 def test_checkbox_get_context_attrs(self):
1492 context = SplitArrayWidget(
1493 forms.CheckboxInput(),
1494 size=2,
1495 ).get_context("name", [True, False])
1496 self.assertEqual(context["widget"]["value"], "[True, False]")
1497 self.assertEqual(
1498 [subwidget["attrs"] for subwidget in context["widget"]["subwidgets"]],
1499 [{"checked": True}, {}],
1500 )
1501
1502 def test_render(self):
1503 self.check_html(
1504 SplitArrayWidget(forms.TextInput(), size=2),
1505 "array",
1506 None,
1507 """
1508 <input name="array_0" type="text">
1509 <input name="array_1" type="text">
1510 """,
1511 )
1512
1513 def test_render_attrs(self):
1514 self.check_html(
1515 SplitArrayWidget(forms.TextInput(), size=2),
1516 "array",
1517 ["val1", "val2"],
1518 attrs={"id": "foo"},
1519 html=("""
1520 <input id="foo_0" name="array_0" type="text" value="val1">
1521 <input id="foo_1" name="array_1" type="text" value="val2">
1522 """),
1523 )
1524
1525 def test_value_omitted_from_data(self):
1526 widget = SplitArrayWidget(forms.TextInput(), size=2)
1527 self.assertIs(widget.value_omitted_from_data({}, {}, "field"), True)
1528 self.assertIs(
1529 widget.value_omitted_from_data({"field_0": "value"}, {}, "field"), False
1530 )
1531 self.assertIs(
1532 widget.value_omitted_from_data({"field_1": "value"}, {}, "field"), False
1533 )
1534 self.assertIs(
1535 widget.value_omitted_from_data(
1536 {"field_0": "value", "field_1": "value"}, {}, "field"
1537 ),
1538 False,
1539 )
1540
1541
1542 class TestAdminUtils(PostgreSQLTestCase):
1543 empty_value = "-empty-"
1544
1545 def test_array_display_for_field(self):
1546 array_field = ArrayField(models.IntegerField())
1547 display_value = display_for_field(
1548 [1, 2],
1549 array_field,
1550 self.empty_value,
1551 )
1552 self.assertEqual(display_value, "1, 2")
1553
1554 def test_array_with_choices_display_for_field(self):
1555 array_field = ArrayField(
1556 models.IntegerField(),
1557 choices=[
1558 ([1, 2, 3], "1st choice"),
1559 ([1, 2], "2nd choice"),
1560 ],
1561 )
1562
1563 display_value = display_for_field(
1564 [1, 2],
1565 array_field,
1566 self.empty_value,
1567 )
1568 self.assertEqual(display_value, "2nd choice")
1569
1570 display_value = display_for_field(
1571 [99, 99],
1572 array_field,
1573 self.empty_value,
1574 )
1575 self.assertEqual(display_value, self.empty_value)