summaryrefslogtreecommitdiff
path: root/tests/postgres_tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests/postgres_tests')
-rw-r--r--tests/postgres_tests/fields.py7
-rw-r--r--tests/postgres_tests/migrations/0002_create_test_models.py17
-rw-r--r--tests/postgres_tests/models.py10
-rw-r--r--tests/postgres_tests/test_bulk_update.py3
-rw-r--r--tests/postgres_tests/test_introspection.py6
-rw-r--r--tests/postgres_tests/test_json.py583
-rw-r--r--tests/postgres_tests/test_json_deprecation.py54
7 files changed, 60 insertions, 620 deletions
diff --git a/tests/postgres_tests/fields.py b/tests/postgres_tests/fields.py
index 4ebc0ce7dc..a36c10c750 100644
--- a/tests/postgres_tests/fields.py
+++ b/tests/postgres_tests/fields.py
@@ -10,7 +10,7 @@ try:
from django.contrib.postgres.fields import (
ArrayField, BigIntegerRangeField, CICharField, CIEmailField,
CITextField, DateRangeField, DateTimeRangeField, DecimalRangeField,
- HStoreField, IntegerRangeField, JSONField,
+ HStoreField, IntegerRangeField,
)
from django.contrib.postgres.search import SearchVectorField
except ImportError:
@@ -26,10 +26,6 @@ except ImportError:
})
return name, path, args, kwargs
- class DummyJSONField(models.Field):
- def __init__(self, encoder=None, **kwargs):
- super().__init__(**kwargs)
-
ArrayField = DummyArrayField
BigIntegerRangeField = models.Field
CICharField = models.Field
@@ -40,7 +36,6 @@ except ImportError:
DecimalRangeField = models.Field
HStoreField = models.Field
IntegerRangeField = models.Field
- JSONField = DummyJSONField
SearchVectorField = models.Field
diff --git a/tests/postgres_tests/migrations/0002_create_test_models.py b/tests/postgres_tests/migrations/0002_create_test_models.py
index ee1463e1eb..cb5f4c6d3e 100644
--- a/tests/postgres_tests/migrations/0002_create_test_models.py
+++ b/tests/postgres_tests/migrations/0002_create_test_models.py
@@ -1,10 +1,9 @@
-from django.core.serializers.json import DjangoJSONEncoder
from django.db import migrations, models
from ..fields import (
ArrayField, BigIntegerRangeField, CICharField, CIEmailField, CITextField,
DateRangeField, DateTimeRangeField, DecimalRangeField, EnumField,
- HStoreField, IntegerRangeField, JSONField, SearchVectorField,
+ HStoreField, IntegerRangeField, SearchVectorField,
)
from ..models import TagField
@@ -60,7 +59,7 @@ class Migration(migrations.Migration):
('uuids', ArrayField(models.UUIDField(), size=None, default=list)),
('decimals', ArrayField(models.DecimalField(max_digits=5, decimal_places=2), size=None, default=list)),
('tags', ArrayField(TagField(), blank=True, null=True, size=None)),
- ('json', ArrayField(JSONField(default={}), default=[])),
+ ('json', ArrayField(models.JSONField(default={}), default=[])),
('int_ranges', ArrayField(IntegerRangeField(), null=True, blank=True)),
('bigint_ranges', ArrayField(BigIntegerRangeField(), null=True, blank=True)),
],
@@ -271,18 +270,6 @@ class Migration(migrations.Migration):
bases=(models.Model,),
),
migrations.CreateModel(
- name='JSONModel',
- fields=[
- ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
- ('field', JSONField(null=True, blank=True)),
- ('field_custom', JSONField(null=True, blank=True, encoder=DjangoJSONEncoder)),
- ],
- options={
- 'required_db_vendor': 'postgresql',
- },
- bases=(models.Model,),
- ),
- migrations.CreateModel(
name='ArrayEnumModel',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
diff --git a/tests/postgres_tests/models.py b/tests/postgres_tests/models.py
index 24605954b2..464245fbab 100644
--- a/tests/postgres_tests/models.py
+++ b/tests/postgres_tests/models.py
@@ -1,10 +1,9 @@
-from django.core.serializers.json import DjangoJSONEncoder
from django.db import models
from .fields import (
ArrayField, BigIntegerRangeField, CICharField, CIEmailField, CITextField,
DateRangeField, DateTimeRangeField, DecimalRangeField, EnumField,
- HStoreField, IntegerRangeField, JSONField, SearchVectorField,
+ HStoreField, IntegerRangeField, SearchVectorField,
)
@@ -68,7 +67,7 @@ class OtherTypesArrayModel(PostgreSQLModel):
uuids = ArrayField(models.UUIDField(), default=list)
decimals = ArrayField(models.DecimalField(max_digits=5, decimal_places=2), default=list)
tags = ArrayField(TagField(), blank=True, null=True)
- json = ArrayField(JSONField(default=dict), default=list)
+ json = ArrayField(models.JSONField(default=dict), default=list)
int_ranges = ArrayField(IntegerRangeField(), blank=True, null=True)
bigint_ranges = ArrayField(BigIntegerRangeField(), blank=True, null=True)
@@ -150,11 +149,6 @@ class RangeLookupsModel(PostgreSQLModel):
decimal_field = models.DecimalField(max_digits=5, decimal_places=2, blank=True, null=True)
-class JSONModel(PostgreSQLModel):
- field = JSONField(blank=True, null=True)
- field_custom = JSONField(blank=True, null=True, encoder=DjangoJSONEncoder)
-
-
class ArrayFieldSubclass(ArrayField):
def __init__(self, *args, **kwargs):
super().__init__(models.IntegerField())
diff --git a/tests/postgres_tests/test_bulk_update.py b/tests/postgres_tests/test_bulk_update.py
index 6dd7036a9b..7fa2a6a7db 100644
--- a/tests/postgres_tests/test_bulk_update.py
+++ b/tests/postgres_tests/test_bulk_update.py
@@ -2,7 +2,7 @@ from datetime import date
from . import PostgreSQLTestCase
from .models import (
- HStoreModel, IntegerArrayModel, JSONModel, NestedIntegerArrayModel,
+ HStoreModel, IntegerArrayModel, NestedIntegerArrayModel,
NullableIntegerArrayModel, OtherTypesArrayModel, RangesModel,
)
@@ -17,7 +17,6 @@ class BulkSaveTests(PostgreSQLTestCase):
test_data = [
(IntegerArrayModel, 'field', [], [1, 2, 3]),
(NullableIntegerArrayModel, 'field', [1, 2, 3], None),
- (JSONModel, 'field', {'a': 'b'}, {'c': 'd'}),
(NestedIntegerArrayModel, 'field', [], [[1, 2, 3]]),
(HStoreModel, 'field', {}, {1: 2}),
(RangesModel, 'ints', None, NumericRange(lower=1, upper=10)),
diff --git a/tests/postgres_tests/test_introspection.py b/tests/postgres_tests/test_introspection.py
index 8ae5b80da1..50cb9b2828 100644
--- a/tests/postgres_tests/test_introspection.py
+++ b/tests/postgres_tests/test_introspection.py
@@ -19,12 +19,6 @@ class InspectDBTests(PostgreSQLTestCase):
for field_output in field_outputs:
self.assertIn(field_output, output)
- def test_json_field(self):
- self.assertFieldsInModel(
- 'postgres_tests_jsonmodel',
- ['field = django.contrib.postgres.fields.JSONField(blank=True, null=True)'],
- )
-
def test_range_fields(self):
self.assertFieldsInModel(
'postgres_tests_rangesmodel',
diff --git a/tests/postgres_tests/test_json.py b/tests/postgres_tests/test_json.py
deleted file mode 100644
index 2ff765e918..0000000000
--- a/tests/postgres_tests/test_json.py
+++ /dev/null
@@ -1,583 +0,0 @@
-import datetime
-import operator
-import uuid
-from decimal import Decimal
-
-from django.core import checks, exceptions, serializers
-from django.core.serializers.json import DjangoJSONEncoder
-from django.db import connection
-from django.db.models import Count, F, OuterRef, Q, Subquery
-from django.db.models.expressions import RawSQL
-from django.db.models.functions import Cast
-from django.forms import CharField, Form, widgets
-from django.test.utils import CaptureQueriesContext, isolate_apps
-from django.utils.html import escape
-
-from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase
-from .models import JSONModel, PostgreSQLModel
-
-try:
- from django.contrib.postgres import forms
- from django.contrib.postgres.fields import JSONField
- from django.contrib.postgres.fields.jsonb import KeyTextTransform, KeyTransform
-except ImportError:
- pass
-
-
-class TestModelMetaOrdering(PostgreSQLSimpleTestCase):
- def test_ordering_by_json_field_value(self):
- class TestJSONModel(JSONModel):
- class Meta:
- ordering = ['field__value']
-
- self.assertEqual(TestJSONModel.check(), [])
-
-
-class TestSaveLoad(PostgreSQLTestCase):
- def test_null(self):
- instance = JSONModel()
- instance.save()
- loaded = JSONModel.objects.get()
- self.assertIsNone(loaded.field)
-
- def test_empty_object(self):
- instance = JSONModel(field={})
- instance.save()
- loaded = JSONModel.objects.get()
- self.assertEqual(loaded.field, {})
-
- def test_empty_list(self):
- instance = JSONModel(field=[])
- instance.save()
- loaded = JSONModel.objects.get()
- self.assertEqual(loaded.field, [])
-
- def test_boolean(self):
- instance = JSONModel(field=True)
- instance.save()
- loaded = JSONModel.objects.get()
- self.assertIs(loaded.field, True)
-
- def test_string(self):
- instance = JSONModel(field='why?')
- instance.save()
- loaded = JSONModel.objects.get()
- self.assertEqual(loaded.field, 'why?')
-
- def test_number(self):
- instance = JSONModel(field=1)
- instance.save()
- loaded = JSONModel.objects.get()
- self.assertEqual(loaded.field, 1)
-
- def test_realistic_object(self):
- obj = {
- 'a': 'b',
- 'c': 1,
- 'd': ['e', {'f': 'g'}],
- 'h': True,
- 'i': False,
- 'j': None,
- }
- instance = JSONModel(field=obj)
- instance.save()
- loaded = JSONModel.objects.get()
- self.assertEqual(loaded.field, obj)
-
- def test_custom_encoding(self):
- """
- JSONModel.field_custom has a custom DjangoJSONEncoder.
- """
- some_uuid = uuid.uuid4()
- obj_before = {
- 'date': datetime.date(2016, 8, 12),
- 'datetime': datetime.datetime(2016, 8, 12, 13, 44, 47, 575981),
- 'decimal': Decimal('10.54'),
- 'uuid': some_uuid,
- }
- obj_after = {
- 'date': '2016-08-12',
- 'datetime': '2016-08-12T13:44:47.575',
- 'decimal': '10.54',
- 'uuid': str(some_uuid),
- }
- JSONModel.objects.create(field_custom=obj_before)
- loaded = JSONModel.objects.get()
- self.assertEqual(loaded.field_custom, obj_after)
-
-
-class TestQuerying(PostgreSQLTestCase):
- @classmethod
- def setUpTestData(cls):
- cls.objs = JSONModel.objects.bulk_create([
- JSONModel(field=None),
- JSONModel(field=True),
- JSONModel(field=False),
- JSONModel(field='yes'),
- JSONModel(field=7),
- JSONModel(field=[]),
- JSONModel(field={}),
- JSONModel(field={
- 'a': 'b',
- 'c': 1,
- }),
- JSONModel(field={
- 'a': 'b',
- 'c': 1,
- 'd': ['e', {'f': 'g'}],
- 'h': True,
- 'i': False,
- 'j': None,
- 'k': {'l': 'm'},
- }),
- JSONModel(field=[1, [2]]),
- JSONModel(field={
- 'k': True,
- 'l': False,
- }),
- JSONModel(field={
- 'foo': 'bar',
- 'baz': {'a': 'b', 'c': 'd'},
- 'bar': ['foo', 'bar'],
- 'bax': {'foo': 'bar'},
- }),
- ])
-
- def test_exact(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__exact={}),
- [self.objs[6]]
- )
-
- def test_exact_complex(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__exact={'a': 'b', 'c': 1}),
- [self.objs[7]]
- )
-
- def test_isnull(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__isnull=True),
- [self.objs[0]]
- )
-
- def test_ordering_by_transform(self):
- objs = [
- JSONModel.objects.create(field={'ord': 93, 'name': 'bar'}),
- JSONModel.objects.create(field={'ord': 22.1, 'name': 'foo'}),
- JSONModel.objects.create(field={'ord': -1, 'name': 'baz'}),
- JSONModel.objects.create(field={'ord': 21.931902, 'name': 'spam'}),
- JSONModel.objects.create(field={'ord': -100291029, 'name': 'eggs'}),
- ]
- query = JSONModel.objects.filter(field__name__isnull=False).order_by('field__ord')
- self.assertSequenceEqual(query, [objs[4], objs[2], objs[3], objs[1], objs[0]])
-
- def test_ordering_grouping_by_key_transform(self):
- base_qs = JSONModel.objects.filter(field__d__0__isnull=False)
- for qs in (
- base_qs.order_by('field__d__0'),
- base_qs.annotate(key=KeyTransform('0', KeyTransform('d', 'field'))).order_by('key'),
- ):
- self.assertSequenceEqual(qs, [self.objs[8]])
- qs = JSONModel.objects.filter(field__isnull=False)
- self.assertQuerysetEqual(
- qs.values('field__d__0').annotate(count=Count('field__d__0')).order_by('count'),
- [1, 10],
- operator.itemgetter('count'),
- )
- self.assertQuerysetEqual(
- qs.filter(field__isnull=False).annotate(
- key=KeyTextTransform('f', KeyTransform('1', KeyTransform('d', 'field'))),
- ).values('key').annotate(count=Count('key')).order_by('count'),
- [(None, 0), ('g', 1)],
- operator.itemgetter('key', 'count'),
- )
-
- def test_key_transform_raw_expression(self):
- expr = RawSQL('%s::jsonb', ['{"x": "bar"}'])
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__foo=KeyTransform('x', expr)),
- [self.objs[-1]],
- )
-
- def test_key_transform_expression(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__d__0__isnull=False).annotate(
- key=KeyTransform('d', 'field'),
- chain=KeyTransform('0', 'key'),
- expr=KeyTransform('0', Cast('key', JSONField())),
- ).filter(chain=F('expr')),
- [self.objs[8]],
- )
-
- def test_nested_key_transform_raw_expression(self):
- expr = RawSQL('%s::jsonb', ['{"x": {"y": "bar"}}'])
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__foo=KeyTransform('y', KeyTransform('x', expr))),
- [self.objs[-1]],
- )
-
- def test_nested_key_transform_expression(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__d__0__isnull=False).annotate(
- key=KeyTransform('d', 'field'),
- chain=KeyTransform('f', KeyTransform('1', 'key')),
- expr=KeyTransform('f', KeyTransform('1', Cast('key', JSONField()))),
- ).filter(chain=F('expr')),
- [self.objs[8]],
- )
-
- def test_deep_values(self):
- query = JSONModel.objects.values_list('field__k__l')
- self.assertSequenceEqual(
- query,
- [
- (None,), (None,), (None,), (None,), (None,), (None,),
- (None,), (None,), ('m',), (None,), (None,), (None,),
- ]
- )
-
- def test_deep_distinct(self):
- query = JSONModel.objects.distinct('field__k__l').values_list('field__k__l')
- self.assertSequenceEqual(query, [('m',), (None,)])
-
- def test_isnull_key(self):
- # key__isnull works the same as has_key='key'.
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__a__isnull=True),
- self.objs[:7] + self.objs[9:]
- )
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__a__isnull=False),
- [self.objs[7], self.objs[8]]
- )
-
- def test_none_key(self):
- self.assertSequenceEqual(JSONModel.objects.filter(field__j=None), [self.objs[8]])
-
- def test_none_key_exclude(self):
- obj = JSONModel.objects.create(field={'j': 1})
- self.assertSequenceEqual(JSONModel.objects.exclude(field__j=None), [obj])
-
- def test_isnull_key_or_none(self):
- obj = JSONModel.objects.create(field={'a': None})
- self.assertSequenceEqual(
- JSONModel.objects.filter(Q(field__a__isnull=True) | Q(field__a=None)),
- self.objs[:7] + self.objs[9:] + [obj]
- )
-
- def test_contains(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__contains={'a': 'b'}),
- [self.objs[7], self.objs[8]]
- )
-
- def test_contained_by(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__contained_by={'a': 'b', 'c': 1, 'h': True}),
- [self.objs[6], self.objs[7]]
- )
-
- def test_has_key(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__has_key='a'),
- [self.objs[7], self.objs[8]]
- )
-
- def test_has_keys(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__has_keys=['a', 'c', 'h']),
- [self.objs[8]]
- )
-
- def test_has_any_keys(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__has_any_keys=['c', 'l']),
- [self.objs[7], self.objs[8], self.objs[10]]
- )
-
- def test_shallow_list_lookup(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__0=1),
- [self.objs[9]]
- )
-
- def test_shallow_obj_lookup(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__a='b'),
- [self.objs[7], self.objs[8]]
- )
-
- def test_obj_subquery_lookup(self):
- qs = JSONModel.objects.annotate(
- value=Subquery(JSONModel.objects.filter(pk=OuterRef('pk')).values('field')),
- ).filter(value__a='b')
- self.assertSequenceEqual(qs, [self.objs[7], self.objs[8]])
-
- def test_deep_lookup_objs(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__k__l='m'),
- [self.objs[8]]
- )
-
- def test_shallow_lookup_obj_target(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__k={'l': 'm'}),
- [self.objs[8]]
- )
-
- def test_deep_lookup_array(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__1__0=2),
- [self.objs[9]]
- )
-
- def test_deep_lookup_mixed(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__d__1__f='g'),
- [self.objs[8]]
- )
-
- def test_deep_lookup_transform(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__c__gt=1),
- []
- )
- self.assertSequenceEqual(
- JSONModel.objects.filter(field__c__lt=5),
- [self.objs[7], self.objs[8]]
- )
-
- def test_usage_in_subquery(self):
- self.assertSequenceEqual(
- JSONModel.objects.filter(id__in=JSONModel.objects.filter(field__c=1)),
- self.objs[7:9]
- )
-
- def test_iexact(self):
- self.assertTrue(JSONModel.objects.filter(field__foo__iexact='BaR').exists())
- self.assertFalse(JSONModel.objects.filter(field__foo__iexact='"BaR"').exists())
-
- def test_icontains(self):
- self.assertFalse(JSONModel.objects.filter(field__foo__icontains='"bar"').exists())
-
- def test_startswith(self):
- self.assertTrue(JSONModel.objects.filter(field__foo__startswith='b').exists())
-
- def test_istartswith(self):
- self.assertTrue(JSONModel.objects.filter(field__foo__istartswith='B').exists())
-
- def test_endswith(self):
- self.assertTrue(JSONModel.objects.filter(field__foo__endswith='r').exists())
-
- def test_iendswith(self):
- self.assertTrue(JSONModel.objects.filter(field__foo__iendswith='R').exists())
-
- def test_regex(self):
- self.assertTrue(JSONModel.objects.filter(field__foo__regex=r'^bar$').exists())
-
- def test_iregex(self):
- self.assertTrue(JSONModel.objects.filter(field__foo__iregex=r'^bAr$').exists())
-
- def test_key_sql_injection(self):
- with CaptureQueriesContext(connection) as queries:
- self.assertFalse(
- JSONModel.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'],
- )
-
- def test_lookups_with_key_transform(self):
- tests = (
- ('field__d__contains', 'e'),
- ('field__baz__contained_by', {'a': 'b', 'c': 'd', 'e': 'f'}),
- ('field__baz__has_key', 'c'),
- ('field__baz__has_keys', ['a', 'c']),
- ('field__baz__has_any_keys', ['a', 'x']),
- ('field__contains', KeyTransform('bax', 'field')),
- (
- 'field__contained_by',
- KeyTransform('x', RawSQL('%s::jsonb', ['{"x": {"a": "b", "c": 1, "d": "e"}}'])),
- ),
- ('field__has_key', KeyTextTransform('foo', 'field')),
- )
- for lookup, value in tests:
- with self.subTest(lookup=lookup):
- self.assertTrue(JSONModel.objects.filter(
- **{lookup: value},
- ).exists())
-
- def test_key_escape(self):
- obj = JSONModel.objects.create(field={'%total': 10})
- self.assertEqual(JSONModel.objects.filter(**{'field__%total': 10}).get(), obj)
-
-
-@isolate_apps('postgres_tests')
-class TestChecks(PostgreSQLSimpleTestCase):
-
- def test_invalid_default(self):
- class MyModel(PostgreSQLModel):
- field = JSONField(default={})
-
- model = MyModel()
- self.assertEqual(model.check(), [
- checks.Warning(
- msg=(
- "JSONField 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):
- field = JSONField(default=dict)
-
- model = MyModel()
- self.assertEqual(model.check(), [])
-
- def test_valid_default_none(self):
- class MyModel(PostgreSQLModel):
- field = JSONField(default=None)
-
- model = MyModel()
- self.assertEqual(model.check(), [])
-
-
-class TestSerialization(PostgreSQLSimpleTestCase):
- test_data = (
- '[{"fields": {"field": %s, "field_custom": null}, '
- '"model": "postgres_tests.jsonmodel", "pk": null}]'
- )
- test_values = (
- # (Python value, serialized value),
- ({'a': 'b', 'c': None}, '{"a": "b", "c": null}'),
- ('abc', '"abc"'),
- ('{"a": "a"}', '"{\\"a\\": \\"a\\"}"'),
- )
-
- def test_dumping(self):
- for value, serialized in self.test_values:
- with self.subTest(value=value):
- instance = JSONModel(field=value)
- data = serializers.serialize('json', [instance])
- self.assertJSONEqual(data, self.test_data % serialized)
-
- def test_loading(self):
- for value, serialized in self.test_values:
- with self.subTest(value=value):
- instance = list(serializers.deserialize('json', self.test_data % serialized))[0].object
- self.assertEqual(instance.field, value)
-
-
-class TestValidation(PostgreSQLSimpleTestCase):
-
- def test_not_serializable(self):
- field = JSONField()
- with self.assertRaises(exceptions.ValidationError) as cm:
- field.clean(datetime.timedelta(days=1), None)
- self.assertEqual(cm.exception.code, 'invalid')
- self.assertEqual(cm.exception.message % cm.exception.params, "Value must be valid JSON.")
-
- def test_custom_encoder(self):
- with self.assertRaisesMessage(ValueError, "The encoder parameter must be a callable object."):
- field = JSONField(encoder=DjangoJSONEncoder())
- field = JSONField(encoder=DjangoJSONEncoder)
- self.assertEqual(field.clean(datetime.timedelta(days=1), None), datetime.timedelta(days=1))
-
-
-class TestFormField(PostgreSQLSimpleTestCase):
-
- def test_valid(self):
- field = forms.JSONField()
- value = field.clean('{"a": "b"}')
- self.assertEqual(value, {'a': 'b'})
-
- def test_valid_empty(self):
- field = forms.JSONField(required=False)
- value = field.clean('')
- self.assertIsNone(value)
-
- def test_invalid(self):
- field = forms.JSONField()
- with self.assertRaises(exceptions.ValidationError) as cm:
- field.clean('{some badly formed: json}')
- self.assertEqual(cm.exception.messages[0], '“{some badly formed: json}” value must be valid JSON.')
-
- def test_formfield(self):
- model_field = JSONField()
- form_field = model_field.formfield()
- self.assertIsInstance(form_field, forms.JSONField)
-
- def test_formfield_disabled(self):
- class JsonForm(Form):
- name = CharField()
- jfield = forms.JSONField(disabled=True)
-
- form = JsonForm({'name': 'xyz', 'jfield': '["bar"]'}, initial={'jfield': ['foo']})
- self.assertIn('[&quot;foo&quot;]</textarea>', form.as_p())
-
- def test_prepare_value(self):
- field = forms.JSONField()
- self.assertEqual(field.prepare_value({'a': 'b'}), '{"a": "b"}')
- self.assertEqual(field.prepare_value(None), 'null')
- self.assertEqual(field.prepare_value('foo'), '"foo"')
-
- def test_redisplay_wrong_input(self):
- """
- When displaying a bound form (typically due to invalid input), the form
- should not overquote JSONField inputs.
- """
- class JsonForm(Form):
- name = CharField(max_length=2)
- jfield = forms.JSONField()
-
- # JSONField input is fine, name is too long
- form = JsonForm({'name': 'xyz', 'jfield': '["foo"]'})
- self.assertIn('[&quot;foo&quot;]</textarea>', form.as_p())
-
- # This time, the JSONField input is wrong
- form = JsonForm({'name': 'xy', 'jfield': '{"foo"}'})
- # Appears once in the textarea and once in the error message
- self.assertEqual(form.as_p().count(escape('{"foo"}')), 2)
-
- def test_widget(self):
- """The default widget of a JSONField is a Textarea."""
- field = forms.JSONField()
- self.assertIsInstance(field.widget, widgets.Textarea)
-
- def test_custom_widget_kwarg(self):
- """The widget can be overridden with a kwarg."""
- field = forms.JSONField(widget=widgets.Input)
- self.assertIsInstance(field.widget, widgets.Input)
-
- def test_custom_widget_attribute(self):
- """The widget can be overridden with an attribute."""
- class CustomJSONField(forms.JSONField):
- widget = widgets.Input
-
- field = CustomJSONField()
- self.assertIsInstance(field.widget, widgets.Input)
-
- def test_already_converted_value(self):
- field = forms.JSONField(required=False)
- tests = [
- '["a", "b", "c"]', '{"a": 1, "b": 2}', '1', '1.5', '"foo"',
- 'true', 'false', 'null',
- ]
- for json_string in tests:
- val = field.clean(json_string)
- self.assertEqual(field.clean(val), val)
-
- def test_has_changed(self):
- field = forms.JSONField()
- self.assertIs(field.has_changed({'a': True}, '{"a": 1}'), True)
- self.assertIs(field.has_changed({'a': 1, 'b': 2}, '{"b": 2, "a": 1}'), False)
diff --git a/tests/postgres_tests/test_json_deprecation.py b/tests/postgres_tests/test_json_deprecation.py
new file mode 100644
index 0000000000..80deb0cb15
--- /dev/null
+++ b/tests/postgres_tests/test_json_deprecation.py
@@ -0,0 +1,54 @@
+try:
+ from django.contrib.postgres.fields import JSONField
+ from django.contrib.postgres.fields.jsonb import KeyTransform, KeyTextTransform
+ from django.contrib.postgres import forms
+except ImportError:
+ pass
+
+from django.core.checks import Warning as DjangoWarning
+from django.utils.deprecation import RemovedInDjango40Warning
+
+from . import PostgreSQLSimpleTestCase
+from .models import PostgreSQLModel
+
+
+class DeprecationTests(PostgreSQLSimpleTestCase):
+ def test_model_field_deprecation_message(self):
+ class PostgreSQLJSONModel(PostgreSQLModel):
+ field = JSONField()
+
+ self.assertEqual(PostgreSQLJSONModel().check(), [
+ DjangoWarning(
+ 'django.contrib.postgres.fields.JSONField is deprecated. '
+ 'Support for it (except in historical migrations) will be '
+ 'removed in Django 4.0.',
+ hint='Use django.db.models.JSONField instead.',
+ obj=PostgreSQLJSONModel._meta.get_field('field'),
+ id='fields.W904',
+ ),
+ ])
+
+ def test_form_field_deprecation_message(self):
+ msg = (
+ 'django.contrib.postgres.forms.JSONField is deprecated in favor '
+ 'of django.forms.JSONField.'
+ )
+ with self.assertWarnsMessage(RemovedInDjango40Warning, msg):
+ forms.JSONField()
+
+ def test_key_transform_deprecation_message(self):
+ msg = (
+ 'django.contrib.postgres.fields.jsonb.KeyTransform is deprecated '
+ 'in favor of django.db.models.fields.json.KeyTransform.'
+ )
+ with self.assertWarnsMessage(RemovedInDjango40Warning, msg):
+ KeyTransform('foo', 'bar')
+
+ def test_key_text_transform_deprecation_message(self):
+ msg = (
+ 'django.contrib.postgres.fields.jsonb.KeyTextTransform is '
+ 'deprecated in favor of '
+ 'django.db.models.fields.json.KeyTextTransform.'
+ )
+ with self.assertWarnsMessage(RemovedInDjango40Warning, msg):
+ KeyTextTransform('foo', 'bar')
generated by cgit v1.3 (git 2.53.0) at 2026-05-02 00:50:34 +0000