tdd-cli 0.1.0__py3-none-any.whl

tddcli/adapters/pytest_adapter.py

@@ -0,0 +1,179 @@
+"""pytest adapter.
+
+Two defects in the prior system are corrected here (R10.2):
+
+* `collectors` is inspected, so an import error reports `not_collected` and is never
+  conflated with a mistyped identifier (`not_found`). One resolves by writing a stub;
+  the other by fixing a name. Conflating them sent agents to ask a human.
+* The report file is written to a fresh temp directory each run, so a stale report can
+  never be read as if current.
+"""
+
+from __future__ import annotations
+
+import json
+import shlex
+import tempfile
+from pathlib import Path
+
+from .base import (
+    FAILED,
+    NOT_COLLECTED,
+    NOT_FOUND,
+    PASSED,
+    Adapter,
+    Collection,
+    GateResult,
+    Verdict,
+    run_command,
+)
+
+#: Environment-manager marker files, most specific first. A pyproject.toml alone is
+#: NOT a marker: Poetry, pipenv, PDM and plain-venv projects all have one, and
+#: assuming uv there runs the suite in an environment the project never built.
+RUNNER_MARKERS = (
+    ("uv.lock", "uv run "),
+    ("poetry.lock", "poetry run "),
+    ("Pipfile", "pipenv run "),
+    ("pdm.lock", "pdm run "),
+)
+
+
+class PytestAdapter(Adapter):
+    name = "pytest"
+
+    def stub_hint(self) -> str:
+        return "`raise NotImplementedError` in every body"
+
+    def _runner_prefix(self) -> str:
+        """The project root is checked before the worktree root: a workspace keeps
+        one lockfile at the top, but a member with its own marker owns its choice."""
+        for base in (self.root, self.worktree):
+            for marker, prefix in RUNNER_MARKERS:
+                if (base / marker).is_file():
+                    return prefix
+        pyproject = self.root / "pyproject.toml"
+        if pyproject.is_file() and "[tool.poetry]" in pyproject.read_text():
+            return "poetry run "
+        return ""
+
+    def _base_cmd(self) -> str:
+        return f"{self._runner_prefix()}pytest"
+
+    def plugin_probe_cmd(self) -> str:
+        """The pytest-json-report check, runnable in the project's own environment."""
+        return f"{self._runner_prefix()}python -c 'import pytest_jsonreport'"
+
+    def _test_cmd(self) -> str:
+        """The project's own suite command, so the suite under TDD is the real one."""
+        return self.project.test_command or self._base_cmd()
+
+    def _collect_cmd(self) -> str:
+        return self.project.collect_command or self._base_cmd()
+
+    def run(self, target: str | None = None) -> Verdict:
+        verdict = Verdict(project=self.project.name, adapter=self.name, target=target)
+        with tempfile.TemporaryDirectory(prefix="tdd-pytest-") as tmp:
+            report_path = Path(tmp) / "report.json"
+            # Only reporting flags are appended — parallelism, markers and plugins
+            # stay exactly as the project declared them. json-report is xdist-safe:
+            # `collectors` is omitted when nothing fails to collect, and present with
+            # the failing entry when something does, which is when it is consulted.
+            cmd = (
+                f"{self._test_cmd()} --json-report"
+                f" --json-report-file={shlex.quote(str(report_path))}"
+            )
+            code, out, err = self._run_suite(cmd)
+            if not report_path.is_file():
+                verdict.error = (
+                    "pytest produced no JSON report (is pytest-json-report installed?): "
+                    + (err or out)[:500]
+                )
+                return verdict
+            report = json.loads(report_path.read_text())
+
+        verdict.duration_ms = int(report.get("duration", 0) * 1000)
+
+        uncollectable: set[str] = set()
+        for collector in report.get("collectors", []):
+            if collector.get("outcome") not in (None, "passed"):
+                uncollectable.add(collector.get("nodeid", ""))
+
+        for test in report.get("tests", []):
+            qualified = self.qualify(test["nodeid"])
+            if test["outcome"] == "passed":
+                verdict.passed.append(qualified)
+            elif test["outcome"] in ("failed", "error"):
+                verdict.failed.append(qualified)
+
+        if target is None:
+            verdict.target_outcome = NOT_FOUND
+            return verdict
+
+        native = self.strip(target)
+        hit = next(
+            (t for t in report.get("tests", []) if t["nodeid"] == native), None
+        )
+        if hit is not None:
+            verdict.target_outcome = PASSED if hit["outcome"] == "passed" else FAILED
+            call = hit.get("call") or hit.get("setup") or {}
+            verdict.target_failure = str(call.get("longrepr", ""))[:1500]
+        else:
+            target_file = native.split("::", 1)[0]
+            if any(c == target_file or c.startswith(target_file) for c in uncollectable):
+                verdict.target_outcome = NOT_COLLECTED
+                verdict.target_failure = self._collector_error(report, target_file)[:1500]
+            else:
+                verdict.target_outcome = NOT_FOUND
+        return verdict
+
+    @staticmethod
+    def _collector_error(report: dict, target_file: str) -> str:
+        for collector in report.get("collectors", []):
+            if collector.get("nodeid", "").startswith(target_file):
+                return str(collector.get("longrepr", ""))
+        return ""
+
+    def _test_files(self) -> list[Path]:
+        found: list[Path] = []
+        for pattern in self.project.test_paths or ["tests/"]:
+            if pattern.endswith("/"):
+                base = self.root / pattern
+                if base.is_dir():
+                    found.extend(sorted(base.rglob("test_*.py")))
+                    found.extend(sorted(base.rglob("*_test.py")))
+            else:
+                found.extend(sorted(self.root.glob(pattern)))
+        return sorted({p for p in found if p.is_file()})
+
+    def collectable(self) -> GateResult:
+        """A single whole-suite `--collect-only` (§10), not the per-file
+        `collect()` loop below — that loop is R10.3/R10.4's per-file collection,
+        the slow path (the whole-suite probe costs 0.04s on a broken project vs.
+        minutes for the per-file sweep on a real one).
+
+        Reads **stdout**, not stderr: `uv` writes environment warnings
+        (`VIRTUAL_ENV=... does not match ...`) to stderr while pytest writes the
+        actual `ModuleNotFoundError` to stdout. A doctor check that reads stderr
+        loses the real error and the failure surfaces unattributed.
+        """
+        code, out, err = run_command(f"{self._collect_cmd()} --collect-only -q", self.root)
+        return GateResult(ok=code == 0, output="" if code == 0 else out.strip()[:2000])
+
+    def collect(self) -> Collection:
+        """Per file (R10.3) — one uncollectable module must not destroy the whole set."""
+        result = Collection()
+        for path in self._test_files():
+            rel = path.relative_to(self.root)
+            code, out, err = run_command(
+                f"{self._collect_cmd()} --collect-only -q {shlex.quote(str(rel))}",
+                self.root,
+            )
+            if code != 0:
+                result.failed_files[str(rel)] = (err or out).strip()[:800]
+                continue
+            for line in out.splitlines():
+                line = line.strip()
+                if "::" in line and not line.startswith(("=", "-", "no tests")):
+                    result.tests.add(self.qualify(line))
+        return result

