Cover with tests

AlexPetul · AlexPetul · commit 842df003c19d · 2024-05-18T18:55:45.000+04:00
diff --git a/django_custom_jsonfield/fields.py b/django_custom_jsonfield/fields.py
@@ -2,12 +2,12 @@
 from django.core import checks, exceptions
 from django.db import models
 from django.utils.translation import gettext_lazy as _
-from jsonschema.validators import validator_for
+from jsonschema import validators
 
 
 class CustomJSONField(models.JSONField):
     default_error_messages = {
-        "invalid_data": _("Value does not match the schema."),
+        "invalid_data": _("Value does not match the JSON schema."),
     }
 
     def __init__(self, schema: dict, **kwargs):
@@ -16,6 +16,10 @@ def __init__(self, schema: dict, **kwargs):
         self.schema = schema
         super().__init__(**kwargs)
 
+    @property
+    def non_db_attrs(self):
+        return super().non_db_attrs + ("schema",)
+
     def check(self, **kwargs):
         return [
             *super().check(**kwargs),
@@ -35,7 +39,7 @@ def validate(self, value, model_instance):
             ) from e
 
     def _check_jsonschema(self):
-        validator = validator_for(self.schema)
+        validator = validators.validator_for(self.schema)
         try:
             validator.check_schema(self.schema)
         except jsonschema.exceptions.SchemaError:
diff --git a/django_custom_jsonfield/forms.py b/django_custom_jsonfield/forms.py
diff --git a/django_custom_jsonfield/openapi.py b/django_custom_jsonfield/openapi.py
@@ -1,20 +1,47 @@
+from drf_spectacular.drainage import warn
 from drf_spectacular.openapi import (
     OpenApiSerializerFieldExtension,
+    OpenApiTypes,
     build_array_type,
+    build_basic_type,
     build_object_type,
-    follow_field_source,
 )
 
 
 class CustomJSONFieldSerializerExtension(OpenApiSerializerFieldExtension):
     target_class = "django_custom_jsonfield.serializers.CustomJSONField"
 
     def map_serializer_field(self, auto_schema, direction):
-        model = self.target.parent.Meta.model
-        model_field = follow_field_source(model, self.target.source.split("."))
-        schema = model_field.schema
+        schema = self.target.schema
 
-        if schema["type"] == "object":
-            return build_object_type(schema["properties"])
-        elif schema["type"] == "array":
-            return build_array_type(schema["items"])
+        try:
+            if schema["type"] == "object":
+                kwargs = {}
+                if "additionalProperties" in schema:
+                    kwargs["additionalProperties"] = schema["additionalProperties"]
+
+                return build_object_type(
+                    schema["properties"],
+                    required=schema.get("required"),
+                    description=schema.get("description"),
+                    **kwargs,
+                )
+            elif schema["type"] == "array":
+                return build_array_type(
+                    schema["items"],
+                    min_length=schema.get("minLength"),
+                    max_length=schema.get("maxLength"),
+                )
+            else:
+                basic_type_mapping = {
+                    "string": OpenApiTypes.STR,
+                    "number": OpenApiTypes.NUMBER,
+                    "integer": OpenApiTypes.INT,
+                    "boolean": OpenApiTypes.BOOL,
+                    "null": OpenApiTypes.NONE,
+                }
+
+                return build_basic_type(basic_type_mapping[schema["type"]])
+        except:  # noqa: E722
+            warn(f"Encountered an issue resolving field {schema}, defaulting to string.")
+            return build_basic_type(OpenApiTypes.STR)
diff --git a/django_custom_jsonfield/serializers.py b/django_custom_jsonfield/serializers.py
@@ -1,11 +1,23 @@
+import jsonschema
+from django.utils.translation import gettext_lazy as _
 from rest_framework import serializers
 
 
 class CustomJSONField(serializers.JSONField):
-    def to_internal_value(self, data):
-        data = super().to_internal_value(data)
+    default_error_messages = {
+        "invalid_data": _("Value does not match the JSON schema."),
+    }
 
-        # if jsonschema.validate(data):
-        #     pass
+    def __init__(self, schema: dict, **kwargs):
+        self.schema = schema
+        super().__init__(**kwargs)
+        self.validators.append(self._validate_data)
 
-        return data
+    def _validate_data(self, value):
+        try:
+            jsonschema.validate(value, self.schema)
+        except jsonschema.exceptions.ValidationError:
+            raise serializers.ValidationError(
+                self.default_error_messages["invalid_data"],
+                code="invalid_data",
+            )
diff --git a/runtests.py b/runtests.py
@@ -9,4 +9,4 @@ def exit_on_failure(ret, message=None):
 
 
 if __name__ == "__main__":
-    exit_on_failure(pytest.main())
+    exit_on_failure(pytest.main(["--cov", "django_custom_jsonfield", "--cov-report", "xml"]))
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -6,7 +6,10 @@ def pytest_configure(config):
 
     settings.configure(
         DATABASES={
-            "default": {"ENGINE": "django.db.backends.sqlite3", "NAME": ":memory:"}
+            "default": {
+                "ENGINE": "django.db.backends.sqlite3",
+                "NAME": ":memory:",
+            },
         },
         SECRET_KEY="doesn't really matter",
     )
diff --git a/tests/test_model_field.py b/tests/test_model_field.py
@@ -1,5 +1,9 @@
+from typing import Any
+
 import pytest
+from django import VERSION as DJANGO_VERSION
 from django.core import checks
+from django.core.exceptions import ValidationError
 from django.db import models
 
 from django_custom_jsonfield.fields import CustomJSONField
@@ -13,7 +17,7 @@
         {"pattern": "*invalid.regex"},
     ],
 )
