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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-httpchain
-Version: 0.4.0
+Version: 0.6.0
 Summary: pytest plugin for HTTP testing using JSON files
 Keywords: testing,pytest,requests
 Author: Alexander Eresov
@@ -198,17 +198,7 @@ pip install 'git+https://github.com/aeresov/pytest-httpchain@main'
 
 ## AI agent support
 
-`pytest-httpchain` ships tooling to help AI coding agents (and humans) author and check test scenarios.
-
-### Claude Code skill
-
-Install the authoring skill into your project (or `--global` for personal scope):
-
-```bash
-uvx pytest-httpchain install
-```
-
-This writes `.claude/skills/pytest-httpchain/SKILL.md` with guidance for writing scenarios.
+`pytest-httpchain` ships a scenario validator to help AI coding agents (and humans) author and check test scenarios.
 
 ### Scenario validation
 
@@ -242,6 +232,27 @@ A JSON Schema is published for as-you-type validation and autocomplete. Referenc
 }
 ```
 
+The hosted schema tracks the latest release; to pin the schema matching your installed version (e.g. for CI), emit it locally:
+
+```bash
+uvx pytest-httpchain schema --output scenario.schema.json
+```
+
+### Inspecting scenarios
+
+More read-only commands help author and debug scenarios offline — no network, no test run:
+
+```bash
+# Print a scenario with all $ref/$include/$merge inlined and deep-merged
+uvx pytest-httpchain resolve tests/test_login.http.json
+
+# Summarize stages and the variable data-flow (which stage saves what, who consumes it)
+uvx pytest-httpchain show tests/test_login.http.json
+
+# Render the stage data-flow as a Mermaid flowchart
+uvx pytest-httpchain graph tests/test_login.http.json
+```
+
 ## Documentation
 
 -   [Full Documentation](https://aeresov.github.io/pytest-httpchain) - Complete usage guide

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

@@ -171,17 +171,7 @@ pip install 'git+https://github.com/aeresov/pytest-httpchain@main'
 
 ## AI agent support
 
-`pytest-httpchain` ships tooling to help AI coding agents (and humans) author and check test scenarios.
-
-### Claude Code skill
-
-Install the authoring skill into your project (or `--global` for personal scope):
-
-```bash
-uvx pytest-httpchain install
-```
-
-This writes `.claude/skills/pytest-httpchain/SKILL.md` with guidance for writing scenarios.
+`pytest-httpchain` ships a scenario validator to help AI coding agents (and humans) author and check test scenarios.
 
 ### Scenario validation
 
@@ -215,6 +205,27 @@ A JSON Schema is published for as-you-type validation and autocomplete. Referenc
 }
 ```
 
