Debian Codegraph @

tests/model_fields/test_jsonfield.py

raw
1 import operator
2 import uuid
3 from unittest import mock
4
5 from django import forms
6 from django.core import serializers
7 from django.core.exceptions import ValidationError
8 from django.core.serializers.json import DjangoJSONEncoder
9 from django.db import (
10 DataError,
11 IntegrityError,
12 NotSupportedError,
13 OperationalError,
14 connection,
15 models,
16 transaction,
17 )
18 from django.db.models import (
19 Count,
20 ExpressionWrapper,
21 F,
22 IntegerField,
23 JSONField,
24 OuterRef,
25 Q,
26 Subquery,
27 Transform,
28 Value,
29 )
30 from django.db.models.expressions import RawSQL
31 from django.db.models.fields.json import (
32 KT,
33 HasKey,
34 KeyTextTransform,
35 KeyTransform,
36 KeyTransformFactory,
37 KeyTransformTextLookupMixin,
38 )
39 from django.db.models.functions import Cast
40 from django.test import SimpleTestCase, TestCase, skipIfDBFeature, skipUnlessDBFeature
41 from django.test.utils import CaptureQueriesContext
42
43 from .models import (
44 CustomJSONDecoder,
45 CustomSerializationJSONModel,
46 JSONModel,
47 NullableJSONModel,
48 RelatedJSONModel,
49 )
50
51
52 @skipUnlessDBFeature("supports_json_field")
53 class JSONFieldTests(TestCase):
54 def test_invalid_value(self):
55 msg = "is not JSON serializable"
56 with self.assertRaisesMessage(TypeError, msg):
57 NullableJSONModel.objects.create(
58 value={
59 "uuid": uuid.UUID("d85e2076-b67c-4ee7-8c3a-2bf5a2cc2475"),
60 }
61 )
62
63 def test_custom_encoder_decoder(self):
64 value = {"uuid": uuid.UUID("{d85e2076-b67c-4ee7-8c3a-2bf5a2cc2475}")}
65 obj = NullableJSONModel(value_custom=value)
66 obj.clean_fields()
67 obj.save()
68 obj.refresh_from_db()
69 self.assertEqual(obj.value_custom, value)
70
71 def test_db_check_constraints(self):
72 value = "{@!invalid json value 123 $!@#"
73 with mock.patch.object(DjangoJSONEncoder, "encode", return_value=value):
74 with self.assertRaises((IntegrityError, DataError, OperationalError)):
75 NullableJSONModel.objects.create(value_custom=value)
76
77
78 class TestMethods(SimpleTestCase):
79 def test_deconstruct(self):
80 field = models.JSONField()
81 name, path, args, kwargs = field.deconstruct()
82 self.assertEqual(path, "django.db.models.JSONField")
83 self.assertEqual(args, [])
84 self.assertEqual(kwargs, {})
85
86 def test_deconstruct_custom_encoder_decoder(self):
87 field = models.JSONField(encoder=DjangoJSONEncoder, decoder=CustomJSONDecoder)
88 name, path, args, kwargs = field.deconstruct()
89 self.assertEqual(kwargs["encoder"], DjangoJSONEncoder)
90 self.assertEqual(kwargs["decoder"], CustomJSONDecoder)
91
92 def test_get_transforms(self):
93 @models.JSONField.register_lookup
94 class MyTransform(Transform):
95 lookup_name = "my_transform"
96
97 field = models.JSONField()
98 transform = field.get_transform("my_transform")
99 self.assertIs(transform, MyTransform)
100 models.JSONField._unregister_lookup(MyTransform)
101 transform = field.get_transform("my_transform")
102 self.assertIsInstance(transform, KeyTransformFactory)
103
104 def test_key_transform_text_lookup_mixin_non_key_transform(self):
105 transform = Transform("test")
106 msg = (
107 "Transform should be an instance of KeyTransform in order to use "
108 "this lookup."
109 )
110 with self.assertRaisesMessage(TypeError, msg):
111 KeyTransformTextLookupMixin(transform)
112
113 def test_get_prep_value(self):
114 class JSONFieldGetPrepValue(models.JSONField):
115 def get_prep_value(self, value):
116 if value is True:
117 return {"value": True}
118 return value
119
120 def noop_adapt_json_value(value, encoder):
121 return value
122
123 field = JSONFieldGetPrepValue()
124 with mock.patch.object(
125 connection.ops, "adapt_json_value", noop_adapt_json_value
126 ):
127 self.assertEqual(
128 field.get_db_prep_value(True, connection, prepared=False),
129 {"value": True},
130 )
131 self.assertIs(
132 field.get_db_prep_value(True, connection, prepared=True), True
133 )
134 self.assertEqual(field.get_db_prep_value(1, connection, prepared=False), 1)
135
136
137 class TestValidation(SimpleTestCase):
138 def test_invalid_encoder(self):
139 msg = "The encoder parameter must be a callable object."
140 with self.assertRaisesMessage(ValueError, msg):
141 models.JSONField(encoder=DjangoJSONEncoder())
142
143 def test_invalid_decoder(self):
144 msg = "The decoder parameter must be a callable object."
145 with self.assertRaisesMessage(ValueError, msg):
146 models.JSONField(decoder=CustomJSONDecoder())
147
148 def test_validation_error(self):
149 field = models.JSONField()
150 msg = "Value must be valid JSON."
151 value = uuid.UUID("{d85e2076-b67c-4ee7-8c3a-2bf5a2cc2475}")
152 with self.assertRaisesMessage(ValidationError, msg):
153 field.clean({"uuid": value}, None)
154
155 def test_custom_encoder(self):
156 field = models.JSONField(encoder=DjangoJSONEncoder)
157 value = uuid.UUID("{d85e2076-b67c-4ee7-8c3a-2bf5a2cc2475}")
158 field.clean({"uuid": value}, None)
159
160
161 class TestFormField(SimpleTestCase):
162 def test_formfield(self):
163 model_field = models.JSONField()
164 form_field = model_field.formfield()
165 self.assertIsInstance(form_field, forms.JSONField)
166
167 def test_formfield_custom_encoder_decoder(self):
168 model_field = models.JSONField(
169 encoder=DjangoJSONEncoder, decoder=CustomJSONDecoder
170 )
171 form_field = model_field.formfield()
172 self.assertIs(form_field.encoder, DjangoJSONEncoder)
173 self.assertIs(form_field.decoder, CustomJSONDecoder)
174
175
176 class TestSerialization(SimpleTestCase):
177 test_data = (
178 '[{"fields": {"value": %s}, "model": "model_fields.jsonmodel", "pk": null}]'
179 )
180 test_values = (
181 # (Python value, serialized value),
182 ({"a": "b", "c": None}, '{"a": "b", "c": null}'),
183 ("abc", '"abc"'),
184 ('{"a": "a"}', '"{\\"a\\": \\"a\\"}"'),
185 )
186
187 def test_dumping(self):
188 for value, serialized in self.test_values:
189 with self.subTest(value=value):
190 instance = JSONModel(value=value)
191 data = serializers.serialize("json", [instance])
192 self.assertJSONEqual(data, self.test_data % serialized)
193
194 def test_loading(self):
195 for value, serialized in self.test_values:
196 with self.subTest(value=value):
197 instance = list(
198 serializers.deserialize("json", self.test_data % serialized)
199 )[0].object
200 self.assertEqual(instance.value, value)
201
202 def test_xml_serialization(self):
203 test_xml_data = (
204 '<django-objects version="1.0">'
205 '<object model="model_fields.nullablejsonmodel">'
206 '<field name="value" type="JSONField">%s'
207 "</field></object></django-objects>"
208 )
209 for value, serialized in self.test_values:
210 with self.subTest(value=value):
211 instance = NullableJSONModel(value=value)
212 data = serializers.serialize("xml", [instance], fields=["value"])
213 self.assertXMLEqual(data, test_xml_data % serialized)
214 new_instance = list(serializers.deserialize("xml", data))[0].object
215 self.assertEqual(new_instance.value, instance.value)
216
217
218 @skipUnlessDBFeature("supports_json_field")
219 class TestSaveLoad(TestCase):
220 def test_null(self):
221 obj = NullableJSONModel(value=None)
222 obj.save()
223 obj.refresh_from_db()
224 self.assertIsNone(obj.value)
225
226 @skipUnlessDBFeature("supports_primitives_in_json_field")
227 def test_json_null_different_from_sql_null(self):
228 json_null = NullableJSONModel.objects.create(value=Value(None, JSONField()))
229 NullableJSONModel.objects.update(value=Value(None, JSONField()))
230 json_null.refresh_from_db()
231 sql_null = NullableJSONModel.objects.create(value=None)
232 sql_null.refresh_from_db()
233 # 'null' is not equal to NULL in the database.
234 self.assertSequenceEqual(
235 NullableJSONModel.objects.filter(value=Value(None, JSONField())),
236 [json_null],
237 )
238 self.assertSequenceEqual(
239 NullableJSONModel.objects.filter(value=None),
240 [json_null],
241 )
242 self.assertSequenceEqual(
243 NullableJSONModel.objects.filter(value__isnull=True),
244 [sql_null],
245 )
246 # 'null' is equal to NULL in Python (None).
247 self.assertEqual(json_null.value, sql_null.value)
248
249 @skipUnlessDBFeature("supports_primitives_in_json_field")
250 def test_primitives(self):
251 values = [
252 True,
253 1,
254 1.45,
255 "String",
256 "",
257 ]
258 for value in values:
259 with self.subTest(value=value):
260 obj = JSONModel(value=value)
261 obj.save()
262 obj.refresh_from_db()
263 self.assertEqual(obj.value, value)
264
265 def test_dict(self):
266 values = [
267 {},
268 {"name": "John", "age": 20, "height": 180.3},
269 {"a": True, "b": {"b1": False, "b2": None}},
270 ]
271 for value in values:
272 with self.subTest(value=value):
273 obj = JSONModel.objects.create(value=value)
274 obj.refresh_from_db()
275 self.assertEqual(obj.value, value)
276
277 def test_list(self):
278 values = [
279 [],
280 ["John", 20, 180.3],
281 [True, [False, None]],
282 ]
283 for value in values:
284 with self.subTest(value=value):
285 obj = JSONModel.objects.create(value=value)
286 obj.refresh_from_db()
287 self.assertEqual(obj.value, value)
288
289 def test_realistic_object(self):
290 value = {
291 "name": "John",
292 "age": 20,
293 "pets": [
294 {"name": "Kit", "type": "cat", "age": 2},
295 {"name": "Max", "type": "dog", "age": 1},
296 ],
297 "courses": [
298 ["A1", "A2", "A3"],
299 ["B1", "B2"],
300 ["C1"],
301 ],
302 }
303 obj = JSONModel.objects.create(value=value)
304 obj.refresh_from_db()
305 self.assertEqual(obj.value, value)
306
307 @skipUnlessDBFeature("supports_primitives_in_json_field")
308 def test_bulk_update_custom_get_prep_value(self):
309 objs = CustomSerializationJSONModel.objects.bulk_create(
310 [CustomSerializationJSONModel(pk=1, json_field={"version": "1"})]
311 )
312 objs[0].json_field["version"] = "1-alpha"
313 CustomSerializationJSONModel.objects.bulk_update(objs, ["json_field"])
314 self.assertSequenceEqual(
315 CustomSerializationJSONModel.objects.values("json_field"),
316 [{"json_field": '{"version": "1-alpha"}'}],
317 )
318
319
320 @skipUnlessDBFeature("supports_json_field")
321 class TestQuerying(TestCase):
322 @classmethod
323 def setUpTestData(cls):
324 cls.primitives = [True, False, "yes", 7, 9.6]
325 values = [
326 None,
327 [],
328 {},
329 {"a": "b", "c": 14},
330 {
331 "a": "b",
332 "c": 14,
333 "d": ["e", {"f": "g"}],
334 "h": True,
335 "i": False,
336 "j": None,
337 "k": {"l": "m"},
338 "n": [None, True, False],
339 "o": '"quoted"',
340 "p": 4.2,
341 "r": {"s": True, "t": False},
342 },
343 [1, [2]],
344 {"k": True, "l": False, "foo": "bax"},
345 {
346 "foo": "bar",
347 "baz": {"a": "b", "c": "d"},
348 "bar": ["foo", "bar"],
349 "bax": {"foo": "bar"},
350 },
351 ]
352 cls.objs = [NullableJSONModel.objects.create(value=value) for value in values]
353 if connection.features.supports_primitives_in_json_field:
354 cls.objs.extend(
355 [
356 NullableJSONModel.objects.create(value=value)
357 for value in cls.primitives
358 ]
359 )
360 cls.raw_sql = "%s::jsonb" if connection.vendor == "postgresql" else "%s"
361
362 def test_exact(self):
363 self.assertSequenceEqual(
364 NullableJSONModel.objects.filter(value__exact={}),
365 [self.objs[2]],
366 )
367
368 def test_exact_complex(self):
369 self.assertSequenceEqual(
370 NullableJSONModel.objects.filter(value__exact={"a": "b", "c": 14}),
371 [self.objs[3]],
372 )
373
374 def test_icontains(self):
375 self.assertCountEqual(
376 NullableJSONModel.objects.filter(value__icontains="BaX"),
377 self.objs[6:8],
378 )
379
380 def test_isnull(self):
381 self.assertSequenceEqual(
382 NullableJSONModel.objects.filter(value__isnull=True),
383 [self.objs[0]],
384 )
385
386 def test_ordering_by_transform(self):
387 mariadb = connection.vendor == "mysql" and connection.mysql_is_mariadb
388 values = [
389 {"ord": 93, "name": "bar"},
390 {"ord": 22.1, "name": "foo"},
391 {"ord": -1, "name": "baz"},
392 {"ord": 21.931902, "name": "spam"},
393 {"ord": -100291029, "name": "eggs"},
394 ]
395 for field_name in ["value", "value_custom"]:
396 with self.subTest(field=field_name):
397 objs = [
398 NullableJSONModel.objects.create(**{field_name: value})
399 for value in values
400 ]
401 query = NullableJSONModel.objects.filter(
402 **{"%s__name__isnull" % field_name: False},
403 ).order_by("%s__ord" % field_name)
404 expected = [objs[4], objs[2], objs[3], objs[1], objs[0]]
405 if mariadb or connection.vendor == "oracle":
406 # MariaDB and Oracle return JSON values as strings.
407 expected = [objs[2], objs[4], objs[3], objs[1], objs[0]]
408 self.assertSequenceEqual(query, expected)
409
410 def test_ordering_grouping_by_key_transform(self):
411 base_qs = NullableJSONModel.objects.filter(value__d__0__isnull=False)
412 for qs in (
413 base_qs.order_by("value__d__0"),
414 base_qs.annotate(
415 key=KeyTransform("0", KeyTransform("d", "value"))
416 ).order_by("key"),
417 ):
418 self.assertSequenceEqual(qs, [self.objs[4]])
419 none_val = "" if connection.features.interprets_empty_strings_as_nulls else None
420 qs = NullableJSONModel.objects.filter(value__isnull=False)
421 self.assertQuerySetEqual(
422 qs.filter(value__isnull=False)
423 .annotate(key=KT("value__d__1__f"))
424 .values("key")
425 .annotate(count=Count("key"))
426 .order_by("count"),
427 [(none_val, 0), ("g", 1)],
428 operator.itemgetter("key", "count"),
429 )
430
431 def test_ordering_grouping_by_count(self):
432 qs = (
433 NullableJSONModel.objects.filter(
434 value__isnull=False,
435 )
436 .values("value__d__0")
437 .annotate(count=Count("value__d__0"))
438 .order_by("count")
439 )
440 self.assertQuerySetEqual(qs, [0, 1], operator.itemgetter("count"))
441
442 def test_order_grouping_custom_decoder(self):
443 NullableJSONModel.objects.create(value_custom={"a": "b"})
444 qs = NullableJSONModel.objects.filter(value_custom__isnull=False)
445 self.assertSequenceEqual(
446 qs.values(
447 "value_custom__a",
448 )
449 .annotate(
450 count=Count("id"),
451 )
452 .order_by("value_custom__a"),
453 [{"value_custom__a": "b", "count": 1}],
454 )
455
456 def test_key_transform_raw_expression(self):
457 expr = RawSQL(self.raw_sql, ['{"x": "bar"}'])
458 self.assertSequenceEqual(
459 NullableJSONModel.objects.filter(value__foo=KeyTransform("x", expr)),
460 [self.objs[7]],
461 )
462
463 def test_nested_key_transform_raw_expression(self):
464 expr = RawSQL(self.raw_sql, ['{"x": {"y": "bar"}}'])
465 self.assertSequenceEqual(
466 NullableJSONModel.objects.filter(
467 value__foo=KeyTransform("y", KeyTransform("x", expr))
468 ),
469 [self.objs[7]],
470 )
471
472 def test_key_transform_expression(self):
473 self.assertSequenceEqual(
474 NullableJSONModel.objects.filter(value__d__0__isnull=False)
475 .annotate(
476 key=KeyTransform("d", "value"),
477 chain=KeyTransform("0", "key"),
478 expr=KeyTransform("0", Cast("key", models.JSONField())),
479 )
480 .filter(chain=F("expr")),
481 [self.objs[4]],
482 )
483
484 def test_key_transform_annotation_expression(self):
485 obj = NullableJSONModel.objects.create(value={"d": ["e", "e"]})
486 self.assertSequenceEqual(
487 NullableJSONModel.objects.filter(value__d__0__isnull=False)
488 .annotate(
489 key=F("value__d"),
490 chain=F("key__0"),
491 expr=Cast("key", models.JSONField()),
492 )
493 .filter(chain=F("expr__1")),
494 [obj],
495 )
496
497 def test_nested_key_transform_expression(self):
498 self.assertSequenceEqual(
499 NullableJSONModel.objects.filter(value__d__0__isnull=False)
500 .annotate(
501 key=KeyTransform("d", "value"),
502 chain=KeyTransform("f", KeyTransform("1", "key")),
503 expr=KeyTransform(
504 "f", KeyTransform("1", Cast("key", models.JSONField()))
505 ),
506 )
507 .filter(chain=F("expr")),
508 [self.objs[4]],
509 )
510
511 def test_nested_key_transform_annotation_expression(self):
512 obj = NullableJSONModel.objects.create(
513 value={"d": ["e", {"f": "g"}, {"f": "g"}]},
514 )
515 self.assertSequenceEqual(
516 NullableJSONModel.objects.filter(value__d__0__isnull=False)
517 .annotate(
518 key=F("value__d"),
519 chain=F("key__1__f"),
520 expr=Cast("key", models.JSONField()),
521 )
522 .filter(chain=F("expr__2__f")),
523 [obj],
524 )
525
526 def test_nested_key_transform_on_subquery(self):
527 self.assertSequenceEqual(
528 NullableJSONModel.objects.filter(value__d__0__isnull=False)
529 .annotate(
530 subquery_value=Subquery(
531 NullableJSONModel.objects.filter(pk=OuterRef("pk")).values("value")
532 ),
533 key=KeyTransform("d", "subquery_value"),
534 chain=KeyTransform("f", KeyTransform("1", "key")),
535 )
536 .filter(chain="g"),
537 [self.objs[4]],
538 )
539
540 def test_key_text_transform_char_lookup(self):
541 qs = NullableJSONModel.objects.annotate(
542 char_value=KeyTextTransform("foo", "value"),
543 ).filter(char_value__startswith="bar")
544 self.assertSequenceEqual(qs, [self.objs[7]])
545
546 qs = NullableJSONModel.objects.annotate(
547 char_value=KeyTextTransform(1, KeyTextTransform("bar", "value")),
548 ).filter(char_value__startswith="bar")
549 self.assertSequenceEqual(qs, [self.objs[7]])
550
551 def test_expression_wrapper_key_transform(self):
552 self.assertCountEqual(
553 NullableJSONModel.objects.annotate(
554 expr=ExpressionWrapper(
555 KeyTransform("c", "value"),
556 output_field=IntegerField(),
557 ),
558 ).filter(expr__isnull=False),
559 self.objs[3:5],
560 )
561
562 def test_has_key(self):
563 self.assertCountEqual(
564 NullableJSONModel.objects.filter(value__has_key="a"),
565 [self.objs[3], self.objs[4]],
566 )
567
568 def test_has_key_null_value(self):
569 self.assertSequenceEqual(
570 NullableJSONModel.objects.filter(value__has_key="j"),
571 [self.objs[4]],
572 )
573
574 def test_has_key_deep(self):
575 tests = [
576 (Q(value__baz__has_key="a"), self.objs[7]),
577 (
578 Q(value__has_key=KeyTransform("a", KeyTransform("baz", "value"))),
579 self.objs[7],
580 ),
581 (Q(value__has_key=F("value__baz__a")), self.objs[7]),
582 (
583 Q(value__has_key=KeyTransform("c", KeyTransform("baz", "value"))),
584 self.objs[7],
585 ),
586 (Q(value__has_key=F("value__baz__c")), self.objs[7]),
587 (Q(value__d__1__has_key="f"), self.objs[4]),
588 (
589 Q(
590 value__has_key=KeyTransform(
591 "f", KeyTransform("1", KeyTransform("d", "value"))
592 )
593 ),
594 self.objs[4],
595 ),
596 (Q(value__has_key=F("value__d__1__f")), self.objs[4]),
597 ]
598 for condition, expected in tests:
599 with self.subTest(condition=condition):
600 self.assertSequenceEqual(
601 NullableJSONModel.objects.filter(condition),
602 [expected],
603 )
604
605 def test_has_key_literal_lookup(self):
606 self.assertSequenceEqual(
607 NullableJSONModel.objects.filter(
608 HasKey(Value({"foo": "bar"}, JSONField()), "foo")
609 ).order_by("id"),
610 self.objs,
611 )
612
613 def test_has_key_list(self):
614 obj = NullableJSONModel.objects.create(value=[{"a": 1}, {"b": "x"}])
615 tests = [
616 Q(value__1__has_key="b"),
617 Q(value__has_key=KeyTransform("b", KeyTransform(1, "value"))),
618 Q(value__has_key=KeyTransform("b", KeyTransform("1", "value"))),
619 Q(value__has_key=F("value__1__b")),
620 ]
621 for condition in tests:
622 with self.subTest(condition=condition):
623 self.assertSequenceEqual(
624 NullableJSONModel.objects.filter(condition),
625 [obj],
626 )
627
628 def test_has_keys(self):
629 self.assertSequenceEqual(
630 NullableJSONModel.objects.filter(value__has_keys=["a", "c", "h"]),
631 [self.objs[4]],
632 )
633
634 def test_has_any_keys(self):
635 self.assertCountEqual(
636 NullableJSONModel.objects.filter(value__has_any_keys=["c", "l"]),
637 [self.objs[3], self.objs[4], self.objs[6]],
638 )
639
640 def test_has_key_number(self):
641 obj = NullableJSONModel.objects.create(
642 value={
643 "123": "value",
644 "nested": {"456": "bar", "lorem": "abc", "999": True},
645 "array": [{"789": "baz", "777": "def", "ipsum": 200}],
646 "000": "val",
647 }
648 )
649 tests = [
650 Q(value__has_key="123"),
651 Q(value__nested__has_key="456"),
652 Q(value__array__0__has_key="789"),
653 Q(value__has_keys=["nested", "123", "array", "000"]),
654 Q(value__nested__has_keys=["lorem", "999", "456"]),
655 Q(value__array__0__has_keys=["789", "ipsum", "777"]),
656 Q(value__has_any_keys=["000", "nonexistent"]),
657 Q(value__nested__has_any_keys=["999", "nonexistent"]),
658 Q(value__array__0__has_any_keys=["777", "nonexistent"]),
659 ]
660 for condition in tests:
661 with self.subTest(condition=condition):
662 self.assertSequenceEqual(
663 NullableJSONModel.objects.filter(condition),
664 [obj],
665 )
666
667 @skipUnlessDBFeature("supports_json_field_contains")
668 def test_contains(self):
669 tests = [
670 ({}, self.objs[2:5] + self.objs[6:8]),
671 ({"baz": {"a": "b", "c": "d"}}, [self.objs[7]]),
672 ({"baz": {"a": "b"}}, [self.objs[7]]),
673 ({"baz": {"c": "d"}}, [self.objs[7]]),
674 ({"k": True, "l": False}, [self.objs[6]]),
675 ({"d": ["e", {"f": "g"}]}, [self.objs[4]]),
676 ({"d": ["e"]}, [self.objs[4]]),
677 ({"d": [{"f": "g"}]}, [self.objs[4]]),
678 ([1, [2]], [self.objs[5]]),
679 ([1], [self.objs[5]]),
680 ([[2]], [self.objs[5]]),
681 ({"n": [None, True, False]}, [self.objs[4]]),
682 ({"j": None}, [self.objs[4]]),
683 ]
684 for value, expected in tests:
685 with self.subTest(value=value):
686 qs = NullableJSONModel.objects.filter(value__contains=value)
687 self.assertCountEqual(qs, expected)
688
689 @skipIfDBFeature("supports_json_field_contains")
690 def test_contains_unsupported(self):
691 msg = "contains lookup is not supported on this database backend."
692 with self.assertRaisesMessage(NotSupportedError, msg):
693 NullableJSONModel.objects.filter(
694 value__contains={"baz": {"a": "b", "c": "d"}},
695 ).get()
696
697 @skipUnlessDBFeature(
698 "supports_primitives_in_json_field",
699 "supports_json_field_contains",
700 )
701 def test_contains_primitives(self):
702 for value in self.primitives:
703 with self.subTest(value=value):
704 qs = NullableJSONModel.objects.filter(value__contains=value)
705 self.assertIs(qs.exists(), True)
706
707 @skipUnlessDBFeature("supports_json_field_contains")
708 def test_contained_by(self):
709 qs = NullableJSONModel.objects.filter(
710 value__contained_by={"a": "b", "c": 14, "h": True}
711 )
712 self.assertCountEqual(qs, self.objs[2:4])
713
714 @skipIfDBFeature("supports_json_field_contains")
715 def test_contained_by_unsupported(self):
716 msg = "contained_by lookup is not supported on this database backend."
717 with self.assertRaisesMessage(NotSupportedError, msg):
718 NullableJSONModel.objects.filter(value__contained_by={"a": "b"}).get()
719
720 def test_deep_values(self):
721 qs = NullableJSONModel.objects.values_list("value__k__l").order_by("pk")
722 expected_objs = [(None,)] * len(self.objs)
723 expected_objs[4] = ("m",)
724 self.assertSequenceEqual(qs, expected_objs)
725
726 @skipUnlessDBFeature("can_distinct_on_fields")
727 def test_deep_distinct(self):
728 query = NullableJSONModel.objects.distinct("value__k__l").values_list(
729 "value__k__l"
730 )
731 expected = [("m",), (None,)]
732 if not connection.features.nulls_order_largest:
733 expected.reverse()
734 self.assertSequenceEqual(query, expected)
735
736 def test_isnull_key(self):
737 # key__isnull=False works the same as has_key='key'.
738 self.assertCountEqual(
739 NullableJSONModel.objects.filter(value__a__isnull=True),
740 self.objs[:3] + self.objs[5:],
741 )
742 self.assertCountEqual(
743 NullableJSONModel.objects.filter(value__j__isnull=True),
744 self.objs[:4] + self.objs[5:],
745 )
746 self.assertCountEqual(
747 NullableJSONModel.objects.filter(value__a__isnull=False),
748 [self.objs[3], self.objs[4]],
749 )
750 self.assertSequenceEqual(
751 NullableJSONModel.objects.filter(value__j__isnull=False),
752 [self.objs[4]],
753 )
754
755 def test_isnull_key_or_none(self):
756 obj = NullableJSONModel.objects.create(value={"a": None})
757 self.assertCountEqual(
758 NullableJSONModel.objects.filter(
759 Q(value__a__isnull=True) | Q(value__a=None)
760 ),
761 self.objs[:3] + self.objs[5:] + [obj],
762 )
763
764 def test_none_key(self):
765 self.assertSequenceEqual(
766 NullableJSONModel.objects.filter(value__j=None),
767 [self.objs[4]],
768 )
769
770 def test_none_key_exclude(self):
771 obj = NullableJSONModel.objects.create(value={"j": 1})
772 if connection.vendor == "oracle":
773 # Oracle supports filtering JSON objects with NULL keys, but the
774 # current implementation doesn't support it.
775 self.assertSequenceEqual(
776 NullableJSONModel.objects.exclude(value__j=None),
777 self.objs[1:4] + self.objs[5:] + [obj],
778 )
779 else:
780 self.assertSequenceEqual(
781 NullableJSONModel.objects.exclude(value__j=None), [obj]
782 )
783
784 def test_shallow_list_lookup(self):
785 self.assertSequenceEqual(
786 NullableJSONModel.objects.filter(value__0=1),
787 [self.objs[5]],
788 )
789
790 def test_shallow_obj_lookup(self):
791 self.assertCountEqual(
792 NullableJSONModel.objects.filter(value__a="b"),
793 [self.objs[3], self.objs[4]],
794 )
795
796 def test_obj_subquery_lookup(self):
797 qs = NullableJSONModel.objects.annotate(
798 field=Subquery(
799 NullableJSONModel.objects.filter(pk=OuterRef("pk")).values("value")
800 ),
801 ).filter(field__a="b")
802 self.assertCountEqual(qs, [self.objs[3], self.objs[4]])
803
804 def test_deep_lookup_objs(self):
805 self.assertSequenceEqual(
806 NullableJSONModel.objects.filter(value__k__l="m"),
807 [self.objs[4]],
808 )
809
810 def test_shallow_lookup_obj_target(self):
811 self.assertSequenceEqual(
812 NullableJSONModel.objects.filter(value__k={"l": "m"}),
813 [self.objs[4]],
814 )
815
816 def test_deep_lookup_array(self):
817 self.assertSequenceEqual(
818 NullableJSONModel.objects.filter(value__1__0=2),
819 [self.objs[5]],
820 )
821
822 def test_deep_lookup_mixed(self):
823 self.assertSequenceEqual(
824 NullableJSONModel.objects.filter(value__d__1__f="g"),
825 [self.objs[4]],
826 )
827
828 def test_deep_lookup_transform(self):
829 self.assertCountEqual(
830 NullableJSONModel.objects.filter(value__c__gt=2),
831 [self.objs[3], self.objs[4]],
832 )
833 self.assertCountEqual(
834 NullableJSONModel.objects.filter(value__c__gt=2.33),
835 [self.objs[3], self.objs[4]],
836 )
837 self.assertIs(NullableJSONModel.objects.filter(value__c__lt=5).exists(), False)
838
839 def test_lookups_special_chars(self):
840 test_keys = [
841 "CONTROL",
842 "single'",
843 "dollar$",
844 "dot.dot",
845 "with space",
846 "back\\slash",
847 "question?mark",
848 "user@name",
849 "emo🤡'ji",
850 "com,ma",
851 "curly{{{brace}}}s",
852 "escape\uffff'seq'\uffffue\uffff'nce",
853 ]
854 json_value = {key: "some value" for key in test_keys}
855 obj = NullableJSONModel.objects.create(value=json_value)
856 obj.refresh_from_db()
857 self.assertEqual(obj.value, json_value)
858
859 for key in test_keys:
860 lookups = {
861 "has_key": Q(value__has_key=key),
862 "has_keys": Q(value__has_keys=[key, "CONTROL"]),
863 "has_any_keys": Q(value__has_any_keys=[key, "does_not_exist"]),
864 "exact": Q(**{f"value__{key}": "some value"}),
865 }
866 for lookup, condition in lookups.items():
867 results = NullableJSONModel.objects.filter(condition)
868 with self.subTest(key=key, lookup=lookup):
869 self.assertSequenceEqual(results, [obj])
870
871 def test_lookups_special_chars_double_quotes(self):
872 test_keys = [
873 'double"',
874 "m\\i@x. m🤡'a,t{{{ch}}}e?d$\"'es\uffff'ca\uffff'pe",
875 ]
876 json_value = {key: "some value" for key in test_keys}
877 obj = NullableJSONModel.objects.create(value=json_value)
878 obj.refresh_from_db()
879 self.assertEqual(obj.value, json_value)
880 self.assertSequenceEqual(
881 NullableJSONModel.objects.filter(value__has_keys=test_keys), [obj]
882 )
883 for key in test_keys:
884 with self.subTest(key=key):
885 results = NullableJSONModel.objects.filter(
886 Q(value__has_key=key),
887 Q(value__has_any_keys=[key, "does_not_exist"]),
888 Q(**{f"value__{key}": "some value"}),
889 )
890 self.assertSequenceEqual(results, [obj])
891
892 def test_lookup_exclude(self):
893 tests = [
894 (Q(value__a="b"), [self.objs[0]]),
895 (Q(value__foo="bax"), [self.objs[0], self.objs[7]]),
896 ]
897 for condition, expected in tests:
898 self.assertCountEqual(
899 NullableJSONModel.objects.exclude(condition),
900 expected,
901 )
902 self.assertCountEqual(
903 NullableJSONModel.objects.filter(~condition),
904 expected,
905 )
906
907 def test_lookup_exclude_nonexistent_key(self):
908 # Values without the key are ignored.
909 condition = Q(value__foo="bax")
910 objs_with_value = [self.objs[6]]
911 objs_with_different_value = [self.objs[0], self.objs[7]]
912 self.assertCountEqual(
913 NullableJSONModel.objects.exclude(condition),
914 objs_with_different_value,
915 )
916 self.assertSequenceEqual(
917 NullableJSONModel.objects.exclude(~condition),
918 objs_with_value,
919 )
920 self.assertCountEqual(
921 NullableJSONModel.objects.filter(condition | ~condition),
922 objs_with_value + objs_with_different_value,
923 )
924 self.assertCountEqual(
925 NullableJSONModel.objects.exclude(condition & ~condition),
926 objs_with_value + objs_with_different_value,
927 )
928 # Add the __isnull lookup to get an exhaustive set.
929 self.assertCountEqual(
930 NullableJSONModel.objects.exclude(condition & Q(value__foo__isnull=False)),
931 self.objs[0:6] + self.objs[7:],
932 )
933 self.assertSequenceEqual(
934 NullableJSONModel.objects.filter(condition & Q(value__foo__isnull=False)),
935 objs_with_value,
936 )
937
938 def test_usage_in_subquery(self):
939 self.assertCountEqual(
940 NullableJSONModel.objects.filter(
941 id__in=NullableJSONModel.objects.filter(value__c=14),
942 ),
943 self.objs[3:5],
944 )
945
946 @skipUnlessDBFeature("supports_json_field_contains")
947 def test_array_key_contains(self):
948 tests = [
949 ([], [self.objs[7]]),
950 ("bar", [self.objs[7]]),
951 (["bar"], [self.objs[7]]),
952 ("ar", []),
953 ]
954 for value, expected in tests:
955 with self.subTest(value=value):
956 self.assertSequenceEqual(
957 NullableJSONModel.objects.filter(value__bar__contains=value),
958 expected,
959 )
960
961 def test_key_iexact(self):
962 self.assertIs(
963 NullableJSONModel.objects.filter(value__foo__iexact="BaR").exists(), True
964 )
965 self.assertIs(
966 NullableJSONModel.objects.filter(value__foo__iexact='"BaR"').exists(), False
967 )
968
969 def test_key_in(self):
970 tests = [
971 ("value__c__in", [14], self.objs[3:5]),
972 ("value__c__in", [14, 15], self.objs[3:5]),
973 ("value__0__in", [1], [self.objs[5]]),
974 ("value__0__in", [1, 3], [self.objs[5]]),
975 ("value__foo__in", ["bar"], [self.objs[7]]),
976 (
977 "value__foo__in",
978 [KeyTransform("foo", KeyTransform("bax", "value"))],
979 [self.objs[7]],
980 ),
981 ("value__foo__in", [F("value__bax__foo")], [self.objs[7]]),
982 (
983 "value__foo__in",
984 [KeyTransform("foo", KeyTransform("bax", "value")), "baz"],
985 [self.objs[7]],
986 ),
987 ("value__foo__in", [F("value__bax__foo"), "baz"], [self.objs[7]]),
988 ("value__foo__in", ["bar", "baz"], [self.objs[7]]),
989 ("value__bar__in", [["foo", "bar"]], [self.objs[7]]),
990 ("value__bar__in", [["foo", "bar"], ["a"]], [self.objs[7]]),
991 ("value__bax__in", [{"foo": "bar"}, {"a": "b"}], [self.objs[7]]),
992 ("value__h__in", [True, "foo"], [self.objs[4]]),
993 ("value__i__in", [False, "foo"], [self.objs[4]]),
994 ]
995 for lookup, value, expected in tests:
996 with self.subTest(lookup=lookup, value=value), transaction.atomic():
997 self.assertCountEqual(
998 NullableJSONModel.objects.filter(**{lookup: value}),
999 expected,
1000 )
1001
1002 def test_key_values(self):
1003 qs = NullableJSONModel.objects.filter(value__h=True)
1004 tests = [
1005 ("value__a", "b"),
1006 ("value__c", 14),
1007 ("value__d", ["e", {"f": "g"}]),
1008 ("value__h", True),
1009 ("value__i", False),
1010 ("value__j", None),
1011 ("value__k", {"l": "m"}),
1012 ("value__n", [None, True, False]),
1013 ("value__p", 4.2),
1014 ("value__r", {"s": True, "t": False}),
1015 ]
1016 for lookup, expected in tests:
1017 with self.subTest(lookup=lookup):
1018 self.assertEqual(qs.values_list(lookup, flat=True).get(), expected)
1019
1020 def test_key_values_boolean(self):
1021 qs = NullableJSONModel.objects.filter(value__h=True, value__i=False)
1022 tests = [
1023 ("value__h", True),
1024 ("value__i", False),
1025 ]
1026 for lookup, expected in tests:
1027 with self.subTest(lookup=lookup):
1028 self.assertIs(qs.values_list(lookup, flat=True).get(), expected)
1029
1030 @skipUnlessDBFeature("supports_json_field_contains")
1031 def test_key_contains(self):
1032 self.assertIs(
1033 NullableJSONModel.objects.filter(value__foo__contains="ar").exists(), False
1034 )
1035 self.assertIs(
1036 NullableJSONModel.objects.filter(value__foo__contains="bar").exists(), True
1037 )
1038
1039 def test_key_icontains(self):
1040 self.assertIs(
1041 NullableJSONModel.objects.filter(value__foo__icontains="Ar").exists(), True
1042 )
1043
1044 def test_key_startswith(self):
1045 self.assertIs(
1046 NullableJSONModel.objects.filter(value__foo__startswith="b").exists(), True
1047 )
1048
1049 def test_key_istartswith(self):
1050 self.assertIs(
1051 NullableJSONModel.objects.filter(value__foo__istartswith="B").exists(), True
1052 )
1053
1054 def test_key_endswith(self):
1055 self.assertIs(
1056 NullableJSONModel.objects.filter(value__foo__endswith="r").exists(), True
1057 )
1058
1059 def test_key_iendswith(self):
1060 self.assertIs(
1061 NullableJSONModel.objects.filter(value__foo__iendswith="R").exists(), True
1062 )
1063
1064 def test_key_regex(self):
1065 self.assertIs(
1066 NullableJSONModel.objects.filter(value__foo__regex=r"^bar$").exists(), True
1067 )
1068
1069 def test_key_iregex(self):
1070 self.assertIs(
1071 NullableJSONModel.objects.filter(value__foo__iregex=r"^bAr$").exists(), True
1072 )
1073
1074 def test_key_quoted_string(self):
1075 self.assertEqual(
1076 NullableJSONModel.objects.filter(value__o='"quoted"').get(),
1077 self.objs[4],
1078 )
1079
1080 @skipUnlessDBFeature("has_json_operators")
1081 def test_key_sql_injection(self):
1082 with CaptureQueriesContext(connection) as queries:
1083 self.assertIs(
1084 NullableJSONModel.objects.filter(
1085 **{
1086 """value__test' = '"a"') OR 1 = 1 OR ('d""": "x",
1087 }
1088 ).exists(),
1089 False,
1090 )
1091 self.assertIn(
1092 """."value" -> 'test'' = ''"a"'') OR 1 = 1 OR (''d') = '"x"'""",
1093 queries[0]["sql"],
1094 )
1095
1096 @skipIfDBFeature("has_json_operators")
1097 def test_key_sql_injection_escape(self):
1098 query = str(
1099 JSONModel.objects.filter(
1100 **{
1101 """value__test") = '"a"' OR 1 = 1 OR ("d""": "x",
1102 }
1103 ).query
1104 )
1105 self.assertIn('"test\\"', query)
1106 self.assertIn('\\"d', query)
1107
1108 def test_key_escape(self):
1109 obj = NullableJSONModel.objects.create(value={"%total": 10})
1110 self.assertEqual(
1111 NullableJSONModel.objects.filter(**{"value__%total": 10}).get(), obj
1112 )
1113
1114 def test_none_key_and_exact_lookup(self):
1115 self.assertSequenceEqual(
1116 NullableJSONModel.objects.filter(value__a="b", value__j=None),
1117 [self.objs[4]],
1118 )
1119
1120 def test_lookups_with_key_transform(self):
1121 tests = (
1122 ("value__baz__has_key", "c"),
1123 ("value__baz__has_keys", ["a", "c"]),
1124 ("value__baz__has_any_keys", ["a", "x"]),
1125 ("value__has_key", KeyTextTransform("foo", "value")),
1126 )
1127 for lookup, value in tests:
1128 with self.subTest(lookup=lookup):
1129 self.assertIs(
1130 NullableJSONModel.objects.filter(
1131 **{lookup: value},
1132 ).exists(),
1133 True,
1134 )
1135
1136 @skipUnlessDBFeature("supports_json_field_contains")
1137 def test_contains_contained_by_with_key_transform(self):
1138 tests = [
1139 ("value__d__contains", "e"),
1140 ("value__d__contains", [{"f": "g"}]),
1141 ("value__contains", KeyTransform("bax", "value")),
1142 ("value__contains", F("value__bax")),
1143 ("value__baz__contains", {"a": "b"}),
1144 ("value__baz__contained_by", {"a": "b", "c": "d", "e": "f"}),
1145 (
1146 "value__contained_by",
1147 KeyTransform(
1148 "x",
1149 RawSQL(
1150 self.raw_sql,
1151 ['{"x": {"a": "b", "c": 1, "d": "e"}}'],
1152 ),
1153 ),
1154 ),
1155 ]
1156 # For databases where {'f': 'g'} (without surrounding []) matches
1157 # [{'f': 'g'}].
1158 if not connection.features.json_key_contains_list_matching_requires_list:
1159 tests.append(("value__d__contains", {"f": "g"}))
1160 for lookup, value in tests:
1161 with self.subTest(lookup=lookup, value=value):
1162 self.assertIs(
1163 NullableJSONModel.objects.filter(
1164 **{lookup: value},
1165 ).exists(),
1166 True,
1167 )
1168
1169 def test_join_key_transform_annotation_expression(self):
1170 related_obj = RelatedJSONModel.objects.create(
1171 value={"d": ["f", "e"]},
1172 json_model=self.objs[4],
1173 )
1174 RelatedJSONModel.objects.create(
1175 value={"d": ["e", "f"]},
1176 json_model=self.objs[4],
1177 )
1178 self.assertSequenceEqual(
1179 RelatedJSONModel.objects.annotate(
1180 key=F("value__d"),
1181 related_key=F("json_model__value__d"),
1182 chain=F("key__1"),
1183 expr=Cast("key", models.JSONField()),
1184 ).filter(chain=F("related_key__0")),
1185 [related_obj],
1186 )
1187
1188 def test_key_text_transform_from_lookup(self):
1189 qs = NullableJSONModel.objects.annotate(b=KT("value__bax__foo")).filter(
1190 b__contains="ar",
1191 )
1192 self.assertSequenceEqual(qs, [self.objs[7]])
1193 qs = NullableJSONModel.objects.annotate(c=KT("value__o")).filter(
1194 c__contains="uot",
1195 )
1196 self.assertSequenceEqual(qs, [self.objs[4]])
1197
1198 def test_key_text_transform_from_lookup_invalid(self):
1199 msg = "Lookup must contain key or index transforms."
1200 with self.assertRaisesMessage(ValueError, msg):
1201 KT("value")
1202 with self.assertRaisesMessage(ValueError, msg):
1203 KT("")
1204
1205 def test_literal_annotation_filtering(self):
1206 all_objects = NullableJSONModel.objects.order_by("id")
1207 qs = all_objects.annotate(data=Value({"foo": "bar"}, JSONField())).filter(
1208 data__foo="bar"
1209 )
1210 self.assertQuerySetEqual(qs, all_objects)