Tighten dataclass runtime and Windows fuzz harness

Author: ostrowr

pybindings/jsoncompat/codegen/dataclasses.py

@@ -390,7 +390,7 @@ def _jsoncompat_construct_value(annotation: Any, value: Any) -> Any:
         if isinstance(value, bool):
             return value
         raise TypeError(f"expected bool, got {type(value).__name__}")
-    if annotation is type(None):
+    if annotation is None or annotation is type(None):
         if value is None:
             return None
         raise TypeError(f"expected null, got {type(value).__name__}")
@@ -408,14 +408,26 @@ def _jsoncompat_construct_value(annotation: Any, value: Any) -> Any:
             _jsoncompat_construct_value(item_annotation, item)
             for item in value_items
         ]
+    if origin is dict:
+        key_annotation, value_annotation = _jsoncompat_dict_annotations(annotation)
+        if not isinstance(value, dict):
+            raise TypeError(f"expected dict, got {type(value).__name__}")
+        value_object = cast(dict[Any, Any], value)
+        return {
+            _jsoncompat_construct_value(key_annotation, key): _jsoncompat_construct_value(
+                value_annotation,
+                item,
+            )
+            for key, item in value_object.items()
+        }
     if origin in {types.UnionType, Union}:
         return _jsoncompat_construct_union(get_args(annotation), value)
     if origin is Literal:
         if value in get_args(annotation):
             return value
         raise TypeError(f"expected one of {get_args(annotation)!r}, got {value!r}")
 
-    return value
+    raise TypeError(f"unsupported runtime annotation {annotation!r}")
 
 
 def _jsoncompat_construct_union(branches: tuple[Any, ...], value: Any) -> Any:
@@ -504,6 +516,13 @@ def _jsoncompat_extra_value_annotation(annotation: Any) -> Any:
     return Any
 
 
+def _jsoncompat_dict_annotations(annotation: Any) -> tuple[Any, Any]:
+    args = get_args(annotation)
+    if len(args) == 2:
+        return args[0], args[1]
+    return Any, Any
+
+
 def _jsoncompat_validate_python_value(annotation: Any, value: Any) -> None:
     if annotation is Any:
         return
@@ -527,7 +546,7 @@ def _jsoncompat_validate_python_value(annotation: Any, value: Any) -> None:
         if isinstance(value, bool):
             return
         raise TypeError(f"expected bool, got {type(value).__name__}")
-    if annotation is type(None):
+    if annotation is None or annotation is type(None):
         if value is None:
             return
         raise TypeError(f"expected null, got {type(value).__name__}")
@@ -548,6 +567,15 @@ def _jsoncompat_validate_python_value(annotation: Any, value: Any) -> None:
         for item in value_items:
             _jsoncompat_validate_python_value(item_annotation, item)
         return
+    if origin is dict:
+        key_annotation, value_annotation = _jsoncompat_dict_annotations(annotation)
+        if not isinstance(value, dict):
+            raise TypeError(f"expected dict, got {type(value).__name__}")
+        value_object = cast(dict[Any, Any], value)
+        for key, item in value_object.items():
+            _jsoncompat_validate_python_value(key_annotation, key)
+            _jsoncompat_validate_python_value(value_annotation, item)
+        return
     if origin in {types.UnionType, Union}:
         for branch in get_args(annotation):
             try:
@@ -561,6 +589,8 @@ def _jsoncompat_validate_python_value(annotation: Any, value: Any) -> None:
             return
         raise TypeError(f"expected one of {get_args(annotation)!r}, got {value!r}")
 
+    raise TypeError(f"unsupported runtime annotation {annotation!r}")
+
 
 def _jsoncompat_new_unchecked[JSONCOMPAT_MODEL_T: DataclassModel](
     model_type: type[JSONCOMPAT_MODEL_T],

tests/dataclasses_backcompat.rs

@@ -233,14 +233,18 @@ fn assert_codegen_error_snapshot(
     });
     let actual = format!("{error}\n");
     assert_eq!(
-        expected,
-        actual,
+        normalized_newlines(&expected),
+        normalized_newlines(&actual),
         "dataclass backcompat example codegen error snapshot is stale for {case_name}/{side}: {}",
         snapshot_path.display(),
     );
     Ok(())
 }
 
