pytest-httpchain 0.3.0__tar.gz → 0.4.0__tar.gz

{pytest_httpchain-0.3.0 → pytest_httpchain-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-httpchain
-Version: 0.3.0
+Version: 0.4.0
 Summary: pytest plugin for HTTP testing using JSON files
 Keywords: testing,pytest,requests
 Author: Alexander Eresov
@@ -212,13 +212,25 @@ This writes `.claude/skills/pytest-httpchain/SKILL.md` with guidance for writing
 
 ### Scenario validation
 
-Validate scenario files for structure and common problems — undefined variables, duplicate stage names, fixture/variable conflicts, stages with no assertions:
+Validate scenario files for structure and common problems — undefined variables, variables referenced before they are saved (data-flow ordering), duplicate stage names, fixture/variable conflicts, no-op `verify` steps, and contradictory body checks:
 
 ```bash
 uvx pytest-httpchain validate tests/test_login.http.json
 ```
 
-It exits non-zero when any file is invalid, so it doubles as a CI gate. The same checks also run automatically at **pytest collection time** — semantic errors fail collection and warnings are reported — so `pytest --collect-only` validates every scenario in your suite.
+Each finding carries a stable diagnostic code (`HTTPCHAINxxx`) and a severity. It exits non-zero when any file is invalid, so it doubles as a CI gate. Use `--format json` for machine-readable output (editor/CI integration):
+
+```bash
+uvx pytest-httpchain validate --format json tests/test_login.http.json
+```
+
+The same checks also run automatically at **pytest collection time** — semantic errors fail collection and warnings are reported — so `pytest --collect-only` validates every scenario in your suite.
+
+For deeper, opt-in checks, add `--deep`: it imports your `module:func` references to confirm they resolve, checks their call signatures (including the injected `response` for save/verify functions), and verifies referenced files and schemas exist. Because it imports your code it is never run at collection time; pair it with `--strict` to fail CI on any warning, and `--syspath` to add import roots:
+
+```bash
+uvx pytest-httpchain validate --deep --strict tests/test_login.http.json
+```
 
 ### Editor schema
 

{pytest_httpchain-0.3.0 → pytest_httpchain-0.4.0}/README.md

@@ -185,13 +185,25 @@ This writes `.claude/skills/pytest-httpchain/SKILL.md` with guidance for writing
 
 ### Scenario validation
 
-Validate scenario files for structure and common problems — undefined variables, duplicate stage names, fixture/variable conflicts, stages with no assertions:
+Validate scenario files for structure and common problems — undefined variables, variables referenced before they are saved (data-flow ordering), duplicate stage names, fixture/variable conflicts, no-op `verify` steps, and contradictory body checks:
 
 ```bash
 uvx pytest-httpchain validate tests/test_login.http.json
 ```
 
-It exits non-zero when any file is invalid, so it doubles as a CI gate. The same checks also run automatically at **pytest collection time** — semantic errors fail collection and warnings are reported — so `pytest --collect-only` validates every scenario in your suite.
+Each finding carries a stable diagnostic code (`HTTPCHAINxxx`) and a severity. It exits non-zero when any file is invalid, so it doubles as a CI gate. Use `--format json` for machine-readable output (editor/CI integration):
+
+```bash
+uvx pytest-httpchain validate --format json tests/test_login.http.json
+```
+
+The same checks also run automatically at **pytest collection time** — semantic errors fail collection and warnings are reported — so `pytest --collect-only` validates every scenario in your suite.
+
+For deeper, opt-in checks, add `--deep`: it imports your `module:func` references to confirm they resolve, checks their call signatures (including the injected `response` for save/verify functions), and verifies referenced files and schemas exist. Because it imports your code it is never run at collection time; pair it with `--strict` to fail CI on any warning, and `--syspath` to add import roots:
+
+```bash
+uvx pytest-httpchain validate --deep --strict tests/test_login.http.json
+```
 
 ### Editor schema
 

{pytest_httpchain-0.3.0 → pytest_httpchain-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytest-httpchain"
-version = "0.3.0"
+version = "0.4.0"
 description = "pytest plugin for HTTP testing using JSON files"
 readme = "README.md"
 requires-python = ">=3.13,<4.0"

pytest_httpchain-0.4.0/src/pytest_httpchain/cli.py

@@ -0,0 +1,83 @@
+import enum
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+app = typer.Typer()
+
+SKILL_FILE = Path(__file__).parent / "skill.md"
+
+
+class OutputFormat(enum.StrEnum):
+    text = "text"
+    json = "json"
+
+
+@app.command()
+def validate(
+    paths: Annotated[list[Path], typer.Argument(help="Scenario JSON file(s) to validate.")],
+    ref_parent_traversal_depth: Annotated[int, typer.Option(help="Maximum $ref parent directory traversal depth.")] = 3,
+    output_format: Annotated[OutputFormat, typer.Option("--format", help="Output format: human-readable text or machine-readable JSON.")] = OutputFormat.text,
+    deep: Annotated[bool, typer.Option("--deep", help="Run deep checks: resolve user-function imports/signatures and referenced files. Imports user modules.")] = False,
+    syspath: Annotated[list[Path] | None, typer.Option("--syspath", help="Extra directories to add to sys.path for --deep import resolution (repeatable).")] = None,
+    strict: Annotated[bool, typer.Option("--strict", help="Treat warnings as failures for the exit code.")] = False,
+) -> None:
+    """Validate pytest-httpchain scenario file(s).
+
+    Reports errors and warnings (each with a stable HTTPCHAINxxx diagnostic code)
+    per file and exits non-zero if any file is invalid (or, with --strict, has any
+    warnings).
+    """
+    from pytest_httpchain.validation import validate_scenario
+
+    results = [(path, validate_scenario(path, ref_parent_traversal_depth=ref_parent_traversal_depth, deep=deep, syspaths=list(syspath or []))) for path in paths]
+
+    def passed(result) -> bool:
+        return result.valid and not (strict and result.warnings)
+
+    all_passed = all(passed(result) for _, result in results)
+
+    if output_format is OutputFormat.json:
+        payload = {
+            "valid": all_passed,
+            "files": [{"path": str(path), "result": result.model_dump()} for path, result in results],
+        }
+        typer.echo(json.dumps(payload, indent=2, default=str))
+    else:
+        for path, result in results:
+            if not result.valid:
+                status = "INVALID"
+            elif result.warnings:
+                status = "FAILED (warnings)" if strict else "OK with warnings"
+            else:
+                status = "OK"
+            typer.echo(f"{path}: {status}")
+            for diagnostic in result.diagnostics:
+                typer.echo(f"  {diagnostic.severity} [{diagnostic.code}]: {diagnostic.message}")
+
+    raise typer.Exit(0 if all_passed else 1)
+
+
+@app.command()
+def install(
+    global_: Annotated[bool, typer.Option("--global", "-g", help="Install to ~/.claude (personal scope) instead of project")] = False,
+    project_dir: Annotated[Path, typer.Option(help="Project directory (ignored with --global)")] = Path("."),
+) -> None:
+    """Install the Claude Code skill for authoring test scenarios."""
+    if global_:
+        _install_skill(Path.home() / ".claude" / "skills" / "pytest-httpchain")
+    else:
+        _install_skill(project_dir.resolve() / ".claude" / "skills" / "pytest-httpchain")
+
+
+def _install_skill(skill_dir: Path) -> None:
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    dest = skill_dir / "SKILL.md"
+    dest.write_text(SKILL_FILE.read_text())
+    typer.echo(f"Installed skill to {dest}")
+
+
+if __name__ == "__main__":
+    app()

{pytest_httpchain-0.3.0 → pytest_httpchain-0.4.0}/src/pytest_httpchain/plugin.py

@@ -66,12 +66,15 @@ class JsonModule(python.Module):
             raise nodes.Collector.CollectError(full_error_msg) from None
 
         # semantic validation: cross-cutting checks the schema cannot express
-        # (duplicate stage names, fixture/variable conflicts, undefined variables, ...)
-        semantic_errors, semantic_warnings, _ = check_scenario(scenario, test_data)
-        for warning in semantic_warnings:
-            warnings.warn(ScenarioValidationWarning(f"{self.path}: {warning}"), stacklevel=2)
-        if semantic_errors:
-            detail = "\n".join(f"  - {e}" for e in semantic_errors)
+        # (duplicate stage names, fixture/variable conflicts, undefined/forward-referenced
+        # variables, no-op verify, contradictory body checks, ...)
+        diagnostics, _ = check_scenario(scenario, test_data)
+        for diagnostic in diagnostics:
+            if diagnostic.severity == "warning":
+                warnings.warn(ScenarioValidationWarning(f"{self.path}: [{diagnostic.code}] {diagnostic.message}"), stacklevel=2)
+        error_diagnostics = [d for d in diagnostics if d.severity == "error"]
+        if error_diagnostics:
+            detail = "\n".join(f"  - [{d.code}] {d.message}" for d in error_diagnostics)
             raise nodes.Collector.CollectError(f"Invalid test scenario in {self.path}:\n{detail}")
 
         # generate python test class

{pytest_httpchain-0.3.0 → pytest_httpchain-0.4.0}/src/pytest_httpchain/skill.md

@@ -255,3 +255,28 @@ Or iterate over parameter sets in parallel:
   ]
 }
 ```
+
+## Validate your scenario
+
+After writing a scenario, validate it (no server or network needed):
+
+```bash
+pytest-httpchain validate test_<name>.http.json
+```
+
+It checks structure plus semantics a JSON Schema cannot, each with a stable `HTTPCHAINxxx` code:
+
+- `HTTPCHAIN003` — a `{{ var }}` that is never defined, saved, or provided as a fixture (likely a typo).
+- `HTTPCHAIN004` — a variable used **before** the stage that saves it, or used in a stage's request when it is only saved in that same stage's response. Remember: a value `save`d in a stage's response is available to *later* response steps and *later* stages, never to the request that produced it.
+- `HTTPCHAIN006` — a `verify` step that asserts nothing.
+- `HTTPCHAIN007` / `HTTPCHAIN008` — body `contains`/`not_contains` (or `matches`/`not_matches`) that list the same value, which can never pass.
+
+Add `--format json` for machine-readable output. The same checks run automatically during `pytest --collect-only`.
+
+For a deeper check that imports your `module:func` references (confirming they resolve and their signatures match — including the injected `response` for save/verify functions) and verifies referenced files/schemas exist, add `--deep` (optionally `--syspath <dir>` for import roots, `--strict` to fail on warnings):
+
+```bash
+pytest-httpchain validate --deep test_<name>.http.json
+```
+
+Note: the HTTP response is **not** ambient in `{{ }}` templates — `save` what you need from a response first, then reference the saved variable.