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

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

@@ -6,6 +6,20 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tdd-cli
-Version: 0.12.1
+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.1 → 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.1"
+__version__ = "0.12.2"

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

@@ -259,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)

{tdd_cli-0.12.1 → 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.1 → tdd_cli-0.12.2}/tests/test_cargo_adapter.py

@@ -582,3 +582,10 @@ def test_a_crate_with_no_manifest_keeps_cargos_default_mapping(tmp_path):
     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.1 → 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"]