claude-dev-env 1.58.0 → 1.59.0

package/hooks/blocking/test_code_rules_enforcer_annotations.py

@@ -95,3 +95,228 @@ def test_should_skip_return_check_in_test_files() -> None:
     assert issues == [], f"Test files must be exempt, got: {issues}"
 
 
+def test_should_flag_unannotated_known_fixture_in_test_file() -> None:
+    source = "def test_board(tmp_path):\n    assert tmp_path.exists()\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"Expected unannotated tmp_path fixture flagged, got: {issues}"
+
+
+def test_should_not_flag_annotated_known_fixture_in_test_file() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_board(tmp_path: Path) -> None:\n"
+        "    assert tmp_path.exists()\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], f"Annotated tmp_path must not be flagged, got: {issues}"
+
+
+def test_should_not_flag_ordinary_test_parameter() -> None:
+    source = "def test_thing(some_value):\n    assert some_value\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Ordinary test params stay exempt; only known fixtures are checked, "
+        f"got: {issues}"
+    )
+
+
+def test_should_not_flag_known_fixture_name_outside_test_files() -> None:
+    source = "def build(monkeypatch):\n    return monkeypatch\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Non-test files are covered by the broad parameter check, not this one, "
+        f"got: {issues}"
+    )
+
+
+def test_should_flag_unannotated_monkeypatch_fixture() -> None:
+    source = "def test_env(monkeypatch):\n    monkeypatch.setenv('A', 'B')\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "monkeypatch" in each_issue and "MonkeyPatch" in each_issue
+        for each_issue in issues
+    ), f"Expected unannotated monkeypatch fixture flagged, got: {issues}"
+
+
+def test_should_not_flag_known_fixture_in_non_test_helper() -> None:
+    source = "def render_view(request):\n    return request.path\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Ordinary helper (non-test, non-fixture) must not be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_unannotated_fixture_in_decorated_fixture() -> None:
+    source = (
+        "import pytest\n"
+        "@pytest.fixture\n"
+        "def board(tmp_path):\n"
+        "    return tmp_path\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"Expected unannotated tmp_path in @pytest.fixture-decorated function flagged, got: {issues}"
+
+
+def test_should_flag_known_fixture_with_wrong_annotation() -> None:
+    source = "def test_board(tmp_path: str):\n    assert tmp_path\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"Expected wrongly annotated tmp_path: str flagged, got: {issues}"
+
+
+def test_should_flag_known_fixture_with_unrelated_annotation() -> None:
+    source = "def test_board(tmp_path: int):\n    assert tmp_path\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"Expected wrongly annotated tmp_path: int flagged, got: {issues}"
+
+
+def test_should_not_flag_correctly_annotated_qualified_fixture() -> None:
+    source = (
+        "import pytest\n"
+        "def test_env(monkeypatch: pytest.MonkeyPatch) -> None:\n"
+        "    monkeypatch.setenv('A', 'B')\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Correctly annotated monkeypatch must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_dotted_pathlib_path_fixture_annotation() -> None:
+    source = (
+        "import pathlib\n"
+        "def test_board(tmp_path: pathlib.Path) -> None:\n"
+        "    assert tmp_path.exists()\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"tmp_path: pathlib.Path is an equally-correct spelling, got: {issues}"
+    )
+
+
+def test_should_not_flag_bare_tail_of_qualified_fixture_annotation() -> None:
+    source = (
+        "from pytest import MonkeyPatch\n"
+        "def test_env(monkeypatch: MonkeyPatch) -> None:\n"
+        "    monkeypatch.setenv('A', 'B')\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"monkeypatch: MonkeyPatch matches the qualified expected tail, got: {issues}"
+    )
+
+
+def test_should_not_flag_forward_reference_fixture_annotation() -> None:
+    source = 'def test_board(tmp_path: "Path") -> None:\n    assert tmp_path\n'
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f'A forward-ref "Path" annotation must not be flagged, got: {issues}'
+    )
+
+
+def test_should_not_flag_star_arg_fixture_name() -> None:
+    source = "def test_board(*tmp_path):\n    assert tmp_path\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A *vararg sharing a fixture name is not an injection site, got: {issues}"
+    )
+
+
+def test_should_not_flag_double_star_arg_fixture_name() -> None:
+    source = "def test_env(**monkeypatch):\n    assert monkeypatch\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A **kwarg sharing a fixture name is not an injection site, got: {issues}"
+    )
+
+
+def test_should_not_flag_positional_only_fixture_name() -> None:
+    source = "def test_board(tmp_path, /):\n    pass\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A positional-only param cannot receive a keyword-injected fixture, got: {issues}"
+    )
+
+
+def test_should_flag_keyword_only_fixture_name() -> None:
+    source = "def test_board(*, tmp_path):\n    pass\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"A keyword-only fixture is still an injection site, got: {issues}"
+
+
+def test_should_not_flag_defaulted_fixture_name() -> None:
+    source = "def test_board(tmp_path=None):\n    pass\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A defaulted param is not fixture-injected and must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_defaulted_keyword_only_fixture_name() -> None:
+    source = "def test_board(*, tmp_path=None):\n    pass\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A defaulted keyword-only param is not fixture-injected, got: {issues}"
+    )
+
+
+def test_should_flag_undefaulted_fixture_before_defaulted_one() -> None:
+    source = "def test_board(tmp_path, capsys=None):\n    pass\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"An undefaulted leading fixture stays an injection site, got: {issues}"
+    assert not any("capsys" in each_issue for each_issue in issues), (
+        f"The trailing defaulted param must not be flagged, got: {issues}"
+    )
+
+

