tdd-cli 0.12.0__tar.gz → 0.12.2__tar.gz

{tdd_cli-0.12.0 → tdd_cli-0.12.2}/CHANGELOG.md

@@ -6,6 +6,38 @@ and the project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.12.2] - 2026-09-17
+
+### Fixed
+
+- **A wildcard directory in `test_paths` matched nothing** (#136): a pattern ending in `/` was
+  compared as a literal prefix by `Project.is_test_file` and joined as a literal path by the cargo
+  adapter's `_test_files`, so `crates/*/tests/` — how a workspace declares one pattern instead of
+  one per crate — matched no file at all. Every test file in such a project classified as
+  implementation, so a RED commit touching only tests was recorded as `implementation_during_red`,
+  reporting the agent for writing production code it had not written; `_test_files` returned an
+  empty list, leaving the unaccounted-files check with nothing to compare. A directory pattern is
+  now matched per path segment (`crates/*/tests/` covers `crates/x/tests/main.rs`, not
+  `crates/x/src/tests/main.rs`), and the adapter globs it.
+
+## [0.12.1] - 2026-09-17
+
+### Fixed
+
+- **cargo: a test target whose name differs from its file's stem** (#134): the adapter derived the
+  target from the `Running tests/<file>.rs` header's path, which is only the target's name under
+  cargo's default of one binary per `tests/*.rs`. A crate that sets `autotests = false` and declares
+  its own `[[test]]` — many files compiled into one binary named something else — was unreachable:
+  collection ran `--test <stem>` and cargo answered ``no test target named `<stem>` in default-run
+  packages``, so every cycle target came back `not_collected`, whatever id the plan declared. The
+  target is now read from the artifact the header names (`…/deps/bridge_tests-<hash>`), which is
+  also the only thing distinguishing two crates in a workspace whose test files are both
+  `tests/main.rs`. The crate manifests supply the mapping back: target → the file it is built from
+  for `target_path` and the collection file set, and the declared spelling for `--test`, since cargo
+  writes a target's `-` as `_` in the artifact. Manifests are located by walking up from the declared
+  `test_paths`, not from `_test_files()`, which does not expand a wildcard directory pattern such as
+  `crates/*/tests/`. Under the default layout target and stem still agree and nothing changes.
+
 ## [0.12.0] - 2026-09-17
 
 ### Changed

{tdd_cli-0.12.0 → tdd_cli-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tdd-cli
-Version: 0.12.0
+Version: 0.12.2
 Summary: Ledger-backed TDD process controller for autonomous coding agents
 Project-URL: Homepage, https://github.com/geuben/tdd-cli
 Project-URL: Repository, https://github.com/geuben/tdd-cli

{tdd_cli-0.12.0 → tdd_cli-0.12.2}/src/tddcli/__init__.py

@@ -3,4 +3,4 @@
 State is derived from observed test execution, never asserted by the caller.
 """
 
-__version__ = "0.12.0"
+__version__ = "0.12.2"

{tdd_cli-0.12.0 → tdd_cli-0.12.2}/src/tddcli/adapters/cargo_adapter.py

@@ -8,6 +8,16 @@ binary name for a file under `tests/` (`tests/roundtrip.rs` → `roundtrip`); th
     lib::layout::tests::wraps_short
     roundtrip::renders_cover_only
 
+The target is the *binary* name, which is only the file stem under cargo's
+default of one binary per `tests/*.rs`. A crate that sets `autotests = false`
+and declares its own `[[test]]` compiles many files into one binary named
+something else entirely — `tests/main.rs` with a `mod` per file, built as
+`bridge_tests` — and then ids read `bridge_tests::adapter_config::parses`, the
+file is `tests/main.rs`, and `--test bridge_tests` is what runs it. The manifest
+is the only thing relating the two, so it is read; the `Running` header's
+artifact (`…/deps/bridge_tests-<hash>`) is what names the target per block,
+since the header's path is `tests/main.rs` in every crate of a workspace.
+
 A targeted run composes to cargo's own selectors without translation —
 `cargo test --lib -- --exact layout::tests::wraps_short` or
 `cargo test --test roundtrip -- --exact renders_cover_only` — and nothing else
@@ -49,6 +59,7 @@ from __future__ import annotations
 import re
 import shlex
 import time
+import tomllib
 from pathlib import Path
 
 from .base import (
@@ -63,7 +74,14 @@ from .base import (
 
 # `     Running unittests src/lib.rs (target/debug/deps/x-abc)` → target "lib"
 # `     Running tests/roundtrip.rs (target/debug/deps/roundtrip-abc)` → "roundtrip"
-_RUNNING_RE = re.compile(r"^\s*Running (?:unittests (\S+)|(\S+)) \(", re.MULTILINE)
+# The artifact in parentheses is captured too: it is the only part of the header
+# that names the *target*, which a crate may name differently from its file
+# (`tests/main.rs` compiled as `bridge_tests`), and the only part that tells two
+# crates' identically-pathed test files apart in a workspace.
+_RUNNING_RE = re.compile(r"^\s*Running (?:unittests (\S+)|(\S+)) \(([^)]*)\)", re.MULTILINE)
+# `bridge_tests-541f4f38a741dff0` → `bridge_tests` (cargo abbreviates the hash
+# in some outputs, so its length is not pinned)
+_ARTIFACT_HASH_RE = re.compile(r"-[0-9a-f]+$")
 _DOCTEST_RE = re.compile(r"^\s*Doc-tests ", re.MULTILINE)
 # `test layout::tests::wraps_short ... ok` / `... FAILED` / `... ignored`
 _TEST_LINE_RE = re.compile(r"^test (\S+) \.\.\. (ok|FAILED|ignored)\s*$", re.MULTILINE)
@@ -76,18 +94,36 @@ _COULD_NOT_COMPILE_RE = re.compile(r"could not compile")
 _NO_LIB_RE = re.compile(r"no library targets found")
 
 
+def _artifact_target(artifact: str) -> str | None:
+    """Target name from a `target/debug/deps/<name>-<hash>` artifact path.
+
+    cargo writes `-` in a target name as `_` here, so the result is the mangled
+    spelling; `CargoAdapter._demangle_target` maps it back to the declared one.
+    """
+    stem = Path(artifact).name
+    stripped = _ARTIFACT_HASH_RE.sub("", stem)
+    return stripped or None
+
+
 def _target_of_header(match: re.Match) -> str | None:
-    unit, path = match.group(1), match.group(2)
+    unit, path, artifact = match.group(1), match.group(2), match.group(3)
     if unit is not None:
         return "lib"
     if path.startswith("tests/") and path.endswith(".rs"):
-        return Path(path).stem
+        # The artifact names the target; the path only names the file it was
+        # built from, and those differ whenever a crate declares `[[test]]`
+        # with a `name` of its own.
+        return _artifact_target(artifact) or Path(path).stem
     return None  # examples/benches: not test targets
 
 
 class CargoAdapter(Adapter):
     name = "cargo"
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._targets_cache: dict[str, str] | None = None
+
     def stub_hint(self) -> str:
         return (
             "a compiling stub — a function whose body is `todo!()` — so the test"
@@ -99,7 +135,10 @@ class CargoAdapter(Adapter):
         if "::" not in native:
             return (
                 f"cargo target ids must be '<target>::<path>' (got {native!r}); expected"
-                " shape: lib::module::tests::name or <tests-file-stem>::name"
+                " shape: lib::module::tests::name or <test-binary>::name — the"
+                " binary is the tests file's stem unless the crate declares"
+                " [[test]] name, and `cargo test --tests -- --list` prints the"
+                " spelling to use"
             )
         return None
 
@@ -107,7 +146,90 @@ class CargoAdapter(Adapter):
         target, _, _ = native.partition("::")
         if target == "lib":
             return None
-        return f"tests/{target}.rs"
+        declared = self._declared_target(target)
+        path = self._manifest_targets().get(declared)
+        # No `[[test]]` entry: cargo's default, one binary per file, named for it.
+        return path or f"tests/{target}.rs"
+
+    # ------------------------------------------------------------------
+    # Target names vs. their files
+    #
+    # By default a target is named after its file (`tests/roundtrip.rs` →
+    # `roundtrip`), and the two are interchangeable. A crate that sets
+    # `autotests = false` and declares its own `[[test]]` breaks that: several
+    # files compile into one binary whose `name` is unrelated to any of them
+    # (`tests/main.rs` → `bridge_tests`). Only the manifest relates the two.
+    # ------------------------------------------------------------------
+
+    def _manifest_targets(self) -> dict[str, str]:
+        """`{declared [[test]] name: path relative to the project root}`.
+
+        Read from the manifest owning each file under `test_paths`, so a
+        workspace contributes one entry per crate that declares a test target.
+        """
+        if self._targets_cache is None:
+            targets: dict[str, str] = {}
+            for manifest in self._manifests():
+                try:
+                    raw = tomllib.loads(manifest.read_text())
+                except (OSError, tomllib.TOMLDecodeError):
+                    continue
+                for entry in raw.get("test", []) or []:
+                    name, rel = entry.get("name"), entry.get("path")
+                    if not name or not rel:
+                        continue
+                    try:
+                        full = (manifest.parent / rel).resolve().relative_to(self.root.resolve())
+                    except ValueError:
+                        continue
+                    targets[name] = str(full)
+            self._targets_cache = targets
+        return self._targets_cache
+
+    def _manifests(self) -> set[Path]:
+        """The nearest Cargo.toml above each declared test directory.
+
+        Walked from `test_paths` rather than `_test_files()`, which does not
+        expand a wildcard directory pattern (`crates/*/tests/`) — the very shape
+        a workspace of crates uses.
+        """
+        found: set[Path] = set()
+        root = self.root.resolve()
+        for pattern in self.project.test_patterns or []:
+            for match in self.root.glob(pattern.rstrip("/") or "."):
+                start = match.resolve()
+                # Bounded by construction: a glob of the root cannot escape it,
+                # so the ascent always reaches root and stops there.
+                for here in [start, *start.parents]:
+                    candidate = here / "Cargo.toml"
+                    if candidate.is_file():
+                        found.add(candidate)
+                        break
+                    if here == root:
+                        break
+        return found
+
+    def _declared_target(self, target: str) -> str:
+        """The `[[test]] name` behind a collected target name.
+
+        cargo writes a target's `-` as `_` in the artifact filename the id is
+        read from, so `my-tests` is collected as `my_tests`; `--test` wants the
+        declared spelling back.
+        """
+        names = self._manifest_targets()
+        if target in names:
+            return target
+        for declared in names:
+            if declared.replace("-", "_") == target:
+                return declared
+        return target
+
+    def _target_of_file(self, rel: str) -> str:
+        """The target a test file belongs to; its stem under cargo's default."""
+        for declared, path in self._manifest_targets().items():
+            if path == rel:
+                return declared
+        return Path(rel).stem
 
     # ------------------------------------------------------------------
     # Commands
@@ -116,10 +238,12 @@ class CargoAdapter(Adapter):
     def _test_cmd(self) -> str:
         return self.project.test_command or "cargo test --tests"
 
-    @staticmethod
-    def _selector(native_id: str) -> str:
+    def _selector(self, native_id: str) -> str:
         target, _, path = native_id.partition("::")
-        scope = "--lib" if target == "lib" else f"--test {shlex.quote(target)}"
+        if target == "lib":
+            scope = "--lib"
+        else:
+            scope = f"--test {shlex.quote(self._declared_target(target))}"
         return f"{scope} -- --exact {shlex.quote(path)}"
 
     def _targeted_cmd(self, native_id: str) -> str:
@@ -135,9 +259,13 @@ class CargoAdapter(Adapter):
         found: set[Path] = set()
         for pattern in self.project.test_patterns or []:
             if pattern.endswith("/"):
-                base = self.root / pattern
-                if base.is_dir():
-                    found.update(p for p in base.glob("*.rs") if p.is_file())
+                # `self.root / pattern` is a literal path, so a wildcard
+                # directory pattern (`crates/*/tests/`) never resolves; glob it.
+                # A trailing slash is accepted by glob on every supported
+                # Python (3.11–3.14), so the pattern goes through as declared.
+                for base in self.root.glob(pattern):
+                    if base.is_dir():
+                        found.update(p for p in base.glob("*.rs") if p.is_file())
             else:
                 found.update(p for p in self.root.glob(pattern) if p.is_file())
         return sorted(found)
@@ -154,18 +282,19 @@ class CargoAdapter(Adapter):
         if code != 0 or _COULD_NOT_COMPILE_RE.search(out):
             return None
         tests = self._parse_list(out)
-        files = {f"tests/{t.split('::', 1)[0]}.rs" for t in tests if not t.startswith("lib::")}
+        files = {self.target_path(t) for t in tests if not t.startswith("lib::")} - {None}
         return {self.qualify(t) for t in tests}, files
 
     def _collect_per_file(self, rels, result):
         for rel in sorted(rels):
-            stem = Path(rel).stem
-            cmd = f"{self._targeted_prefix()} --test {shlex.quote(stem)} -- --list 2>&1"
+            declared = self._target_of_file(rel)
+            cmd = f"{self._targeted_prefix()} --test {shlex.quote(declared)} -- --list 2>&1"
             code, out, _err = self._run_suite(cmd, self._suite_env(None))
             if code != 0 or _COULD_NOT_COMPILE_RE.search(out):
                 result.failed_files[rel] = clip_failure(self._errors(out))
                 continue
-            result.tests |= {self.qualify(t) for t in self._parse_list(out, default=stem)}
+            default = declared.replace("-", "_")
+            result.tests |= {self.qualify(t) for t in self._parse_list(out, default=default)}
         return result
 
     def _targeted_prefix(self) -> str:

{tdd_cli-0.12.0 → tdd_cli-0.12.2}/src/tddcli/config.py

@@ -73,6 +73,20 @@ class Override:
     timeout: int | None = None
 
 
+def _dir_pattern_matches(pattern: str, inner: str) -> bool:
+    """True when `inner` sits under the directory `pattern` describes.
+
+    `pattern` ends in `/` and may contain wildcards; matching is per path
+    segment, so `crates/*/tests/` covers `crates/dd-bridge/tests/main.rs` but
+    not `crates/dd-bridge/src/main.rs`.
+    """
+    segments = pattern.rstrip("/").split("/")
+    parts = inner.split("/")
+    if len(parts) <= len(segments):
+        return False
+    return all(fnmatch(part, seg) for part, seg in zip(parts, segments))
+
+
 @dataclass
 class Project:
     name: str
@@ -141,11 +155,14 @@ class Project:
         inner = self.relative_to_root(rel_path)
         for pattern in self.test_patterns:
             if pattern.endswith("/"):
-                if inner.startswith(pattern):
+                # A directory pattern may carry wildcards (`crates/*/tests/`),
+                # so it is matched as a glob against the leading path segments,
+                # not compared as a literal prefix.
+                if _dir_pattern_matches(pattern, inner):
                     return True
             elif fnmatch(inner, pattern) or fnmatch(rel_path, pattern):
                 return True
-            elif inner.startswith(pattern.rstrip("/") + "/"):
+            elif _dir_pattern_matches(pattern.rstrip("/") + "/", inner):
                 return True
         return False
 

{tdd_cli-0.12.0 → tdd_cli-0.12.2}/tests/test_cargo_adapter.py

@@ -13,7 +13,7 @@ from unittest.mock import patch
 
 from tddcli import config as config_mod
 from tddcli.adapters import available
-from tddcli.adapters.base import FAILED, NOT_COLLECTED, NOT_FOUND, PASSED
+from tddcli.adapters.base import FAILED, NOT_COLLECTED, NOT_FOUND, PASSED, Collection
 from tddcli.adapters.cargo_adapter import CargoAdapter
 
 TOML = """
@@ -395,3 +395,197 @@ def test_every_invocation_carries_the_project_env(tmp_path):
     for call in rs.call_args_list:
         env = call.args[1] if len(call.args) > 1 else call.kwargs.get("extra_env")
         assert env == {"CARGO_HOME": "/opt/cargo"}, call
+
+
+# ---------------------------------------------------------------------------
+# A crate whose test binary is not named after its file
+#
+# `autotests = false` plus a `[[test]]` entry compiles every file under tests/
+# into one binary with a name of its own. The target is then unrelated to the
+# file it was built from, and in a workspace every crate's header reads
+# `Running tests/main.rs` — only the artifact tells them apart.
+# ---------------------------------------------------------------------------
+
+CONSOLIDATED_LIST = """
+     Running tests/main.rs (/work/target/debug/deps/bridge_tests-541f4f38a741dff0)
+
+adapter_config::poll_config_parses_targets_and_maps: test
+adapter_webhook_config::webhook_table_parses_listen_token_and_maps: test
+
+2 tests, 0 benchmarks
+"""
+
+WORKSPACE_LIST = """
+     Running tests/main.rs (/work/target/debug/deps/bridge_tests-541f4f38a741dff0)
+
+adapter_config::poll_config_parses_targets_and_maps: test
+
+     Running tests/main.rs (/work/target/debug/deps/core_tests-9f1e2d3c4b5a6879)
+
+attention_clear::clear_removes_the_alert: test
+
+2 tests, 0 benchmarks
+"""
+
+
+def make_consolidated_adapter(tmp_path: Path) -> CargoAdapter:
+    """A workspace of two crates, each compiling tests/main.rs under its own name."""
+    (tmp_path / "tdd.toml").write_text(
+        "\n".join(
+            [
+                "[project.ws]",
+                'root       = "."',
+                'adapter    = "cargo"',
+                'test_paths = ["crates/*/tests/"]',
+                "",
+            ]
+        )
+    )
+    for crate, target in (("dd-bridge", "bridge_tests"), ("dd-core", "core_tests")):
+        tests = tmp_path / "crates" / crate / "tests"
+        tests.mkdir(parents=True)
+        (tests / "main.rs").write_text("mod adapter_config;\n")
+        (tmp_path / "crates" / crate / "Cargo.toml").write_text(
+            "\n".join(
+                [
+                    "[package]",
+                    f'name = "{crate}"',
+                    "autotests = false",
+                    "",
+                    "[[test]]",
+                    f'name = "{target}"',
+                    'path = "tests/main.rs"',
+                    "",
+                ]
+            )
+        )
+    cfg = config_mod.load(tmp_path)
+    return CargoAdapter(cfg.project("ws"), tmp_path)
+
+
+def test_ids_use_the_binary_name_not_the_file_stem(tmp_path):
+    a = make_consolidated_adapter(tmp_path)
+    assert a._parse_list(CONSOLIDATED_LIST) == {
+        "bridge_tests::adapter_config::poll_config_parses_targets_and_maps",
+        "bridge_tests::adapter_webhook_config::webhook_table_parses_listen_token_and_maps",
+    }
+
+
+def test_identically_pathed_files_are_told_apart_by_their_artifact(tmp_path):
+    a = make_consolidated_adapter(tmp_path)
+    assert a._parse_list(WORKSPACE_LIST) == {
+        "bridge_tests::adapter_config::poll_config_parses_targets_and_maps",
+        "core_tests::attention_clear::clear_removes_the_alert",
+    }
+
+
+def test_targeted_command_scopes_to_the_declared_binary(tmp_path):
+    a = make_consolidated_adapter(tmp_path)
+    assert a._targeted_cmd("bridge_tests::adapter_config::parses") == (
+        "cargo test --test bridge_tests -- --exact adapter_config::parses"
+    )
+
+
+def test_target_path_maps_a_declared_binary_to_the_file_it_is_built_from(tmp_path):
+    a = make_consolidated_adapter(tmp_path)
+    assert a.target_path("bridge_tests::adapter_config::parses") == (
+        "crates/dd-bridge/tests/main.rs"
+    )
+    assert a.target_path("core_tests::attention_clear::clears") == ("crates/dd-core/tests/main.rs")
+
+
+def test_per_file_collection_scopes_to_the_files_binary(tmp_path):
+    a = make_consolidated_adapter(tmp_path)
+    seen: list[str] = []
+
+    def record(cmd, env):
+        seen.append(cmd)
+        return 0, CONSOLIDATED_LIST, ""
+
+    with patch.object(CargoAdapter, "_run_suite", side_effect=record):
+        a._collect_per_file({"crates/dd-bridge/tests/main.rs"}, Collection())
+    assert "--test bridge_tests" in seen[0]
+    assert "--test main" not in seen[0]
+
+
+def test_a_dashed_binary_name_is_run_under_its_declared_spelling(tmp_path):
+    """cargo writes `-` as `_` in the artifact, but `--test` wants the manifest's spelling."""
+    (tmp_path / "tdd.toml").write_text(
+        '[project.ws]\nroot = "."\nadapter = "cargo"\ntest_paths = ["tests/"]\n'
+    )
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "main.rs").write_text("mod a;\n")
+    (tmp_path / "Cargo.toml").write_text(
+        '[package]\nname = "w"\nautotests = false\n\n'
+        '[[test]]\nname = "my-tests"\npath = "tests/main.rs"\n'
+    )
+    cfg = config_mod.load(tmp_path)
+    a = CargoAdapter(cfg.project("ws"), tmp_path)
+    assert a._targeted_cmd("my_tests::a::works") == (
+        "cargo test --test my-tests -- --exact a::works"
+    )
+
+
+def test_collection_reports_the_file_each_target_was_built_from(tmp_path):
+    """The set of covered files is the manifest's, not `tests/<target>.rs`."""
+    a = make_consolidated_adapter(tmp_path)
+    with patch.object(CargoAdapter, "_run_suite", return_value=(0, WORKSPACE_LIST, "")):
+        tests, files = a._collect_batch("cargo test --tests -- --list", {})
+    assert files == {"crates/dd-bridge/tests/main.rs", "crates/dd-core/tests/main.rs"}
+    assert "ws::bridge_tests::adapter_config::poll_config_parses_targets_and_maps" in tests
+
+
+def test_a_malformed_artifact_falls_back_to_the_file_stem(tmp_path):
+    """Nothing usable in the parentheses: the file stem is still cargo's default."""
+    a = make_adapter(tmp_path)
+    output = (
+        "     Running tests/roundtrip.rs (/work/target/debug/deps/-1d2c3b4a)\n"
+        "\nrenders_cover_only: test\n"
+    )
+    assert a._parse_list(output) == {"roundtrip::renders_cover_only"}
+
+
+def test_a_test_entry_without_a_path_resolves_through_cargos_default(tmp_path):
+    """`[[test]] name = "x"` with no `path` means `tests/x.rs`; no mapping needed."""
+    (tmp_path / "tdd.toml").write_text(
+        '[project.ws]\nroot = "."\nadapter = "cargo"\ntest_paths = ["tests/"]\n'
+    )
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "roundtrip.rs").write_text("#[test] fn t() {}\n")
+    (tmp_path / "Cargo.toml").write_text('[package]\nname = "w"\n\n[[test]]\nname = "roundtrip"\n')
+    cfg = config_mod.load(tmp_path)
+    a = CargoAdapter(cfg.project("ws"), tmp_path)
+    assert a._manifest_targets() == {}
+    assert a.target_path("roundtrip::t") == "tests/roundtrip.rs"
+    assert a._targeted_cmd("roundtrip::t") == ("cargo test --test roundtrip -- --exact t")
+
+
+def test_a_file_shaped_test_path_still_finds_the_manifest(tmp_path):
+    """`test_paths` may name files (`tests/*.rs`), not only directories."""
+    (tmp_path / "tdd.toml").write_text(
+        '[project.ws]\nroot = "."\nadapter = "cargo"\ntest_paths = ["tests/*.rs"]\n'
+    )
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "main.rs").write_text("mod a;\n")
+    (tmp_path / "Cargo.toml").write_text(
+        '[package]\nname = "w"\nautotests = false\n\n'
+        '[[test]]\nname = "w_tests"\npath = "tests/main.rs"\n'
+    )
+    cfg = config_mod.load(tmp_path)
+    a = CargoAdapter(cfg.project("ws"), tmp_path)
+    assert a._manifest_targets() == {"w_tests": "tests/main.rs"}
+
+
+def test_a_crate_with_no_manifest_keeps_cargos_default_mapping(tmp_path):
+    """No Cargo.toml above the tests dir: the walk stops at the root, nothing is claimed."""
+    a = make_adapter(tmp_path)  # kernel/tests/roundtrip.rs, no Cargo.toml anywhere
+    assert a._manifest_targets() == {}
+    assert a.target_path("roundtrip::renders_cover_only") == "tests/roundtrip.rs"
+    assert a._target_of_file("tests/roundtrip.rs") == "roundtrip"
+
+
+def test_test_files_expands_a_wildcard_directory_pattern(tmp_path):
+    """`self.root / "crates/*/tests/"` is a literal path and never resolves."""
+    a = make_consolidated_adapter(tmp_path)
+    rels = sorted(str(p.relative_to(tmp_path)) for p in a._test_files())
+    assert rels == ["crates/dd-bridge/tests/main.rs", "crates/dd-core/tests/main.rs"]