tddcli/adapters/vitest_adapter.py

@@ -0,0 +1,170 @@
+"""vitest adapter.
+
+Test ids are `<worktree-relative file> > <fullName>`, where fullName is the
+space-joined ancestorTitles plus the test title. vitest may prefix its JSON with
+non-JSON lines, so the payload is located rather than assumed (R10.2).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shlex
+from pathlib import Path
+
+from .base import (
+    FAILED,
+    NOT_COLLECTED,
+    NOT_FOUND,
+    PASSED,
+    Adapter,
+    Collection,
+    GateResult,
+    Verdict,
+    run_command,
+)
+
+
+def _extract_json(raw: str) -> dict | None:
+    start = raw.find("{")
+    while start != -1:
+        try:
+            return json.loads(raw[start:])
+        except json.JSONDecodeError:
+            start = raw.find("{", start + 1)
+    return None
+
+
+class VitestAdapter(Adapter):
+    name = "vitest"
+
+    def stub_hint(self) -> str:
+        return "`throw new Error(\"not implemented\")` in every body"
+
+    def _id_for(self, suite_path: str, full_name: str) -> str:
+        abs_path = Path(suite_path)
+        try:
+            rel = os.path.relpath(abs_path, self.worktree)
+        except ValueError:
+            rel = suite_path
+        return self.qualify(f"{rel} > {full_name}")
+
+    def run(self, target: str | None = None) -> Verdict:
+        verdict = Verdict(project=self.project.name, adapter=self.name, target=target)
+        base = self.project.test_command or "npx vitest run"
+        code, out, err = self._run_suite(f"{base} --reporter=json")
+        report = _extract_json(out)
+        if report is None:
+            verdict.error = f"vitest produced no JSON output: {(err or out)[:500]}"
+            return verdict
+
+        verdict.duration_ms = int(report.get("duration") or 0)
+        failed_suites: dict[str, str] = {}
+
+        for suite in report.get("testResults", []):
+            suite_path = suite.get("name", "")
+            assertions = suite.get("assertionResults", [])
+            if not assertions and suite.get("status") == "failed":
+                failed_suites[suite_path] = str(suite.get("message", ""))[:1500]
+            for t in assertions:
+                qualified = self._id_for(suite_path, t["fullName"])
+                if t["status"] == "passed":
+                    verdict.passed.append(qualified)
+                elif t["status"] == "failed":
+                    verdict.failed.append(qualified)
+
+        if target is None:
+            verdict.target_outcome = NOT_FOUND
+            return verdict
+
+        if target in verdict.passed:
+            verdict.target_outcome = PASSED
+            return verdict
+        if target in verdict.failed:
+            verdict.target_outcome = FAILED
+            for suite in report.get("testResults", []):
+                for t in suite.get("assertionResults", []):
+                    if self._id_for(suite.get("name", ""), t["fullName"]) == target:
+                        verdict.target_failure = "\n".join(
+                            m[:600] for m in t.get("failureMessages", [])[:3]
+                        )
+            return verdict
+
+        target_file = self.strip(target).split(" > ", 1)[0]
+        for suite_path, message in failed_suites.items():
+            if suite_path.endswith(target_file):
+                verdict.target_outcome = NOT_COLLECTED
+                verdict.target_failure = message
+                return verdict
+        verdict.target_outcome = NOT_FOUND
+        return verdict
+
+    def _test_files(self) -> list[Path]:
+        found: set[Path] = set()
+        for pattern in self.project.test_paths or ["**/*.test.ts"]:
+            pat = pattern.rstrip("/") + "/**/*" if pattern.endswith("/") else pattern
+            for path in self.root.glob(pat):
+                if path.is_file() and path.suffix in (".ts", ".tsx", ".js", ".jsx"):
+                    if "node_modules" not in path.parts:
+                        found.add(path)
+        return sorted(found)
+
+    def _parse_list_output(self, out: str, path: Path) -> set[str]:
+        """Parse `vitest list` text output into ids matching those `run()` produces.
+
+        `vitest list` ignores `--reporter=json` (checked against vitest 4.1.0) and
+        emits one line per test:
+
+            relative/file.test.ts > describe > nested describe > it name
+
+        `run()` reports the same test with `fullName`, which is the ancestor titles
+        and the title joined by a **space**. Splitting on " > " and rejoining the
+        name parts with a space reproduces that exactly; keeping the arrows would
+        yield ids that never match a verdict.
+        """
+        found: set[str] = set()
+        for line in out.splitlines():
+            line = line.strip()
+            if " > " not in line:
+                continue
+            _, _, remainder = line.partition(" > ")
+            full_name = " ".join(part.strip() for part in remainder.split(" > "))
+            if full_name:
+                found.add(self._id_for(str(path), full_name))
+        return found
+
+    def collectable(self) -> GateResult:
+        """A single whole-suite probe, mirroring the pytest adapter's `--collect-only`
+        (§10): `npx vitest list` at the project root rather than the
+        per-file `collect()` loop below."""
+        base = self.project.collect_command or "npx vitest list"
+        code, out, err = run_command(base, self.root)
+        return GateResult(ok=code == 0, output="" if code == 0 else (err or out).strip()[:2000])
+
+    def collect(self) -> Collection:
+        result = Collection()
+        for path in self._test_files():
+            rel = path.relative_to(self.root)
+            base = self.project.collect_command or "npx vitest list"
+            code, out, err = run_command(f"{base} {shlex.quote(str(rel))}", self.root)
+
+            payload = _extract_json(out)
+            if payload is not None:
+                entries = payload if isinstance(payload, list) else payload.get("tests", [])
+                for entry in entries or []:
+                    name = entry.get("fullName") or entry.get("name")
+                    if name:
+                        result.tests.add(self._id_for(str(path), name))
+                continue
+
+            names = self._parse_list_output(out, path)
+            if names:
+                result.tests.update(names)
+            else:
+                # Zero tests from a file that exists is a tooling failure, not an
+                # empty file — record it rather than silently collecting nothing.
+                result.failed_files[str(rel)] = (
+                    f"no tests parsed from `{base}` (exit {code}): "
+                    + (err or out).strip()[:600]
+                )
+        return result