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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-httpchain
-Version: 0.2.4
+Version: 0.4.0
 Summary: pytest plugin for HTTP testing using JSON files
 Keywords: testing,pytest,requests
 Author: Alexander Eresov
@@ -18,8 +18,8 @@ Requires-Dist: httpx[http2]>=0.27.0
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pyrate-limiter>=3.0.0
 Requires-Dist: pytest-httpchain-jsonref
-Requires-Dist: pytest-httpchain-mcp
 Requires-Dist: pytest-httpchain-models
+Requires-Dist: pytest-httpchain-templates
 Requires-Dist: pytest-order>=1.3.0
 Requires-Dist: typer>=0.16.0
 Requires-Python: >=3.13, <4.0
@@ -196,37 +196,51 @@ pip install 'git+https://github.com/aeresov/pytest-httpchain@main'
 -   Template expressions support list/dict comprehensions. You can limit the maximum comprehension length using `max_comprehension_length` ini option, default value is **50000**.
 -   Parallel stage iterations (repeat/foreach) have a safety limit configurable via `max_parallel_iterations` ini option, default value is **10000**.
 
-## MCP Server
+## AI agent support
 
-`pytest-httpchain` includes an MCP (Model Context Protocol) server to aid AI code assistants.
+`pytest-httpchain` ships tooling to help AI coding agents (and humans) author and check test scenarios.
 
-### Setup
+### Claude Code skill
 
-Install the MCP server config and Claude Code skill into your project:
+Install the authoring skill into your project (or `--global` for personal scope):
 
 ```bash
-uvx pytest-httpchain install --skill --mcp
+uvx pytest-httpchain install
 ```
 
-Or configure manually in `.mcp.json`:
+This writes `.claude/skills/pytest-httpchain/SKILL.md` with guidance for writing scenarios.
 
-```json
-{
-    "mcpServers": {
-        "pytest-httpchain": {
-            "command": "uvx",
-            "args": ["pytest-httpchain", "mcp"]
-        }
-    }
-}
+### Scenario validation
+
+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
 ```
 
-### Features
+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 MCP server provides:
+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.
 
--   **Scenario validation** - validate test scenario and scan for possible problems
--   **Claude Code skill** - authoring guidance for writing test scenarios
+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
+
+A JSON Schema is published for as-you-type validation and autocomplete. Reference it from your test files:
+
+```json
+{
+    "$schema": "https://aeresov.github.io/pytest-httpchain/schema/scenario.schema.json"
+}
+```
 
 ## Documentation
 

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

@@ -169,37 +169,51 @@ pip install 'git+https://github.com/aeresov/pytest-httpchain@main'
 -   Template expressions support list/dict comprehensions. You can limit the maximum comprehension length using `max_comprehension_length` ini option, default value is **50000**.
 -   Parallel stage iterations (repeat/foreach) have a safety limit configurable via `max_parallel_iterations` ini option, default value is **10000**.
 
-## MCP Server
+## AI agent support
 
-`pytest-httpchain` includes an MCP (Model Context Protocol) server to aid AI code assistants.
+`pytest-httpchain` ships tooling to help AI coding agents (and humans) author and check test scenarios.
 
-### Setup
+### Claude Code skill
 
-Install the MCP server config and Claude Code skill into your project:
+Install the authoring skill into your project (or `--global` for personal scope):
 
 ```bash
-uvx pytest-httpchain install --skill --mcp
+uvx pytest-httpchain install
 ```
 
-Or configure manually in `.mcp.json`:
+This writes `.claude/skills/pytest-httpchain/SKILL.md` with guidance for writing scenarios.
 
-```json
-{
-    "mcpServers": {
-        "pytest-httpchain": {
-            "command": "uvx",
-            "args": ["pytest-httpchain", "mcp"]
-        }
-    }
-}
+### Scenario validation
+
+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
 ```
 
-### Features
+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 MCP server provides:
+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.
 
--   **Scenario validation** - validate test scenario and scan for possible problems
--   **Claude Code skill** - authoring guidance for writing test scenarios
+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
+
+A JSON Schema is published for as-you-type validation and autocomplete. Reference it from your test files:
+
+```json
+{
+    "$schema": "https://aeresov.github.io/pytest-httpchain/schema/scenario.schema.json"
+}
+```
 
 ## Documentation
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "pytest-httpchain"
-version = "0.2.4"
+version = "0.4.0"
 description = "pytest plugin for HTTP testing using JSON files"
 readme = "README.md"
 requires-python = ">=3.13,<4.0"
