Refactoring (#3)

* Raise KeyError implicitly

* Replace serializers.ValidationError on self.fail

* Refactored tests

Author: AlexPetul

django_custom_jsonfield/rest_framework/openapi.py

@@ -39,11 +39,7 @@ def build_basic_schema(self, schema: dict):
             "null": OpenApiTypes.NONE,
         }
 
-        schema_type = schema["type"]
-        if schema_type not in basic_type_mapping:
-            raise KeyError(f"Unknown schema type: {schema_type}")
-
-        return build_basic_type(basic_type_mapping[schema_type])
+        return build_basic_type(basic_type_mapping[schema["type"]])
 
     def map_serializer_field(self, auto_schema, direction):
         schema = self.target.schema

django_custom_jsonfield/rest_framework/serializers.py

@@ -27,7 +27,4 @@ def _validate_data(self, value):
         try:
             jsonschema.validate(value, self.schema)
         except jsonschema.exceptions.ValidationError:
-            raise serializers.ValidationError(
-                self.error_messages["invalid_data"],
-                code="invalid_data",
-            )
+            self.fail("invalid_data")

tests/test_model_field.py

@@ -18,6 +18,8 @@
     ],
 )
 def test_json_schema_invalid(schema: dict):
+    """Test Django returns errors if JSON schema is invalid."""
+
     class FakeModel(models.Model):
         json_field = CustomJSONField(schema=schema)
 
@@ -52,7 +54,6 @@ class Meta:
             app_label = "test_app"
 
     instance = FakeModel()
-
     assert instance.check() == []
 
 
@@ -61,6 +62,8 @@ class Meta:
     [10, 10.00, list(), tuple(), set(), "", b"", True, None],
 )
 def test_schema_type_invalid(schema: Any):
+    """Test Django raises exception if JSON schema is not typed correctly."""
+
     with pytest.raises(ValueError) as e:
         CustomJSONField(schema=schema)
 
@@ -78,9 +81,17 @@ def test_schema_type_invalid(schema: Any):
                 "required": ["name", "age"],
             },
         ),
+        (
+            "invalid_string",
+            {
+                "const": "custom_string",
+            },
+        ),
     ],
 )
-def test_validate_value_against_schema(value, schema):
+def test_validate_value_against_schema(value: Any, schema: Any):
+    """Test Django raises exception if value doesn't match JSON schema."""
+
     class FakeModel(models.Model):
         json_field = CustomJSONField(schema=schema)
 

tests/test_openapi_schema.py

@@ -8,47 +8,70 @@
 
 
 @pytest.mark.parametrize(
-    "schema",
+    "schema,expected",
     [
-        {
-            "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",
-        },
+        (
+            {
+                "type": "object",
+                "properties": {"name": {"type": "string"}},
+                "required": ["name"],
+                "additionalProperties": True,
+            },
+            {
+                "type": "object",
+                "properties": {"name": {"type": "string"}},
+                "required": ["name"],
+                "additionalProperties": True,
+            },
+        ),
+        (
+            {
+                "type": "object",
+                "properties": {"name": {"type": "string"}},
+            },
+            {
+                "type": "object",
+                "properties": {"name": {"type": "string"}},
+            },
+        ),
+        (
+            {
+                "items": {"type": "integer"},
+                "type": "array",
+                "maxLength": 1,
+                "minLength": 1,
+            },
+            {
+                "items": {"type": "integer"},
+                "type": "array",
+                "maxLength": 1,
+                "minLength": 1,
+            },
+        ),
+        (
+            {
+                "items": {"type": "integer"},
+                "type": "array",
+            },
+            {
+                "items": {"type": "integer"},
+                "type": "array",
+            },
+        ),
+        # basic types
+        ({"type": "number"}, {"type": "number"}),
+        ({"type": "string"}, {"type": "string"}),
+        ({"type": "integer"}, {"type": "integer"}),
+        ({"type": "boolean"}, {"type": "boolean"}),
     ],
 )
-def test_map_serializer_field_ok(schema: dict):
+def test_map_serializer_field_ok(schema: Any, expected: Any):
+    """Test correct mapping of JSON schema to OpenAPI schema."""
+
     json_field = CustomJSONField(schema=schema)
     extension = CustomJSONFieldSerializerExtension(json_field)
     data = extension.map_serializer_field(Mock(), "response")
-    assert data == schema
+    assert data == expected
 
 
 @pytest.mark.parametrize(

tests/test_serializer_field.py

@@ -17,7 +17,9 @@
         ),
     ],
 )
-def test_validate(value: dict, schema: dict):
+def test_validate_invalid_value(value: dict, schema: dict):
+    """Test serializer raises an exception if value does not match JSON schema."""
+
     class FakeSerializer(serializers.Serializer):
         json_field = CustomJSONField(schema=schema)