package/hooks/blocking/test_code_rules_enforcer_cap_meta.py

@@ -70,6 +70,7 @@ KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW: frozenset[str] = frozenset(
         "check_file_global_constants_use_count",
         "check_imports_at_top",
         "check_inline_literal_collections",
+        "check_known_pytest_fixture_annotations",
         "check_library_print",
         "check_loop_variable_naming",
         "check_parameter_annotations",

package/hooks/blocking/test_code_rules_enforcer_dead_dataclass_field.py

@@ -0,0 +1,467 @@
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+ENFORCER_PATH = Path(__file__).resolve().parent / "code_rules_enforcer.py"
+specification = importlib.util.spec_from_file_location(
+    "code_rules_enforcer", ENFORCER_PATH
+)
+assert specification is not None and specification.loader is not None
+code_rules_enforcer = importlib.util.module_from_spec(specification)
+specification.loader.exec_module(code_rules_enforcer)
+
+PRODUCTION_FILE_PATH = "packages/app/services/report.py"
+TEST_FILE_PATH = "packages/app/services/test_report.py"
+MIGRATION_FILE_PATH = "packages/app/migrations/0001_initial.py"
+WORKFLOW_FILE_PATH = "packages/app/skills/thing/workflow/render_report.py"
+
+
+def _check(source: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_dead_dataclass_fields(source, file_path)
+
+
+def test_should_flag_dataclass_field_assigned_but_never_read() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    number: int\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(number=1, url='x')\n"
+        "\n"
+        "def render(metadata: PrMetadata) -> int:\n"
+        "    return metadata.number\n"
+    )
+    issues = _check(source, PRODUCTION_FILE_PATH)
+    assert any(
+        "'url'" in each_issue and "PrMetadata" in each_issue for each_issue in issues
+    ), f"Expected dead 'url' field flagged, got: {issues}"
+    assert not any(
+        "'number'" in each_issue for each_issue in issues
+    ), f"Read field 'number' must not be flagged, got: {issues}"
+
+
+def test_should_not_flag_field_read_via_attribute_access() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+        "\n"
+        "def render(metadata: PrMetadata) -> str:\n"
+        "    return metadata.url\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_when_class_never_constructed_in_file() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PublicConfig:\n"
+        "    url: str\n"
+        "    number: int\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_non_dataclass_class() -> None:
+    source = "class Plain:\n    url: str\n\ndef build() -> Plain:\n    return Plain()\n"
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_classvar_field() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "from typing import ClassVar\n"
+        "\n"
+        "@dataclass\n"
+        "class Counter:\n"
+        "    label: ClassVar[str] = 'count'\n"
+        "    total: int\n"
+        "\n"
+        "def build() -> Counter:\n"
+        "    return Counter(total=1)\n"
+        "\n"
+        "def read(counter: Counter) -> int:\n"
+        "    return counter.total\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_field_read_via_literal_getattr() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return Row(url='x')\n"
+        "\n"
+        "def read(row: Row) -> str:\n"
+        "    return getattr(row, 'url')\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_non_literal_getattr_present() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return Row(url='x')\n"
+        "\n"
+        "def read(row: Row, field_name: str) -> str:\n"
+        "    return getattr(row, field_name)\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_handle_called_dataclass_decorator() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass(frozen=True)\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    issues = _check(source, PRODUCTION_FILE_PATH)
+    assert any(
+        "'url'" in each_issue for each_issue in issues
+    ), f"Expected dead field flagged on called-decorator dataclass, got: {issues}"
+
+
+def test_should_handle_dotted_dataclasses_decorator() -> None:
+    source = (
+        "import dataclasses\n"
+        "\n"
+        "@dataclasses.dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    issues = _check(source, PRODUCTION_FILE_PATH)
+    assert any(
+        "'url'" in each_issue for each_issue in issues
+    ), f"Expected dead field flagged on dotted-decorator dataclass, got: {issues}"
+
+
+def test_should_be_silent_for_test_files() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    assert _check(source, TEST_FILE_PATH) == []
+
+
+def test_should_be_silent_for_migration_files() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    assert _check(source, MIGRATION_FILE_PATH) == []
+
+
+def test_should_flag_dead_field_in_workflow_path() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    issues = _check(source, WORKFLOW_FILE_PATH)
+    assert any(
+        "'url'" in each_issue for each_issue in issues
+    ), f"Workflow-path files are subject to dead-code detection, got: {issues}"
+
+
+def test_should_tolerate_syntax_error() -> None:
+    assert _check("@dataclass\nclass Broken(:\n", PRODUCTION_FILE_PATH) == []
+
+
+def test_validate_content_runs_dead_field_check() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    issues = code_rules_enforcer.validate_content(source, PRODUCTION_FILE_PATH)
+    assert any(
+        "'url'" in each_issue for each_issue in issues
+    ), f"Expected the enforcer dispatch to surface the dead field, got: {issues}"
+
+
+def test_should_suppress_check_when_asdict_consumes_instance() -> None:
+    source = (
+        "from dataclasses import dataclass, asdict\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> dict:\n"
+        "    return asdict(Row(url='x'))\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_astuple_consumes_instance() -> None:
+    source = (
+        "from dataclasses import dataclass, astuple\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> tuple:\n"
+        "    return astuple(Row(url='x'))\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_vars_consumes_instance() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> dict:\n"
+        "    return vars(Row(url='x'))\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_replace_consumes_instance() -> None:
+    source = (
+        "from dataclasses import dataclass, replace\n"
+        "\n"
+        "@dataclass(frozen=True)\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return replace(Row(url='x'), url='y')\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_dotted_replace_consumes_instance() -> None:
+    source = (
+        "import dataclasses\n"
+        "\n"
+        "@dataclasses.dataclass(frozen=True)\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return dataclasses.replace(Row(url='x'), url='y')\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_instance_dict_consumes_instance() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> dict:\n"
+        "    return Row(url='x').__dict__\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_field_read_via_multi_argument_attrgetter() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "from operator import attrgetter\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    first: int\n"
+        "    second: int\n"
+        "\n"
+        "def build() -> tuple:\n"
+        "    return attrgetter('first', 'second')(Row(first=1, second=2))\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_two_instances_compared_for_equality() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def are_same(left: Row, right: Row) -> bool:\n"
+        "    return Row(url='a') == Row(url='b')\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_ordered_instances_compared() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass(order=True)\n"
+        "class Row:\n"
+        "    priority: int\n"
+        "\n"
+        "def is_earlier() -> bool:\n"
+        "    return Row(priority=1) < Row(priority=2)\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_instances_placed_in_set() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass(frozen=True)\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def unique_rows() -> set:\n"
+        "    return {Row(url='a'), Row(url='b')}\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_whole_instance_stringified() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def describe() -> str:\n"
+        "    return str(Row(url='x'))\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_field_read_via_match_class_pattern() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def read(row: Row) -> str:\n"
+        "    match row:\n"
+        "        case Row(url=found):\n"
+        "            return found\n"
+        "    return ''\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return Row(url='x')\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_fields_reflection_consumes_instance() -> None:
+    source = (
+        "import dataclasses\n"
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def field_names() -> list:\n"
+        "    return [each_field.name for each_field in dataclasses.fields(Row(url='x'))]\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_field_read_via_augmented_assignment() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    counter: int\n"
+        "\n"
+        "def bump(row: Row) -> None:\n"
+        "    row.counter += 1\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return Row(counter=0)\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_evaluate_full_file_content_when_supplied() -> None:
+    fragment = "    return metadata.number\n"
+    full_file = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    number: int\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(number=1, url='x')\n"
+        "\n"
+        "def render(metadata: PrMetadata) -> int:\n"
+        "    return metadata.number\n"
+    )
+    issues = code_rules_enforcer.check_dead_dataclass_fields(
+        fragment, PRODUCTION_FILE_PATH, full_file
+    )
+    assert any(
+        "'url'" in each_issue for each_issue in issues
+    ), f"Expected the reconstructed whole-file content to govern, got: {issues}"
+    assert not any(
+        "'number'" in each_issue for each_issue in issues
+    ), f"Read field 'number' must not be flagged, got: {issues}"