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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-httpchain
-Version: 0.5.0
+Version: 0.6.0
 Summary: pytest plugin for HTTP testing using JSON files
 Keywords: testing,pytest,requests
 Author: Alexander Eresov

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

@@ -1,6 +1,6 @@
 [project]
 name = "pytest-httpchain"
-version = "0.5.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.5.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.5.0 → pytest_httpchain-0.6.0}/src/pytest_httpchain/dataflow.py

@@ -14,6 +14,7 @@ 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,
@@ -58,11 +59,15 @@ def analyze_dataflow(scenario: Scenario, test_data: dict[str, Any]) -> DataFlow:
 
     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 fixtures). ``parametrize``
-    values are excluded — they resolve against scenario scope, never saved values.
+    (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):
@@ -80,9 +85,17 @@ def analyze_dataflow(scenario: Scenario, test_data: dict[str, Any]) -> DataFlow:
         for key in ("request", "response", "substitutions", "parallel"):
             extract_template_variables(raw.get(key), refs)
 
-        local = stage_defined_names(stage)
+        # 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)
@@ -104,12 +117,9 @@ def analyze_dataflow(scenario: Scenario, test_data: dict[str, Any]) -> DataFlow:
 
         cumulative_saves |= saves_by_stage[i]
 
-    scenario_fixtures = sorted(f for f in test_data["fixtures"] if isinstance(f, str)) if isinstance(test_data.get("fixtures"), list) else []
     scenario_var_names = set(substitution_names(scenario.substitutions))
-    if isinstance(test_data.get("vars"), dict):
-        scenario_var_names |= {k for k in test_data["vars"] if isinstance(k, str)}
 
-    return DataFlow(stages=stages, edges=edges, scenario_fixtures=scenario_fixtures, scenario_vars=sorted(scenario_var_names))
+    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]]:

{pytest_httpchain-0.5.0 → pytest_httpchain-0.6.0}/src/pytest_httpchain/schema.py

@@ -14,6 +14,18 @@ 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.
 
@@ -37,10 +49,28 @@ def _add_jsonref_support(schema: dict[str, Any]) -> dict[str, Any]:
                 "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
@@ -58,6 +88,23 @@ def _add_jsonref_support(schema: dict[str, Any]) -> dict[str, Any]:
         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
 
 

{pytest_httpchain-0.5.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"
@@ -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,10 +236,6 @@ 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)
 
     for stage in scenario.stages:
@@ -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
@@ -309,14 +312,9 @@ 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)
 
     raws = raw_stages(test_data)
     cumulative_saves: set[str] = set()
@@ -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