{tdd_cli-0.12.0 → tdd_cli-0.12.2}/tests/test_config_and_staging.py

@@ -21,6 +21,11 @@ adapter        = "vitest"
 test_paths     = ["e2e/"]
 in_close_sweep = false
 
+[project.workspace]
+root       = "ws"
+adapter    = "cargo"
+test_paths = ["crates/*/tests/"]
+
 [artifact.openapi]
 path        = "schema/openapi.json"
 produced_by = "backend"
@@ -43,7 +48,7 @@ def cfg(tmp_path):
 
 
 def test_projects_and_roots_are_declared_not_scanned(cfg):
-    assert sorted(cfg.projects) == ["backend", "e2e", "frontend"]
+    assert sorted(cfg.projects) == ["backend", "e2e", "frontend", "workspace"]
     assert cfg.project("backend").root == "backend"
 
 
@@ -320,3 +325,36 @@ def test_health_command_parses_onto_project(tmp_path):
     )
     with pytest.raises(config_mod.ConfigError):
         config_mod.load(tmp_path)
+
+
+def test_a_wildcard_directory_test_path_matches_per_segment(cfg):
+    """`crates/*/tests/` is a glob, not a literal prefix.
+
+    A workspace declares its test directories with one pattern rather than one
+    per crate. Comparing it as a literal string classifies every test file as
+    implementation, which reports the agent for writing production code during
+    RED when it only edited tests.
+    """
+    ws = cfg.project("workspace")
+    assert ws.is_test_file("ws/crates/dd-bridge/tests/main.rs")
+    assert ws.is_test_file("ws/crates/dd-core/tests/attention_clear.rs")
+    # The wildcard spans exactly one segment, and the directory itself is not a file.
+    assert not ws.is_test_file("ws/crates/dd-bridge/src/adapter/config.rs")
+    assert not ws.is_test_file("ws/crates/dd-bridge/src/tests/inner.rs")
+    assert not ws.is_test_file("ws/crates/a/b/tests/deep.rs")
+    assert not ws.is_test_file("ws/crates/dd-bridge/tests")
+
+
+def test_a_wildcard_test_path_classifies_edits_as_tests_not_implementation(cfg):
+    """The staging consequence: RED may touch these without being reported."""
+    changed = {
+        "ws/crates/dd-bridge/tests/main.rs",
+        "ws/crates/dd-bridge/tests/adapter_config.rs",
+        "ws/crates/dd-bridge/src/adapter/config.rs",
+    }
+    out = staging.classify(cfg, changed, ["workspace"], None, set())
+    assert out.tests == [
+        "ws/crates/dd-bridge/tests/adapter_config.rs",
+        "ws/crates/dd-bridge/tests/main.rs",
+    ]
+    assert out.implementation == ["ws/crates/dd-bridge/src/adapter/config.rs"]