-def test_model_check_invalid_schema(schema: dict):
+def test_json_schema_invalid(schema: dict):
     class FakeModel(models.Model):
         json_field = CustomJSONField(schema=schema)
 
@@ -31,3 +35,77 @@ class Meta:
     ]
 
     assert errors == expected_errors
+
+
+def test_json_schema_ok():
+    class FakeModel(models.Model):
+        json_field = CustomJSONField(
+            schema={
+                "type": "array",
+                "minLength": 1,
+                "maxLength": 1,
+                "items": {"type": "integer"},
+            },
+        )
+
+        class Meta:
+            app_label = "test_app"
+
+    instance = FakeModel()
+
+    assert instance.check() == []
+
+
+@pytest.mark.parametrize(
+    "schema",
+    [10, 10.00, list(), tuple(), set(), "", b"", True, None],
+)
+def test_schema_type_invalid(schema: Any):
+    with pytest.raises(ValueError) as e:
+        CustomJSONField(schema=schema)
+
+    assert e.value.args[0] == "The schema parameter must be a dictionary."
+
+
+@pytest.mark.parametrize(
+    "value,schema",
+    [
+        (
+            {"name": "John"},
+            {
+                "type": "object",
+                "properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
+                "required": ["name", "age"],
+            },
+        ),
+    ],
+)
+def test_validate_value_against_schema(value, schema):
+    class FakeModel(models.Model):
+        json_field = CustomJSONField(schema=schema)
+
+        class Meta:
+            app_label = "test_app"
+
+    instance = FakeModel()
+    instance.json_field = value
+
+    with pytest.raises(ValidationError) as e:
+        instance.clean_fields()
+
+    assert isinstance(e.value.args[0]["json_field"][0], ValidationError)
+    assert e.value.args[0]["json_field"][0].args[0] == "Value does not match the JSON schema."
+    assert e.value.args[0]["json_field"][0].args[1] == "invalid_data"
+    assert e.value.args[0]["json_field"][0].args[2] == {"value": value}
+
+
+def test_deconstruct():
+    json_field = CustomJSONField(schema={})
+    _, _, _, kwargs = json_field.deconstruct()
+    assert "schema" in kwargs
+
+
+@pytest.mark.skipif(DJANGO_VERSION < (4, 1), reason="non_db_attrs is only available in Django 4.1+")
+def test_non_db_attrs():
+    json_field = CustomJSONField(schema={})
+    assert "schema" in json_field.non_db_attrs
diff --git a/tests/test_openapi_schema.py b/tests/test_openapi_schema.py
@@ -0,0 +1,65 @@
+from unittest.mock import Mock
+
+import pytest
+
+from django_custom_jsonfield.openapi import CustomJSONFieldSerializerExtension
+from django_custom_jsonfield.serializers import CustomJSONField
+
+
+@pytest.mark.parametrize(
+    "schema",
+    [
+        {
+            "type": "object",
+            "properties": {"name": {"type": "string"}},
+            "required": ["name"],
+            "additionalProperties": True,
+        },
+        {
+            "type": "object",
+            "properties": {"name": {"type": "string"}},
+        },
+        {
+            "items": {"type": "integer"},
+            "type": "array",
+            "maxLength": 1,
+            "minLength": 1,
+        },
+        {
+            "items": {"type": "integer"},
+            "type": "array",
+        },
+        {
+            "type": "number",
+        },
+        {
+            "type": "string",
+        },
+        {
+            "type": "integer",
+        },
+        {
+            "type": "boolean",
+        },
+    ],
+)
+def test_map_serializer_field_ok(schema: dict):
+    json_field = CustomJSONField(schema=schema)
+    extension = CustomJSONFieldSerializerExtension(json_field)
+    data = extension.map_serializer_field(Mock(), "response")
+    assert data == schema
+
+
+@pytest.mark.parametrize(
+    "schema",
+    [
+        {
+            "type": "test",
+        },
+    ],
+)
+def test_map_serializer_field_invalid_schema(schema: dict):
+    json_field = CustomJSONField(schema=schema)
+    extension = CustomJSONFieldSerializerExtension(json_field)
+    data = extension.map_serializer_field(Mock(), "response")
+    assert data == {"type": "string"}
diff --git a/tests/test_serializer_field.py b/tests/test_serializer_field.py
@@ -0,0 +1,36 @@
+import pytest
+from rest_framework import serializers
+from rest_framework.exceptions import ErrorDetail
+
+from django_custom_jsonfield.serializers import CustomJSONField
+
+
+@pytest.mark.parametrize(
+    "value,schema",
+    [
+        (
+            {"name": "John"},
+            {
+                "type": "object",
+                "properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
+                "required": ["name", "age"],
+            },
+        ),
+    ],
+)
+def test_validate(value: dict, schema: dict):
+    class FakeSerializer(serializers.Serializer):
+        json_field = CustomJSONField(schema=schema)
+
+    serializer = FakeSerializer(data={"json_field": value})
+    serializer.is_valid()
+
+    expected_errors = {
+        "json_field": [
+            ErrorDetail(
+                string="Value does not match the JSON schema.",
+                code="invalid_data",
+            ),
+        ],
+    }
+    assert serializer.errors == expected_errors

Original file line number	Diff line number	Diff line change
`@@ -9,4 +9,4 @@ def exit_on_failure(ret, message=None):`
`9`	`9`
`10`	`10`
`11`	`11`	`if __name__ == "__main__":`
`12`		`- exit_on_failure(pytest.main())`
	`12`	`+ exit_on_failure(pytest.main(["--cov", "django_custom_jsonfield", "--cov-report", "xml"]))`