Guard mutable generation inputs

Author: koxudaxi

src/datamodel_code_generator/parser/jsonschema.py

@@ -2153,6 +2153,13 @@ def _deep_merge(self, dict1: dict[Any, Any], dict2: dict[Any, Any]) -> dict[Any,
             result[key] = value
         return result
 
+    def _without_self_metadata(self, raw: dict[str, Any]) -> dict[str, Any]:  # noqa: PLR6301
+        if "self" not in raw:
+            return raw
+        raw = raw.copy()
+        raw.pop("self", None)
+        return raw
+
     def _load_ref_schema_object(self, ref: str) -> JsonSchemaObject:
         """Load a JsonSchemaObject from a $ref using standard resolve/load pipeline."""
         resolved_ref = self.model_resolver.resolve_ref(ref)
@@ -2163,6 +2170,8 @@ def _load_ref_schema_object(self, ref: str) -> JsonSchemaObject:
         if fragment:
             pointer = split_json_pointer(raw_doc, fragment)
             target_schema = get_model_by_path(raw_doc, pointer)
+        if isinstance(target_schema, dict):
+            target_schema = self._without_self_metadata(target_schema)
 
         return self._validate_schema_object(target_schema, [resolved_ref])
 
@@ -5458,9 +5467,10 @@ def _parse_file(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
                 class_name=True,
                 preserve_class_name=preserve_root_class_name,
             ).name
+            # Some jsonschema docs include attribute self to have include version details.
+            # Keep parser-owned and cached raw data unchanged for later reuse.
+            raw = self._without_self_metadata(raw)
             with self.root_id_context(raw):
-                # Some jsonschema docs include attribute self to have include version details
-                raw.pop("self", None)
                 # parse $id before parsing $ref
                 root_obj = self._validate_schema_object(raw, path_parts or ["#"])
                 self.parse_id(root_obj, [*path_parts, "#"] if path_parts else ["#"])

tests/conftest.py

@@ -12,7 +12,9 @@
 import sys
 import time
 from collections import Counter
-from collections.abc import Callable, Mapping, Sequence
+from collections.abc import Callable, Generator, Mapping, Sequence
+from contextlib import contextmanager
+from copy import deepcopy
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from itertools import starmap
@@ -702,6 +704,28 @@ def assert_output(
     _assert_with_external_file(output, expected_path)
 
 
+def _tracks_mutation(value: object) -> bool:
+    match value:
+        case dict() | list():
+            return True
+    return False
+
+
+@contextmanager
+def assert_inputs_not_mutated(inputs: Mapping[str, object] | None) -> Generator[None, None, None]:
+    """Assert guarded mutable inputs are unchanged after the wrapped operation."""
+    __tracebackhide__ = True
+    if inputs is None:
+        yield
+        return
+
+    snapshots = {label: deepcopy(value) for label, value in inputs.items() if _tracks_mutation(value)}
+    yield
+    for label, before in snapshots.items():
+        if (current := inputs[label]) != before:  # pragma: no cover - exercised by helper tests
+            pytest.fail(f"{label} was mutated: before={before!r}, after={current!r}")
+
+
 def assert_directory_content(
     output_dir: Path,
     expected_dir: Path,

tests/main/conftest.py

@@ -11,7 +11,7 @@
 import time
 import warnings
 from argparse import Namespace
-from collections.abc import Callable, Generator, Sequence
+from collections.abc import Callable, Generator, Mapping, Sequence
 from contextlib import contextmanager
 from functools import cache
 from pathlib import Path
@@ -31,6 +31,7 @@
     _infer_expected_file,
     _validation_stats,
     assert_directory_content,
+    assert_inputs_not_mutated,
     assert_output,
     assert_warnings_contain,
     freeze_time,
@@ -611,6 +612,7 @@ def run_generate_file_and_assert(
     expected_file: str | Path | None = None,
     transform: Callable[[str], str] | None = None,
     expected_warnings: Sequence[str] | None = None,
+    unchanged_inputs: Mapping[str, object] | None = None,
     **generate_kwargs: Any,
 ) -> None:
     """Execute generate() for a file input and assert the generated output."""
@@ -632,19 +634,20 @@ def run_generate_file_and_assert(
     if input_file_type is not None:
         generate_options["input_file_type"] = input_file_type
 
-    if expected_warnings is None:
-        generate(
-            input_=input_,
-            **generate_options,
-        )
-    else:
-        with warnings.catch_warnings(record=True) as warning_records:
-            warnings.simplefilter("always")
+    with assert_inputs_not_mutated(unchanged_inputs):
+        if expected_warnings is None:
             generate(
                 input_=input_,
                 **generate_options,
             )
-        assert_warnings_contain(warning_records, *expected_warnings)
+        else:
+            with warnings.catch_warnings(record=True) as warning_records:
+                warnings.simplefilter("always")
+                generate(
+                    input_=input_,
+                    **generate_options,
+                )
+            assert_warnings_contain(warning_records, *expected_warnings)
 
     if expected_file is None:
         frame = inspect.currentframe()
@@ -654,24 +657,32 @@ def run_generate_file_and_assert(
         del frame
 
     assert_func(output_path, expected_file, transform=transform)
-    _assert_builtin_generate_formatter_parity(
-        input_=input_,
-        output_path=output_path,
-        generate_options=generate_options,
-        expected_warnings=expected_warnings,
-    )
+    with assert_inputs_not_mutated(unchanged_inputs):
+        _assert_builtin_generate_formatter_parity(
+            input_=input_,
+            output_path=output_path,
+            generate_options=generate_options,
+            expected_warnings=expected_warnings,
+        )
 
 
 def run_generate_and_assert(
     *,
     input_: Any,
     expected_file: Path,
+    assert_input_unchanged: bool = False,
+    unchanged_inputs: Mapping[str, object] | None = None,
     **generate_kwargs: Any,
 ) -> None:
     """Execute generate(output=None) and assert the returned text output."""
     __tracebackhide__ = True
 
-    result = generate(input_=input_, **_default_formatter_generate_options(generate_kwargs))
+    guarded_inputs = dict(unchanged_inputs or {})
+    if assert_input_unchanged:
+        guarded_inputs["input_"] = input_
+
+    with assert_inputs_not_mutated(guarded_inputs or None):
+        result = generate(input_=input_, **_default_formatter_generate_options(generate_kwargs))
     if not isinstance(result, str):  # pragma: no cover
         pytest.fail(f"Expected generate() to return str, got {type(result).__name__}")
     assert_output(result, expected_file)

tests/main/jsonschema/test_main_jsonschema.py

@@ -23,6 +23,7 @@
     TargetPydanticVersion,
     chdir,
     generate,
+    load_data_from_path,
 )
 from datamodel_code_generator.__main__ import Exit
 from datamodel_code_generator.format import is_supported_in_black
@@ -2247,6 +2248,57 @@ def test_main_generate_without_input_file_type(output_file: Path) -> None:
     )
 
 
+def test_generate_keeps_cached_yaml_ref_original_unchanged(tmp_path: Path) -> None:
+    """Keep cached parsed YAML references unchanged while resolving JSON Schema refs."""
+    schema_path = tmp_path / "schema.yaml"
+    child_path = tmp_path / "child.yaml"
+    output_path = tmp_path / "output.py"
+    schema_path.write_text(
+        """
+title: Root
+type: object
+properties:
+  child:
+    $ref: child.yaml#
+""".lstrip(),
+        encoding="utf-8",
+    )
+    child_path.write_text(
+        """
+self:
+  version: metadata
+title: Child
+type: object
+properties:
+  name:
+    type: string
+""".lstrip(),
+        encoding="utf-8",
+    )
+    cached_child_schema = load_data_from_path(child_path.resolve(), "utf-8")
+
+    def assert_ref_output(
+        output_file: Path,
+        expected_file: str | Path | None = None,  # noqa: ARG001
+        transform: object = None,
+    ) -> None:
+        output = output_file.read_text(encoding="utf-8")
+        if callable(transform):
+            output = transform(output)
+        assert "class Child(BaseModel):" in output
+        assert "class Root(BaseModel):" in output
+
+    run_generate_file_and_assert(
+        input_path=schema_path,
+        output_path=output_path,
+        input_file_type=InputFileType.JsonSchema,
+        assert_func=assert_ref_output,
+        expected_file="unused.py",
+        disable_timestamp=True,
+        unchanged_inputs={"cached child.yaml": cached_child_schema},
+    )
+
+
 def test_main_generate_relative_input_path(output_file: Path) -> None:
     """Test helper with a relative input path."""
     run_generate_file_and_assert(

tests/main/protobuf/test_main_protobuf.py

@@ -14,6 +14,7 @@
     EXPECTED_PROTOBUF_PATH,
     PROTOBUF_DATA_PATH,
     assert_input_file_type,
+    run_generate_and_assert,
     run_generate_file_and_assert,
     run_main_and_assert,
 )
@@ -163,14 +164,14 @@ def test_generate_api_protobuf_definition_key_collision() -> None:
 
 def test_generate_api_protobuf_from_path_list() -> None:
     """Generate Protocol Buffers models from a list of .proto file paths."""
-    result = generate(
-        cast(Any, [(PROTOBUF_DATA_PATH / "spec_proto3.proto").resolve()]),  # noqa: TC006
+    run_generate_and_assert(
+        input_=cast(Any, [(PROTOBUF_DATA_PATH / "spec_proto3.proto").resolve()]),  # noqa: TC006
         input_file_type=InputFileType.Protobuf,
         disable_timestamp=True,
+        expected_file=EXPECTED_PROTOBUF_PATH / "spec_proto3_list_input.py",
+        assert_input_unchanged=True,
     )
 
-    assert_output(result, EXPECTED_PROTOBUF_PATH / "spec_proto3_list_input.py")
-
 
 def test_generate_api_protobuf_rejects_dict_input() -> None:
     """Reject mapping input because Protocol Buffers requires .proto text."""

tests/main/test_main_general.py

@@ -2711,6 +2711,7 @@ def test_generate_with_dict_jsonschema() -> None:
         input_file_type=InputFileType.JsonSchema,
         disable_timestamp=True,
         expected_file=EXPECTED_MAIN_PATH / "dict_input" / "jsonschema.py",
+        assert_input_unchanged=True,
     )
 
 
@@ -2723,6 +2724,7 @@ def test_generate_with_dict_openapi() -> None:
         input_file_type=InputFileType.OpenAPI,
         disable_timestamp=True,
         expected_file=EXPECTED_MAIN_PATH / "dict_input" / "openapi.py",
+        assert_input_unchanged=True,
     )
 
 

tests/test_conftest_helpers.py

@@ -15,6 +15,7 @@
 from tests.conftest import (
     _infer_expected_file,
     assert_exact_directory_content,
+    assert_inputs_not_mutated,
     assert_parser_modules,
     assert_parser_results,
 )
@@ -94,6 +95,89 @@ def test_assert_parser_modules_rejects_unexpected_module(tmp_path: Path) -> None
         assert_parser_modules({("sample.py",): "value = 1\n"}, expected_dir)
 
 
+def test_assert_inputs_not_mutated_allows_unchanged_nested_values() -> None:
+    """Mutation guard accepts unchanged dict/list inputs and ignores immutable labels."""
+    schema = {"properties": {"name": {"type": "string"}}, "required": ["name"]}
+
+    with assert_inputs_not_mutated({"schema": schema, "description": "ignored"}):
+        assert schema["properties"]["name"]["type"] == "string"
+
+
+def test_assert_inputs_not_mutated_reports_nested_mutation() -> None:
+    """Mutation guard reports the label for nested dict/list mutations."""
+    schema = {"properties": {"name": {"type": "string"}}, "required": ["name"]}
+
+    with (
+        pytest.raises(pytest.fail.Exception, match="schema was mutated"),
+        assert_inputs_not_mutated({"schema": schema}),
+    ):
+        schema["required"].append("age")
+
+
+def test_run_generate_and_assert_detects_mutated_input(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """run_generate_and_assert can guard caller-provided dict/list inputs."""
+    schema = {"properties": {"name": {"type": "string"}}, "required": ["name"]}
+
+    def fake_generate(*, input_: object, **_: object) -> str:
+        assert isinstance(input_, dict)
+        input_["required"].append("age")
+        return "value = 1\n"
+
+    def assert_output_noop(output: object, expected_file: Path) -> None:
+        assert output == "value = 1\n"
+        assert expected_file == tmp_path / "expected.py"
+
+    monkeypatch.setattr(main_conftest, "generate", fake_generate)
+    monkeypatch.setattr(main_conftest, "assert_output", assert_output_noop)
+
+    with pytest.raises(pytest.fail.Exception, match="input_ was mutated"):
+        main_conftest.run_generate_and_assert(
+            input_=schema,
+            expected_file=tmp_path / "expected.py",
+            assert_input_unchanged=True,
+        )
+
+
+def test_run_generate_file_and_assert_detects_mutated_unchanged_input(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """run_generate_file_and_assert can guard cached parsed original objects."""
+    cached_schema = {"properties": {"name": {"type": "string"}}, "required": ["name"]}
+    input_path = tmp_path / "schema.json"
+    output_path = tmp_path / "output.py"
+
+    def fake_generate(*, input_: object, **options: object) -> None:
+        assert input_ == input_path
+        cached_schema["required"].append("age")
+        output = options["output"]
+        assert isinstance(output, Path)
+        output.write_text("value = 1\n", encoding="utf-8")
+
+    def assert_file_noop(
+        output_file: Path,
+        expected_file: str | Path | None = None,
+        transform: object = None,
+    ) -> None:
+        assert output_file == output_path
+        assert expected_file == "unused.py"
+        assert transform is None
+
+    monkeypatch.setattr(main_conftest, "generate", fake_generate)
+
+    with pytest.raises(pytest.fail.Exception, match="cached schema was mutated"):
+        main_conftest.run_generate_file_and_assert(
+            input_path=input_path,
+            output_path=output_path,
+            assert_func=assert_file_noop,
+            expected_file="unused.py",
+            unchanged_inputs={"cached schema": cached_schema},
+        )
+
+
 def test_builtin_parity_mock_call_preservation(mocker: MockerFixture) -> None:
     """Mock call history is restored after parity-only calls."""
     mocked_callable = mocker.Mock()