pytest-httpchain 0.7.0__tar.gz → 0.8.0__tar.gz

{pytest_httpchain-0.7.0 → pytest_httpchain-0.8.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pytest-httpchain
-Version: 0.7.0
+Version: 0.8.0
 Summary: pytest plugin for HTTP testing using JSON files
-Keywords: testing,pytest,requests
+Keywords: testing,pytest,httpx,http,api,integration-testing
 Author: Alexander Eresov
 Author-email: Alexander Eresov <aeresov@gmail.com>
 License-Expression: MIT
@@ -197,11 +197,21 @@ pip install 'git+https://github.com/aeresov/pytest-httpchain@main'
 
 -   Test file discovery is based on this name pattern: `test_<name>.<suffix>.json`.
     The `suffix` is configurable as pytest ini option, default value is **http**.
--   `$ref` instructions can point to other files; absolute and relative paths are supported.
+-   `$ref` instructions can point to other files using relative paths; absolute paths are rejected for security.
     You can limit the depth of relative path traversal using `ref_parent_traversal_depth` ini option, default value is **3**.
 -   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**.
 
+### HAR export
+
+Pass `--output-dir DIR` on the pytest command line to write an [HAR](http://www.softwareishard.com/blog/har-12-spec/) file (and a "HAR File" report section) capturing each test's HTTP traffic:
+
+```bash
+pytest --output-dir ./har-output
+```
+
+HAR files contain full requests/responses **including credential headers and saved tokens** — nothing is redacted, so scrub them before sharing. See the [HAR export docs](https://aeresov.github.io/pytest-httpchain/getting-started/#har-export).
+
 ## AI agent support
 
 `pytest-httpchain` ships a scenario validator to help AI coding agents (and humans) author and check test scenarios.
@@ -241,7 +251,7 @@ 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
+uvx pytest-httpchain schema > scenario.schema.json
 ```
 
 ### Inspecting scenarios

{pytest_httpchain-0.7.0 → pytest_httpchain-0.8.0}/README.md

@@ -164,11 +164,21 @@ pip install 'git+https://github.com/aeresov/pytest-httpchain@main'
 
 -   Test file discovery is based on this name pattern: `test_<name>.<suffix>.json`.
     The `suffix` is configurable as pytest ini option, default value is **http**.
--   `$ref` instructions can point to other files; absolute and relative paths are supported.
+-   `$ref` instructions can point to other files using relative paths; absolute paths are rejected for security.
     You can limit the depth of relative path traversal using `ref_parent_traversal_depth` ini option, default value is **3**.
 -   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**.
 
+### HAR export
+
+Pass `--output-dir DIR` on the pytest command line to write an [HAR](http://www.softwareishard.com/blog/har-12-spec/) file (and a "HAR File" report section) capturing each test's HTTP traffic:
+
+```bash
+pytest --output-dir ./har-output
+```
+
+HAR files contain full requests/responses **including credential headers and saved tokens** — nothing is redacted, so scrub them before sharing. See the [HAR export docs](https://aeresov.github.io/pytest-httpchain/getting-started/#har-export).
+
 ## AI agent support
 
 `pytest-httpchain` ships a scenario validator to help AI coding agents (and humans) author and check test scenarios.
@@ -208,7 +218,7 @@ 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
+uvx pytest-httpchain schema > scenario.schema.json
 ```
 
 ### Inspecting scenarios

{pytest_httpchain-0.7.0 → pytest_httpchain-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytest-httpchain"
-version = "0.7.0"
+version = "0.8.0"
 description = "pytest plugin for HTTP testing using JSON files"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -21,7 +21,7 @@ dependencies = [
     "simpleeval>=1.0.3",
     "typer>=0.16.0",
 ]
-keywords = ["testing", "pytest", "requests"]
+keywords = ["testing", "pytest", "httpx", "http", "api", "integration-testing"]
 license = "MIT"
 license-files = ["LICENSE"]
 classifiers = [

{pytest_httpchain-0.7.0 → pytest_httpchain-0.8.0}/src/pytest_httpchain/carrier.py

@@ -155,9 +155,10 @@ class Carrier:
 
             total = len(iteration_substitutions)
             if total == 0:
-                # Unreachable via validated models (foreach values have min_length=1,
-                # repeat is PositiveInt), but guard so a future gap fails loudly
-                # instead of passing a stage that never sent a request.
+                # The models reject the static empty cases (foreach/combinations
+                # have min_length=1, repeat is PositiveInt), but a template- or
+                # $ref-sourced parallel config can still resolve to empty at
+                # runtime, so guard rather than silently send zero requests.
                 raise StageExecutionError("Parallel configuration produced zero iterations; foreach/repeat must yield at least one item")
             if total > cls.max_parallel_iterations:
                 raise StageExecutionError(
@@ -543,6 +544,19 @@ class Carrier:
             cls.client = None
 
 
+def _normalize_cert(cert: Any) -> str | tuple[str, ...]:
+    """Stringify SSL client-cert paths for httpx.
+
+    The model stores ``cert`` as ``pathlib.Path`` (single) or a tuple of Paths.
+    httpx builds the SSL context via ``load_cert_chain(*cert)`` for a non-tuple
+    cert, so a bare ``Path`` is unpacked and raises ``TypeError``. Passing string
+    paths avoids that for both the single-path and (cert, key) tuple forms.
+    """
+    if isinstance(cert, list | tuple):
+        return tuple(str(p) for p in cert)
+    return str(cert)
+
+
 def create_test_class(scenario: Scenario, class_name: str, max_parallel_iterations: int = 10_000) -> type[Carrier]:
     """Create a dynamic test class from a scenario definition."""
     scenario_context = process_substitutions(scenario.substitutions)
@@ -553,7 +567,7 @@ def create_test_class(scenario: Scenario, class_name: str, max_parallel_iteratio
         "http2": True,
     }
     if scenario.ssl.cert is not None:
-        client_kwargs["cert"] = resolved_ssl.cert
+        client_kwargs["cert"] = _normalize_cert(resolved_ssl.cert)
     if scenario.auth:
         resolved_auth = walk(scenario.auth, scenario_context)
         auth_result = call_user_function(resolved_auth)

{pytest_httpchain-0.7.0 → pytest_httpchain-0.8.0}/src/pytest_httpchain/cli.py

@@ -28,23 +28,6 @@ class GraphDirection(enum.StrEnum):
 RefParentTraversalDepth = Annotated[int, typer.Option(help="Maximum $ref parent directory traversal depth.")]
 
 
-def _emit(text: str, output: Path | None, label: str) -> None:
-    """Write text to a file (with a confirmation) or echo it to stdout.
-
-    A failed write reports a clean ``error: ...`` and exits non-zero, matching
-    the load-error handling elsewhere in this module instead of a raw traceback.
-    """
-    if output is None:
-        typer.echo(text)
-        return
-    try:
-        output.write_text(text + "\n")
-    except OSError as e:
-        typer.echo(f"error: cannot write {output}: {e}", err=True)
-        raise typer.Exit(1) from e
-    typer.echo(f"Wrote {label} to {output}")
-
-
 @app.callback()
 def main() -> None:
     """pytest-httpchain command-line tools."""
@@ -99,24 +82,23 @@ def validate(
 
 
 @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)."""
+def schema() -> None:
+    """Emit the JSON Schema for scenario files (editor autocomplete/validation).
+
+    Writes to stdout; redirect to a file (``pytest-httpchain schema > scenario.schema.json``).
+    """
     from pytest_httpchain.schema import build_schema
 
-    text = json.dumps(build_schema(), indent=2, default=str)
-    _emit(text, output, "schema")
+    typer.echo(json.dumps(build_schema(), indent=2, default=str))
 
 
 @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: RefParentTraversalDepth = 3,
     root_path: Annotated[Path | None, typer.Option("--root-path", help="Directory that constrains $ref resolution (default: nearest tests/ ancestor).")] = None,
 ) -> None:
-    """Resolve $ref/$include/$merge and print the merged scenario JSON."""
+    """Resolve $ref/$include/$merge and print the merged scenario JSON to stdout."""
     from pytest_httpchain_jsonref import ReferenceResolverError, load_json
 
     from pytest_httpchain.validation import resolve_root_path
@@ -131,8 +113,7 @@ def resolve(
         typer.echo(f"error: {e}", err=True)
         raise typer.Exit(1) from e
 
-    text = json.dumps(data, indent=2, default=str)
-    _emit(text, output, "resolved scenario")
+    typer.echo(json.dumps(data, indent=2, default=str))
 
 
 def _load_for_inspection(path: Path, depth: int, root_path: Path | None = None) -> tuple["Scenario", dict]:

{pytest_httpchain-0.7.0 → pytest_httpchain-0.8.0}/src/pytest_httpchain/plugin.py

@@ -165,26 +165,33 @@ def pytest_addoption(parser: pytest.Parser) -> None:
 
 
 def pytest_configure(config: pytest.Config) -> None:
-    # Numeric options are registered with type="int", so getini returns an int and a
-    # non-int value in the ini is reported by pytest as a clean usage error. Range
-    # checks below raise pytest.UsageError (not bare ValueError, which pytest renders
-    # as an INTERNALERROR with traceback).
+    # Numeric options are registered with type="int", but pytest performs the
+    # int() conversion with a bare int(value) that raises ValueError for a
+    # non-integer ini value — which pytest renders as an INTERNALERROR traceback.
+    # Wrap the read so a garbage value becomes a clean usage error; the range
+    # checks below likewise raise pytest.UsageError.
+    def _getint(name: str) -> int:
+        try:
+            return config.getini(name)
+        except ValueError as e:
+            raise pytest.UsageError(f"{name} must be an integer: {e}") from None
+
     suffix = str(config.getini(ConfigOptions.SUFFIX))
     if not re.match(r"^[a-zA-Z0-9_-]{1,32}$", suffix):
         raise pytest.UsageError("suffix must contain only alphanumeric characters, underscores, hyphens, and be ≤32 chars")
 
-    ref_parent_traversal_depth = config.getini(ConfigOptions.REF_PARENT_TRAVERSAL_DEPTH)
+    ref_parent_traversal_depth = _getint(ConfigOptions.REF_PARENT_TRAVERSAL_DEPTH)
     if ref_parent_traversal_depth < 0:
         raise pytest.UsageError("ref_parent_traversal_depth must be non-negative")
 
-    max_comprehension_length = config.getini(ConfigOptions.MAX_COMPREHENSION_LENGTH)
+    max_comprehension_length = _getint(ConfigOptions.MAX_COMPREHENSION_LENGTH)
     if max_comprehension_length < 1:
         raise pytest.UsageError("max_comprehension_length must be a positive integer")
     if max_comprehension_length > 1_000_000:
         raise pytest.UsageError("max_comprehension_length must not exceed 1,000,000")
     simpleeval.MAX_COMPREHENSION_LENGTH = max_comprehension_length  # ty: ignore[invalid-assignment]
 
-    max_parallel_iterations = config.getini(ConfigOptions.MAX_PARALLEL_ITERATIONS)
+    max_parallel_iterations = _getint(ConfigOptions.MAX_PARALLEL_ITERATIONS)
     if max_parallel_iterations < 1:
         raise pytest.UsageError("max_parallel_iterations must be a positive integer")
     if max_parallel_iterations > 1_000_000:

{pytest_httpchain-0.7.0 → pytest_httpchain-0.8.0}/src/pytest_httpchain/validation.py

@@ -32,6 +32,9 @@ Code     Severity Meaning
 014      error    Invalid JSON syntax
 015      error    Failed to parse JSON file
 016      error    Fixture referenced in a scenario-level template
+017      error    Scenario-level template references an undefined name
+018      warning  Verify expression is not a template (``{{ }}``) — asserts nothing
+019      error    Invalid pytest marker expression (scenario or stage ``marks``)
 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)
@@ -64,7 +67,7 @@ from pytest_httpchain_models import (
     Verify,
     VerifyStep,
 )
-from pytest_httpchain_templates import TEMPLATE_BUILTINS, TEMPLATE_PATTERN
+from pytest_httpchain_templates import TEMPLATE_BUILTINS, TEMPLATE_PATTERN, is_complete_template
 
 Severity = Literal["error", "warning"]
 
@@ -90,6 +93,8 @@ class DiagnosticCode:
     PARSE_ERROR = "HTTPCHAIN015"
     FIXTURE_IN_SCENARIO_TEMPLATE = "HTTPCHAIN016"
     SCENARIO_UNDEFINED_VAR = "HTTPCHAIN017"
+    NONTEMPLATE_EXPRESSION = "HTTPCHAIN018"
+    INVALID_MARKER = "HTTPCHAIN019"
     # Deep (opt-in) checks: imports, signatures, referenced files.
     REFERENCED_FILE_NOT_FOUND = "HTTPCHAIN020"
     SCHEMA_FILE_INVALID = "HTTPCHAIN021"
@@ -453,6 +458,21 @@ def _verify_diagnostics(scenario: Scenario) -> list[Diagnostic]:
                     )
                 )
 
+            # A verify expression is meant to be a complete ``{{ }}`` template that
+            # evaluates to a truthy/falsy value. A plain string (e.g. a forgotten
+            # ``{{ }}``) is non-empty and therefore always truthy at runtime, so the
+            # assertion silently passes — it tests nothing.
+            for expr in verify.expressions:
+                if isinstance(expr, str) and not is_complete_template(expr):
+                    diagnostics.append(
+                        _diag(
+                            DiagnosticCode.NONTEMPLATE_EXPRESSION,
+                            "warning",
+                            f"Stage '{stage.name}': verify expression {expr!r} is not a template ({{{{ }}}}); it is always truthy and asserts nothing",
+                            location=location,
+                        )
+                    )
+
             # Overlap is compared on the raw (unrendered) strings: identical
             # entries — including identical templates — are caught. A contradiction
             # that only emerges after rendering (e.g. a template that resolves to a
@@ -483,6 +503,47 @@ def _verify_diagnostics(scenario: Scenario) -> list[Diagnostic]:
     return diagnostics
 
 
+def _marker_diagnostics(scenario: Scenario) -> list[Diagnostic]:
+    """Validate scenario- and stage-level pytest marker expressions.
+
+    Markers are parsed by ``make_marker`` only at collection time, so a malformed
+    marker (``skip(``) or an unsupported form (``foo.bar``) would pass ``validate``
+    yet crash collection. Run the same parser here so the validator catches it as
+    an error, keeping ``validate`` a faithful pre-flight check of what collection
+    will accept.
+    """
+    import warnings
+
+    from pytest_httpchain.utils import make_marker
+
+    diagnostics: list[Diagnostic] = []
+
+    def _check(marks: list[str], location: str) -> None:
+        for mark in marks:
+            try:
+                # We only care whether the marker parses; constructing it would
+                # otherwise emit PytestUnknownMarkWarning for custom (unregistered)
+                # marks, which is noise during validation.
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore")
+                    make_marker(mark)
+            except (ValueError, SyntaxError) as e:
+                diagnostics.append(
+                    _diag(
+                        DiagnosticCode.INVALID_MARKER,
+                        "error",
+                        f"Invalid marker {mark!r}: {e}",
+                        location=location,
+                    )
+                )
+
+    _check(scenario.marks, "marks")
+    for i, stage in enumerate(scenario.stages):
+        _check(stage.marks, f"stages[{i}].marks")
+
+    return diagnostics
+
+
 # --------------------------------------------------------------------------- #
 # Deep (opt-in) validation: imports, signatures, referenced files.
 # These touch the filesystem and import user code, so they NEVER run at
@@ -829,6 +890,8 @@ def check_scenario(scenario: Scenario, test_data: dict[str, Any]) -> tuple[list[
 
     diagnostics.extend(_verify_diagnostics(scenario))
 
+    diagnostics.extend(_marker_diagnostics(scenario))
+
     scenario_info = ScenarioInfo(
         num_stages=len(scenario.stages),
         stage_names=stage_names,
@@ -919,7 +982,14 @@ def validate_scenario(
             root_path=root_path,
         )
     except ReferenceResolverError as e:
-        diagnostics.append(_diag(DiagnosticCode.REF_ERROR, "error", f"JSON reference resolution error: {e}"))
+        # The resolver wraps a plain JSON syntax error as a ReferenceResolverError
+        # (chaining the JSONDecodeError as __cause__). Report those under the
+        # accurate "Invalid JSON syntax" code rather than the $ref-flavored one,
+        # which would mislead when no reference is involved.
+        if isinstance(e.__cause__, json.JSONDecodeError):
+            diagnostics.append(_diag(DiagnosticCode.INVALID_JSON, "error", f"Invalid JSON syntax: {e.__cause__}"))
+        else:
+            diagnostics.append(_diag(DiagnosticCode.REF_ERROR, "error", f"JSON reference resolution error: {e}"))
         return _result(diagnostics)
     except json.JSONDecodeError as e:
         diagnostics.append(_diag(DiagnosticCode.INVALID_JSON, "error", f"Invalid JSON syntax: {e}"))