codd-dev 2.44.0__tar.gz → 2.46.0__tar.gz

{codd_dev-2.44.0 → codd_dev-2.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.44.0
+Version: 2.46.0
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev

{codd_dev-2.44.0 → codd_dev-2.46.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.44.0"
+__version__ = "2.46.0"

{codd_dev-2.44.0 → codd_dev-2.46.0}/codd/deployment/defaults/verification_templates.yaml

@@ -5,3 +5,5 @@ templates:
   playwright:
     headless: true
     timeout: 60000
+  pytest_http:
+    timeout: 120000

{codd_dev-2.44.0 → codd_dev-2.46.0}/codd/deployment/extractor.py

@@ -40,11 +40,21 @@ SMOKE_TEST_PATTERNS = (
 )
 # All globs are kept: Playwright's convention is ``*.spec.ts``, a CLI
 # (vitest/jest) e2e is commonly ``*.test.ts``, and ``*.e2e.ts`` is the explicit
-# e2e naming convention codex emits unprompted. Routing to the right RUNNER
-# happens in :func:`_verification_template_ref` (by ``e2e_modality``); discovery
+# e2e naming convention codex emits unprompted. The ``test_*.py``/``*_test.py``
+# globs discover Python HTTP e2e tests (pytest convention) emitted by the
+# language-aware web harness (:mod:`codd.e2e_harness`) for Python projects;
+# bare ``tests/e2e/*.py`` is intentionally NOT a pattern (it would wrongly grab
+# ``__init__.py`` / helper modules). Routing to the right RUNNER happens in
+# :func:`_verification_template_ref` (by extension + ``e2e_modality``); discovery
 # must see every shape so a generated e2e test is not silently dropped (an
-# undiscovered ``.e2e.ts`` e2e means the verify stage never RUNS it).
-E2E_TEST_PATTERNS = ("tests/e2e/*.spec.ts", "tests/e2e/*.test.ts", "tests/e2e/*.e2e.ts")
+# undiscovered e2e means the verify stage never RUNS it).
+E2E_TEST_PATTERNS = (
+    "tests/e2e/*.spec.ts",
+    "tests/e2e/*.test.ts",
+    "tests/e2e/*.e2e.ts",
+    "tests/e2e/test_*.py",
+    "tests/e2e/*_test.py",
+)
 RUNTIME_CAPABILITY_INFERENCE_DEFAULTS = Path(__file__).parent / "defaults" / "runtime_capability_inference.yaml"
 
 DEPLOYMENT_SECTION_IMPL_PATTERNS: dict[str, tuple[str, ...]] = {
@@ -934,6 +944,11 @@ def _verification_template_ref(
 
     ``device`` modality has no built-in runner template yet, so it also keeps
     the legacy ``playwright`` default rather than silently dropping the test.
+
+    A ``.py`` e2e file routes to ``pytest_http`` (Python HTTP e2e), the
+    language-native runner emitted by the language-aware web harness
+    (:mod:`codd.e2e_harness`). The TS/JS modality routing and ``.sh`` → ``curl``
+    behavior are unchanged (generality: node-targeting behavior must not move).
     """
     if cdp_browser_journey:
         return "cdp_browser"
@@ -942,6 +957,8 @@ def _verification_template_ref(
         if modality == "cli":
             return "vitest"
         return "playwright"
+    if path.suffix == ".py":
+        return "pytest_http"
     if path.suffix == ".sh":
         return "curl"
     return "document"

{codd_dev-2.44.0 → codd_dev-2.46.0}/codd/deployment/providers/verification/__init__.py

@@ -8,6 +8,7 @@ from . import cdp_wire as cdp_wire
 from . import curl as curl
 from . import form_strategies as form_strategies
 from . import playwright as playwright
+from . import pytest_http as pytest_http
 from . import vitest as vitest
 
 __all__ = [
@@ -19,5 +20,6 @@ __all__ = [
     "curl",
     "form_strategies",
     "playwright",
+    "pytest_http",
     "vitest",
 ]

codd_dev-2.46.0/codd/deployment/providers/verification/pytest_http.py

@@ -0,0 +1,197 @@
+"""pytest HTTP end-to-end verification template (Python-native web E2E).
+
+The Playwright template (``playwright.py``) drives a BROWSER e2e against
+``*.spec.ts`` files under a node toolchain. For a **Python** web app with an
+HTTP surface and no explicit browser requirement, that is the wrong runner — the
+project has no ``package.json`` and verify fails with ``Cannot find module
+'@playwright/test'`` (the harness, not the code, is broken). The language-aware
+harness resolver (:mod:`codd.e2e_harness`) routes such projects to a Python
+``pytest`` HTTP e2e harness, and the extractor (:func:`_verification_template_ref`)
+sends generated ``tests/e2e/test_*.py`` e2e nodes here.
+
+This template runs a single Python e2e file (or the e2e directory) under
+``python -m pytest -q`` and applies the same ANTI-FALSE-GREEN executed-count
+discipline the rest of the verify layer enforces (mirroring ``vitest.py``): a run
+that COLLECTS/RUNS ZERO tests is a HARD FAIL — pytest exits ``5`` and prints "no
+tests ran" / "collected 0 items" when it finds nothing, which must never count as
+green-on-nothing.
+"""
+
+from __future__ import annotations
+
+import re
+import shlex
+import subprocess
+import time
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from codd.deployment.providers import (
+    VerificationResult,
+    VerificationTemplate,
+    register_verification_template,
+)
+
+
+DEFAULTS_PATH = Path(__file__).parents[2] / "defaults" / "verification_templates.yaml"
+
+#: pytest's exit code when NO tests were collected (``EXIT_NOTESTSCOLLECTED``).
+_PYTEST_NO_TESTS_EXIT_CODE = 5
+
+#: pytest's "nothing ran" signatures. pytest exits 5 (not 0) when it collects no
+#: tests, so the exit code alone normally suffices — but we additionally scan the
+#: output so a wrapper/plugin that swallows exit 5 (or a ``-p no:cacheprovider``
+#: style harness) still cannot pass on zero collected tests.
+_NO_TESTS_MARKERS: tuple[str, ...] = (
+    "no tests ran",
+    "no tests collected",
+    "collected 0 items",
+    "collected 0 item",
+)
+#: ``collected <N> item(s)`` / ``<N> passed`` / ``<N> failed`` — a positive
+#: collected/ran signal. ``collected 0 items`` is handled by the markers above
+#: (this regex requires a non-zero leading digit).
+_COLLECTED_RE = re.compile(r"collected\s+([1-9]\d*)\s+items?", re.IGNORECASE)
+_RAN_RE = re.compile(r"\b\d+\s+(?:passed|failed|error|errors)\b", re.IGNORECASE)
+
+
+def _load_timeout_seconds() -> float:
+    try:
+        defaults = yaml.safe_load(DEFAULTS_PATH.read_text(encoding="utf-8")) or {}
+    except OSError:
+        return 120.0
+    timeout = defaults.get("templates", {}).get("pytest_http", {}).get("timeout", 120000)
+    try:
+        timeout_value = float(timeout)
+    except (TypeError, ValueError):
+        return 120.0
+    return timeout_value / 1000 if timeout_value > 1000 else timeout_value
+
+
+def _project_root(runtime_state: Any) -> Path:
+    root = getattr(runtime_state, "project_root", None) or getattr(runtime_state, "root", None)
+    return Path(root) if root else Path.cwd()
+
+
+@register_verification_template("pytest_http")
+class PytestHttpTemplate(VerificationTemplate):
+    """Generate and execute ``python -m pytest`` commands for Python HTTP e2e tests."""
+
+    def __init__(self, timeout: float | None = None, config: Mapping[str, Any] | None = None) -> None:
+        config_map = dict(config) if isinstance(config, Mapping) else {}
+        configured_timeout = _positive_float(config_map.get("timeout"))
+        self.timeout = timeout if timeout is not None else configured_timeout or _load_timeout_seconds()
+
+    def generate_test_command(self, runtime_state, test_kind: str) -> str:
+        actual_check_command = getattr(runtime_state, "actual_check_command", None)
+        if actual_check_command:
+            return str(actual_check_command)
+
+        kind = test_kind.lower()
+        project_root = _project_root(runtime_state)
+        test_target = _specific_test_target(runtime_state, kind, project_root)
+        if test_target is None:
+            test_target = "tests/e2e/" if kind == "e2e" else "tests/smoke/"
+        # ``python -m pytest`` (not bare ``pytest``) so the project's interpreter
+        # /venv resolves the runner; the positional scopes the run to the e2e
+        # file/dir so an e2e node runs its OWN test, not the whole suite.
+        return f"python -m pytest -q {shlex.quote(test_target)}"
+
+    def execute(self, command: str, cwd: Path | None = None) -> VerificationResult:
+        started_at = time.monotonic()
+        try:
+            completed = subprocess.run(
+                command,
+                shell=True,
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+                timeout=self.timeout,
+            )
+        except subprocess.TimeoutExpired as exc:
+            duration = time.monotonic() - started_at
+            output = exc.stderr or exc.stdout or f"Timed out after {self.timeout:g}s"
+            return VerificationResult(passed=False, output=str(output), duration=duration)
+
+        duration = time.monotonic() - started_at
+        combined = "\n".join(part for part in (completed.stdout, completed.stderr) if part)
+        # ANTI-FALSE-GREEN: pytest exits 5 with "no tests ran" — a collected/ran
+        # count of ZERO is a HARD FAIL regardless of exit code (even 0).
+        if completed.returncode == _PYTEST_NO_TESTS_EXIT_CODE or _collected_zero(combined):
+            return VerificationResult(
+                passed=False,
+                output=(
+                    "pytest collected/ran 0 tests (no tests ran) — "
+                    "treated as a hard failure (anti-false-green).\n" + combined
+                ),
+                duration=duration,
+            )
+        if completed.returncode == 0:
+            return VerificationResult(passed=True, output=completed.stdout, duration=duration)
+        return VerificationResult(
+            passed=False,
+            output=completed.stderr or completed.stdout,
+            duration=duration,
+        )
+
+    #: Python test-file shapes a pytest e2e run can collect: the pytest
+    #: ``test_*.py`` / ``*_test.py`` conventions the generator emits under
+    #: ``tests/e2e/``. Discovery in the extractor must see the same shapes.
+    _RUNNABLE_PY_GLOBS: tuple[str, ...] = ("test_*.py", "*_test.py")
+
+    def find_spec_files(self, project_root: Path, test_kind: str) -> list[Path]:
+        base = "tests/e2e" if test_kind.lower() == "e2e" else "tests/smoke"
+        found: dict[str, Path] = {}
+        for leaf in self._RUNNABLE_PY_GLOBS:
+            for path in project_root.glob(f"{base}/**/{leaf}"):
+                found[str(path)] = path
+        return sorted(found.values())
+
+
+def _collected_zero(output: str) -> bool:
+    """True when the pytest output proves NO test was collected/run.
+
+    Conservative: an explicit "no tests ran" / "collected 0 items" marker is a
+    definite zero. A run that shows a positive ``collected N items`` OR an
+    ``N passed/failed/error`` summary is treated as non-zero. Absent any of
+    those signals we do NOT force-fail here (the exit-code check in ``execute``
+    already catches pytest's exit 5); this guard exists to defeat a wrapper that
+    masks exit 5 while printing a "no tests ran" banner.
+    """
+    lowered = output.lower()
+    if any(marker in lowered for marker in _NO_TESTS_MARKERS):
+        return True
+    return False
+
+
+def _positive_float(value: Any) -> float | None:
+    try:
+        parsed = float(value)
+    except (TypeError, ValueError):
+        return None
+    return parsed if parsed > 0 else None
+
+
+def _specific_test_target(runtime_state: Any, test_kind: str, project_root: Path) -> str | None:
+    source = getattr(runtime_state, "source", None)
+    if not source:
+        return None
+    source_text = str(source).strip()
+    if not source_text:
+        return None
+    expected_prefix = "tests/e2e/" if test_kind == "e2e" else "tests/smoke/"
+    normalized = source_text.replace("\\", "/")
+    if not normalized.startswith(expected_prefix):
+        return None
+
+    path = Path(source_text)
+    candidate = path if path.is_absolute() else project_root / path
+    if not candidate.is_file():
+        return None
+    try:
+        return candidate.relative_to(project_root).as_posix()
+    except ValueError:
+        return str(candidate)

codd_dev-2.46.0/codd/e2e_harness.py

@@ -0,0 +1,177 @@
+"""Deterministic web/HTTP end-to-end harness selection (language-aware).
+
+Historically CoDD's generation pipeline selected a browser E2E harness
+(Playwright/TypeScript ``*.spec.ts``) for ANY project whose capability profile
+declared ``e2e_modality == "browser"`` — regardless of the project's host
+language. A Python Flask web app with an HTTP surface and no node toolchain
+therefore honest-failed at verify time with ``Cannot find module
+'@playwright/test'``: CoDD chose a TS/node verification harness it had no way to
+run. The CLI branch was already language-native ("invoke the built CLI as a
+subprocess; do NOT use Playwright"); the web branch was not.
+
+This module is the single, DETERMINISTIC decision point that makes web/HTTP E2E
+harness selection language-aware, mirroring the CLI branch. The rules below are
+pure functions of ``project_language`` + ``capabilities`` (+ explicit
+``constraints``); they NEVER infer intent from LLM prose. The North-Star
+contract is anti-false-green-safe: when browser automation is NOT explicitly
+required, a Python project gets a Python ``pytest`` HTTP E2E harness instead of
+TS Playwright. The worst case of preferring HTTP E2E for an ambiguous project is
+a false-RED / coverage gap (an honest fail), never a false-GREEN.
+
+The matrix is generic (host-language × modality), not Python+Playwright
+special-cased: TypeScript/node browser projects keep the existing Playwright
+path BYTE-FOR-BYTE; a non-Python HTTP surface keeps today's behavior.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from codd.project_types import ProjectCapabilities
+
+
+__all__ = ["E2EHarnessSpec", "resolve_e2e_harness"]
+
+
+#: Config/constraint keys whose VALUE explicitly selects a node/Playwright
+#: browser-automation harness. Matching is exact (lower-cased) — prose is never
+#: parsed. Keeping this a small allow-list (rather than a substring scan) is what
+#: keeps the resolver deterministic and free of LLM-inference.
+_EXPLICIT_BROWSER_HARNESS_VALUES = frozenset(
+    {"playwright", "playwright_node", "cypress", "browser", "node"}
+)
+
+#: Constraint keys that, when truthy, declare browser automation is required.
+_EXPLICIT_BROWSER_FLAG_KEYS = frozenset(
+    {"browser_automation_required", "requires_browser", "browser_required"}
+)
+
+#: Constraint keys whose value is read as an explicit harness selector.
+_E2E_HARNESS_SELECTOR_KEYS = frozenset({"e2e_harness", "e2e_runner", "harness"})
+
+
+@dataclass(frozen=True)
+class E2EHarnessSpec:
+    """The resolved web/HTTP E2E harness for a project.
+
+    ``runner``    — logical runner id (``pytest_http`` | ``playwright`` |
+                    ``native_cli`` | ``none``).
+    ``language``  — host language the generated tests are written in.
+    ``output_ext``— file extension for generated E2E test files (``.py`` | ``.ts``).
+    ``template_ref`` — the verification template the extractor/verify layer
+                    routes this harness to (``pytest_http`` | ``playwright`` |
+                    ``native_cli`` | ``none``).
+    ``requires_node_manifest`` — True when the harness needs a node manifest
+                    (``package.json``) to run (Playwright). Consumed by the
+                    conditional node-manifest scaffold (deferred) and the
+                    toolchain-coherence gate; never inferred from prose.
+    """
+
+    runner: str
+    language: str
+    output_ext: str
+    template_ref: str
+    requires_node_manifest: bool = False
+
+
+def _explicit_browser_required(constraints: Mapping[str, Any] | None) -> bool:
+    """True ONLY when constraints/config EXPLICITLY declare browser automation.
+
+    Deterministic: a truthy boolean flag key (e.g. ``browser_automation_required:
+    true``) OR a harness-selector key whose value names a browser/node runner
+    (e.g. ``e2e_harness: playwright_node``). Ambiguous/absent → False, which
+    routes Python projects to ``pytest_http`` (at worst a false-RED / coverage
+    gap, never a false-GREEN). LLM prose is NEVER parsed.
+    """
+
+    if not isinstance(constraints, Mapping):
+        return False
+
+    for key, value in constraints.items():
+        if not isinstance(key, str):
+            continue
+        normalized_key = key.strip().lower()
+        if normalized_key in _EXPLICIT_BROWSER_FLAG_KEYS and bool(value):
+            return True
+        if normalized_key in _E2E_HARNESS_SELECTOR_KEYS and isinstance(value, str):
+            if value.strip().lower() in _EXPLICIT_BROWSER_HARNESS_VALUES:
+                return True
+    return False
+
+
+def resolve_e2e_harness(
+    *,
+    project_language: str | None,
+    capabilities: ProjectCapabilities,
+    constraints: Mapping[str, Any] | None = None,
+) -> E2EHarnessSpec:
+    """Deterministically resolve the E2E harness for a project.
+
+    Rules (pure function of inputs; no prose inference):
+
+    * ``e2e_modality == "cli"`` → native CLI harness (subprocess on the built
+      CLI). Output ext follows host language (``.py`` for Python, else ``.ts``).
+      The CLI branch already works end-to-end; this is here for completeness so
+      the resolver is the single decision point.
+    * ``e2e_modality == "browser"``:
+        - Python AND NOT explicit-browser-required → ``pytest_http`` / ``.py``.
+        - else → ``playwright`` / ``.ts`` (requires a node manifest).
+    * non-browser HTTP surface (``network_surface == "http"``) → ``pytest_http``
+      / ``.py`` for Python; for any other language keep today's behavior by
+      routing to the Playwright/node path (``.ts``) so generality holds.
+    * otherwise → a ``none`` spec (no E2E layer applies).
+    """
+
+    lang = (project_language or "").strip().lower()
+    is_python = lang == "python"
+    modality = capabilities.e2e_modality
+
+    if modality == "cli":
+        return E2EHarnessSpec(
+            runner="native_cli",
+            language=lang or "python",
+            output_ext=".py" if is_python else ".ts",
+            template_ref="native_cli",
+        )
+
+    if modality == "browser":
+        if is_python and not _explicit_browser_required(constraints):
+            return E2EHarnessSpec(
+                runner="pytest_http",
+                language="python",
+                output_ext=".py",
+                template_ref="pytest_http",
+            )
+        return E2EHarnessSpec(
+            runner="playwright",
+            language="typescript",
+            output_ext=".ts",
+            template_ref="playwright",
+            requires_node_manifest=True,
+        )
+
+    if capabilities.network_surface == "http":
+        if is_python:
+            return E2EHarnessSpec(
+                runner="pytest_http",
+                language="python",
+                output_ext=".py",
+                template_ref="pytest_http",
+            )
+        # Non-Python HTTP surface: preserve today's TS/Playwright behavior.
+        return E2EHarnessSpec(
+            runner="playwright",
+            language=lang or "typescript",
+            output_ext=".ts",
+            template_ref="playwright",
+            requires_node_manifest=True,
+        )
+
+    return E2EHarnessSpec(
+        runner="none",
+        language=lang or "python",
+        output_ext=".py" if is_python else ".ts",
+        template_ref="none",
+    )