+The hosted schema tracks the latest release; to pin the schema matching your installed version (e.g. for CI), emit it locally:
+
+```bash
+uvx pytest-httpchain schema --output scenario.schema.json
+```
+
+### Inspecting scenarios
+
+More read-only commands help author and debug scenarios offline — no network, no test run:
+
+```bash
+# Print a scenario with all $ref/$include/$merge inlined and deep-merged
+uvx pytest-httpchain resolve tests/test_login.http.json
+
+# Summarize stages and the variable data-flow (which stage saves what, who consumes it)
+uvx pytest-httpchain show tests/test_login.http.json
+
+# Render the stage data-flow as a Mermaid flowchart
+uvx pytest-httpchain graph tests/test_login.http.json
+```
+
 ## Documentation
 
 -   [Full Documentation](https://aeresov.github.io/pytest-httpchain) - Complete usage guide

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

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

{pytest_httpchain-0.4.0 → pytest_httpchain-0.6.0}/src/pytest_httpchain/carrier.py

@@ -79,12 +79,24 @@ class Carrier:
     max_parallel_iterations: ClassVar[int] = 10_000
 
     @classmethod
-    def execute_stage(cls, stage: Stage, fixture_kwargs: dict[str, Any]) -> None:
+    def _resolve_always_run(cls, stage: Stage, stage_fixtures: dict[str, Any]) -> bool:
+        """Resolve ``always_run``, evaluating a template form against the context
+        available at stage start: fixtures and parametrize parameters plus the
+        global context (scenario substitutions and earlier saves). Stage
+        substitutions are not yet processed at this point. The result is coerced
+        with Python truthiness."""
+        if isinstance(stage.always_run, bool):
+            return stage.always_run
         try:
-            if cls.aborted and not stage.always_run:
-                pytest.skip(reason="Flow aborted")
+            return bool(walk(stage.always_run, ChainMap(stage_fixtures, cls.global_context)))
+        except TemplatesError as e:
+            raise StageExecutionError(f"Failed to evaluate always_run template: {e}") from e
 
-            # prepare stage context
+    @classmethod
+    def execute_stage(cls, stage: Stage, fixture_kwargs: dict[str, Any]) -> None:
+        try:
+            # prepare stage context (before the abort check, so an always_run
+            # template sees the same fixture layer as stage templates)
             stage_fixtures: dict[str, Any] = {}
             for name, value in fixture_kwargs.items():
                 if callable(value) and not inspect.isclass(value):
@@ -92,6 +104,9 @@ class Carrier:
                 else:
                     stage_fixtures[name] = value
 
+            if cls.aborted and not cls._resolve_always_run(stage, stage_fixtures):
+                pytest.skip(reason="Flow aborted")
+
             # Build base context for iterations (substitutions + fixtures + global)
             local_context = ChainMap(stage_fixtures, cls.global_context)
             stage_substitutions = process_substitutions(stage.substitutions, local_context)
@@ -519,7 +534,7 @@ def create_test_class(scenario: Scenario, class_name: str, max_parallel_iteratio
                         parametrize_marker = pytest.mark.parametrize(",".join(param_names), param_values, ids=param_ids)
                         stage_method = parametrize_marker(stage_method)
 
-        all_fixtures = ["self"] + all_param_names + stage.fixtures
+        all_fixtures = ["self"] + list(dict.fromkeys(all_param_names + stage.fixtures + scenario.fixtures))
         stage_method.__signature__ = inspect.Signature([inspect.Parameter(name, inspect.Parameter.POSITIONAL_OR_KEYWORD) for name in all_fixtures])  # type: ignore[assignment]
 
         all_marks = [f"order({i})"] + stage.marks

pytest_httpchain-0.6.0/src/pytest_httpchain/cli.py

@@ -0,0 +1,222 @@
+import enum
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+app = typer.Typer()
+
+
+class OutputFormat(enum.StrEnum):
+    text = "text"
+    json = "json"
+
+
+class GraphDirection(enum.StrEnum):
+    TD = "TD"
+    LR = "LR"
+
+
+@app.callback()
+def main() -> None:
+    """pytest-httpchain command-line tools."""
+
+
+@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 schema(
+    output: Annotated[Path | None, typer.Option("--output", "-o", help="Write schema to PATH instead of stdout.")] = None,
+) -> None:
+    """Emit the JSON Schema for scenario files (editor autocomplete/validation)."""
+    from pytest_httpchain.schema import build_schema
+
+    text = json.dumps(build_schema(), indent=2, default=str)
+    if output is not None:
+        output.write_text(text + "\n")
+        typer.echo(f"Wrote schema to {output}")
+    else:
+        typer.echo(text)
+
+
+@app.command()
+def resolve(
+    scenario: Annotated[Path, typer.Argument(help="Scenario JSON file to resolve.")],
+    output: Annotated[Path | None, typer.Option("--output", "-o", help="Write resolved JSON to PATH instead of stdout.")] = None,
+    ref_parent_traversal_depth: Annotated[int, typer.Option(help="Maximum $ref parent directory traversal depth.")] = 3,
+) -> None:
+    """Resolve $ref/$include/$merge and print the merged scenario JSON."""
+    import pytest_httpchain_jsonref.loader
+    from pytest_httpchain_jsonref.exceptions import ReferenceResolverError
+
+    from pytest_httpchain.validation import resolve_root_path
+
+    try:
+        data = pytest_httpchain_jsonref.loader.load_json(
+            scenario,
+            max_parent_traversal_depth=ref_parent_traversal_depth,
+            root_path=resolve_root_path(scenario),
+        )
+    except (ReferenceResolverError, json.JSONDecodeError, OSError) as e:
+        typer.echo(f"error: {e}", err=True)
+        raise typer.Exit(1) from e
+
+    text = json.dumps(data, indent=2, default=str)
+    if output is not None:
+        output.write_text(text + "\n")
+        typer.echo(f"Wrote resolved scenario to {output}")
+    else:
+        typer.echo(text)
+
+
+def _load_for_inspection(path: Path, depth: int):
+    """Load + validate a scenario for show/graph, mapping failures to Exit(1)."""
+    from pydantic import ValidationError
+    from pytest_httpchain_jsonref.exceptions import ReferenceResolverError
+
+    from pytest_httpchain.dataflow import load_scenario
+
+    try:
+        return load_scenario(path, ref_parent_traversal_depth=depth)
+    except (ReferenceResolverError, json.JSONDecodeError, OSError) as e:
+        typer.echo(f"error: cannot load {path}: {e}", err=True)
+        raise typer.Exit(1) from e
+    except ValidationError:
+        typer.echo(f"error: {path} is not a valid scenario — run `pytest-httpchain validate {path}` for details", err=True)
+        raise typer.Exit(1) from None
+
+
+def _render_show_text(path: Path, scenario, flow) -> list[str]:
+    producer_of: dict[tuple[int, str], int] = {}
+    for edge in flow.edges:
+        for name in edge.vars:
+            producer_of[(edge.consumer, name)] = edge.producer
+
+    all_fixtures = sorted({*flow.scenario_fixtures, *(f for s in flow.stages for f in s.fixtures)})
+    lines: list[str] = [scenario.description or path.name]
+    summary = f"{len(flow.stages)} stage(s)"
+    if all_fixtures:
+        summary += f" · fixtures: {all_fixtures}"
+    if flow.scenario_vars:
+        summary += f" · vars: {flow.scenario_vars}"
+    lines.append(summary)
+    lines.append("")
+
+    for s in flow.stages:
+        name = s.name or f"(stage {s.index + 1})"
+        lines.append(f"{s.index + 1} · {name}    {s.method} {s.url}")
+        if s.saves:
+            lines.append(f"    saves:    {', '.join(s.saves)}")
+        if s.consumes:
+            parts: list[str] = []
+            for name in s.consumes:
+                producer = producer_of.get((s.index, name))
+                if producer is None:
+                    parts.append(name)
+                else:
+                    producer_name = flow.stages[producer].name or f"stage {producer + 1}"
+                    parts.append(f"{name} (from #{producer + 1} {producer_name})")
+            lines.append(f"    consumes: {', '.join(parts)}")
+        if s.marks:
+            lines.append(f"    marks:    {', '.join(s.marks)}")
+    return lines
+
+
+@app.command()
+def show(
+    scenario: Annotated[Path, typer.Argument(help="Scenario JSON file to summarize.")],
+    output_format: Annotated[OutputFormat, typer.Option("--format", help="Output format: human-readable text or machine-readable JSON.")] = OutputFormat.text,
+    ref_parent_traversal_depth: Annotated[int, typer.Option(help="Maximum $ref parent directory traversal depth.")] = 3,
+) -> None:
+    """Summarize a scenario's stages and variable data-flow."""
+    from pytest_httpchain.dataflow import analyze_dataflow
+
+    sc, test_data = _load_for_inspection(scenario, ref_parent_traversal_depth)
+    flow = analyze_dataflow(sc, test_data)
+
+    if output_format is OutputFormat.json:
+        payload = flow.model_dump()
+        payload["description"] = sc.description or None
+        typer.echo(json.dumps(payload, indent=2, default=str))
+    else:
+        for line in _render_show_text(scenario, sc, flow):
+            typer.echo(line)
+
+
+def _mermaid_label(text: str) -> str:
+    return text.replace('"', "'").replace("\n", " ")
+
+
+def _to_mermaid(flow, direction: str = "TD") -> str:
+    lines = [f"flowchart {direction}"]
+    if not flow.stages:
+        lines.append("    %% (no stages)")
+        return "\n".join(lines)
+    for s in flow.stages:
+        label = f"{s.index + 1} · {s.name}" if s.name else f"{s.index + 1}"
+        lines.append(f'    S{s.index}["{_mermaid_label(label)}"]')
+    for edge in flow.edges:
+        lines.append(f"    S{edge.producer} -->|{', '.join(edge.vars)}| S{edge.consumer}")
+    return "\n".join(lines)
+
+
+@app.command()
+def graph(
+    scenario: Annotated[Path, typer.Argument(help="Scenario JSON file to graph.")],
+    direction: Annotated[GraphDirection, typer.Option("--direction", help="Flowchart orientation.")] = GraphDirection.TD,
+    ref_parent_traversal_depth: Annotated[int, typer.Option(help="Maximum $ref parent directory traversal depth.")] = 3,
+) -> None:
+    """Emit a Mermaid flowchart of the stage data-flow."""
+    from pytest_httpchain.dataflow import analyze_dataflow
+
+    sc, test_data = _load_for_inspection(scenario, ref_parent_traversal_depth)
+    flow = analyze_dataflow(sc, test_data)
+    typer.echo(_to_mermaid(flow, direction.value))
+
+
+if __name__ == "__main__":
+    app()

pytest_httpchain-0.6.0/src/pytest_httpchain/dataflow.py

@@ -0,0 +1,137 @@
+"""Structured stage data-flow analysis for the ``show`` and ``graph`` CLI commands.
+
+Reuses the same extraction helpers as the order-aware validator
+(``validation._dataflow_diagnostics``) but produces a graph model instead of
+diagnostics: which variables each stage saves, which it consumes from earlier
+stages, and the producer -> consumer edges between stages.
+"""
+
+from pathlib import Path
+from typing import Any
+
+import pytest_httpchain_jsonref.loader
+from pydantic import BaseModel
+from pytest_httpchain_models import Scenario
+
+from pytest_httpchain.validation import (
+    _parameter_names,
+    extract_template_variables,
+    raw_stages,
+    resolve_root_path,
+    saved_in_stage,
+    stage_defined_names,
+    substitution_names,
+)
+
+
+class DataFlowEdge(BaseModel):
+    """A data dependency: ``vars`` saved by stage ``producer`` are referenced by stage ``consumer``."""
+
+    producer: int
+    consumer: int
+    vars: list[str]
+
+
+class StageFlow(BaseModel):
+    """Per-stage data-flow summary."""
+
+    index: int
+    name: str
+    method: str
+    url: str
+    fixtures: list[str]
+    marks: list[str]
+    saves: list[str]
+    consumes: list[str]
+
+
+class DataFlow(BaseModel):
+    """Whole-scenario data-flow graph."""
+
+    stages: list[StageFlow]
+    edges: list[DataFlowEdge]
+    scenario_fixtures: list[str] = []
+    scenario_vars: list[str] = []
+
+
+def analyze_dataflow(scenario: Scenario, test_data: dict[str, Any]) -> DataFlow:
+    """Build the stage data-flow graph for a validated scenario.
+
+    A stage *consumes* a variable when its request/response/substitutions/parallel
+    templates reference a name saved by an earlier stage and not redefined locally
+    (own substitutions, parametrize/foreach parameters, or stage/scenario fixtures).
+    ``always_run`` references count too, but only fixtures and parametrize
+    parameters shadow them — always_run resolves before stage substitutions exist.
+    ``parametrize`` values are excluded — they resolve against scenario scope,
+    never saved values.
+    """
+    raws = raw_stages(test_data)
+    saves_by_stage = [saved_in_stage(stage) for stage in scenario.stages]
+    scenario_fixture_names = set(scenario.fixtures)
+
+    first_save_stage: dict[str, int] = {}
+    for i, saved in enumerate(saves_by_stage):
+        for name in saved:
+            first_save_stage.setdefault(name, i)
+
+    stages: list[StageFlow] = []
+    edges: list[DataFlowEdge] = []
+    cumulative_saves: set[str] = set()
+
+    for i, stage in enumerate(scenario.stages):
+        raw = raws[i] if i < len(raws) and isinstance(raws[i], dict) else {}
+
+        refs: set[str] = set()
+        for key in ("request", "response", "substitutions", "parallel"):
+            extract_template_variables(raw.get(key), refs)
+
+        # Scenario fixtures count as local everywhere: at runtime they sit above
+        # the global context in the ChainMap, shadowing any same-named save.
+        local = stage_defined_names(stage) | scenario_fixture_names
+        consumes = {name for name in refs if name in cumulative_saves and name not in local}
+
+        # always_run resolves before stage substitutions exist, so only fixtures
+        # and parametrize parameters shadow an earlier save there.
+        always_run_refs = extract_template_variables(raw.get("always_run"))
+        always_run_local = set(stage.fixtures) | _parameter_names(stage.parametrize) | scenario_fixture_names
+        consumes |= {name for name in always_run_refs if name in cumulative_saves and name not in always_run_local}
+
+        by_producer: dict[int, list[str]] = {}
+        for name in consumes:
+            by_producer.setdefault(first_save_stage[name], []).append(name)
+        for producer in sorted(by_producer):
+            edges.append(DataFlowEdge(producer=producer, consumer=i, vars=sorted(by_producer[producer])))
+
+        stages.append(
+            StageFlow(
+                index=i,
+                name=stage.name,
+                method=str(stage.request.method),
+                url=str(stage.request.url),
+                fixtures=sorted(stage.fixtures),
+                marks=list(stage.marks),
+                saves=sorted(saves_by_stage[i]),
+                consumes=sorted(consumes),
+            )
+        )
+
+        cumulative_saves |= saves_by_stage[i]
+
+    scenario_var_names = set(substitution_names(scenario.substitutions))
+
+    return DataFlow(stages=stages, edges=edges, scenario_fixtures=sorted(scenario.fixtures), scenario_vars=sorted(scenario_var_names))
+
+
+def load_scenario(path: Path, ref_parent_traversal_depth: int = 3) -> tuple[Scenario, dict[str, Any]]:
+    """Load + ``$ref``-resolve + validate a scenario file.
+
+    Returns ``(scenario, raw_test_data)``. Raises ``ReferenceResolverError``,
+    ``json.JSONDecodeError`` or ``pydantic.ValidationError`` on failure — callers
+    map these to user-facing errors.
+    """
+    test_data = pytest_httpchain_jsonref.loader.load_json(
+        path,
+        max_parent_traversal_depth=ref_parent_traversal_depth,
+        root_path=resolve_root_path(path),
+    )
+    return Scenario.model_validate(test_data), test_data

pytest_httpchain-0.6.0/src/pytest_httpchain/schema.py

@@ -0,0 +1,116 @@
+"""Build the JSON Schema for pytest-httpchain scenario files.
+
+Shared by the ``pytest-httpchain schema`` CLI command and
+``scripts/generate_schema.py``. The schema is derived from the Pydantic
+``Scenario`` model and augmented so editors accept pytest-httpchain's
+``$ref``/``$include``/``$merge`` reference directives at any object level.
+"""
+
+from typing import Any
+
+from pytest_httpchain_models import Scenario
+
+SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema"
+SCHEMA_ID = "https://aeresov.github.io/pytest-httpchain/schema/scenario.schema.json"
+
+
+def _one_of_to_any_of(node: Any) -> None:
+    """Recursively rename ``oneOf`` to ``anyOf`` in place."""
+    if isinstance(node, dict):
+        if "oneOf" in node:
+            node["anyOf"] = node.pop("oneOf")
+        for value in node.values():
+            _one_of_to_any_of(value)
+    elif isinstance(node, list):
+        for item in node:
+            _one_of_to_any_of(item)
+
+
+def _add_jsonref_support(schema: dict[str, Any]) -> dict[str, Any]:
+    """Allow ``$include``/``$merge``/``$ref`` objects as alternatives anywhere.
+
+    pytest-httpchain-jsonref can substitute any element at runtime, so each
+    definition and root property is wrapped in an ``anyOf`` that also accepts a
+    reference object — otherwise editors flag missing required properties when a
+    reference is used.
+    """
+    if "$defs" not in schema:
+        schema["$defs"] = {}
+
+    schema["$defs"]["JsonRef"] = {
+        "type": "object",
+        "description": "Reference to external JSON file or JSON pointer. Use $include or $merge (preferred) or $ref. Resolved at runtime by pytest-httpchain-jsonref.",
+        "properties": {
+            "$include": {
+                "type": "string",
+                "description": "Path to external JSON file, JSON pointer (#/path), or combined (file.json#/path). Preferred over $ref to avoid VS Code conflicts.",
+            },
+            "$merge": {
+                "type": "string",
+                "description": "Alias for $include. Path to external JSON file, JSON pointer (#/path), or combined (file.json#/path).",
+            },
+            "$ref": {
+                "type": "string",
+                "description": "Legacy alias for $include. May conflict with VS Code's own $ref handling.",
+            },
+        },
+        # Without at least one directive key this branch would match EVERY
+        # object, silencing the strict alternative in the surrounding anyOf.
+        "anyOf": [
+            {"required": ["$include"]},
+            {"required": ["$merge"]},
+            {"required": ["$ref"]},
+        ],
+        "additionalProperties": True,
+    }
+
+    # Pydantic emits oneOf for tagged unions. A reference object matches the
+    # JsonRef branch of EVERY union member (each $defs entry is wrapped below),
+    # which oneOf counts as "valid under more than one" and rejects. anyOf
+    # keeps the same accept set otherwise: members forbid each other's tag
+    # fields, so a non-reference object can never match two branches.
+    _one_of_to_any_of(schema)
+
+    for type_name, original_def in list(schema["$defs"].items()):
+        if type_name == "JsonRef":
+            continue
+        schema["$defs"][type_name] = {"anyOf": [{"$ref": "#/$defs/JsonRef"}, original_def]}
+        if "title" in original_def:
+            schema["$defs"][type_name]["title"] = original_def.pop("title")
+        if "description" in original_def:
+            schema["$defs"][type_name]["description"] = original_def.pop("description")
+
+    for prop_name, prop_def in list(schema.get("properties", {}).items()):
+        schema["properties"][prop_name] = {
+            "anyOf": [{"$ref": "#/$defs/JsonRef"}, prop_def],
+            "title": prop_def.get("title", prop_name),
+        }
+        if "description" in prop_def:
+            schema["properties"][prop_name]["description"] = prop_def.get("description")
+
+    # The Scenario model forbids extra keys, so the root carries
+    # additionalProperties: false. Keys that are legitimate in a scenario
+    # *file* but handled before model validation must be declared explicitly:
+    # "$schema" (editor metadata, stripped by the loader) and the reference
+    # directives (resolved by the loader, supported at the document root).
+    schema.setdefault("properties", {})
+    schema["properties"]["$schema"] = {
+        "type": "string",
+        "description": "URL of this schema, for editor as-you-type validation. Stripped before the file is parsed.",
+    }
+    for directive, directive_def in schema["$defs"]["JsonRef"]["properties"].items():
+        schema["properties"][directive] = directive_def
+    schema["properties"]["$ref"] = {
+        "type": "string",
+        "description": "Legacy alias for $include. May conflict with VS Code's own $ref handling.",
+    }
+
+    return schema
+
+
+def build_schema() -> dict[str, Any]:
+    """Return the augmented JSON Schema dict for the ``Scenario`` model."""
+    schema = Scenario.model_json_schema()
+    schema["$schema"] = SCHEMA_DIALECT
+    schema["$id"] = SCHEMA_ID
+    return _add_jsonref_support(schema)

{pytest_httpchain-0.4.0 → pytest_httpchain-0.6.0}/src/pytest_httpchain/validation.py

@@ -24,12 +24,14 @@ Code     Severity Meaning
 006      warning  Verify step asserts nothing (no-op)
 007      error    Body ``contains``/``not_contains`` list the same substring
 008      error    Body ``matches``/``not_matches`` list the same pattern
+009      warning  Saved variable is shadowed by a scenario-level fixture
 010      error    File not found
 011      error    Path is not a file
 012      error    ``$ref`` resolution failed
 013      warning  File extension is not ``.json``
 014      error    Invalid JSON syntax
 015      error    Failed to parse JSON file
+016      error    Fixture referenced in a scenario-level template
 020      warning  Referenced file does not exist (deep, opt-in)
 021      warning  Schema file is not valid JSON / not a valid schema (deep)
 022      warning  User function cannot be imported (deep)
@@ -70,12 +72,14 @@ class DiagnosticCode:
     NOOP_VERIFY = "HTTPCHAIN006"
     CONTAINS_CONTRADICTION = "HTTPCHAIN007"
     MATCHES_CONTRADICTION = "HTTPCHAIN008"
+    FIXTURE_SHADOWS_SAVE = "HTTPCHAIN009"
     FILE_NOT_FOUND = "HTTPCHAIN010"
     NOT_A_FILE = "HTTPCHAIN011"
     REF_ERROR = "HTTPCHAIN012"
     WRONG_EXTENSION = "HTTPCHAIN013"
     INVALID_JSON = "HTTPCHAIN014"
     PARSE_ERROR = "HTTPCHAIN015"
+    FIXTURE_IN_SCENARIO_TEMPLATE = "HTTPCHAIN016"
     # Deep (opt-in) checks: imports, signatures, referenced files.
     REFERENCED_FILE_NOT_FOUND = "HTTPCHAIN020"
     SCHEMA_FILE_INVALID = "HTTPCHAIN021"
@@ -152,7 +156,7 @@ def extract_template_variables(obj: Any, variables: set[str] | None = None) -> s
     return variables
 
 
-def _substitution_names(substitutions: Any) -> set[str]:
+def substitution_names(substitutions: Any) -> set[str]:
     """Names introduced by a list of ``vars``/``functions`` substitution entries."""
     names: set[str] = set()
     for sub in substitutions or []:
@@ -165,7 +169,7 @@ def _substitution_names(substitutions: Any) -> set[str]:
     return names
 
 
-def _saved_in_stage(stage: Stage) -> set[str]:
+def saved_in_stage(stage: Stage) -> set[str]:
     """Variable names a single stage's response steps save into the context."""
     saved: set[str] = set()
     for response_step in stage.response:
@@ -177,7 +181,7 @@ def _saved_in_stage(stage: Stage) -> set[str]:
             saved.update(jmespath.keys())
         substitutions = getattr(save, "substitutions", None)
         if substitutions is not None:
-            saved |= _substitution_names(substitutions)
+            saved |= substitution_names(substitutions)
         # user_functions saves return arbitrary dict keys -> not statically known.
     return saved
 
@@ -186,7 +190,7 @@ def extract_saved_variables(scenario: Scenario) -> set[str]:
     """Extract variable names saved across all response steps in the scenario."""
     saved_vars: set[str] = set()
     for stage in scenario.stages:
-        saved_vars |= _saved_in_stage(stage)
+        saved_vars |= saved_in_stage(stage)
     return saved_vars
 
 
@@ -210,10 +214,10 @@ def _parameter_names(params: Any) -> set[str]:
     return names
 
 
-def _stage_defined_names(stage: Stage) -> set[str]:
+def stage_defined_names(stage: Stage) -> set[str]:
     """Names available *within a single stage*: its substitutions, parametrize /
     foreach parameters, and its declared fixtures."""
-    names = _substitution_names(stage.substitutions)
+    names = substitution_names(stage.substitutions)
     names |= _parameter_names(stage.parametrize)
     if stage.parallel is not None:
         names |= _parameter_names(getattr(stage.parallel, "foreach", None))
@@ -221,7 +225,7 @@ def _stage_defined_names(stage: Stage) -> set[str]:
     return names
 
 
-def extract_defined_variables(scenario: Scenario, test_data: dict[str, Any]) -> set[str]:
+def extract_defined_variables(scenario: Scenario) -> set[str]:
     """Extract variable names made available before/within templates (scenario-wide).
 
     Sources: ``vars`` and ``functions`` substitutions (scenario- and stage-level),
@@ -232,14 +236,10 @@ def extract_defined_variables(scenario: Scenario, test_data: dict[str, Any]) ->
     """
     defined_vars: set[str] = set()
 
-    # Defensive: a top-level "vars" key is not a model field but is tolerated.
-    if isinstance(test_data.get("vars"), dict):
-        defined_vars.update(k for k in test_data["vars"] if isinstance(k, str))
-
-    defined_vars |= _substitution_names(scenario.substitutions)
+    defined_vars |= substitution_names(scenario.substitutions)
 
     for stage in scenario.stages:
-        defined_vars |= _substitution_names(stage.substitutions)
+        defined_vars |= substitution_names(stage.substitutions)
         defined_vars |= _parameter_names(stage.parametrize)
         if stage.parallel is not None:
             defined_vars |= _parameter_names(getattr(stage.parallel, "foreach", None))
@@ -247,7 +247,7 @@ def extract_defined_variables(scenario: Scenario, test_data: dict[str, Any]) ->
     return defined_vars
 
 
-def _raw_stages(test_data: dict[str, Any]) -> list[Any]:
+def raw_stages(test_data: dict[str, Any]) -> list[Any]:
     """Raw (pre-validation) stage bodies in declaration order.
 
     Stages may be authored as a list or as a ``{name: stage}`` mapping; both
@@ -283,13 +283,16 @@ def _dataflow_diagnostics(scenario: Scenario, test_data: dict[str, Any]) -> list
     Walks stages in execution order tracking which variables are available at
     each reference site, mirroring the runtime scoping in ``carrier.py``:
 
-    * scenario-level substitutions (and a tolerated top-level ``vars``) are
-      available everywhere;
+    * scenario-level substitutions and scenario-level fixtures are available
+      everywhere;
     * a stage's own substitutions, parametrize/foreach parameters and fixtures
       are available to that stage's request and response;
     * a value saved in a stage's response is available to that stage's response
       and to *later* stages — but never to the same stage's request, and never
-      to earlier stages.
+      to earlier stages;
+    * ``always_run`` is evaluated at stage start, before stage substitutions are
+      processed and before any iteration runs: only fixtures, parametrize
+      parameters, scenario substitutions and earlier saves are in scope.
 
     A reference that is unavailable is reported as :data:`DiagnosticCode.FORWARD_REF`
     if the name is saved somewhere later (an ordering bug) or
@@ -298,7 +301,7 @@ def _dataflow_diagnostics(scenario: Scenario, test_data: dict[str, Any]) -> list
     diagnostics: list[Diagnostic] = []
 
     all_saved = extract_saved_variables(scenario)
-    saves_by_stage: list[set[str]] = [_saved_in_stage(stage) for stage in scenario.stages]
+    saves_by_stage: list[set[str]] = [saved_in_stage(stage) for stage in scenario.stages]
     first_save_stage: dict[str, int] = {}
     for i, saved in enumerate(saves_by_stage):
         for name in saved:
@@ -309,22 +312,17 @@ def _dataflow_diagnostics(scenario: Scenario, test_data: dict[str, Any]) -> list
     # fixtures, no stage substitutions, no parameter names, no saved values exist
     # yet. ``scenario_scope`` is that narrow set; ``scenario_available`` is the
     # everywhere-available set used for ordinary request/response references.
-    scenario_scope: set[str] = set()
-    if isinstance(test_data.get("vars"), dict):
-        scenario_scope |= {k for k in test_data["vars"] if isinstance(k, str)}
-    scenario_scope |= _substitution_names(scenario.substitutions)
+    scenario_scope: set[str] = set(substitution_names(scenario.substitutions))
 
-    scenario_available = set(scenario_scope)
-    if isinstance(test_data.get("fixtures"), list):
-        scenario_available |= {f for f in test_data["fixtures"] if isinstance(f, str)}
+    scenario_available = scenario_scope | set(scenario.fixtures)
 
-    raw_stages = _raw_stages(test_data)
+    raws = raw_stages(test_data)
     cumulative_saves: set[str] = set()
 
     for i, stage in enumerate(scenario.stages):
-        raw = raw_stages[i] if i < len(raw_stages) and isinstance(raw_stages[i], dict) else {}
+        raw = raws[i] if i < len(raws) and isinstance(raws[i], dict) else {}
 
-        request_available = scenario_available | _stage_defined_names(stage) | cumulative_saves
+        request_available = scenario_available | stage_defined_names(stage) | cumulative_saves
         response_available = request_available | saves_by_stage[i]
 
         # ``parallel.foreach`` values are resolved at stage execution against the
@@ -347,6 +345,31 @@ def _dataflow_diagnostics(scenario: Scenario, test_data: dict[str, Any]) -> list
                 )
             )
 
+        # ``always_run`` resolves at stage start (carrier.execute_stage) against
+        # fixtures + parametrize parameters + global context — stage substitutions
+        # and foreach parameters don't exist yet, and neither do this stage's saves.
+        always_run_available = scenario_available | set(stage.fixtures) | _parameter_names(stage.parametrize) | cumulative_saves
+        for name in sorted(extract_template_variables(raw.get("always_run"))):
+            if name in always_run_available:
+                continue
+            if name in all_saved:
+                j = first_save_stage[name]
+                if j == i:
+                    msg = f"Stage '{stage.name}': always_run references '{name}', which is only saved in this stage's response — always_run is evaluated before the stage runs"
+                else:
+                    msg = f"Stage '{stage.name}': always_run references '{name}' before it is saved (saved in stage '{scenario.stages[j].name}')"
+                diagnostics.append(_diag(DiagnosticCode.FORWARD_REF, "warning", msg, location=stage.name))
+            else:
+                diagnostics.append(
+                    _diag(
+                        DiagnosticCode.UNDEFINED_VAR,
+                        "warning",
+                        f"Stage '{stage.name}': always_run references '{name}' — potentially not in scope; only fixtures, "
+                        f"parametrize parameters, scenario substitutions, and variables saved by earlier stages are available",
+                        location=stage.name,
+                    )
+                )
+
         undefined_here: set[str] = set()
 
         for refs, available, in_request in (
@@ -642,14 +665,12 @@ def check_scenario(scenario: Scenario, test_data: dict[str, Any]) -> tuple[list[
             )
         )
 
-    fixtures: list[str] = []
-    if isinstance(test_data.get("fixtures"), list):
-        fixtures.extend(test_data["fixtures"])
+    fixtures: list[str] = list(scenario.fixtures)
     for stage in scenario.stages:
         fixtures.extend(stage.fixtures)
     fixtures = sorted(set(fixtures))
 
-    vars_defined = extract_defined_variables(scenario, test_data)
+    vars_defined = extract_defined_variables(scenario)
     vars_saved = extract_saved_variables(scenario)
     vars_referenced = extract_template_variables(test_data)
 
@@ -663,6 +684,35 @@ def check_scenario(scenario: Scenario, test_data: dict[str, Any]) -> tuple[list[
             )
         )
 
+    # Scenario fixtures are injected into every stage and sit above the global
+    # context in the runtime ChainMap, so a save under the same name can never
+    # be read back — the fixture value always wins.
+    shadowed_saves = set(scenario.fixtures) & vars_saved
+    if shadowed_saves:
+        diagnostics.append(
+            _diag(
+                DiagnosticCode.FIXTURE_SHADOWS_SAVE,
+                "warning",
+                f"Saved variables shadowed by scenario-level fixtures: {sorted(shadowed_saves)} (fixture values win in every stage; these saves can never be read)",
+            )
+        )
+
+    # Scenario-level templates (substitutions/auth/ssl) resolve once at class
+    # creation (carrier.create_test_class), before any fixture exists — a fixture
+    # reference there is a guaranteed collection-time crash.
+    for key in ("substitutions", "auth", "ssl"):
+        scenario_level_refs = extract_template_variables(test_data.get(key))
+        fixture_refs = scenario_level_refs & set(fixtures)
+        if fixture_refs:
+            diagnostics.append(
+                _diag(
+                    DiagnosticCode.FIXTURE_IN_SCENARIO_TEMPLATE,
+                    "error",
+                    f"Fixtures referenced in scenario-level '{key}' templates: {sorted(fixture_refs)} (scenario-level templates resolve at collection time, before fixtures exist)",
+                    location=key,
+                )
+            )
+
     # NOTE: response data (response/status_code/body/json/text/headers/cookies) is
     # NOT ambient in {{ }} templates — it reaches save/verify handlers directly and
     # only enters the template context via an earlier `save` step. So there are no
@@ -736,6 +786,17 @@ def check_scenario(scenario: Scenario, test_data: dict[str, Any]) -> tuple[list[
     return diagnostics, scenario_info
 
 
+def resolve_root_path(path: Path) -> Path:
+    """Directory that constrains ``$ref`` resolution: the nearest ``tests/``
+    ancestor of ``path``, else the file's own parent."""
+    potential_root = path.parent
+    while potential_root.parent != potential_root:
+        if potential_root.name == "tests":
+            return potential_root
+        potential_root = potential_root.parent
+    return path.parent
+
+
 def validate_scenario(
     path: Path,
     ref_parent_traversal_depth: int = 3,
@@ -772,14 +833,7 @@ def validate_scenario(
         )
 
     if root_path is None:
-        potential_root = path.parent
-        while potential_root.parent != potential_root:
-            if potential_root.name == "tests":
-                root_path = potential_root
-                break
-            potential_root = potential_root.parent
-        else:
-            root_path = path.parent
+        root_path = resolve_root_path(path)
 
     try:
         test_data = pytest_httpchain_jsonref.loader.load_json(

pytest_httpchain-0.4.0/src/pytest_httpchain/cli.py

@@ -1,83 +0,0 @@
-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.4.0/src/pytest_httpchain/skill.md

@@ -1,282 +0,0 @@
----
-name: pytest-httpchain
-description: Write and edit pytest-httpchain HTTP API test scenarios in JSON format
----
-
-# pytest-httpchain test authoring
-
-pytest-httpchain is a pytest plugin for declarative HTTP API integration testing. Test scenarios are JSON files discovered by pattern `test_<name>.http.json`.
-
-## Scenario structure
-
-```json
-{
-  "description": "optional scenario description",
-  "marks": ["optional_pytest_markers"],
-  "substitutions": [],
-  "stages": []
-}
-```
-
-## Stage structure
-
-```json
-{
-  "name": "stage name",
-  "description": "optional",
-  "fixtures": ["fixture_name"],
-  "marks": ["skip", "xfail(reason='not ready')"],
-  "always_run": false,
-  "substitutions": [],
-  "parametrize": [],
-  "parallel": null,
-  "request": { ... },
-  "response": [ ... ]
-}
-```
-
-Stages run sequentially and share a global context. Values saved in one stage are available in subsequent stages.
-
-Stages can also be written as a dict (keys become stage names):
-
-```json
-{
-  "stages": {
-    "create user": { "request": { ... }, "response": [ ... ] },
-    "get user":    { "request": { ... }, "response": [ ... ] }
-  }
-}
-```
-
-## Request
-
-```json
-{
-  "url": "{{ server }}/api/users",
-  "method": "POST",
-  "headers": { "Authorization": "Bearer {{ token }}" },
-  "params": { "page": 1 },
-  "body": { "json": { "name": "Alice" } },
-  "timeout": 30.0,
-  "allow_redirects": true
-}
-```
-
-**Body types** (use exactly one key):
-- `{"json": { ... }}` - JSON body
-- `{"form": { ... }}` - URL-encoded form
-- `{"text": "..."}` - raw text
-- `{"xml": "<root/>"}` - XML
-- `{"base64": "..."}` - base64-encoded binary
-- `{"binary": "/path/to/file"}` - file upload
-- `{"files": {"field": "/path/to/file"}}` - multipart file upload
-- `{"graphql": {"query": "...", "variables": {}}}` - GraphQL
-
-## Response steps
-
-Response is a list of verify and save steps, executed in order:
-
-```json
-"response": [
-  {
-    "verify": {
-      "status": 200,
-      "headers": { "content-type": "application/json" },
-      "body": {
-        "schema": { "type": "object", "required": ["id"] },
-        "contains": ["expected text"],
-        "not_contains": ["error"],
-        "matches": ["\\d{4}-\\d{2}-\\d{2}"],
-        "not_matches": ["forbidden"]
-      }
-    }
-  },
-  {
-    "save": {
-      "jmespath": {
-        "user_id": "data.id",
-        "user_name": "data.name",
-        "total": "length(items)"
-      }
-    }
-  },
-  {
-    "verify": {
-      "expressions": [
-        "{{ total > 0 }}",
-        "{{ user_name != '' }}"
-      ]
-    }
-  }
-]
-```
-
-**Important:** `verify.expressions` are `{{ }}` templates evaluated against the **context** (saved variables, fixtures, substitutions). The HTTP response is **not** ambient in templates — there is no `response`/`status_code`/`body`/`json` variable. To assert on response data, either:
-- use `verify.status`, `verify.headers`, `verify.body` (these check the response directly), or
-- `save` the value first (e.g. via `jmespath`) and reference the saved variable in a later `expressions` step (as shown above).
-
-**Save types:**
-- `{"jmespath": {...}}` - extract values from JSON response via JMESPath
-- `{"substitutions": [...]}` - compute values using template expressions
-- `{"user_functions": [...]}` - call Python functions to process response
-
-## Template expressions
-
-Use `{{ expr }}` syntax. Expressions are evaluated with Python semantics.
-
-**Available context:** all saved variables, fixture values, and substitution results.
-
-**Built-in functions:** `len`, `min`, `max`, `sum`, `abs`, `round`, `sorted`, `range`, `zip`, `enumerate`, `bool`, `int`, `float`, `str`, `dict`, `list`, `tuple`, `set`, `uuid4()`, `env(var, default)`, `get(var, default)`, `exists(var)`, `rand()`, `randint(a, b)`
-
-**JSON literals:** `true`, `false`, `null` map to Python `True`, `False`, `None`.
-
-## Substitutions
-
-Define variables before stages run:
-
-```json
-"substitutions": [
-  { "vars": { "base_url": "https://api.example.com", "count": "{{ 2 + 3 }}" } },
-  { "functions": { "generate_token": "mymodule:create_jwt" } }
-]
-```
-
-Substitutions can appear at scenario level (global) or stage level (local).
-
-## References ($include / $ref)
-
-Split scenarios across files using `$include` (preferred) or `$ref`:
-
-```json
-{
-  "request": {
-    "$include": "common.json#/requests/get_user"
-  }
-}
-```
-
-Sibling properties are deep-merged with the referenced content:
-
-```json
-{
-  "$include": "base_request.json",
-  "headers": { "X-Custom": "override" }
-}
-```
-
-## Parametrize
-
-Run a stage with different inputs:
-
-```json
-"parametrize": [
-  {
-    "individual": { "user_id": [1, 2, 3] },
-    "ids": ["user-one", "user-two", "user-three"]
-  }
-]
-```
-
-Or use combinations:
-
-```json
-"parametrize": [
-  {
-    "combinations": [
-      { "method": "GET", "expected": 200 },
-      { "method": "DELETE", "expected": 403 }
-    ]
-  }
-]
-```
-
-## Parallel execution
-
-Execute requests concurrently for load testing:
-
-```json
-"parallel": {
-  "repeat": 100,
-  "max_concurrency": 10,
-  "calls_per_sec": 50
-}
-```
-
-Or iterate over parameter sets in parallel:
-
-```json
-"parallel": {
-  "foreach": [{ "individual": { "id": [1, 2, 3, 4, 5] } }],
-  "max_concurrency": 5
-}
-```
-
-## Complete example: multi-stage API test
-
-```json
-{
-  "substitutions": [
-    { "vars": { "base": "{{ env('API_URL', 'http://localhost:8000') }}" } }
-  ],
-  "stages": [
-    {
-      "name": "create user",
-      "request": {
-        "url": "{{ base }}/users",
-        "method": "POST",
-        "body": { "json": { "name": "Alice", "email": "alice@example.com" } }
-      },
-      "response": [
-        { "verify": { "status": 201 } },
-        { "save": { "jmespath": { "user_id": "id" } } }
-      ]
-    },
-    {
-      "name": "get user",
-      "request": {
-        "url": "{{ base }}/users/{{ user_id }}"
-      },
-      "response": [
-        { "verify": { "status": 200 } },
-        { "save": { "jmespath": { "name": "name" } } },
-        { "verify": { "expressions": ["{{ name == 'Alice' }}"] } }
-      ]
-    },
-    {
-      "name": "delete user",
-      "request": {
-        "url": "{{ base }}/users/{{ user_id }}",
-        "method": "DELETE"
-      },
-      "response": [
-        { "verify": { "status": 204 } }
-      ]
-    }
-  ]
-}
-```
-
-## 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.