Debian Codegraph @

tests/postgres_tests/test_hstore.py

raw
1 import json
2
3 from django.core import checks, exceptions, serializers
4 from django.db import connection
5 from django.db.models import F, OuterRef, Subquery
6 from django.db.models.expressions import RawSQL
7 from django.forms import Form
8 from django.test.utils import CaptureQueriesContext, isolate_apps
9
10 from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase
11 from .models import HStoreModel, PostgreSQLModel
12
13 try:
14 from django.contrib.postgres import forms
15 from django.contrib.postgres.fields import HStoreField
16 from django.contrib.postgres.fields.hstore import KeyTransform
17 from django.contrib.postgres.validators import KeysValidator
18 except ImportError:
19 pass
20
21
22 class SimpleTests(PostgreSQLTestCase):
23 def test_save_load_success(self):
24 value = {"a": "b"}
25 instance = HStoreModel(field=value)
26 instance.save()
27 reloaded = HStoreModel.objects.get()
28 self.assertEqual(reloaded.field, value)
29
30 def test_null(self):
31 instance = HStoreModel(field=None)
32 instance.save()
33 reloaded = HStoreModel.objects.get()
34 self.assertIsNone(reloaded.field)
35
36 def test_value_null(self):
37 value = {"a": None}
38 instance = HStoreModel(field=value)
39 instance.save()
40 reloaded = HStoreModel.objects.get()
41 self.assertEqual(reloaded.field, value)
42
43 def test_key_val_cast_to_string(self):
44 value = {"a": 1, "b": "B", 2: "c", "ï": "ê"}
45 expected_value = {"a": "1", "b": "B", "2": "c", "ï": "ê"}
46
47 instance = HStoreModel.objects.create(field=value)
48 instance = HStoreModel.objects.get()
49 self.assertEqual(instance.field, expected_value)
50
51 instance = HStoreModel.objects.get(field__a=1)
52 self.assertEqual(instance.field, expected_value)
53
54 instance = HStoreModel.objects.get(field__has_keys=[2, "a", "ï"])
55 self.assertEqual(instance.field, expected_value)
56
57 def test_array_field(self):
58 value = [
59 {"a": 1, "b": "B", 2: "c", "ï": "ê"},
60 {"a": 1, "b": "B", 2: "c", "ï": "ê"},
61 ]
62 expected_value = [
63 {"a": "1", "b": "B", "2": "c", "ï": "ê"},
64 {"a": "1", "b": "B", "2": "c", "ï": "ê"},
65 ]
66 instance = HStoreModel.objects.create(array_field=value)
67 instance.refresh_from_db()
68 self.assertEqual(instance.array_field, expected_value)
69
70
71 class TestQuerying(PostgreSQLTestCase):
72 @classmethod
73 def setUpTestData(cls):
74 cls.objs = HStoreModel.objects.bulk_create(
75 [
76 HStoreModel(field={"a": "b"}),
77 HStoreModel(field={"a": "b", "c": "d"}),
78 HStoreModel(field={"c": "d"}),
79 HStoreModel(field={}),
80 HStoreModel(field=None),
81 HStoreModel(field={"cat": "TigrOu", "breed": "birman"}),
82 HStoreModel(field={"cat": "minou", "breed": "ragdoll"}),
83 HStoreModel(field={"cat": "kitty", "breed": "Persian"}),
84 HStoreModel(field={"cat": "Kit Kat", "breed": "persian"}),
85 ]
86 )
87
88 def test_exact(self):
89 self.assertSequenceEqual(
90 HStoreModel.objects.filter(field__exact={"a": "b"}), self.objs[:1]
91 )
92
93 def test_contained_by(self):
94 self.assertSequenceEqual(
95 HStoreModel.objects.filter(field__contained_by={"a": "b", "c": "d"}),
96 self.objs[:4],
97 )
98
99 def test_contains(self):
100 self.assertSequenceEqual(
101 HStoreModel.objects.filter(field__contains={"a": "b"}), self.objs[:2]
102 )
103
104 def test_in_generator(self):
105 def search():
106 yield {"a": "b"}
107
108 self.assertSequenceEqual(
109 HStoreModel.objects.filter(field__in=search()), self.objs[:1]
110 )
111
112 def test_has_key(self):
113 self.assertSequenceEqual(
114 HStoreModel.objects.filter(field__has_key="c"), self.objs[1:3]
115 )
116
117 def test_has_keys(self):
118 self.assertSequenceEqual(
119 HStoreModel.objects.filter(field__has_keys=["a", "c"]), self.objs[1:2]
120 )
121
122 def test_has_any_keys(self):
123 self.assertSequenceEqual(
124 HStoreModel.objects.filter(field__has_any_keys=["a", "c"]), self.objs[:3]
125 )
126
127 def test_key_transform(self):
128 self.assertSequenceEqual(
129 HStoreModel.objects.filter(field__a="b"), self.objs[:2]
130 )
131
132 def test_key_transform_raw_expression(self):
133 expr = RawSQL("%s::hstore", ["x => b, y => c"])
134 self.assertSequenceEqual(
135 HStoreModel.objects.filter(field__a=KeyTransform("x", expr)), self.objs[:2]
136 )
137
138 def test_key_transform_annotation(self):
139 qs = HStoreModel.objects.annotate(a=F("field__a"))
140 self.assertCountEqual(
141 qs.values_list("a", flat=True),
142 ["b", "b", None, None, None, None, None, None, None],
143 )
144
145 def test_keys(self):
146 self.assertSequenceEqual(
147 HStoreModel.objects.filter(field__keys=["a"]), self.objs[:1]
148 )
149
150 def test_values(self):
151 self.assertSequenceEqual(
152 HStoreModel.objects.filter(field__values=["b"]), self.objs[:1]
153 )
154
155 def test_field_chaining_contains(self):
156 self.assertSequenceEqual(
157 HStoreModel.objects.filter(field__a__contains="b"), self.objs[:2]
158 )
159
160 def test_field_chaining_icontains(self):
161 self.assertSequenceEqual(
162 HStoreModel.objects.filter(field__cat__icontains="INo"),
163 [self.objs[6]],
164 )
165
166 def test_field_chaining_startswith(self):
167 self.assertSequenceEqual(
168 HStoreModel.objects.filter(field__cat__startswith="kit"),
169 [self.objs[7]],
170 )
171
172 def test_field_chaining_istartswith(self):
173 self.assertSequenceEqual(
174 HStoreModel.objects.filter(field__cat__istartswith="kit"),
175 self.objs[7:],
176 )
177
178 def test_field_chaining_endswith(self):
179 self.assertSequenceEqual(
180 HStoreModel.objects.filter(field__cat__endswith="ou"),
181 [self.objs[6]],
182 )
183
184 def test_field_chaining_iendswith(self):
185 self.assertSequenceEqual(
186 HStoreModel.objects.filter(field__cat__iendswith="ou"),
187 self.objs[5:7],
188 )
189
190 def test_field_chaining_iexact(self):
191 self.assertSequenceEqual(
192 HStoreModel.objects.filter(field__breed__iexact="persian"),
193 self.objs[7:],
194 )
195
196 def test_field_chaining_regex(self):
197 self.assertSequenceEqual(
198 HStoreModel.objects.filter(field__cat__regex=r"ou$"),
199 [self.objs[6]],
200 )
201
202 def test_field_chaining_iregex(self):
203 self.assertSequenceEqual(
204 HStoreModel.objects.filter(field__cat__iregex=r"oU$"),
205 self.objs[5:7],
206 )
207
208 def test_order_by_field(self):
209 more_objs = (
210 HStoreModel.objects.create(field={"g": "637"}),
211 HStoreModel.objects.create(field={"g": "002"}),
212 HStoreModel.objects.create(field={"g": "042"}),
213 HStoreModel.objects.create(field={"g": "981"}),
214 )
215 self.assertSequenceEqual(
216 HStoreModel.objects.filter(field__has_key="g").order_by("field__g"),
217 [more_objs[1], more_objs[2], more_objs[0], more_objs[3]],
218 )
219
220 def test_keys_contains(self):
221 self.assertSequenceEqual(
222 HStoreModel.objects.filter(field__keys__contains=["a"]), self.objs[:2]
223 )
224
225 def test_values_overlap(self):
226 self.assertSequenceEqual(
227 HStoreModel.objects.filter(field__values__overlap=["b", "d"]), self.objs[:3]
228 )
229
230 def test_key_isnull(self):
231 obj = HStoreModel.objects.create(field={"a": None})
232 self.assertSequenceEqual(
233 HStoreModel.objects.filter(field__a__isnull=True),
234 self.objs[2:9] + [obj],
235 )
236 self.assertSequenceEqual(
237 HStoreModel.objects.filter(field__a__isnull=False), self.objs[:2]
238 )
239
240 def test_usage_in_subquery(self):
241 self.assertSequenceEqual(
242 HStoreModel.objects.filter(id__in=HStoreModel.objects.filter(field__a="b")),
243 self.objs[:2],
244 )
245
246 def test_key_sql_injection(self):
247 with CaptureQueriesContext(connection) as queries:
248 self.assertFalse(
249 HStoreModel.objects.filter(
250 **{
251 "field__test' = 'a') OR 1 = 1 OR ('d": "x",
252 }
253 ).exists()
254 )
255 self.assertIn(
256 """."field" -> 'test'' = ''a'') OR 1 = 1 OR (''d') = 'x' """,
257 queries[0]["sql"],
258 )
259
260 def test_obj_subquery_lookup(self):
261 qs = HStoreModel.objects.annotate(
262 value=Subquery(
263 HStoreModel.objects.filter(pk=OuterRef("pk")).values("field")
264 ),
265 ).filter(value__a="b")
266 self.assertSequenceEqual(qs, self.objs[:2])
267
268
269 @isolate_apps("postgres_tests")
270 class TestChecks(PostgreSQLSimpleTestCase):
271 def test_invalid_default(self):
272 class MyModel(PostgreSQLModel):
273 field = HStoreField(default={})
274
275 model = MyModel()
276 self.assertEqual(
277 model.check(),
278 [
279 checks.Warning(
280 msg=(
281 "HStoreField default should be a callable instead of an "
282 "instance so that it's not shared between all field "
283 "instances."
284 ),
285 hint="Use a callable instead, e.g., use `dict` instead of `{}`.",
286 obj=MyModel._meta.get_field("field"),
287 id="fields.E010",
288 )
289 ],
290 )
291
292 def test_valid_default(self):
293 class MyModel(PostgreSQLModel):
294 field = HStoreField(default=dict)
295
296 self.assertEqual(MyModel().check(), [])
297
298
299 class TestSerialization(PostgreSQLSimpleTestCase):
300 field_values = [
301 ({"a": "b"}, [{"a": "b"}, {"b": "a"}]),
302 (
303 {"все": "Трурль и Клапауций"},
304 [{"Трурль": "Клапауций"}, {"Клапауций": "Трурль"}],
305 ),
306 ]
307
308 @staticmethod
309 def create_json_data(field_value, array_field_value):
310 fields = {
311 "field": json.dumps(field_value, ensure_ascii=False),
312 "array_field": json.dumps(
313 [json.dumps(item, ensure_ascii=False) for item in array_field_value],
314 ensure_ascii=False,
315 ),
316 }
317 return json.dumps(
318 [{"model": "postgres_tests.hstoremodel", "pk": None, "fields": fields}]
319 )
320
321 def test_dumping(self):
322 for field_value, array_field_value in self.field_values:
323 with self.subTest(field_value=field_value, array_value=array_field_value):
324 instance = HStoreModel(field=field_value, array_field=array_field_value)
325 data = serializers.serialize("json", [instance])
326 json_data = self.create_json_data(field_value, array_field_value)
327 self.assertEqual(json.loads(data), json.loads(json_data))
328
329 def test_loading(self):
330 for field_value, array_field_value in self.field_values:
331 with self.subTest(field_value=field_value, array_value=array_field_value):
332 json_data = self.create_json_data(field_value, array_field_value)
333 instance = list(serializers.deserialize("json", json_data))[0].object
334 self.assertEqual(instance.field, field_value)
335 self.assertEqual(instance.array_field, array_field_value)
336
337 def test_roundtrip_with_null(self):
338 for field_value in [
339 {"a": "b", "c": None},
340 {"Енеїда": "Ти знаєш, він який суціга", "Зефір": None},
341 ]:
342 with self.subTest(field_value=field_value):
343 instance = HStoreModel(field=field_value)
344 data = serializers.serialize("json", [instance])
345 new_instance = list(serializers.deserialize("json", data))[0].object
346 self.assertEqual(instance.field, new_instance.field)
347
348
349 class TestValidation(PostgreSQLSimpleTestCase):
350 def test_not_a_string(self):
351 field = HStoreField()
352 with self.assertRaises(exceptions.ValidationError) as cm:
353 field.clean({"a": 1}, None)
354 self.assertEqual(cm.exception.code, "not_a_string")
355 self.assertEqual(
356 cm.exception.message % cm.exception.params,
357 "The value of “a” is not a string or null.",
358 )
359
360 def test_none_allowed_as_value(self):
361 field = HStoreField()
362 self.assertEqual(field.clean({"a": None}, None), {"a": None})
363
364
365 class TestFormField(PostgreSQLSimpleTestCase):
366 def test_valid(self):
367 field = forms.HStoreField()
368 value = field.clean('{"a": "b"}')
369 self.assertEqual(value, {"a": "b"})
370
371 def test_invalid_json(self):
372 field = forms.HStoreField()
373 with self.assertRaises(exceptions.ValidationError) as cm:
374 field.clean('{"a": "b"')
375 self.assertEqual(cm.exception.messages[0], "Could not load JSON data.")
376 self.assertEqual(cm.exception.code, "invalid_json")
377
378 def test_non_dict_json(self):
379 field = forms.HStoreField()
380 msg = "Input must be a JSON dictionary."
381 with self.assertRaisesMessage(exceptions.ValidationError, msg) as cm:
382 field.clean('["a", "b", 1]')
383 self.assertEqual(cm.exception.code, "invalid_format")
384
385 def test_not_string_values(self):
386 field = forms.HStoreField()
387 value = field.clean('{"a": 1}')
388 self.assertEqual(value, {"a": "1"})
389
390 def test_none_value(self):
391 field = forms.HStoreField()
392 value = field.clean('{"a": null}')
393 self.assertEqual(value, {"a": None})
394
395 def test_empty(self):
396 field = forms.HStoreField(required=False)
397 value = field.clean("")
398 self.assertEqual(value, {})
399
400 def test_model_field_formfield(self):
401 model_field = HStoreField()
402 form_field = model_field.formfield()
403 self.assertIsInstance(form_field, forms.HStoreField)
404
405 def test_field_has_changed(self):
406 class HStoreFormTest(Form):
407 f1 = forms.HStoreField()
408
409 form_w_hstore = HStoreFormTest()
410 self.assertFalse(form_w_hstore.has_changed())
411
412 form_w_hstore = HStoreFormTest({"f1": '{"a": 1}'})
413 self.assertTrue(form_w_hstore.has_changed())
414
415 form_w_hstore = HStoreFormTest({"f1": '{"a": 1}'}, initial={"f1": '{"a": 1}'})
416 self.assertFalse(form_w_hstore.has_changed())
417
418 form_w_hstore = HStoreFormTest({"f1": '{"a": 2}'}, initial={"f1": '{"a": 1}'})
419 self.assertTrue(form_w_hstore.has_changed())
420
421 form_w_hstore = HStoreFormTest({"f1": '{"a": 1}'}, initial={"f1": {"a": 1}})
422 self.assertFalse(form_w_hstore.has_changed())
423
424 form_w_hstore = HStoreFormTest({"f1": '{"a": 2}'}, initial={"f1": {"a": 1}})
425 self.assertTrue(form_w_hstore.has_changed())
426
427 def test_prepare_value(self):
428 field = forms.HStoreField()
429 self.assertEqual(
430 field.prepare_value({"aira_maplayer": "Αρδευτικό δίκτυο"}),
431 '{"aira_maplayer": "Αρδευτικό δίκτυο"}',
432 )
433
434
435 class TestValidator(PostgreSQLSimpleTestCase):
436 def test_simple_valid(self):
437 validator = KeysValidator(keys=["a", "b"])
438 validator({"a": "foo", "b": "bar", "c": "baz"})
439
440 def test_missing_keys(self):
441 validator = KeysValidator(keys=["a", "b"])
442 with self.assertRaises(exceptions.ValidationError) as cm:
443 validator({"a": "foo", "c": "baz"})
444 self.assertEqual(cm.exception.messages[0], "Some keys were missing: b")
445 self.assertEqual(cm.exception.code, "missing_keys")
446
447 def test_strict_valid(self):
448 validator = KeysValidator(keys=["a", "b"], strict=True)
449 validator({"a": "foo", "b": "bar"})
450
451 def test_extra_keys(self):
452 validator = KeysValidator(keys=["a", "b"], strict=True)
453 with self.assertRaises(exceptions.ValidationError) as cm:
454 validator({"a": "foo", "b": "bar", "c": "baz"})
455 self.assertEqual(cm.exception.messages[0], "Some unknown keys were provided: c")
456 self.assertEqual(cm.exception.code, "extra_keys")
457
458 def test_custom_messages(self):
459 messages = {
460 "missing_keys": "Foobar",
461 }
462 validator = KeysValidator(keys=["a", "b"], strict=True, messages=messages)
463 with self.assertRaises(exceptions.ValidationError) as cm:
464 validator({"a": "foo", "c": "baz"})
465 self.assertEqual(cm.exception.messages[0], "Foobar")
466 self.assertEqual(cm.exception.code, "missing_keys")
467 with self.assertRaises(exceptions.ValidationError) as cm:
468 validator({"a": "foo", "b": "bar", "c": "baz"})
469 self.assertEqual(cm.exception.messages[0], "Some unknown keys were provided: c")
470 self.assertEqual(cm.exception.code, "extra_keys")
471
472 def test_deconstruct(self):
473 messages = {
474 "missing_keys": "Foobar",
475 }
476 validator = KeysValidator(keys=["a", "b"], strict=True, messages=messages)
477 path, args, kwargs = validator.deconstruct()
478 self.assertEqual(path, "django.contrib.postgres.validators.KeysValidator")
479 self.assertEqual(args, ())
480 self.assertEqual(
481 kwargs, {"keys": ["a", "b"], "strict": True, "messages": messages}
482 )