diff options
Diffstat (limited to 'tests/postgres_tests/test_hstore.py')
| -rw-r--r-- | tests/postgres_tests/test_hstore.py | 315 |
1 files changed, 159 insertions, 156 deletions
diff --git a/tests/postgres_tests/test_hstore.py b/tests/postgres_tests/test_hstore.py index b6fdd2da60..2aaad637c6 100644 --- a/tests/postgres_tests/test_hstore.py +++ b/tests/postgres_tests/test_hstore.py @@ -21,7 +21,7 @@ except ImportError: class SimpleTests(PostgreSQLTestCase): def test_save_load_success(self): - value = {'a': 'b'} + value = {"a": "b"} instance = HStoreModel(field=value) instance.save() reloaded = HStoreModel.objects.get() @@ -34,15 +34,15 @@ class SimpleTests(PostgreSQLTestCase): self.assertIsNone(reloaded.field) def test_value_null(self): - value = {'a': None} + value = {"a": None} instance = HStoreModel(field=value) instance.save() reloaded = HStoreModel.objects.get() self.assertEqual(reloaded.field, value) def test_key_val_cast_to_string(self): - value = {'a': 1, 'b': 'B', 2: 'c', 'ï': 'ê'} - expected_value = {'a': '1', 'b': 'B', '2': 'c', 'ï': 'ê'} + value = {"a": 1, "b": "B", 2: "c", "ï": "ê"} + expected_value = {"a": "1", "b": "B", "2": "c", "ï": "ê"} instance = HStoreModel.objects.create(field=value) instance = HStoreModel.objects.get() @@ -51,17 +51,17 @@ class SimpleTests(PostgreSQLTestCase): instance = HStoreModel.objects.get(field__a=1) self.assertEqual(instance.field, expected_value) - instance = HStoreModel.objects.get(field__has_keys=[2, 'a', 'ï']) + instance = HStoreModel.objects.get(field__has_keys=[2, "a", "ï"]) self.assertEqual(instance.field, expected_value) def test_array_field(self): value = [ - {'a': 1, 'b': 'B', 2: 'c', 'ï': 'ê'}, - {'a': 1, 'b': 'B', 2: 'c', 'ï': 'ê'}, + {"a": 1, "b": "B", 2: "c", "ï": "ê"}, + {"a": 1, "b": "B", 2: "c", "ï": "ê"}, ] expected_value = [ - {'a': '1', 'b': 'B', '2': 'c', 'ï': 'ê'}, - {'a': '1', 'b': 'B', '2': 'c', 'ï': 'ê'}, + {"a": "1", "b": "B", "2": "c", "ï": "ê"}, + {"a": "1", "b": "B", "2": "c", "ï": "ê"}, ] instance = HStoreModel.objects.create(array_field=value) instance.refresh_from_db() @@ -69,231 +69,225 @@ class SimpleTests(PostgreSQLTestCase): class TestQuerying(PostgreSQLTestCase): - @classmethod def setUpTestData(cls): - cls.objs = HStoreModel.objects.bulk_create([ - HStoreModel(field={'a': 'b'}), - HStoreModel(field={'a': 'b', 'c': 'd'}), - HStoreModel(field={'c': 'd'}), - HStoreModel(field={}), - HStoreModel(field=None), - HStoreModel(field={'cat': 'TigrOu', 'breed': 'birman'}), - HStoreModel(field={'cat': 'minou', 'breed': 'ragdoll'}), - HStoreModel(field={'cat': 'kitty', 'breed': 'Persian'}), - HStoreModel(field={'cat': 'Kit Kat', 'breed': 'persian'}), - ]) + cls.objs = HStoreModel.objects.bulk_create( + [ + HStoreModel(field={"a": "b"}), + HStoreModel(field={"a": "b", "c": "d"}), + HStoreModel(field={"c": "d"}), + HStoreModel(field={}), + HStoreModel(field=None), + HStoreModel(field={"cat": "TigrOu", "breed": "birman"}), + HStoreModel(field={"cat": "minou", "breed": "ragdoll"}), + HStoreModel(field={"cat": "kitty", "breed": "Persian"}), + HStoreModel(field={"cat": "Kit Kat", "breed": "persian"}), + ] + ) def test_exact(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__exact={'a': 'b'}), - self.objs[:1] + HStoreModel.objects.filter(field__exact={"a": "b"}), self.objs[:1] ) def test_contained_by(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__contained_by={'a': 'b', 'c': 'd'}), - self.objs[:4] + HStoreModel.objects.filter(field__contained_by={"a": "b", "c": "d"}), + self.objs[:4], ) def test_contains(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__contains={'a': 'b'}), - self.objs[:2] + HStoreModel.objects.filter(field__contains={"a": "b"}), self.objs[:2] ) def test_in_generator(self): def search(): - yield {'a': 'b'} + yield {"a": "b"} + self.assertSequenceEqual( - HStoreModel.objects.filter(field__in=search()), - self.objs[:1] + HStoreModel.objects.filter(field__in=search()), self.objs[:1] ) def test_has_key(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__has_key='c'), - self.objs[1:3] + HStoreModel.objects.filter(field__has_key="c"), self.objs[1:3] ) def test_has_keys(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__has_keys=['a', 'c']), - self.objs[1:2] + HStoreModel.objects.filter(field__has_keys=["a", "c"]), self.objs[1:2] ) def test_has_any_keys(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__has_any_keys=['a', 'c']), - self.objs[:3] + HStoreModel.objects.filter(field__has_any_keys=["a", "c"]), self.objs[:3] ) def test_key_transform(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__a='b'), - self.objs[:2] + HStoreModel.objects.filter(field__a="b"), self.objs[:2] ) def test_key_transform_raw_expression(self): - expr = RawSQL('%s::hstore', ['x => b, y => c']) + expr = RawSQL("%s::hstore", ["x => b, y => c"]) self.assertSequenceEqual( - HStoreModel.objects.filter(field__a=KeyTransform('x', expr)), - self.objs[:2] + HStoreModel.objects.filter(field__a=KeyTransform("x", expr)), self.objs[:2] ) def test_key_transform_annotation(self): - qs = HStoreModel.objects.annotate(a=F('field__a')) + qs = HStoreModel.objects.annotate(a=F("field__a")) self.assertCountEqual( - qs.values_list('a', flat=True), - ['b', 'b', None, None, None, None, None, None, None], + qs.values_list("a", flat=True), + ["b", "b", None, None, None, None, None, None, None], ) def test_keys(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__keys=['a']), - self.objs[:1] + HStoreModel.objects.filter(field__keys=["a"]), self.objs[:1] ) def test_values(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__values=['b']), - self.objs[:1] + HStoreModel.objects.filter(field__values=["b"]), self.objs[:1] ) def test_field_chaining_contains(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__a__contains='b'), - self.objs[:2] + HStoreModel.objects.filter(field__a__contains="b"), self.objs[:2] ) def test_field_chaining_icontains(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__cat__icontains='INo'), + HStoreModel.objects.filter(field__cat__icontains="INo"), [self.objs[6]], ) def test_field_chaining_startswith(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__cat__startswith='kit'), + HStoreModel.objects.filter(field__cat__startswith="kit"), [self.objs[7]], ) def test_field_chaining_istartswith(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__cat__istartswith='kit'), + HStoreModel.objects.filter(field__cat__istartswith="kit"), self.objs[7:], ) def test_field_chaining_endswith(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__cat__endswith='ou'), + HStoreModel.objects.filter(field__cat__endswith="ou"), [self.objs[6]], ) def test_field_chaining_iendswith(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__cat__iendswith='ou'), + HStoreModel.objects.filter(field__cat__iendswith="ou"), self.objs[5:7], ) def test_field_chaining_iexact(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__breed__iexact='persian'), + HStoreModel.objects.filter(field__breed__iexact="persian"), self.objs[7:], ) def test_field_chaining_regex(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__cat__regex=r'ou$'), + HStoreModel.objects.filter(field__cat__regex=r"ou$"), [self.objs[6]], ) def test_field_chaining_iregex(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__cat__iregex=r'oU$'), + HStoreModel.objects.filter(field__cat__iregex=r"oU$"), self.objs[5:7], ) def test_order_by_field(self): more_objs = ( - HStoreModel.objects.create(field={'g': '637'}), - HStoreModel.objects.create(field={'g': '002'}), - HStoreModel.objects.create(field={'g': '042'}), - HStoreModel.objects.create(field={'g': '981'}), + HStoreModel.objects.create(field={"g": "637"}), + HStoreModel.objects.create(field={"g": "002"}), + HStoreModel.objects.create(field={"g": "042"}), + HStoreModel.objects.create(field={"g": "981"}), ) self.assertSequenceEqual( - HStoreModel.objects.filter(field__has_key='g').order_by('field__g'), - [more_objs[1], more_objs[2], more_objs[0], more_objs[3]] + HStoreModel.objects.filter(field__has_key="g").order_by("field__g"), + [more_objs[1], more_objs[2], more_objs[0], more_objs[3]], ) def test_keys_contains(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__keys__contains=['a']), - self.objs[:2] + HStoreModel.objects.filter(field__keys__contains=["a"]), self.objs[:2] ) def test_values_overlap(self): self.assertSequenceEqual( - HStoreModel.objects.filter(field__values__overlap=['b', 'd']), - self.objs[:3] + HStoreModel.objects.filter(field__values__overlap=["b", "d"]), self.objs[:3] ) def test_key_isnull(self): - obj = HStoreModel.objects.create(field={'a': None}) + obj = HStoreModel.objects.create(field={"a": None}) self.assertSequenceEqual( HStoreModel.objects.filter(field__a__isnull=True), self.objs[2:9] + [obj], ) self.assertSequenceEqual( - HStoreModel.objects.filter(field__a__isnull=False), - self.objs[:2] + HStoreModel.objects.filter(field__a__isnull=False), self.objs[:2] ) def test_usage_in_subquery(self): self.assertSequenceEqual( - HStoreModel.objects.filter(id__in=HStoreModel.objects.filter(field__a='b')), - self.objs[:2] + HStoreModel.objects.filter(id__in=HStoreModel.objects.filter(field__a="b")), + self.objs[:2], ) def test_key_sql_injection(self): with CaptureQueriesContext(connection) as queries: self.assertFalse( - HStoreModel.objects.filter(**{ - "field__test' = 'a') OR 1 = 1 OR ('d": 'x', - }).exists() + HStoreModel.objects.filter( + **{ + "field__test' = 'a') OR 1 = 1 OR ('d": "x", + } + ).exists() ) self.assertIn( """."field" -> 'test'' = ''a'') OR 1 = 1 OR (''d') = 'x' """, - queries[0]['sql'], + queries[0]["sql"], ) def test_obj_subquery_lookup(self): qs = HStoreModel.objects.annotate( - value=Subquery(HStoreModel.objects.filter(pk=OuterRef('pk')).values('field')), - ).filter(value__a='b') + value=Subquery( + HStoreModel.objects.filter(pk=OuterRef("pk")).values("field") + ), + ).filter(value__a="b") self.assertSequenceEqual(qs, self.objs[:2]) -@isolate_apps('postgres_tests') +@isolate_apps("postgres_tests") class TestChecks(PostgreSQLSimpleTestCase): - def test_invalid_default(self): class MyModel(PostgreSQLModel): field = HStoreField(default={}) model = MyModel() - self.assertEqual(model.check(), [ - checks.Warning( - msg=( - "HStoreField 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 `dict` instead of `{}`.', - obj=MyModel._meta.get_field('field'), - id='fields.E010', - ) - ]) + self.assertEqual( + model.check(), + [ + checks.Warning( + msg=( + "HStoreField 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 `dict` instead of `{}`.", + obj=MyModel._meta.get_field("field"), + id="fields.E010", + ) + ], + ) def test_valid_default(self): class MyModel(PostgreSQLModel): @@ -303,83 +297,90 @@ class TestChecks(PostgreSQLSimpleTestCase): class TestSerialization(PostgreSQLSimpleTestCase): - test_data = json.dumps([{ - 'model': 'postgres_tests.hstoremodel', - 'pk': None, - 'fields': { - 'field': json.dumps({'a': 'b'}), - 'array_field': json.dumps([ - json.dumps({'a': 'b'}), - json.dumps({'b': 'a'}), - ]), - }, - }]) + test_data = json.dumps( + [ + { + "model": "postgres_tests.hstoremodel", + "pk": None, + "fields": { + "field": json.dumps({"a": "b"}), + "array_field": json.dumps( + [ + json.dumps({"a": "b"}), + json.dumps({"b": "a"}), + ] + ), + }, + } + ] + ) def test_dumping(self): - instance = HStoreModel(field={'a': 'b'}, array_field=[{'a': 'b'}, {'b': 'a'}]) - data = serializers.serialize('json', [instance]) + instance = HStoreModel(field={"a": "b"}, array_field=[{"a": "b"}, {"b": "a"}]) + 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, {'a': 'b'}) - self.assertEqual(instance.array_field, [{'a': 'b'}, {'b': 'a'}]) + instance = list(serializers.deserialize("json", self.test_data))[0].object + self.assertEqual(instance.field, {"a": "b"}) + self.assertEqual(instance.array_field, [{"a": "b"}, {"b": "a"}]) def test_roundtrip_with_null(self): - instance = HStoreModel(field={'a': 'b', 'c': None}) - data = serializers.serialize('json', [instance]) - new_instance = list(serializers.deserialize('json', data))[0].object + instance = HStoreModel(field={"a": "b", "c": None}) + data = serializers.serialize("json", [instance]) + new_instance = list(serializers.deserialize("json", data))[0].object self.assertEqual(instance.field, new_instance.field) class TestValidation(PostgreSQLSimpleTestCase): - def test_not_a_string(self): field = HStoreField() with self.assertRaises(exceptions.ValidationError) as cm: - field.clean({'a': 1}, None) - self.assertEqual(cm.exception.code, 'not_a_string') - self.assertEqual(cm.exception.message % cm.exception.params, 'The value of “a” is not a string or null.') + field.clean({"a": 1}, None) + self.assertEqual(cm.exception.code, "not_a_string") + self.assertEqual( + cm.exception.message % cm.exception.params, + "The value of “a” is not a string or null.", + ) def test_none_allowed_as_value(self): field = HStoreField() - self.assertEqual(field.clean({'a': None}, None), {'a': None}) + self.assertEqual(field.clean({"a": None}, None), {"a": None}) class TestFormField(PostgreSQLSimpleTestCase): - def test_valid(self): field = forms.HStoreField() value = field.clean('{"a": "b"}') - self.assertEqual(value, {'a': 'b'}) + self.assertEqual(value, {"a": "b"}) def test_invalid_json(self): field = forms.HStoreField() with self.assertRaises(exceptions.ValidationError) as cm: field.clean('{"a": "b"') - self.assertEqual(cm.exception.messages[0], 'Could not load JSON data.') - self.assertEqual(cm.exception.code, 'invalid_json') + self.assertEqual(cm.exception.messages[0], "Could not load JSON data.") + self.assertEqual(cm.exception.code, "invalid_json") def test_non_dict_json(self): field = forms.HStoreField() - msg = 'Input must be a JSON dictionary.' + msg = "Input must be a JSON dictionary." with self.assertRaisesMessage(exceptions.ValidationError, msg) as cm: field.clean('["a", "b", 1]') - self.assertEqual(cm.exception.code, 'invalid_format') + self.assertEqual(cm.exception.code, "invalid_format") def test_not_string_values(self): field = forms.HStoreField() value = field.clean('{"a": 1}') - self.assertEqual(value, {'a': '1'}) + self.assertEqual(value, {"a": "1"}) def test_none_value(self): field = forms.HStoreField() value = field.clean('{"a": null}') - self.assertEqual(value, {'a': None}) + self.assertEqual(value, {"a": None}) def test_empty(self): field = forms.HStoreField(required=False) - value = field.clean('') + value = field.clean("") self.assertEqual(value, {}) def test_model_field_formfield(self): @@ -390,69 +391,71 @@ class TestFormField(PostgreSQLSimpleTestCase): def test_field_has_changed(self): class HStoreFormTest(Form): f1 = forms.HStoreField() + form_w_hstore = HStoreFormTest() self.assertFalse(form_w_hstore.has_changed()) - form_w_hstore = HStoreFormTest({'f1': '{"a": 1}'}) + form_w_hstore = HStoreFormTest({"f1": '{"a": 1}'}) self.assertTrue(form_w_hstore.has_changed()) - form_w_hstore = HStoreFormTest({'f1': '{"a": 1}'}, initial={'f1': '{"a": 1}'}) + form_w_hstore = HStoreFormTest({"f1": '{"a": 1}'}, initial={"f1": '{"a": 1}'}) self.assertFalse(form_w_hstore.has_changed()) - form_w_hstore = HStoreFormTest({'f1': '{"a": 2}'}, initial={'f1': '{"a": 1}'}) + form_w_hstore = HStoreFormTest({"f1": '{"a": 2}'}, initial={"f1": '{"a": 1}'}) self.assertTrue(form_w_hstore.has_changed()) - form_w_hstore = HStoreFormTest({'f1': '{"a": 1}'}, initial={'f1': {"a": 1}}) + form_w_hstore = HStoreFormTest({"f1": '{"a": 1}'}, initial={"f1": {"a": 1}}) self.assertFalse(form_w_hstore.has_changed()) - form_w_hstore = HStoreFormTest({'f1': '{"a": 2}'}, initial={'f1': {"a": 1}}) + form_w_hstore = HStoreFormTest({"f1": '{"a": 2}'}, initial={"f1": {"a": 1}}) self.assertTrue(form_w_hstore.has_changed()) class TestValidator(PostgreSQLSimpleTestCase): - def test_simple_valid(self): - validator = KeysValidator(keys=['a', 'b']) - validator({'a': 'foo', 'b': 'bar', 'c': 'baz'}) + validator = KeysValidator(keys=["a", "b"]) + validator({"a": "foo", "b": "bar", "c": "baz"}) def test_missing_keys(self): - validator = KeysValidator(keys=['a', 'b']) + validator = KeysValidator(keys=["a", "b"]) with self.assertRaises(exceptions.ValidationError) as cm: - validator({'a': 'foo', 'c': 'baz'}) - self.assertEqual(cm.exception.messages[0], 'Some keys were missing: b') - self.assertEqual(cm.exception.code, 'missing_keys') + validator({"a": "foo", "c": "baz"}) + self.assertEqual(cm.exception.messages[0], "Some keys were missing: b") + self.assertEqual(cm.exception.code, "missing_keys") def test_strict_valid(self): - validator = KeysValidator(keys=['a', 'b'], strict=True) - validator({'a': 'foo', 'b': 'bar'}) + validator = KeysValidator(keys=["a", "b"], strict=True) + validator({"a": "foo", "b": "bar"}) def test_extra_keys(self): - validator = KeysValidator(keys=['a', 'b'], strict=True) + validator = KeysValidator(keys=["a", "b"], strict=True) with self.assertRaises(exceptions.ValidationError) as cm: - validator({'a': 'foo', 'b': 'bar', 'c': 'baz'}) - self.assertEqual(cm.exception.messages[0], 'Some unknown keys were provided: c') - self.assertEqual(cm.exception.code, 'extra_keys') + validator({"a": "foo", "b": "bar", "c": "baz"}) + self.assertEqual(cm.exception.messages[0], "Some unknown keys were provided: c") + self.assertEqual(cm.exception.code, "extra_keys") def test_custom_messages(self): messages = { - 'missing_keys': 'Foobar', + "missing_keys": "Foobar", } - validator = KeysValidator(keys=['a', 'b'], strict=True, messages=messages) + validator = KeysValidator(keys=["a", "b"], strict=True, messages=messages) with self.assertRaises(exceptions.ValidationError) as cm: - validator({'a': 'foo', 'c': 'baz'}) - self.assertEqual(cm.exception.messages[0], 'Foobar') - self.assertEqual(cm.exception.code, 'missing_keys') + validator({"a": "foo", "c": "baz"}) + self.assertEqual(cm.exception.messages[0], "Foobar") + self.assertEqual(cm.exception.code, "missing_keys") with self.assertRaises(exceptions.ValidationError) as cm: - validator({'a': 'foo', 'b': 'bar', 'c': 'baz'}) - self.assertEqual(cm.exception.messages[0], 'Some unknown keys were provided: c') - self.assertEqual(cm.exception.code, 'extra_keys') + validator({"a": "foo", "b": "bar", "c": "baz"}) + self.assertEqual(cm.exception.messages[0], "Some unknown keys were provided: c") + self.assertEqual(cm.exception.code, "extra_keys") def test_deconstruct(self): messages = { - 'missing_keys': 'Foobar', + "missing_keys": "Foobar", } - validator = KeysValidator(keys=['a', 'b'], strict=True, messages=messages) + validator = KeysValidator(keys=["a", "b"], strict=True, messages=messages) path, args, kwargs = validator.deconstruct() - self.assertEqual(path, 'django.contrib.postgres.validators.KeysValidator') + self.assertEqual(path, "django.contrib.postgres.validators.KeysValidator") self.assertEqual(args, ()) - self.assertEqual(kwargs, {'keys': ['a', 'b'], 'strict': True, 'messages': messages}) + self.assertEqual( + kwargs, {"keys": ["a", "b"], "strict": True, "messages": messages} + ) |