mirror of
https://github.com/django/django.git
synced 2024-12-23 01:25:58 +00:00
65ad4ade74
Previously the order was always extra_fields + model_fields + annotations with
respective local ordering inferred from the insertion order of *selected.
This commits introduces a new `Query.selected` propery that keeps tracks of the
global select order as specified by on values assignment. This is crucial
feature to allow the combination of queries mixing annotations and table
references.
It also allows the removal of the re-ordering shenanigans perform by
ValuesListIterable in order to re-map the tuples returned from the database
backend to the order specified by values_list() as they'll be in the right
order at query compilation time.
Refs #28553 as the initially reported issue that was only partially fixed
for annotations by d6b6e5d0fd.
Thanks Mariusz Felisiak and Sarah Boyce for review.
1525 lines
55 KiB
Python
1525 lines
55 KiB
Python
import decimal
|
|
import enum
|
|
import json
|
|
import unittest
|
|
import uuid
|
|
|
|
from django import forms
|
|
from django.contrib.admin.utils import display_for_field
|
|
from django.core import checks, exceptions, serializers, validators
|
|
from django.core.exceptions import FieldError
|
|
from django.core.management import call_command
|
|
from django.db import IntegrityError, connection, models
|
|
from django.db.models.expressions import Exists, F, OuterRef, RawSQL, Value
|
|
from django.db.models.functions import Cast, JSONObject, Upper
|
|
from django.test import TransactionTestCase, override_settings, skipUnlessDBFeature
|
|
from django.test.utils import isolate_apps
|
|
from django.utils import timezone
|
|
|
|
from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase, PostgreSQLWidgetTestCase
|
|
from .models import (
|
|
ArrayEnumModel,
|
|
ArrayFieldSubclass,
|
|
CharArrayModel,
|
|
DateTimeArrayModel,
|
|
IntegerArrayModel,
|
|
NestedIntegerArrayModel,
|
|
NullableIntegerArrayModel,
|
|
OtherTypesArrayModel,
|
|
PostgreSQLModel,
|
|
Tag,
|
|
)
|
|
|
|
try:
|
|
from django.contrib.postgres.aggregates import ArrayAgg
|
|
from django.contrib.postgres.expressions import ArraySubquery
|
|
from django.contrib.postgres.fields import ArrayField
|
|
from django.contrib.postgres.fields.array import IndexTransform, SliceTransform
|
|
from django.contrib.postgres.forms import (
|
|
SimpleArrayField,
|
|
SplitArrayField,
|
|
SplitArrayWidget,
|
|
)
|
|
from django.db.backends.postgresql.psycopg_any import NumericRange
|
|
except ImportError:
|
|
pass
|
|
|
|
|
|
@isolate_apps("postgres_tests")
|
|
class BasicTests(PostgreSQLSimpleTestCase):
|
|
def test_get_field_display(self):
|
|
class MyModel(PostgreSQLModel):
|
|
field = ArrayField(
|
|
models.CharField(max_length=16),
|
|
choices=[
|
|
["Media", [(["vinyl", "cd"], "Audio")]],
|
|
(("mp3", "mp4"), "Digital"),
|
|
],
|
|
)
|
|
|
|
tests = (
|
|
(["vinyl", "cd"], "Audio"),
|
|
(("mp3", "mp4"), "Digital"),
|
|
(("a", "b"), "('a', 'b')"),
|
|
(["c", "d"], "['c', 'd']"),
|
|
)
|
|
for value, display in tests:
|
|
with self.subTest(value=value, display=display):
|
|
instance = MyModel(field=value)
|
|
self.assertEqual(instance.get_field_display(), display)
|
|
|
|
def test_get_field_display_nested_array(self):
|
|
class MyModel(PostgreSQLModel):
|
|
field = ArrayField(
|
|
ArrayField(models.CharField(max_length=16)),
|
|
choices=[
|
|
[
|
|
"Media",
|
|
[([["vinyl", "cd"], ("x",)], "Audio")],
|
|
],
|
|
((["mp3"], ("mp4",)), "Digital"),
|
|
],
|
|
)
|
|
|
|
tests = (
|
|
([["vinyl", "cd"], ("x",)], "Audio"),
|
|
((["mp3"], ("mp4",)), "Digital"),
|
|
((("a", "b"), ("c",)), "(('a', 'b'), ('c',))"),
|
|
([["a", "b"], ["c"]], "[['a', 'b'], ['c']]"),
|
|
)
|
|
for value, display in tests:
|
|
with self.subTest(value=value, display=display):
|
|
instance = MyModel(field=value)
|
|
self.assertEqual(instance.get_field_display(), display)
|
|
|
|
|
|
class TestSaveLoad(PostgreSQLTestCase):
|
|
def test_integer(self):
|
|
instance = IntegerArrayModel(field=[1, 2, 3])
|
|
instance.save()
|
|
loaded = IntegerArrayModel.objects.get()
|
|
self.assertEqual(instance.field, loaded.field)
|
|
|
|
def test_char(self):
|
|
instance = CharArrayModel(field=["hello", "goodbye"])
|
|
instance.save()
|
|
loaded = CharArrayModel.objects.get()
|
|
self.assertEqual(instance.field, loaded.field)
|
|
|
|
def test_dates(self):
|
|
instance = DateTimeArrayModel(
|
|
datetimes=[timezone.now()],
|
|
dates=[timezone.now().date()],
|
|
times=[timezone.now().time()],
|
|
)
|
|
instance.save()
|
|
loaded = DateTimeArrayModel.objects.get()
|
|
self.assertEqual(instance.datetimes, loaded.datetimes)
|
|
self.assertEqual(instance.dates, loaded.dates)
|
|
self.assertEqual(instance.times, loaded.times)
|
|
|
|
def test_tuples(self):
|
|
instance = IntegerArrayModel(field=(1,))
|
|
instance.save()
|
|
loaded = IntegerArrayModel.objects.get()
|
|
self.assertSequenceEqual(instance.field, loaded.field)
|
|
|
|
def test_integers_passed_as_strings(self):
|
|
# This checks that get_prep_value is deferred properly
|
|
instance = IntegerArrayModel(field=["1"])
|
|
instance.save()
|
|
loaded = IntegerArrayModel.objects.get()
|
|
self.assertEqual(loaded.field, [1])
|
|
|
|
def test_default_null(self):
|
|
instance = NullableIntegerArrayModel()
|
|
instance.save()
|
|
loaded = NullableIntegerArrayModel.objects.get(pk=instance.pk)
|
|
self.assertIsNone(loaded.field)
|
|
self.assertEqual(instance.field, loaded.field)
|
|
|
|
def test_null_handling(self):
|
|
instance = NullableIntegerArrayModel(field=None)
|
|
instance.save()
|
|
loaded = NullableIntegerArrayModel.objects.get()
|
|
self.assertEqual(instance.field, loaded.field)
|
|
|
|
instance = IntegerArrayModel(field=None)
|
|
with self.assertRaises(IntegrityError):
|
|
instance.save()
|
|
|
|
def test_nested(self):
|
|
instance = NestedIntegerArrayModel(field=[[1, 2], [3, 4]])
|
|
instance.save()
|
|
loaded = NestedIntegerArrayModel.objects.get()
|
|
self.assertEqual(instance.field, loaded.field)
|
|
|
|
def test_other_array_types(self):
|
|
instance = OtherTypesArrayModel(
|
|
ips=["192.168.0.1", "::1"],
|
|
uuids=[uuid.uuid4()],
|
|
decimals=[decimal.Decimal(1.25), 1.75],
|
|
tags=[Tag(1), Tag(2), Tag(3)],
|
|
json=[{"a": 1}, {"b": 2}],
|
|
int_ranges=[NumericRange(10, 20), NumericRange(30, 40)],
|
|
bigint_ranges=[
|
|
NumericRange(7000000000, 10000000000),
|
|
NumericRange(50000000000, 70000000000),
|
|
],
|
|
)
|
|
instance.save()
|
|
loaded = OtherTypesArrayModel.objects.get()
|
|
self.assertEqual(instance.ips, loaded.ips)
|
|
self.assertEqual(instance.uuids, loaded.uuids)
|
|
self.assertEqual(instance.decimals, loaded.decimals)
|
|
self.assertEqual(instance.tags, loaded.tags)
|
|
self.assertEqual(instance.json, loaded.json)
|
|
self.assertEqual(instance.int_ranges, loaded.int_ranges)
|
|
self.assertEqual(instance.bigint_ranges, loaded.bigint_ranges)
|
|
|
|
def test_null_from_db_value_handling(self):
|
|
instance = OtherTypesArrayModel.objects.create(
|
|
ips=["192.168.0.1", "::1"],
|
|
uuids=[uuid.uuid4()],
|
|
decimals=[decimal.Decimal(1.25), 1.75],
|
|
tags=None,
|
|
)
|
|
instance.refresh_from_db()
|
|
self.assertIsNone(instance.tags)
|
|
self.assertEqual(instance.json, [])
|
|
self.assertIsNone(instance.int_ranges)
|
|
self.assertIsNone(instance.bigint_ranges)
|
|
|
|
def test_model_set_on_base_field(self):
|
|
instance = IntegerArrayModel()
|
|
field = instance._meta.get_field("field")
|
|
self.assertEqual(field.model, IntegerArrayModel)
|
|
self.assertEqual(field.base_field.model, IntegerArrayModel)
|
|
|
|
def test_nested_nullable_base_field(self):
|
|
instance = NullableIntegerArrayModel.objects.create(
|
|
field_nested=[[None, None], [None, None]],
|
|
)
|
|
self.assertEqual(instance.field_nested, [[None, None], [None, None]])
|
|
|
|
|
|
class TestQuerying(PostgreSQLTestCase):
|
|
@classmethod
|
|
def setUpTestData(cls):
|
|
cls.objs = NullableIntegerArrayModel.objects.bulk_create(
|
|
[
|
|
NullableIntegerArrayModel(order=1, field=[1]),
|
|
NullableIntegerArrayModel(order=2, field=[2]),
|
|
NullableIntegerArrayModel(order=3, field=[2, 3]),
|
|
NullableIntegerArrayModel(order=4, field=[20, 30, 40]),
|
|
NullableIntegerArrayModel(order=5, field=None),
|
|
]
|
|
)
|
|
|
|
def test_empty_list(self):
|
|
NullableIntegerArrayModel.objects.create(field=[])
|
|
obj = (
|
|
NullableIntegerArrayModel.objects.annotate(
|
|
empty_array=models.Value(
|
|
[], output_field=ArrayField(models.IntegerField())
|
|
),
|
|
)
|
|
.filter(field=models.F("empty_array"))
|
|
.get()
|
|
)
|
|
self.assertEqual(obj.field, [])
|
|
self.assertEqual(obj.empty_array, [])
|
|
|
|
def test_exact(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__exact=[1]), self.objs[:1]
|
|
)
|
|
|
|
def test_exact_null_only_array(self):
|
|
obj = NullableIntegerArrayModel.objects.create(
|
|
field=[None], field_nested=[None, None]
|
|
)
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__exact=[None]), [obj]
|
|
)
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field_nested__exact=[None, None]),
|
|
[obj],
|
|
)
|
|
|
|
def test_exact_null_only_nested_array(self):
|
|
obj1 = NullableIntegerArrayModel.objects.create(field_nested=[[None, None]])
|
|
obj2 = NullableIntegerArrayModel.objects.create(
|
|
field_nested=[[None, None], [None, None]],
|
|
)
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field_nested__exact=[[None, None]],
|
|
),
|
|
[obj1],
|
|
)
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field_nested__exact=[[None, None], [None, None]],
|
|
),
|
|
[obj2],
|
|
)
|
|
|
|
def test_exact_with_expression(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__exact=[Value(1)]),
|
|
self.objs[:1],
|
|
)
|
|
|
|
def test_exact_charfield(self):
|
|
instance = CharArrayModel.objects.create(field=["text"])
|
|
self.assertSequenceEqual(
|
|
CharArrayModel.objects.filter(field=["text"]), [instance]
|
|
)
|
|
|
|
def test_exact_nested(self):
|
|
instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
|
|
self.assertSequenceEqual(
|
|
NestedIntegerArrayModel.objects.filter(field=[[1, 2], [3, 4]]), [instance]
|
|
)
|
|
|
|
def test_isnull(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__isnull=True), self.objs[-1:]
|
|
)
|
|
|
|
def test_gt(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__gt=[0]), self.objs[:4]
|
|
)
|
|
|
|
def test_lt(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__lt=[2]), self.objs[:1]
|
|
)
|
|
|
|
def test_in(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__in=[[1], [2]]),
|
|
self.objs[:2],
|
|
)
|
|
|
|
def test_in_subquery(self):
|
|
IntegerArrayModel.objects.create(field=[2, 3])
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field__in=IntegerArrayModel.objects.values_list("field", flat=True)
|
|
),
|
|
self.objs[2:3],
|
|
)
|
|
|
|
@unittest.expectedFailure
|
|
def test_in_including_F_object(self):
|
|
# This test asserts that Array objects passed to filters can be
|
|
# constructed to contain F objects. This currently doesn't work as the
|
|
# psycopg mogrify method that generates the ARRAY() syntax is
|
|
# expecting literals, not column references (#27095).
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__in=[[models.F("id")]]),
|
|
self.objs[:2],
|
|
)
|
|
|
|
def test_in_as_F_object(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__in=[models.F("field")]),
|
|
self.objs[:4],
|
|
)
|
|
|
|
def test_contained_by(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__contained_by=[1, 2]),
|
|
self.objs[:2],
|
|
)
|
|
|
|
def test_contained_by_including_F_object(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field__contained_by=[models.F("order"), 2]
|
|
),
|
|
self.objs[:3],
|
|
)
|
|
|
|
def test_contains(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__contains=[2]),
|
|
self.objs[1:3],
|
|
)
|
|
|
|
def test_contains_subquery(self):
|
|
IntegerArrayModel.objects.create(field=[2, 3])
|
|
inner_qs = IntegerArrayModel.objects.values_list("field", flat=True)
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__contains=inner_qs[:1]),
|
|
self.objs[2:3],
|
|
)
|
|
inner_qs = IntegerArrayModel.objects.filter(field__contains=OuterRef("field"))
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(Exists(inner_qs)),
|
|
self.objs[1:3],
|
|
)
|
|
|
|
def test_contains_including_expression(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field__contains=[2, Value(6) / Value(2)],
|
|
),
|
|
self.objs[2:3],
|
|
)
|
|
|
|
def test_icontains(self):
|
|
# Using the __icontains lookup with ArrayField is inefficient.
|
|
instance = CharArrayModel.objects.create(field=["FoO"])
|
|
self.assertSequenceEqual(
|
|
CharArrayModel.objects.filter(field__icontains="foo"), [instance]
|
|
)
|
|
|
|
def test_contains_charfield(self):
|
|
# Regression for #22907
|
|
self.assertSequenceEqual(
|
|
CharArrayModel.objects.filter(field__contains=["text"]), []
|
|
)
|
|
|
|
def test_contained_by_charfield(self):
|
|
self.assertSequenceEqual(
|
|
CharArrayModel.objects.filter(field__contained_by=["text"]), []
|
|
)
|
|
|
|
def test_overlap_charfield(self):
|
|
self.assertSequenceEqual(
|
|
CharArrayModel.objects.filter(field__overlap=["text"]), []
|
|
)
|
|
|
|
def test_overlap_charfield_including_expression(self):
|
|
obj_1 = CharArrayModel.objects.create(field=["TEXT", "lower text"])
|
|
obj_2 = CharArrayModel.objects.create(field=["lower text", "TEXT"])
|
|
CharArrayModel.objects.create(field=["lower text", "text"])
|
|
self.assertSequenceEqual(
|
|
CharArrayModel.objects.filter(
|
|
field__overlap=[
|
|
Upper(Value("text")),
|
|
"other",
|
|
]
|
|
),
|
|
[obj_1, obj_2],
|
|
)
|
|
|
|
def test_overlap_values(self):
|
|
qs = NullableIntegerArrayModel.objects.filter(order__lt=3)
|
|
self.assertCountEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field__overlap=qs.values_list("field"),
|
|
),
|
|
self.objs[:3],
|
|
)
|
|
self.assertCountEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field__overlap=qs.values("field"),
|
|
),
|
|
self.objs[:3],
|
|
)
|
|
|
|
def test_lookups_autofield_array(self):
|
|
qs = (
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field__0__isnull=False,
|
|
)
|
|
.values("field__0")
|
|
.annotate(
|
|
arrayagg=ArrayAgg("id"),
|
|
)
|
|
.order_by("field__0")
|
|
)
|
|
tests = (
|
|
("contained_by", [self.objs[1].pk, self.objs[2].pk, 0], [2]),
|
|
("contains", [self.objs[2].pk], [2]),
|
|
("exact", [self.objs[3].pk], [20]),
|
|
("overlap", [self.objs[1].pk, self.objs[3].pk], [2, 20]),
|
|
)
|
|
for lookup, value, expected in tests:
|
|
with self.subTest(lookup=lookup):
|
|
self.assertSequenceEqual(
|
|
qs.filter(
|
|
**{"arrayagg__" + lookup: value},
|
|
).values_list("field__0", flat=True),
|
|
expected,
|
|
)
|
|
|
|
@skipUnlessDBFeature("allows_group_by_select_index")
|
|
def test_group_by_order_by_select_index(self):
|
|
with self.assertNumQueries(1) as ctx:
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field__0__isnull=False,
|
|
)
|
|
.values("field__0")
|
|
.annotate(arrayagg=ArrayAgg("id"))
|
|
.order_by("field__0"),
|
|
[
|
|
{"field__0": 1, "arrayagg": [self.objs[0].pk]},
|
|
{"field__0": 2, "arrayagg": [self.objs[1].pk, self.objs[2].pk]},
|
|
{"field__0": 20, "arrayagg": [self.objs[3].pk]},
|
|
],
|
|
)
|
|
sql = ctx[0]["sql"]
|
|
self.assertIn("GROUP BY 1", sql)
|
|
self.assertIn("ORDER BY 1", sql)
|
|
|
|
def test_order_by_arrayagg_index(self):
|
|
qs = (
|
|
NullableIntegerArrayModel.objects.values("order")
|
|
.annotate(ids=ArrayAgg("id"))
|
|
.order_by("-ids__0")
|
|
)
|
|
self.assertQuerySetEqual(
|
|
qs, [{"order": obj.order, "ids": [obj.id]} for obj in reversed(self.objs)]
|
|
)
|
|
|
|
def test_index(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__0=2), self.objs[1:3]
|
|
)
|
|
|
|
def test_index_chained(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__0__lt=3), self.objs[0:3]
|
|
)
|
|
|
|
def test_index_nested(self):
|
|
instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
|
|
self.assertSequenceEqual(
|
|
NestedIntegerArrayModel.objects.filter(field__0__0=1), [instance]
|
|
)
|
|
|
|
@unittest.expectedFailure
|
|
def test_index_used_on_nested_data(self):
|
|
instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
|
|
self.assertSequenceEqual(
|
|
NestedIntegerArrayModel.objects.filter(field__0=[1, 2]), [instance]
|
|
)
|
|
|
|
def test_index_transform_expression(self):
|
|
expr = RawSQL("string_to_array(%s, ';')", ["1;2"])
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field__0=Cast(
|
|
IndexTransform(1, models.IntegerField, expr),
|
|
output_field=models.IntegerField(),
|
|
),
|
|
),
|
|
self.objs[:1],
|
|
)
|
|
|
|
def test_index_annotation(self):
|
|
qs = NullableIntegerArrayModel.objects.annotate(second=models.F("field__1"))
|
|
self.assertCountEqual(
|
|
qs.values_list("second", flat=True),
|
|
[None, None, None, 3, 30],
|
|
)
|
|
|
|
def test_overlap(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__overlap=[1, 2]),
|
|
self.objs[0:3],
|
|
)
|
|
|
|
def test_len(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__len__lte=2), self.objs[0:3]
|
|
)
|
|
|
|
def test_len_empty_array(self):
|
|
obj = NullableIntegerArrayModel.objects.create(field=[])
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__len=0), [obj]
|
|
)
|
|
|
|
def test_slice(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__0_1=[2]), self.objs[1:3]
|
|
)
|
|
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(field__0_2=[2, 3]), self.objs[2:3]
|
|
)
|
|
|
|
def test_order_by_slice(self):
|
|
more_objs = (
|
|
NullableIntegerArrayModel.objects.create(field=[1, 637]),
|
|
NullableIntegerArrayModel.objects.create(field=[2, 1]),
|
|
NullableIntegerArrayModel.objects.create(field=[3, -98123]),
|
|
NullableIntegerArrayModel.objects.create(field=[4, 2]),
|
|
)
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.order_by("field__1"),
|
|
[
|
|
more_objs[2],
|
|
more_objs[1],
|
|
more_objs[3],
|
|
self.objs[2],
|
|
self.objs[3],
|
|
more_objs[0],
|
|
self.objs[4],
|
|
self.objs[1],
|
|
self.objs[0],
|
|
],
|
|
)
|
|
|
|
@unittest.expectedFailure
|
|
def test_slice_nested(self):
|
|
instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
|
|
self.assertSequenceEqual(
|
|
NestedIntegerArrayModel.objects.filter(field__0__0_1=[1]), [instance]
|
|
)
|
|
|
|
def test_slice_transform_expression(self):
|
|
expr = RawSQL("string_to_array(%s, ';')", ["9;2;3"])
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
field__0_2=SliceTransform(2, 3, expr)
|
|
),
|
|
self.objs[2:3],
|
|
)
|
|
|
|
def test_slice_annotation(self):
|
|
qs = NullableIntegerArrayModel.objects.annotate(
|
|
first_two=models.F("field__0_2"),
|
|
)
|
|
self.assertCountEqual(
|
|
qs.values_list("first_two", flat=True),
|
|
[None, [1], [2], [2, 3], [20, 30]],
|
|
)
|
|
|
|
def test_slicing_of_f_expressions(self):
|
|
tests = [
|
|
(F("field")[:2], [1, 2]),
|
|
(F("field")[2:], [3, 4]),
|
|
(F("field")[1:3], [2, 3]),
|
|
(F("field")[3], [4]),
|
|
(F("field")[:3][1:], [2, 3]), # Nested slicing.
|
|
(F("field")[:3][1], [2]), # Slice then index.
|
|
]
|
|
for expression, expected in tests:
|
|
with self.subTest(expression=expression, expected=expected):
|
|
instance = IntegerArrayModel.objects.create(field=[1, 2, 3, 4])
|
|
instance.field = expression
|
|
instance.save()
|
|
instance.refresh_from_db()
|
|
self.assertEqual(instance.field, expected)
|
|
|
|
def test_slicing_of_f_expressions_with_annotate(self):
|
|
IntegerArrayModel.objects.create(field=[1, 2, 3])
|
|
annotated = IntegerArrayModel.objects.annotate(
|
|
first_two=F("field")[:2],
|
|
after_two=F("field")[2:],
|
|
random_two=F("field")[1:3],
|
|
).get()
|
|
self.assertEqual(annotated.first_two, [1, 2])
|
|
self.assertEqual(annotated.after_two, [3])
|
|
self.assertEqual(annotated.random_two, [2, 3])
|
|
|
|
def test_slicing_of_f_expressions_with_len(self):
|
|
queryset = NullableIntegerArrayModel.objects.annotate(
|
|
subarray=F("field")[:1]
|
|
).filter(field__len=F("subarray__len"))
|
|
self.assertSequenceEqual(queryset, self.objs[:2])
|
|
|
|
def test_usage_in_subquery(self):
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.filter(
|
|
id__in=NullableIntegerArrayModel.objects.filter(field__len=3)
|
|
),
|
|
[self.objs[3]],
|
|
)
|
|
|
|
def test_enum_lookup(self):
|
|
class TestEnum(enum.Enum):
|
|
VALUE_1 = "value_1"
|
|
|
|
instance = ArrayEnumModel.objects.create(array_of_enums=[TestEnum.VALUE_1])
|
|
self.assertSequenceEqual(
|
|
ArrayEnumModel.objects.filter(array_of_enums__contains=[TestEnum.VALUE_1]),
|
|
[instance],
|
|
)
|
|
|
|
def test_unsupported_lookup(self):
|
|
msg = (
|
|
"Unsupported lookup '0_bar' for ArrayField or join on the field not "
|
|
"permitted."
|
|
)
|
|
with self.assertRaisesMessage(FieldError, msg):
|
|
list(NullableIntegerArrayModel.objects.filter(field__0_bar=[2]))
|
|
|
|
msg = (
|
|
"Unsupported lookup '0bar' for ArrayField or join on the field not "
|
|
"permitted."
|
|
)
|
|
with self.assertRaisesMessage(FieldError, msg):
|
|
list(NullableIntegerArrayModel.objects.filter(field__0bar=[2]))
|
|
|
|
def test_grouping_by_annotations_with_array_field_param(self):
|
|
value = models.Value([1], output_field=ArrayField(models.IntegerField()))
|
|
self.assertEqual(
|
|
NullableIntegerArrayModel.objects.annotate(
|
|
array_length=models.Func(
|
|
value,
|
|
1,
|
|
function="ARRAY_LENGTH",
|
|
output_field=models.IntegerField(),
|
|
),
|
|
)
|
|
.values("array_length")
|
|
.annotate(
|
|
count=models.Count("pk"),
|
|
)
|
|
.get()["array_length"],
|
|
1,
|
|
)
|
|
|
|
def test_filter_by_array_subquery(self):
|
|
inner_qs = NullableIntegerArrayModel.objects.filter(
|
|
field__len=models.OuterRef("field__len"),
|
|
).values("field")
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.alias(
|
|
same_sized_fields=ArraySubquery(inner_qs),
|
|
).filter(same_sized_fields__len__gt=1),
|
|
self.objs[0:2],
|
|
)
|
|
|
|
def test_annotated_array_subquery(self):
|
|
inner_qs = NullableIntegerArrayModel.objects.exclude(
|
|
pk=models.OuterRef("pk")
|
|
).values("order")
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.annotate(
|
|
sibling_ids=ArraySubquery(inner_qs),
|
|
)
|
|
.get(order=1)
|
|
.sibling_ids,
|
|
[2, 3, 4, 5],
|
|
)
|
|
|
|
def test_group_by_with_annotated_array_subquery(self):
|
|
inner_qs = NullableIntegerArrayModel.objects.exclude(
|
|
pk=models.OuterRef("pk")
|
|
).values("order")
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.annotate(
|
|
sibling_ids=ArraySubquery(inner_qs),
|
|
sibling_count=models.Max("sibling_ids__len"),
|
|
).values_list("sibling_count", flat=True),
|
|
[len(self.objs) - 1] * len(self.objs),
|
|
)
|
|
|
|
def test_annotated_ordered_array_subquery(self):
|
|
inner_qs = NullableIntegerArrayModel.objects.order_by("-order").values("order")
|
|
self.assertSequenceEqual(
|
|
NullableIntegerArrayModel.objects.annotate(
|
|
ids=ArraySubquery(inner_qs),
|
|
)
|
|
.first()
|
|
.ids,
|
|
[5, 4, 3, 2, 1],
|
|
)
|
|
|
|
def test_annotated_array_subquery_with_json_objects(self):
|
|
inner_qs = NullableIntegerArrayModel.objects.exclude(
|
|
pk=models.OuterRef("pk")
|
|
).values(json=JSONObject(order="order", field="field"))
|
|
siblings_json = (
|
|
NullableIntegerArrayModel.objects.annotate(
|
|
siblings_json=ArraySubquery(inner_qs),
|
|
)
|
|
.values_list("siblings_json", flat=True)
|
|
.get(order=1)
|
|
)
|
|
self.assertSequenceEqual(
|
|
siblings_json,
|
|
[
|
|
{"field": [2], "order": 2},
|
|
{"field": [2, 3], "order": 3},
|
|
{"field": [20, 30, 40], "order": 4},
|
|
{"field": None, "order": 5},
|
|
],
|
|
)
|
|
|
|
|
|
class TestDateTimeExactQuerying(PostgreSQLTestCase):
|
|
@classmethod
|
|
def setUpTestData(cls):
|
|
now = timezone.now()
|
|
cls.datetimes = [now]
|
|
cls.dates = [now.date()]
|
|
cls.times = [now.time()]
|
|
cls.objs = [
|
|
DateTimeArrayModel.objects.create(
|
|
datetimes=cls.datetimes, dates=cls.dates, times=cls.times
|
|
),
|
|
]
|
|
|
|
def test_exact_datetimes(self):
|
|
self.assertSequenceEqual(
|
|
DateTimeArrayModel.objects.filter(datetimes=self.datetimes), self.objs
|
|
)
|
|
|
|
def test_exact_dates(self):
|
|
self.assertSequenceEqual(
|
|
DateTimeArrayModel.objects.filter(dates=self.dates), self.objs
|
|
)
|
|
|
|
def test_exact_times(self):
|
|
self.assertSequenceEqual(
|
|
DateTimeArrayModel.objects.filter(times=self.times), self.objs
|
|
)
|
|
|
|
|
|
class TestOtherTypesExactQuerying(PostgreSQLTestCase):
|
|
@classmethod
|
|
def setUpTestData(cls):
|
|
cls.ips = ["192.168.0.1", "::1"]
|
|
cls.uuids = [uuid.uuid4()]
|
|
cls.decimals = [decimal.Decimal(1.25), 1.75]
|
|
cls.tags = [Tag(1), Tag(2), Tag(3)]
|
|
cls.objs = [
|
|
OtherTypesArrayModel.objects.create(
|
|
ips=cls.ips,
|
|
uuids=cls.uuids,
|
|
decimals=cls.decimals,
|
|
tags=cls.tags,
|
|
)
|
|
]
|
|
|
|
def test_exact_ip_addresses(self):
|
|
self.assertSequenceEqual(
|
|
OtherTypesArrayModel.objects.filter(ips=self.ips), self.objs
|
|
)
|
|
|
|
def test_exact_uuids(self):
|
|
self.assertSequenceEqual(
|
|
OtherTypesArrayModel.objects.filter(uuids=self.uuids), self.objs
|
|
)
|
|
|
|
def test_exact_decimals(self):
|
|
self.assertSequenceEqual(
|
|
OtherTypesArrayModel.objects.filter(decimals=self.decimals), self.objs
|
|
)
|
|
|
|
def test_exact_tags(self):
|
|
self.assertSequenceEqual(
|
|
OtherTypesArrayModel.objects.filter(tags=self.tags), self.objs
|
|
)
|
|
|
|
|
|
@isolate_apps("postgres_tests")
|
|
class TestChecks(PostgreSQLSimpleTestCase):
|
|
def test_field_checks(self):
|
|
class MyModel(PostgreSQLModel):
|
|
field = ArrayField(models.CharField(max_length=-1))
|
|
|
|
model = MyModel()
|
|
errors = model.check()
|
|
self.assertEqual(len(errors), 1)
|
|
# The inner CharField has a non-positive max_length.
|
|
self.assertEqual(errors[0].id, "postgres.E001")
|
|
self.assertIn("max_length", errors[0].msg)
|
|
|
|
def test_invalid_base_fields(self):
|
|
class MyModel(PostgreSQLModel):
|
|
field = ArrayField(
|
|
models.ManyToManyField("postgres_tests.IntegerArrayModel")
|
|
)
|
|
|
|
model = MyModel()
|
|
errors = model.check()
|
|
self.assertEqual(len(errors), 1)
|
|
self.assertEqual(errors[0].id, "postgres.E002")
|
|
|
|
def test_invalid_default(self):
|
|
class MyModel(PostgreSQLModel):
|
|
field = ArrayField(models.IntegerField(), default=[])
|
|
|
|
model = MyModel()
|
|
self.assertEqual(
|
|
model.check(),
|
|
[
|
|
checks.Warning(
|
|
msg=(
|
|
"ArrayField default should be a callable instead of an "
|
|
"instance so that it's not shared between all field "
|
|
"instances."
|
|
),
|
|
hint="Use a callable instead, e.g., use `list` instead of `[]`.",
|
|
obj=MyModel._meta.get_field("field"),
|
|
id="fields.E010",
|
|
)
|
|
],
|
|
)
|
|
|
|
def test_valid_default(self):
|
|
class MyModel(PostgreSQLModel):
|
|
field = ArrayField(models.IntegerField(), default=list)
|
|
|
|
model = MyModel()
|
|
self.assertEqual(model.check(), [])
|
|
|
|
def test_valid_default_none(self):
|
|
class MyModel(PostgreSQLModel):
|
|
field = ArrayField(models.IntegerField(), default=None)
|
|
|
|
model = MyModel()
|
|
self.assertEqual(model.check(), [])
|
|
|
|
def test_nested_field_checks(self):
|
|
"""
|
|
Nested ArrayFields are permitted.
|
|
"""
|
|
|
|
class MyModel(PostgreSQLModel):
|
|
field = ArrayField(ArrayField(models.CharField(max_length=-1)))
|
|
|
|
model = MyModel()
|
|
errors = model.check()
|
|
self.assertEqual(len(errors), 1)
|
|
# The inner CharField has a non-positive max_length.
|
|
self.assertEqual(errors[0].id, "postgres.E001")
|
|
self.assertIn("max_length", errors[0].msg)
|
|
|
|
def test_choices_tuple_list(self):
|
|
class MyModel(PostgreSQLModel):
|
|
field = ArrayField(
|
|
models.CharField(max_length=16),
|
|
choices=[
|
|
[
|
|
"Media",
|
|
[(["vinyl", "cd"], "Audio"), (("vhs", "dvd"), "Video")],
|
|
],
|
|
(["mp3", "mp4"], "Digital"),
|
|
],
|
|
)
|
|
|
|
self.assertEqual(MyModel._meta.get_field("field").check(), [])
|
|
|
|
|
|
@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests")
|
|
class TestMigrations(TransactionTestCase):
|
|
available_apps = ["postgres_tests"]
|
|
|
|
def test_deconstruct(self):
|
|
field = ArrayField(models.IntegerField())
|
|
name, path, args, kwargs = field.deconstruct()
|
|
new = ArrayField(*args, **kwargs)
|
|
self.assertEqual(type(new.base_field), type(field.base_field))
|
|
self.assertIsNot(new.base_field, field.base_field)
|
|
|
|
def test_deconstruct_with_size(self):
|
|
field = ArrayField(models.IntegerField(), size=3)
|
|
name, path, args, kwargs = field.deconstruct()
|
|
new = ArrayField(*args, **kwargs)
|
|
self.assertEqual(new.size, field.size)
|
|
|
|
def test_deconstruct_args(self):
|
|
field = ArrayField(models.CharField(max_length=20))
|
|
name, path, args, kwargs = field.deconstruct()
|
|
new = ArrayField(*args, **kwargs)
|
|
self.assertEqual(new.base_field.max_length, field.base_field.max_length)
|
|
|
|
def test_subclass_deconstruct(self):
|
|
field = ArrayField(models.IntegerField())
|
|
name, path, args, kwargs = field.deconstruct()
|
|
self.assertEqual(path, "django.contrib.postgres.fields.ArrayField")
|
|
|
|
field = ArrayFieldSubclass()
|
|
name, path, args, kwargs = field.deconstruct()
|
|
self.assertEqual(path, "postgres_tests.models.ArrayFieldSubclass")
|
|
|
|
@override_settings(
|
|
MIGRATION_MODULES={
|
|
"postgres_tests": "postgres_tests.array_default_migrations",
|
|
}
|
|
)
|
|
def test_adding_field_with_default(self):
|
|
# See #22962
|
|
table_name = "postgres_tests_integerarraydefaultmodel"
|
|
with connection.cursor() as cursor:
|
|
self.assertNotIn(table_name, connection.introspection.table_names(cursor))
|
|
call_command("migrate", "postgres_tests", verbosity=0)
|
|
with connection.cursor() as cursor:
|
|
self.assertIn(table_name, connection.introspection.table_names(cursor))
|
|
call_command("migrate", "postgres_tests", "zero", verbosity=0)
|
|
with connection.cursor() as cursor:
|
|
self.assertNotIn(table_name, connection.introspection.table_names(cursor))
|
|
|
|
@override_settings(
|
|
MIGRATION_MODULES={
|
|
"postgres_tests": "postgres_tests.array_index_migrations",
|
|
}
|
|
)
|
|
def test_adding_arrayfield_with_index(self):
|
|
"""
|
|
ArrayField shouldn't have varchar_patterns_ops or text_patterns_ops indexes.
|
|
"""
|
|
table_name = "postgres_tests_chartextarrayindexmodel"
|
|
call_command("migrate", "postgres_tests", verbosity=0)
|
|
with connection.cursor() as cursor:
|
|
like_constraint_columns_list = [
|
|
v["columns"]
|
|
for k, v in list(
|
|
connection.introspection.get_constraints(cursor, table_name).items()
|
|
)
|
|
if k.endswith("_like")
|
|
]
|
|
# Only the CharField should have a LIKE index.
|
|
self.assertEqual(like_constraint_columns_list, [["char2"]])
|
|
# All fields should have regular indexes.
|
|
with connection.cursor() as cursor:
|
|
indexes = [
|
|
c["columns"][0]
|
|
for c in connection.introspection.get_constraints(
|
|
cursor, table_name
|
|
).values()
|
|
if c["index"] and len(c["columns"]) == 1
|
|
]
|
|
self.assertIn("char", indexes)
|
|
self.assertIn("char2", indexes)
|
|
self.assertIn("text", indexes)
|
|
call_command("migrate", "postgres_tests", "zero", verbosity=0)
|
|
with connection.cursor() as cursor:
|
|
self.assertNotIn(table_name, connection.introspection.table_names(cursor))
|
|
|
|
|
|
class TestSerialization(PostgreSQLSimpleTestCase):
|
|
test_data = (
|
|
'[{"fields": {"field": "[\\"1\\", \\"2\\", null]"}, '
|
|
'"model": "postgres_tests.integerarraymodel", "pk": null}]'
|
|
)
|
|
|
|
def test_dumping(self):
|
|
instance = IntegerArrayModel(field=[1, 2, None])
|
|
data = serializers.serialize("json", [instance])
|
|
self.assertEqual(json.loads(data), json.loads(self.test_data))
|
|
|
|
def test_loading(self):
|
|
instance = list(serializers.deserialize("json", self.test_data))[0].object
|
|
self.assertEqual(instance.field, [1, 2, None])
|
|
|
|
|
|
class TestValidation(PostgreSQLSimpleTestCase):
|
|
def test_unbounded(self):
|
|
field = ArrayField(models.IntegerField())
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean([1, None], None)
|
|
self.assertEqual(cm.exception.code, "item_invalid")
|
|
self.assertEqual(
|
|
cm.exception.message % cm.exception.params,
|
|
"Item 2 in the array did not validate: This field cannot be null.",
|
|
)
|
|
|
|
def test_blank_true(self):
|
|
field = ArrayField(models.IntegerField(blank=True, null=True))
|
|
# This should not raise a validation error
|
|
field.clean([1, None], None)
|
|
|
|
def test_with_size(self):
|
|
field = ArrayField(models.IntegerField(), size=3)
|
|
field.clean([1, 2, 3], None)
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean([1, 2, 3, 4], None)
|
|
self.assertEqual(
|
|
cm.exception.messages[0],
|
|
"List contains 4 items, it should contain no more than 3.",
|
|
)
|
|
|
|
def test_with_size_singular(self):
|
|
field = ArrayField(models.IntegerField(), size=1)
|
|
field.clean([1], None)
|
|
msg = "List contains 2 items, it should contain no more than 1."
|
|
with self.assertRaisesMessage(exceptions.ValidationError, msg):
|
|
field.clean([1, 2], None)
|
|
|
|
def test_nested_array_mismatch(self):
|
|
field = ArrayField(ArrayField(models.IntegerField()))
|
|
field.clean([[1, 2], [3, 4]], None)
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean([[1, 2], [3, 4, 5]], None)
|
|
self.assertEqual(cm.exception.code, "nested_array_mismatch")
|
|
self.assertEqual(
|
|
cm.exception.messages[0], "Nested arrays must have the same length."
|
|
)
|
|
|
|
def test_with_base_field_error_params(self):
|
|
field = ArrayField(models.CharField(max_length=2))
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean(["abc"], None)
|
|
self.assertEqual(len(cm.exception.error_list), 1)
|
|
exception = cm.exception.error_list[0]
|
|
self.assertEqual(
|
|
exception.message,
|
|
"Item 1 in the array did not validate: Ensure this value has at most 2 "
|
|
"characters (it has 3).",
|
|
)
|
|
self.assertEqual(exception.code, "item_invalid")
|
|
self.assertEqual(
|
|
exception.params,
|
|
{"nth": 1, "value": "abc", "limit_value": 2, "show_value": 3},
|
|
)
|
|
|
|
def test_with_validators(self):
|
|
field = ArrayField(
|
|
models.IntegerField(validators=[validators.MinValueValidator(1)])
|
|
)
|
|
field.clean([1, 2], None)
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean([0], None)
|
|
self.assertEqual(len(cm.exception.error_list), 1)
|
|
exception = cm.exception.error_list[0]
|
|
self.assertEqual(
|
|
exception.message,
|
|
"Item 1 in the array did not validate: Ensure this value is greater than "
|
|
"or equal to 1.",
|
|
)
|
|
self.assertEqual(exception.code, "item_invalid")
|
|
self.assertEqual(
|
|
exception.params, {"nth": 1, "value": 0, "limit_value": 1, "show_value": 0}
|
|
)
|
|
|
|
|
|
class TestSimpleFormField(PostgreSQLSimpleTestCase):
|
|
def test_valid(self):
|
|
field = SimpleArrayField(forms.CharField())
|
|
value = field.clean("a,b,c")
|
|
self.assertEqual(value, ["a", "b", "c"])
|
|
|
|
def test_to_python_fail(self):
|
|
field = SimpleArrayField(forms.IntegerField())
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean("a,b,9")
|
|
self.assertEqual(
|
|
cm.exception.messages[0],
|
|
"Item 1 in the array did not validate: Enter a whole number.",
|
|
)
|
|
|
|
def test_validate_fail(self):
|
|
field = SimpleArrayField(forms.CharField(required=True))
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean("a,b,")
|
|
self.assertEqual(
|
|
cm.exception.messages[0],
|
|
"Item 3 in the array did not validate: This field is required.",
|
|
)
|
|
|
|
def test_validate_fail_base_field_error_params(self):
|
|
field = SimpleArrayField(forms.CharField(max_length=2))
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean("abc,c,defg")
|
|
errors = cm.exception.error_list
|
|
self.assertEqual(len(errors), 2)
|
|
first_error = errors[0]
|
|
self.assertEqual(
|
|
first_error.message,
|
|
"Item 1 in the array did not validate: Ensure this value has at most 2 "
|
|
"characters (it has 3).",
|
|
)
|
|
self.assertEqual(first_error.code, "item_invalid")
|
|
self.assertEqual(
|
|
first_error.params,
|
|
{"nth": 1, "value": "abc", "limit_value": 2, "show_value": 3},
|
|
)
|
|
second_error = errors[1]
|
|
self.assertEqual(
|
|
second_error.message,
|
|
"Item 3 in the array did not validate: Ensure this value has at most 2 "
|
|
"characters (it has 4).",
|
|
)
|
|
self.assertEqual(second_error.code, "item_invalid")
|
|
self.assertEqual(
|
|
second_error.params,
|
|
{"nth": 3, "value": "defg", "limit_value": 2, "show_value": 4},
|
|
)
|
|
|
|
def test_validators_fail(self):
|
|
field = SimpleArrayField(forms.RegexField("[a-e]{2}"))
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean("a,bc,de")
|
|
self.assertEqual(
|
|
cm.exception.messages[0],
|
|
"Item 1 in the array did not validate: Enter a valid value.",
|
|
)
|
|
|
|
def test_delimiter(self):
|
|
field = SimpleArrayField(forms.CharField(), delimiter="|")
|
|
value = field.clean("a|b|c")
|
|
self.assertEqual(value, ["a", "b", "c"])
|
|
|
|
def test_delimiter_with_nesting(self):
|
|
field = SimpleArrayField(SimpleArrayField(forms.CharField()), delimiter="|")
|
|
value = field.clean("a,b|c,d")
|
|
self.assertEqual(value, [["a", "b"], ["c", "d"]])
|
|
|
|
def test_prepare_value(self):
|
|
field = SimpleArrayField(forms.CharField())
|
|
value = field.prepare_value(["a", "b", "c"])
|
|
self.assertEqual(value, "a,b,c")
|
|
|
|
def test_max_length(self):
|
|
field = SimpleArrayField(forms.CharField(), max_length=2)
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean("a,b,c")
|
|
self.assertEqual(
|
|
cm.exception.messages[0],
|
|
"List contains 3 items, it should contain no more than 2.",
|
|
)
|
|
|
|
def test_min_length(self):
|
|
field = SimpleArrayField(forms.CharField(), min_length=4)
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean("a,b,c")
|
|
self.assertEqual(
|
|
cm.exception.messages[0],
|
|
"List contains 3 items, it should contain no fewer than 4.",
|
|
)
|
|
|
|
def test_min_length_singular(self):
|
|
field = SimpleArrayField(forms.IntegerField(), min_length=2)
|
|
field.clean([1, 2])
|
|
msg = "List contains 1 item, it should contain no fewer than 2."
|
|
with self.assertRaisesMessage(exceptions.ValidationError, msg):
|
|
field.clean([1])
|
|
|
|
def test_required(self):
|
|
field = SimpleArrayField(forms.CharField(), required=True)
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean("")
|
|
self.assertEqual(cm.exception.messages[0], "This field is required.")
|
|
|
|
def test_model_field_formfield(self):
|
|
model_field = ArrayField(models.CharField(max_length=27))
|
|
form_field = model_field.formfield()
|
|
self.assertIsInstance(form_field, SimpleArrayField)
|
|
self.assertIsInstance(form_field.base_field, forms.CharField)
|
|
self.assertEqual(form_field.base_field.max_length, 27)
|
|
|
|
def test_model_field_formfield_size(self):
|
|
model_field = ArrayField(models.CharField(max_length=27), size=4)
|
|
form_field = model_field.formfield()
|
|
self.assertIsInstance(form_field, SimpleArrayField)
|
|
self.assertEqual(form_field.max_length, 4)
|
|
|
|
def test_model_field_choices(self):
|
|
model_field = ArrayField(models.IntegerField(choices=((1, "A"), (2, "B"))))
|
|
form_field = model_field.formfield()
|
|
self.assertEqual(form_field.clean("1,2"), [1, 2])
|
|
|
|
def test_already_converted_value(self):
|
|
field = SimpleArrayField(forms.CharField())
|
|
vals = ["a", "b", "c"]
|
|
self.assertEqual(field.clean(vals), vals)
|
|
|
|
def test_has_changed(self):
|
|
field = SimpleArrayField(forms.IntegerField())
|
|
self.assertIs(field.has_changed([1, 2], [1, 2]), False)
|
|
self.assertIs(field.has_changed([1, 2], "1,2"), False)
|
|
self.assertIs(field.has_changed([1, 2], "1,2,3"), True)
|
|
self.assertIs(field.has_changed([1, 2], "a,b"), True)
|
|
|
|
def test_has_changed_empty(self):
|
|
field = SimpleArrayField(forms.CharField())
|
|
self.assertIs(field.has_changed(None, None), False)
|
|
self.assertIs(field.has_changed(None, ""), False)
|
|
self.assertIs(field.has_changed(None, []), False)
|
|
self.assertIs(field.has_changed([], None), False)
|
|
self.assertIs(field.has_changed([], ""), False)
|
|
|
|
|
|
class TestSplitFormField(PostgreSQLSimpleTestCase):
|
|
def test_valid(self):
|
|
class SplitForm(forms.Form):
|
|
array = SplitArrayField(forms.CharField(), size=3)
|
|
|
|
data = {"array_0": "a", "array_1": "b", "array_2": "c"}
|
|
form = SplitForm(data)
|
|
self.assertTrue(form.is_valid())
|
|
self.assertEqual(form.cleaned_data, {"array": ["a", "b", "c"]})
|
|
|
|
def test_required(self):
|
|
class SplitForm(forms.Form):
|
|
array = SplitArrayField(forms.CharField(), required=True, size=3)
|
|
|
|
data = {"array_0": "", "array_1": "", "array_2": ""}
|
|
form = SplitForm(data)
|
|
self.assertFalse(form.is_valid())
|
|
self.assertEqual(form.errors, {"array": ["This field is required."]})
|
|
|
|
def test_remove_trailing_nulls(self):
|
|
class SplitForm(forms.Form):
|
|
array = SplitArrayField(
|
|
forms.CharField(required=False), size=5, remove_trailing_nulls=True
|
|
)
|
|
|
|
data = {
|
|
"array_0": "a",
|
|
"array_1": "",
|
|
"array_2": "b",
|
|
"array_3": "",
|
|
"array_4": "",
|
|
}
|
|
form = SplitForm(data)
|
|
self.assertTrue(form.is_valid(), form.errors)
|
|
self.assertEqual(form.cleaned_data, {"array": ["a", "", "b"]})
|
|
|
|
def test_remove_trailing_nulls_not_required(self):
|
|
class SplitForm(forms.Form):
|
|
array = SplitArrayField(
|
|
forms.CharField(required=False),
|
|
size=2,
|
|
remove_trailing_nulls=True,
|
|
required=False,
|
|
)
|
|
|
|
data = {"array_0": "", "array_1": ""}
|
|
form = SplitForm(data)
|
|
self.assertTrue(form.is_valid())
|
|
self.assertEqual(form.cleaned_data, {"array": []})
|
|
|
|
def test_required_field(self):
|
|
class SplitForm(forms.Form):
|
|
array = SplitArrayField(forms.CharField(), size=3)
|
|
|
|
data = {"array_0": "a", "array_1": "b", "array_2": ""}
|
|
form = SplitForm(data)
|
|
self.assertFalse(form.is_valid())
|
|
self.assertEqual(
|
|
form.errors,
|
|
{
|
|
"array": [
|
|
"Item 3 in the array did not validate: This field is required."
|
|
]
|
|
},
|
|
)
|
|
|
|
def test_invalid_integer(self):
|
|
msg = (
|
|
"Item 2 in the array did not validate: Ensure this value is less than or "
|
|
"equal to 100."
|
|
)
|
|
with self.assertRaisesMessage(exceptions.ValidationError, msg):
|
|
SplitArrayField(forms.IntegerField(max_value=100), size=2).clean([0, 101])
|
|
|
|
def test_rendering(self):
|
|
class SplitForm(forms.Form):
|
|
array = SplitArrayField(forms.CharField(), size=3)
|
|
|
|
self.assertHTMLEqual(
|
|
str(SplitForm()),
|
|
"""
|
|
<div>
|
|
<label for="id_array_0">Array:</label>
|
|
<input id="id_array_0" name="array_0" type="text" required>
|
|
<input id="id_array_1" name="array_1" type="text" required>
|
|
<input id="id_array_2" name="array_2" type="text" required>
|
|
</div>
|
|
""",
|
|
)
|
|
|
|
def test_invalid_char_length(self):
|
|
field = SplitArrayField(forms.CharField(max_length=2), size=3)
|
|
with self.assertRaises(exceptions.ValidationError) as cm:
|
|
field.clean(["abc", "c", "defg"])
|
|
self.assertEqual(
|
|
cm.exception.messages,
|
|
[
|
|
"Item 1 in the array did not validate: Ensure this value has at most 2 "
|
|
"characters (it has 3).",
|
|
"Item 3 in the array did not validate: Ensure this value has at most 2 "
|
|
"characters (it has 4).",
|
|
],
|
|
)
|
|
|
|
def test_splitarraywidget_value_omitted_from_data(self):
|
|
class Form(forms.ModelForm):
|
|
field = SplitArrayField(forms.IntegerField(), required=False, size=2)
|
|
|
|
class Meta:
|
|
model = IntegerArrayModel
|
|
fields = ("field",)
|
|
|
|
form = Form({"field_0": "1", "field_1": "2"})
|
|
self.assertEqual(form.errors, {})
|
|
obj = form.save(commit=False)
|
|
self.assertEqual(obj.field, [1, 2])
|
|
|
|
def test_splitarrayfield_has_changed(self):
|
|
class Form(forms.ModelForm):
|
|
field = SplitArrayField(forms.IntegerField(), required=False, size=2)
|
|
|
|
class Meta:
|
|
model = IntegerArrayModel
|
|
fields = ("field",)
|
|
|
|
tests = [
|
|
({}, {"field_0": "", "field_1": ""}, True),
|
|
({"field": None}, {"field_0": "", "field_1": ""}, True),
|
|
({"field": [1]}, {"field_0": "", "field_1": ""}, True),
|
|
({"field": [1]}, {"field_0": "1", "field_1": "0"}, True),
|
|
({"field": [1, 2]}, {"field_0": "1", "field_1": "2"}, False),
|
|
({"field": [1, 2]}, {"field_0": "a", "field_1": "b"}, True),
|
|
]
|
|
for initial, data, expected_result in tests:
|
|
with self.subTest(initial=initial, data=data):
|
|
obj = IntegerArrayModel(**initial)
|
|
form = Form(data, instance=obj)
|
|
self.assertIs(form.has_changed(), expected_result)
|
|
|
|
def test_splitarrayfield_remove_trailing_nulls_has_changed(self):
|
|
class Form(forms.ModelForm):
|
|
field = SplitArrayField(
|
|
forms.IntegerField(), required=False, size=2, remove_trailing_nulls=True
|
|
)
|
|
|
|
class Meta:
|
|
model = IntegerArrayModel
|
|
fields = ("field",)
|
|
|
|
tests = [
|
|
({}, {"field_0": "", "field_1": ""}, False),
|
|
({"field": None}, {"field_0": "", "field_1": ""}, False),
|
|
({"field": []}, {"field_0": "", "field_1": ""}, False),
|
|
({"field": [1]}, {"field_0": "1", "field_1": ""}, False),
|
|
]
|
|
for initial, data, expected_result in tests:
|
|
with self.subTest(initial=initial, data=data):
|
|
obj = IntegerArrayModel(**initial)
|
|
form = Form(data, instance=obj)
|
|
self.assertIs(form.has_changed(), expected_result)
|
|
|
|
|
|
class TestSplitFormWidget(PostgreSQLWidgetTestCase):
|
|
def test_get_context(self):
|
|
self.assertEqual(
|
|
SplitArrayWidget(forms.TextInput(), size=2).get_context(
|
|
"name", ["val1", "val2"]
|
|
),
|
|
{
|
|
"widget": {
|
|
"name": "name",
|
|
"is_hidden": False,
|
|
"required": False,
|
|
"value": "['val1', 'val2']",
|
|
"attrs": {},
|
|
"template_name": "postgres/widgets/split_array.html",
|
|
"subwidgets": [
|
|
{
|
|
"name": "name_0",
|
|
"is_hidden": False,
|
|
"required": False,
|
|
"value": "val1",
|
|
"attrs": {},
|
|
"template_name": "django/forms/widgets/text.html",
|
|
"type": "text",
|
|
},
|
|
{
|
|
"name": "name_1",
|
|
"is_hidden": False,
|
|
"required": False,
|
|
"value": "val2",
|
|
"attrs": {},
|
|
"template_name": "django/forms/widgets/text.html",
|
|
"type": "text",
|
|
},
|
|
],
|
|
}
|
|
},
|
|
)
|
|
|
|
def test_checkbox_get_context_attrs(self):
|
|
context = SplitArrayWidget(
|
|
forms.CheckboxInput(),
|
|
size=2,
|
|
).get_context("name", [True, False])
|
|
self.assertEqual(context["widget"]["value"], "[True, False]")
|
|
self.assertEqual(
|
|
[subwidget["attrs"] for subwidget in context["widget"]["subwidgets"]],
|
|
[{"checked": True}, {}],
|
|
)
|
|
|
|
def test_render(self):
|
|
self.check_html(
|
|
SplitArrayWidget(forms.TextInput(), size=2),
|
|
"array",
|
|
None,
|
|
"""
|
|
<input name="array_0" type="text">
|
|
<input name="array_1" type="text">
|
|
""",
|
|
)
|
|
|
|
def test_render_attrs(self):
|
|
self.check_html(
|
|
SplitArrayWidget(forms.TextInput(), size=2),
|
|
"array",
|
|
["val1", "val2"],
|
|
attrs={"id": "foo"},
|
|
html=(
|
|
"""
|
|
<input id="foo_0" name="array_0" type="text" value="val1">
|
|
<input id="foo_1" name="array_1" type="text" value="val2">
|
|
"""
|
|
),
|
|
)
|
|
|
|
def test_value_omitted_from_data(self):
|
|
widget = SplitArrayWidget(forms.TextInput(), size=2)
|
|
self.assertIs(widget.value_omitted_from_data({}, {}, "field"), True)
|
|
self.assertIs(
|
|
widget.value_omitted_from_data({"field_0": "value"}, {}, "field"), False
|
|
)
|
|
self.assertIs(
|
|
widget.value_omitted_from_data({"field_1": "value"}, {}, "field"), False
|
|
)
|
|
self.assertIs(
|
|
widget.value_omitted_from_data(
|
|
{"field_0": "value", "field_1": "value"}, {}, "field"
|
|
),
|
|
False,
|
|
)
|
|
|
|
|
|
class TestAdminUtils(PostgreSQLTestCase):
|
|
empty_value = "-empty-"
|
|
|
|
def test_array_display_for_field(self):
|
|
array_field = ArrayField(models.IntegerField())
|
|
display_value = display_for_field(
|
|
[1, 2],
|
|
array_field,
|
|
self.empty_value,
|
|
)
|
|
self.assertEqual(display_value, "1, 2")
|
|
|
|
def test_array_with_choices_display_for_field(self):
|
|
array_field = ArrayField(
|
|
models.IntegerField(),
|
|
choices=[
|
|
([1, 2, 3], "1st choice"),
|
|
([1, 2], "2nd choice"),
|
|
],
|
|
)
|
|
|
|
display_value = display_for_field(
|
|
[1, 2],
|
|
array_field,
|
|
self.empty_value,
|
|
)
|
|
self.assertEqual(display_value, "2nd choice")
|
|
|
|
display_value = display_for_field(
|
|
[99, 99],
|
|
array_field,
|
|
self.empty_value,
|
|
)
|
|
self.assertEqual(display_value, self.empty_value)
|