Update test coverage. move merge_json_schema

Author: Sparrow1029

pydantic_forms/utils/json.py

@@ -81,13 +81,11 @@
 from datetime import datetime
 from functools import partial
 from ipaddress import IPv4Address, IPv4Network, IPv6Address, IPv6Network
-from typing import Annotated, Any, Iterable, Sequence, Union, get_args
+from typing import Any, Sequence, Union
 from uuid import UUID
 
 import structlog
-from more_itertools import first
-from pydantic import BaseModel, Field
-from pydantic.fields import FieldInfo
+from pydantic import BaseModel
 
 try:
     import orjson
@@ -235,35 +233,3 @@ def isoformat(dt: datetime) -> str:
     """
     # IMPORTANT should the format be ever changed, be sure to update TIMESTAMP_REGEX as well!
     return dt.isoformat(timespec="seconds")
-
-
-# Helper utils
-def _get_field_info_with_schema(type_: Any) -> Iterable[FieldInfo]:
-    for annotation in get_args(type_):
-        if isinstance(annotation, FieldInfo) and annotation.json_schema_extra:
-            yield annotation
-
-
-def update_json_schema(type_: Any, json_schema: dict[str, Any]) -> Any:
-    """Add json_schema to type_'s annotations.
-
-    Existing json schema annotations are updated in a dict.update() fashion.
-    """
-    if not (field_info := first(_get_field_info_with_schema(type_), None)):
-        return Annotated[type_, Field(json_schema_extra=json_schema)]
-
-    if isinstance((existing_schema := field_info.json_schema_extra), dict):
-        existing_schema.update(json_schema)
-    else:
-        raise TypeError(f"Cannot update json_schema_extra of type {type(existing_schema)}")
-    return type_
-
-
-def merge_json_schema(target_type: Any, source_type: Any) -> Any:
-    """Add json_schema from source_type to target_type."""
-    if not (source_field_info := first(_get_field_info_with_schema(source_type), None)):
-        raise TypeError("Source type has no json_schema_extra")
-
-    if isinstance((existing_source_schema := source_field_info.json_schema_extra), dict):
-        return update_json_schema(target_type, existing_source_schema)
-    raise TypeError(f"Cannot merge source_type json_schema_extra from type {type(existing_source_schema)}")

pydantic_forms/validators/components/read_only.py

@@ -2,13 +2,14 @@
 
 import sys
 from itertools import chain
-from typing import Annotated, Any, Literal
+from typing import Annotated, Any, Iterable, Literal, get_args
 from uuid import UUID
 
+from more_itertools import first
 from pydantic import AfterValidator, BeforeValidator, Field, PlainSerializer, TypeAdapter
+from pydantic.fields import FieldInfo
 
 from pydantic_forms.types import strEnum
-from pydantic_forms.utils.json import merge_json_schema
 
 # from pydantic.json_schema
 JSON_SCHEMA_TYPES = {
@@ -76,6 +77,30 @@ def to_value(item: Any) -> Any:
     ]
 
 
+# Helper utils
+def _get_field_info_with_schema(type_: Any) -> Iterable[FieldInfo]:
+    for annotation in get_args(type_):
+        if isinstance(annotation, FieldInfo) and annotation.json_schema_extra:
+            yield annotation
+
+
+def merge_json_schema(source_type: Any, target_type: Any) -> Any:
+    """Add json_schema from source_type to target_type."""
+    if not (source_field_info := first(_get_field_info_with_schema(source_type), None)):
+        raise TypeError("Source type has no json_schema_extra")
+    if not (target_field_info := first(_get_field_info_with_schema(target_type), None)):
+        raise TypeError("Target type has no json_schema_extra")
+    source_schema = source_field_info.json_schema_extra
+    target_schema = target_field_info.json_schema_extra
+
+    if not isinstance(source_schema, dict) or not isinstance(target_schema, dict):
+        raise TypeError(
+            f"Cannot merge json_schema_extra of source_type {type(source_schema)} with target_type {type(target_type)}"
+        )
+    source_schema.update(target_schema)
+    return source_type
+
+
 def read_only_field(default: Any, merge_type: Any | None = None) -> Any:
     """Create type with json schema that sets frontend form field to active=false.
 
@@ -112,7 +137,6 @@ def serialize_json(_v: Any) -> str:
         BeforeValidator(validate),
         PlainSerializer(serialize_json, when_used="json"),
     ]
-    try:
+    if merge_type is not None:
         return merge_json_schema(read_only_type, merge_type)
-    except TypeError:
-        return read_only_type
+    return read_only_type

tests/unit_tests/test_read_only_field.py

@@ -1,12 +1,15 @@
 import json
 from uuid import UUID
 
+from more_itertools import first
+from pydantic.config import JsonDict
 import pytest
 from pydantic import BaseModel, ValidationError
 
 from pydantic_forms.core import FormPage
 from pydantic_forms.types import strEnum
 from pydantic_forms.validators import read_only_field, read_only_list, LongText, OrganisationId
+from pydantic_forms.validators.components.read_only import merge_json_schema, _get_field_info_with_schema
 
 
 class TestEnum(strEnum):
@@ -150,7 +153,6 @@ class Form(FormPage):
         "type": "object",
         "properties": {
             "read_only_list": {
-                # "const": schema_value,
                 "default": schema_value,
                 "items": expected_item_type,
                 "title": "Read Only List",
@@ -209,3 +211,35 @@ class OrgIdForm(FormPage):
     org_id_read_only = org_id_validated.model_json_schema()["properties"]["read_only"]
     assert org_id_read_only["format"] == "organisationId"
     assert org_id_read_only["uniforms"]["disabled"]
+
+
+def test_read_only_unsupported_type():
+    with pytest.raises(TypeError, match="^Cannot make a read_only_field for type"):
+
+        class Form(FormPage):
+            read_only: read_only_field({"value": 42})
+
+
+def test_read_only_merge_json_schema_fails_without_json_schema_extra():
+    with pytest.raises(TypeError, match="Target type has no json_schema_extra"):
+
+        class Form(FormPage):
+            read_only: read_only_field(True, merge_type=JsonDict)
+
+
+def test_merge_json_schema():
+    with pytest.raises(TypeError, match="Source type has no json_schema_extra"):
+        merge_json_schema("text", LongText)
+
+    with pytest.raises(TypeError, match="Target type has no json_schema_extra"):
+        merge_json_schema(OrganisationId, test_uuid1)
+
+    # TODO: This may be a test for a contrived error -- not sure if it's possible to hit the block
+    # this is testing without messing things up pretty bad as shown here
+    with pytest.raises(TypeError, match="^Cannot merge.*"):
+        longtext = LongText
+        org_id = OrganisationId
+        for typ in (longtext, org_id):
+            field_info = first(_get_field_info_with_schema(typ))
+            field_info.json_schema_extra = "wrong"
+        merge_json_schema(org_id, longtext)