+fn normalized_newlines(contents: &str) -> String {
+    contents.replace("\r\n", "\n")
+}
+
 fn round_trip_valid(
     case_name: &str,
     side: &str,

tests/dataclasses_fuzz.rs

@@ -79,7 +79,7 @@ fn assert_codegen_error_snapshot(
         )
     })?;
     let actual = format!("{error}\n");
-    if expected != actual {
+    if normalized_newlines(&expected) != normalized_newlines(&actual) {
         return Err(format!(
             "dataclass fuzz codegen error snapshot is stale for schema #{} in {}: {}\n\nexpected:\n{}\nactual:\n{}",
             schema_case.index,
@@ -92,3 +92,7 @@ fn assert_codegen_error_snapshot(
     }
     Ok(())
 }
+
+fn normalized_newlines(contents: &str) -> String {
+    contents.replace("\r\n", "\n")
+}

tests/python_dataclasses_runtime.rs

@@ -73,6 +73,47 @@ for factory in (
         raise AssertionError("invalid dataclass payload was accepted")
 
 
+@dataclass(frozen=True, slots=True, kw_only=True)
+class AuditContext(DataclassModel):
+    __jsoncompat_schema__: ClassVar[str] = '{"type":"object","properties":{"tags":{"type":"object","additionalProperties":{"type":"string"}}},"required":["tags"],"additionalProperties":false}'
+
+    tags: dict[str, str] = field("tags")
+
+
+context = AuditContext(tags={"team": "schema"})
+assert context.to_json() == {"tags": {"team": "schema"}}
+assert AuditContext.from_json({"tags": {"team": "schema"}}).tags == {
+    "team": "schema"
+}
+
+for factory in (
+    lambda: AuditContext(tags="oops"),
+    lambda: AuditContext(tags={1: "schema"}),
+    lambda: AuditContext(tags={"team": 1}),
+):
+    try:
+        factory()
+    except (TypeError, ValueError):
+        pass
+    else:
+        raise AssertionError("mapping annotations accepted an invalid value")
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class UnsupportedRuntimeAnnotation(DataclassModel):
+    __jsoncompat_schema__: ClassVar[str] = '{"type":"object","properties":{"tags":{"type":"array","items":{"type":"string"}}},"required":["tags"],"additionalProperties":false}'
+
+    tags: tuple[str, ...] = field("tags")
+
+
+try:
+    UnsupportedRuntimeAnnotation(tags=("schema",))
+except TypeError as error:
+    assert "unsupported runtime annotation" in str(error)
+else:
+    raise AssertionError("unsupported runtime annotations must fail loudly")
+
+
 @dataclass(frozen=True, slots=True, kw_only=True)
 class ProfileRoot(DataclassRootModel):
     __jsoncompat_schema__: ClassVar[str] = '{"type":"string","minLength":1}'

tests/support/python_env.rs

@@ -5,6 +5,7 @@ use std::process::Command;
 pub fn python_command() -> Command {
     let mut command = Command::new("uv");
     command.env_remove("VIRTUAL_ENV");
+    configure_utf8_python_io(&mut command);
     command
         .arg("run")
         .arg("--project")
@@ -18,6 +19,7 @@ pub fn python_command() -> Command {
 pub fn pyright_command() -> Command {
     let mut command = Command::new("uv");
     command.env_remove("VIRTUAL_ENV");
+    configure_utf8_python_io(&mut command);
     command
         .arg("run")
         .arg("--project")
@@ -40,6 +42,12 @@ pub fn add_repo_python_path(command: &mut Command) -> &mut Command {
     )
 }
 
+fn configure_utf8_python_io(command: &mut Command) -> &mut Command {
+    command
+        .env("PYTHONUTF8", "1")
+        .env("PYTHONIOENCODING", "utf-8")
+}
+
 fn repo_pybindings_path() -> PathBuf {
     std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("pybindings")
 }