@@ -10,8 +10,8 @@ dependencies = [
     "pydantic>=2.11.7",
     "pyrate-limiter>=3.0.0",
     "pytest-httpchain-jsonref",
-    "pytest-httpchain-mcp",
     "pytest-httpchain-models",
+    "pytest-httpchain-templates",
     "pytest-order>=1.3.0",
     "typer>=0.16.0",
 ]
@@ -54,7 +54,6 @@ members = ["packages/*"]
 pytest-httpchain-core = { workspace = true }
 pytest-httpchain-jsonref = { workspace = true }
 pytest-httpchain-templates = { workspace = true }
-pytest-httpchain-mcp = { workspace = true }
 pytest-httpchain-models = { workspace = true }
 pytest-httpchain-userfunc = { workspace = true }
 
@@ -103,7 +102,6 @@ pythonpath = [
     "packages/pytest-httpchain-core/src",
     "packages/pytest-httpchain-jsonref/src",
     "packages/pytest-httpchain-templates/src",
-    "packages/pytest-httpchain-mcp/src",
     "packages/pytest-httpchain-models/src",
     "packages/pytest-httpchain-userfunc/src",
 ]
@@ -124,7 +122,6 @@ source = [
     "packages/pytest-httpchain-core/src",
     "packages/pytest-httpchain-jsonref/src",
     "packages/pytest-httpchain-templates/src",
-    "packages/pytest-httpchain-mcp/src",
     "packages/pytest-httpchain-models/src",
     "packages/pytest-httpchain-userfunc/src",
 ]

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

@@ -180,7 +180,7 @@ class Carrier:
                         cls.last_request = exc.request
                     if exc.response is not None:
                         cls.last_response = exc.response
-                raise StageExecutionError(f"Parallel execution failed at iteration {idx}: {exc}")
+                raise StageExecutionError(f"Parallel execution failed at iteration {idx}: {exc}") from exc
 
         except (
             TemplatesError,
@@ -199,7 +199,7 @@ class Carrier:
             "method": request_model.method,
             "url": str(request_model.url),
             "headers": request_model.headers,
-            "params": request_model.params,
+            "params": request_model.params or None,
             "timeout": request_model.timeout,
             "follow_redirects": request_model.allow_redirects,
         }
@@ -209,7 +209,7 @@ class Carrier:
                 auth_result = call_user_function(request_model.auth)
                 request_kwargs["auth"] = auth_result
             except UserFunctionError as e:
-                raise RequestError(f"Failed to configure authentication: {str(e)}") from None
+                raise RequestError(f"Failed to configure authentication: {e}") from None
 
         match request_model.body:
             case None:
@@ -233,19 +233,16 @@ class Carrier:
 
             case BinaryBody(binary=file_path):
                 try:
-                    with open(file_path, "rb") as f:
-                        binary_data = f.read()
-                    request_kwargs["content"] = binary_data
+                    request_kwargs["content"] = Path(file_path).read_bytes()
                 except FileNotFoundError:
                     raise RequestError(f"Binary file not found: {file_path}") from None
 
             case FilesBody(files=file_paths):
                 files_list = []
                 for field_name, file_path in file_paths.items():
+                    path = Path(file_path)
                     try:
-                        with open(file_path, "rb") as f:
-                            file_content = f.read()
-                        files_list.append((field_name, (Path(file_path).name, file_content)))
+                        files_list.append((field_name, (path.name, path.read_bytes())))
                     except FileNotFoundError:
                         raise RequestError(f"File not found for upload: {file_path}") from None
                 request_kwargs["files"] = files_list
@@ -257,13 +254,13 @@ class Carrier:
         try:
             return cls.client.request(**request_kwargs)
         except httpx.TimeoutException as e:
-            raise RequestError(f"HTTP request timed out: {str(e)}") from None
+            raise RequestError(f"HTTP request timed out: {e}") from None
         except httpx.ConnectError as e:
-            raise RequestError(f"HTTP connection error: {str(e)}") from None
+            raise RequestError(f"HTTP connection error: {e}") from None
         except httpx.HTTPError as e:
-            raise RequestError(f"HTTP request failed: {str(e)}") from None
+            raise RequestError(f"HTTP request failed: {e}") from None
         except Exception as e:
-            raise RequestError(f"Unexpected error: {str(e)}") from None
+            raise RequestError(f"Unexpected error: {e}") from None
 
     @staticmethod
     def _process_save_step(save_model: Save, response: httpx.Response, context: ChainMap[str, Any]) -> dict[str, Any]:
@@ -274,21 +271,21 @@ class Carrier:
                 try:
                     response_json = response.json()
                 except (json.JSONDecodeError, UnicodeDecodeError) as e:
-                    raise SaveError(f"Cannot extract variables, response is not valid JSON: {str(e)}") from None
+                    raise SaveError(f"Cannot extract variables, response is not valid JSON: {e}") from None
 
                 for var_name, jmespath_expr in save_model.jmespath.items():
                     try:
                         saved_value = jmespath.search(jmespath_expr, response_json)
                         step_saved[var_name] = saved_value
                     except jmespath.exceptions.JMESPathError as e:
-                        raise SaveError(f"Error saving variable {var_name}: {str(e)}") from None
+                        raise SaveError(f"Error saving variable {var_name}: {e}") from None
 
             case SubstitutionsSave():
                 try:
                     substitution_result = process_substitutions(save_model.substitutions, context)
                     step_saved.update(substitution_result)
                 except TemplatesError as e:
-                    raise SaveError(f"Error processing substitutions: {str(e)}") from None
+                    raise SaveError(f"Error processing substitutions: {e}") from None
 
             case UserFunctionsSave():
                 for func_item in save_model.user_functions:
@@ -298,12 +295,11 @@ class Carrier:
                         if not isinstance(func_result, dict):
                             raise SaveError(f"Save function must return dict, got {type(func_result).__name__}")
 
-                        result_dict = cast(dict[str, Any], func_result)
-                        step_saved.update(result_dict)
+                        step_saved.update(func_result)
                     except SaveError:
                         raise
                     except UserFunctionError as e:
-                        raise SaveError(f"Error calling user function '{func_item}': {str(e)}") from None
+                        raise SaveError(f"Error calling user function '{func_item}': {e}") from None
 
         return step_saved
 
@@ -333,7 +329,7 @@ class Carrier:
             except VerificationError:
                 raise
             except UserFunctionError as e:
-                raise VerificationError(f"Error calling user function '{func_item}': {str(e)}") from None
+                raise VerificationError(f"Error calling user function '{func_item}': {e}") from None
 
         if verify_model.body.schema:
             schema = verify_model.body.schema
@@ -343,21 +339,21 @@ class Carrier:
                     schema = json.loads(schema_path.read_text())
                     check_json_schema(schema)
                 except (OSError, json.JSONDecodeError) as e:
-                    raise VerificationError(f"Error reading body schema file '{schema_path}': {str(e)}") from None
+                    raise VerificationError(f"Error reading body schema file '{schema_path}': {e}") from None
                 except jsonschema.SchemaError as e:
                     raise VerificationError(f"Invalid JSON Schema in file '{schema_path}': {e}") from None
 
             try:
                 response_json = response.json()
             except (json.JSONDecodeError, UnicodeDecodeError) as e:
-                raise VerificationError(f"Cannot validate schema, response is not valid JSON: {str(e)}") from None
+                raise VerificationError(f"Cannot validate schema, response is not valid JSON: {e}") from None
 
             try:
                 jsonschema.validate(instance=response_json, schema=schema)
             except jsonschema.ValidationError as e:
-                raise VerificationError(f"Body schema validation failed: {str(e)}") from None
+                raise VerificationError(f"Body schema validation failed: {e}") from None
             except jsonschema.SchemaError as e:
-                raise VerificationError(f"Invalid body validation schema: {str(e)}") from None
+                raise VerificationError(f"Invalid body validation schema: {e}") from None
 
         for substring in verify_model.body.contains:
             if substring not in response.text:
@@ -438,7 +434,7 @@ class Carrier:
             try:
                 ctx.__exit__(None, None, None)
             except Exception as e:
-                logger.error(f"Error while cleaning up context manager fixture: {str(e)}")
+                logger.error(f"Error while cleaning up context manager fixture: {e}")
 
         if cls.client is not None:
             cls.client.close()

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.2.4 → pytest_httpchain-0.4.0}/src/pytest_httpchain/har_writer.py

@@ -238,7 +238,6 @@ def write_har_file(
     entry = request_response_to_har_entry(request, response, started_datetime, elapsed_ms)
     har = create_har_log([entry], comment=f"Test: {test_name}")
 
-    with open(filepath, "w", encoding="utf-8") as f:
-        json.dump(har, f, indent=2, ensure_ascii=False)
+    filepath.write_text(json.dumps(har, indent=2, ensure_ascii=False), encoding="utf-8")
 
     return filepath

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

@@ -1,6 +1,7 @@
 import logging
 import re
 import types
+import warnings
 from collections.abc import Iterable
 from pathlib import Path
 from typing import Any
@@ -19,10 +20,15 @@ from .carrier import Carrier, create_test_class
 from .har_writer import write_har_file
 from .report_formatter import format_request, format_response
 from .utils import make_marker
+from .validation import check_scenario
 
 logger = logging.getLogger(__name__)
 
 
+class ScenarioValidationWarning(pytest.PytestWarning):
+    """A collected scenario has a non-fatal validation issue (e.g. an undefined variable)."""
+
+
 class JsonModule(python.Module):
     """JSON test module that collects and executes HTTP chain tests.
 
@@ -42,9 +48,9 @@ class JsonModule(python.Module):
                 root_path=root_path,
             )
         except pytest_httpchain_jsonref.ReferenceResolverError as e:
-            raise nodes.Collector.CollectError(f"Cannot load JSON file {self.path}: {str(e)}") from None
+            raise nodes.Collector.CollectError(f"Cannot load JSON file {self.path}: {e}") from None
         except Exception as e:
-            raise nodes.Collector.CollectError(f"Failed to parse JSON file {self.path}: {str(e)}") from None
+            raise nodes.Collector.CollectError(f"Failed to parse JSON file {self.path}: {e}") from None
 
         # validate general scenario structure
         try:
@@ -59,6 +65,18 @@ class JsonModule(python.Module):
             full_error_msg = f"Cannot parse test scenario in {self.path}:\n" + "\n".join(error_details)
             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/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
         max_parallel_iterations = int(self.config.getini(ConfigOptions.MAX_PARALLEL_ITERATIONS))
         CarrierClass = create_test_class(scenario, self.name, max_parallel_iterations=max_parallel_iterations)

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

@@ -82,10 +82,6 @@ Response is a list of verify and save steps, executed in order:
     "verify": {
       "status": 200,
       "headers": { "content-type": "application/json" },
-      "expressions": [
-        "{{ user_count > 0 }}",
-        "{{ 'error' not in body }}"
-      ],
       "body": {
         "schema": { "type": "object", "required": ["id"] },
         "contains": ["expected text"],
@@ -103,10 +99,22 @@ Response is a list of verify and save steps, executed in order:
         "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
@@ -229,12 +237,9 @@ Or iterate over parameter sets in parallel:
         "url": "{{ base }}/users/{{ user_id }}"
       },
       "response": [
-        {
-          "verify": {
-            "status": 200,
-            "expressions": ["{{ body.name == 'Alice' }}"]
-          }
-        }
+        { "verify": { "status": 200 } },
+        { "save": { "jmespath": { "name": "name" } } },
+        { "verify": { "expressions": ["{{ name == 'Alice' }}"] } }
       ]
     },
     {
@@ -250,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.

{pytest_httpchain-0.2.4 → pytest_httpchain-0.4.0}/src/pytest_httpchain/utils.py

@@ -31,11 +31,11 @@ def make_marker(mark_str: str) -> pytest.MarkDecorator:
 
 def process_substitutions(
     substitutions: Sequence[Substitution],
-    context: Mapping[str, Any] = {},
+    context: Mapping[str, Any] | None = None,
 ) -> dict[str, Any]:
-    result = {}
+    result: dict[str, Any] = {}
     for step in substitutions:
-        current_context = {**context, **result}
+        current_context = {**(context or {}), **result}
         match step:
             case FunctionsSubstitution():
                 for alias, func_def in step.functions.items():