schemathesis 4.0.0a3__py3-none-any.whl → 4.0.0a4__py3-none-any.whl

schemathesis/pytest/plugin.py

@@ -149,11 +149,10 @@ class SchemathesisCase(PyCollector):
             error = result.err()
             funcobj = error.as_failing_test_function()
             name = self.name
-            # `full_path` is always available in this case
             if error.method:
-                name += f"[{error.method.upper()} {error.full_path}]"
+                name += f"[{error.method.upper()} {error.path}]"
             else:
-                name += f"[{error.full_path}]"
+                name += f"[{error.path}]"
 
         cls = self._get_class_parent()
         definition: FunctionDefinition = FunctionDefinition.from_parent(

schemathesis/schemas.py

@@ -619,7 +619,7 @@ class APIOperation(Generic[P]):
 
     def __post_init__(self) -> None:
         if self.label is None:
-            self.label = f"{self.method.upper()} {self.full_path}"  # type: ignore
+            self.label = f"{self.method.upper()} {self.path}"  # type: ignore
 
     @property
     def full_path(self) -> str:

schemathesis/specs/openapi/checks.py

@@ -41,11 +41,20 @@ if TYPE_CHECKING:
     from ...schemas import APIOperation
 
 
+def is_unexpected_http_status_case(case: Case) -> bool:
+    # Skip checks for requests using HTTP methods not defined in the API spec
+    return bool(
+        case.meta
+        and isinstance(case.meta.phase.data, CoveragePhaseData)
+        and case.meta.phase.data.description.startswith("Unspecified HTTP method")
+    )
+
+
 @schemathesis.check
 def status_code_conformance(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     responses = case.operation.definition.raw.get("responses", {})
     # "default" can be used as the default response object for all HTTP codes that are not covered individually
@@ -74,7 +83,7 @@ def _expand_responses(responses: dict[str | int, Any]) -> Generator[int, None, N
 def content_type_conformance(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     documented_content_types = case.operation.schema.get_content_types(case.operation, response)
     if not documented_content_types:
@@ -128,7 +137,7 @@ def response_headers_conformance(ctx: CheckContext, response: Response, case: Ca
     from .parameters import OpenAPI20Parameter, OpenAPI30Parameter
     from .schemas import BaseOpenAPISchema, OpenApi30, _maybe_raise_one_or_more
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     resolved = case.operation.schema.get_headers(case.operation, response)
     if not resolved:
@@ -208,7 +217,7 @@ def _coerce_header_value(value: str, schema: dict[str, Any]) -> str | int | floa
 def response_schema_conformance(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     return case.operation.validate_response(response)
 
@@ -217,7 +226,11 @@ def response_schema_conformance(ctx: CheckContext, response: Response, case: Cas
 def negative_data_rejection(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema) or case.meta is None:
+    if (
+        not isinstance(case.operation.schema, BaseOpenAPISchema)
+        or case.meta is None
+        or is_unexpected_http_status_case(case)
+    ):
         return True
 
     config = ctx.config.get(negative_data_rejection, NegativeDataRejectionConfig())
@@ -241,7 +254,11 @@ def negative_data_rejection(ctx: CheckContext, response: Response, case: Case) -
 def positive_data_acceptance(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema) or case.meta is None:
+    if (
+        not isinstance(case.operation.schema, BaseOpenAPISchema)
+        or case.meta is None
+        or is_unexpected_http_status_case(case)
+    ):
         return True
 
     config = ctx.config.get(positive_data_acceptance, PositiveDataAcceptanceConfig())
@@ -260,7 +277,7 @@ def positive_data_acceptance(ctx: CheckContext, response: Response, case: Case)
 def missing_required_header(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     # NOTE: This check is intentionally not registered with `@schemathesis.check` because it is experimental
     meta = case.meta
-    if meta is None or not isinstance(meta.phase.data, CoveragePhaseData):
+    if meta is None or not isinstance(meta.phase.data, CoveragePhaseData) or is_unexpected_http_status_case(case):
         return None
     data = meta.phase.data
     if (
@@ -332,7 +349,7 @@ def has_only_additional_properties_in_non_body_parameters(case: Case) -> bool:
 def use_after_free(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     if response.status_code == 404 or response.status_code >= 500:
         return None
@@ -373,7 +390,7 @@ def use_after_free(ctx: CheckContext, response: Response, case: Case) -> bool |
 def ensure_resource_availability(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
 
     # First, check if this is a 4XX response
@@ -453,7 +470,7 @@ def ignored_auth(ctx: CheckContext, response: Response, case: Case) -> bool | No
     """Check if an operation declares authentication as a requirement but does not actually enforce it."""
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
     security_parameters = _get_security_parameters(case.operation)
     # Authentication is required for this API operation and response is successful

schemathesis/specs/openapi/expressions/__init__.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 import json
 from typing import Any
 
+from schemathesis.core.transforms import UNRESOLVABLE, Unresolvable
 from schemathesis.generation.stateful.state_machine import StepOutput
 
 from . import lexer, nodes, parser
@@ -25,21 +26,36 @@ def evaluate(expr: Any, output: StepOutput, evaluate_nested: bool = False) -> An
     parts = [node.evaluate(output) for node in parser.parse(expr)]
     if len(parts) == 1:
         return parts[0]  # keep the return type the same as the internal value type
-    # otherwise, concatenate into a string
+    if any(isinstance(part, Unresolvable) for part in parts):
+        return UNRESOLVABLE
     return "".join(str(part) for part in parts if part is not None)
 
 
 def _evaluate_nested(expr: dict[str, Any] | list, output: StepOutput) -> Any:
     if isinstance(expr, dict):
-        return {
-            _evaluate_object_key(key, output): evaluate(value, output, evaluate_nested=True)
-            for key, value in expr.items()
-        }
-    return [evaluate(item, output, evaluate_nested=True) for item in expr]
+        result_dict = {}
+        for key, value in expr.items():
+            new_key = _evaluate_object_key(key, output)
+            if new_key is UNRESOLVABLE:
+                return new_key
+            new_value = evaluate(value, output, evaluate_nested=True)
+            if new_value is UNRESOLVABLE:
+                return new_value
+            result_dict[new_key] = new_value
+        return result_dict
+    result_list = []
+    for item in expr:
+        new_value = evaluate(item, output, evaluate_nested=True)
+        if new_value is UNRESOLVABLE:
+            return new_value
+        result_list.append(new_value)
+    return result_list
 
 
 def _evaluate_object_key(key: str, output: StepOutput) -> Any:
     evaluated = evaluate(key, output)
+    if evaluated is UNRESOLVABLE:
+        return evaluated
     if isinstance(evaluated, str):
         return evaluated
     if isinstance(evaluated, bool):

schemathesis/specs/openapi/expressions/nodes.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Any, cast
 
 from requests.structures import CaseInsensitiveDict
 
-from schemathesis.core.transforms import UNRESOLVABLE, resolve_pointer
+from schemathesis.core.transforms import UNRESOLVABLE, Unresolvable, resolve_pointer
 from schemathesis.generation.stateful.state_machine import StepOutput
 from schemathesis.transport.requests import REQUESTS_TRANSPORT
 
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 class Node:
     """Generic expression node."""
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         raise NotImplementedError
 
 
@@ -39,7 +39,7 @@ class String(Node):
 
     value: str
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         """String tokens are passed as they are.
 
         ``foo{$request.path.id}``
@@ -53,7 +53,7 @@ class String(Node):
 class URL(Node):
     """A node for `$url` expression."""
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         import requests
 
         base_url = output.case.operation.base_url or "http://127.0.0.1"
@@ -66,7 +66,7 @@ class URL(Node):
 class Method(Node):
     """A node for `$method` expression."""
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         return output.case.operation.method.upper()
 
 
@@ -74,7 +74,7 @@ class Method(Node):
 class StatusCode(Node):
     """A node for `$statusCode` expression."""
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         return str(output.response.status_code)
 
 
@@ -86,7 +86,7 @@ class NonBodyRequest(Node):
     parameter: str
     extractor: Extractor | None = None
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         container: dict | CaseInsensitiveDict = {
             "query": output.case.query,
             "path": output.case.path_parameters,
@@ -96,9 +96,9 @@ class NonBodyRequest(Node):
             container = CaseInsensitiveDict(container)
         value = container.get(self.parameter)
         if value is None:
-            return ""
+            return UNRESOLVABLE
         if self.extractor is not None:
-            return self.extractor.extract(value) or ""
+            return self.extractor.extract(value) or UNRESOLVABLE
         return value
 
 
@@ -108,14 +108,11 @@ class BodyRequest(Node):
 
     pointer: str | None = None
 
-    def evaluate(self, output: StepOutput) -> Any:
+    def evaluate(self, output: StepOutput) -> Any | Unresolvable:
         document = output.case.body
         if self.pointer is None:
             return document
-        resolved = resolve_pointer(document, self.pointer[1:])
-        if resolved is UNRESOLVABLE:
-            return None
-        return resolved
+        return resolve_pointer(document, self.pointer[1:])
 
 
 @dataclass
@@ -125,12 +122,12 @@ class HeaderResponse(Node):
     parameter: str
     extractor: Extractor | None = None
 
-    def evaluate(self, output: StepOutput) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         value = output.response.headers.get(self.parameter.lower())
         if value is None:
-            return ""
+            return UNRESOLVABLE
         if self.extractor is not None:
-            return self.extractor.extract(value[0]) or ""
+            return self.extractor.extract(value[0]) or UNRESOLVABLE
         return value[0]
 
 
@@ -145,7 +142,4 @@ class BodyResponse(Node):
         if self.pointer is None:
             # We need the parsed document - data will be serialized before sending to the application
             return document
-        resolved = resolve_pointer(document, self.pointer[1:])
-        if resolved is UNRESOLVABLE:
-            return None
-        return resolved
+        return resolve_pointer(document, self.pointer[1:])

schemathesis/specs/openapi/expressions/parser.py

@@ -46,7 +46,7 @@ def _parse_variable(tokens: lexer.TokenGenerator, token: lexer.Token, expr: str)
     elif token.value == nodes.NodeType.RESPONSE.value:
         yield _parse_response(tokens, expr)
     else:
-        raise UnknownToken(token.value)
+        raise UnknownToken(f"Invalid expression `{expr}`. Unknown token: `{token.value}`")
 
 
 def _parse_request(tokens: lexer.TokenGenerator, expr: str) -> nodes.BodyRequest | nodes.NonBodyRequest:

schemathesis/specs/openapi/parameters.py

@@ -376,7 +376,6 @@ def get_parameter_schema(operation: APIOperation, data: dict[str, Any]) -> dict[
                 ),
                 path=operation.path,
                 method=operation.method,
-                full_path=operation.full_path,
             )
         return data["schema"]
     # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#fixed-fields-10
@@ -388,7 +387,6 @@ def get_parameter_schema(operation: APIOperation, data: dict[str, Any]) -> dict[
             MISSING_SCHEMA_OR_CONTENT_MESSAGE.format(location=data.get("in", ""), name=data.get("name", "<UNKNOWN>")),
             path=operation.path,
             method=operation.method,
-            full_path=operation.full_path,
         ) from exc
     options = iter(content.values())
     media_type_object = next(options)

schemathesis/specs/openapi/schemas.py

@@ -41,11 +41,12 @@ from schemathesis.generation.case import Case
 from schemathesis.generation.meta import CaseMetadata
 from schemathesis.generation.overrides import Override, OverrideMark, check_no_override_mark
 from schemathesis.openapi.checks import JsonSchemaError, MissingContentType
+from schemathesis.specs.openapi.stateful import links
 
 from ...generation import GenerationConfig, GenerationMode
 from ...hooks import HookContext, HookDispatcher
 from ...schemas import APIOperation, APIOperationMap, ApiStatistic, BaseSchema, OperationDefinition
-from . import links, serialization
+from . import serialization
 from ._cache import OperationCache
 from ._hypothesis import openapi_cases
 from .converter import to_json_schema, to_json_schema_recursive
@@ -155,7 +156,6 @@ class BaseOpenAPISchema(BaseSchema):
             return True
         if self.filter_set.is_empty():
             return False
-        path = self.get_full_path(path)
         # Attribute assignment is way faster than creating a new namespace every time
         operation = _ctx_cache.operation
         operation.method = method
@@ -365,28 +365,24 @@ class BaseOpenAPISchema(BaseSchema):
     def _into_err(self, error: Exception, path: str | None, method: str | None) -> Err[InvalidSchema]:
         __tracebackhide__ = True
         try:
-            full_path = self.get_full_path(path) if isinstance(path, str) else None
-            self._raise_invalid_schema(error, full_path, path, method)
+            self._raise_invalid_schema(error, path, method)
         except InvalidSchema as exc:
             return Err(exc)
 
     def _raise_invalid_schema(
         self,
         error: Exception,
-        full_path: str | None = None,
         path: str | None = None,
         method: str | None = None,
     ) -> NoReturn:
         __tracebackhide__ = True
         if isinstance(error, RefResolutionError):
-            raise InvalidSchema.from_reference_resolution_error(
-                error, path=path, method=method, full_path=full_path
-            ) from None
+            raise InvalidSchema.from_reference_resolution_error(error, path=path, method=method) from None
         try:
             self.validate()
         except jsonschema.ValidationError as exc:
-            raise InvalidSchema.from_jsonschema_error(exc, path=path, method=method, full_path=full_path) from None
-        raise InvalidSchema(SCHEMA_ERROR_MESSAGE, path=path, method=method, full_path=full_path) from error
+            raise InvalidSchema.from_jsonschema_error(exc, path=path, method=method) from None
+        raise InvalidSchema(SCHEMA_ERROR_MESSAGE, path=path, method=method) from error
 
     def validate(self) -> None:
         with suppress(TypeError):
@@ -584,8 +580,7 @@ class BaseOpenAPISchema(BaseSchema):
             responses = operation.definition.raw["responses"]
         except KeyError as exc:
             path = operation.path
-            full_path = self.get_full_path(path) if isinstance(path, str) else None
-            self._raise_invalid_schema(exc, full_path, path, operation.method)
+            self._raise_invalid_schema(exc, path, operation.method)
         status_code = str(response.status_code)
         if status_code in responses:
             return self.resolver.resolve_in_scope(responses[status_code], operation.definition.scope)
@@ -654,7 +649,12 @@ class BaseOpenAPISchema(BaseSchema):
     def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
         result: dict[str, dict[str, Any]] = defaultdict(dict)
         for status_code, link in links.get_all_links(operation):
-            result[status_code][link.name] = link
+            if isinstance(link, Ok):
+                name = link.ok().name
+            else:
+                name = link.err().name
+            result[status_code][name] = link
+
         return result
 
     def get_tags(self, operation: APIOperation) -> list[str] | None:

schemathesis/specs/openapi/stateful/__init__.py

@@ -7,15 +7,17 @@ from typing import TYPE_CHECKING, Any, Callable, Iterator
 from hypothesis import strategies as st
 from hypothesis.stateful import Bundle, Rule, precondition, rule
 
+from schemathesis.core.errors import InvalidStateMachine
 from schemathesis.core.result import Ok
+from schemathesis.core.transforms import UNRESOLVABLE
 from schemathesis.engine.recorder import ScenarioRecorder
 from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import strategies
 from schemathesis.generation.stateful.state_machine import APIStateMachine, StepInput, StepOutput, _normalize_name
 from schemathesis.schemas import APIOperation
-from schemathesis.specs.openapi.links import OpenApiLink, get_all_links
 from schemathesis.specs.openapi.stateful.control import TransitionController
+from schemathesis.specs.openapi.stateful.links import OpenApiLink, get_all_links
 from schemathesis.specs.openapi.utils import expand_status_code
 
 if TYPE_CHECKING:
@@ -72,15 +74,35 @@ class ApiTransitions:
         self.operations.setdefault(link.target.label, OperationTransitions()).incoming.append(link)
 
 
+@dataclass
+class RootTransitions:
+    """Classification of API operations that can serve as entry points."""
+
+    __slots__ = ("reliable", "fallback")
+
+    def __init__(self) -> None:
+        # Operations likely to succeed and provide data for other transitions
+        self.reliable: set[str] = set()
+        # Operations that might work but are less reliable
+        self.fallback: set[str] = set()
+
+
 def collect_transitions(operations: list[APIOperation]) -> ApiTransitions:
     """Collect all transitions between operations."""
     transitions = ApiTransitions()
 
     selected_labels = {operation.label for operation in operations}
+    errors = []
     for operation in operations:
         for _, link in get_all_links(operation):
-            if link.target.label in selected_labels:
-                transitions.add_outgoing(operation.label, link)
+            if isinstance(link, Ok):
+                if link.ok().target.label in selected_labels:
+                    transitions.add_outgoing(operation.label, link.ok())
+            else:
+                errors.append(link.err())
+
+    if errors:
+        raise InvalidStateMachine(errors)
 
     return transitions
 
@@ -109,15 +131,37 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
     rules = {}
     catch_all = Bundle("catch_all")
 
+    # We want stateful testing to be effective and focus on meaningful transitions.
+    # An operation is considered as a "root" transition (entry point) if it satisfies certain criteria
+    # that indicate it's likely to succeed and provide data for other transitions.
+    # For example:
+    #   - POST operations that create resources
+    #   - GET operations without path parameters (e.g., GET /users/ to list all users)
+    #
+    # We avoid adding operations as roots if they:
+    #   1. Have incoming transitions that will provide proper data
+    #      Example: If POST /users/ -> GET /users/{id} exists, we don't need
+    #      to generate random user IDs for GET /users/{id}
+    #   2. Are unlikely to succeed with random data
+    #      Example: GET /users/{id} with random ID is likely to return 404
+    #
+    # This way we:
+    #   1. Maximize the chance of successful transitions
+    #   2. Don't waste the test budget (limited number of steps) on likely-to-fail operations
+    #   3. Focus on transitions that are designed to work together via links
+
+    roots = classify_root_transitions(operations, transitions)
+
     for target in operations:
         if target.label in transitions.operations:
             incoming = transitions.operations[target.label].incoming
             if incoming:
                 for link in incoming:
                     bundle_name = f"{link.source.label} -> {link.status_code}"
-                    name = _normalize_name(f"{link.status_code} -> {target.label}")
-                    name = _normalize_name(f"{link.source.label} -> {link.status_code} -> {target.label}")
-                    assert name not in rules
+                    name = _normalize_name(
+                        f"{link.source.label} -> {link.status_code} -> {link.name} -> {target.label}"
+                    )
+                    assert name not in rules, name
                     rules[name] = precondition(is_transition_allowed(bundle_name, link.source.label, target.label))(
                         transition(
                             name=name,
@@ -127,13 +171,8 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
                             ),
                         )
                     )
-            if transitions.operations[target.label].outgoing and target.method == "post":
-                # Allow POST methods for operations with outgoing transitions.
-                # This approach also includes cases when there is an incoming transition back to POST
-                # For example, POST /users/ -> GET /users/{id}/
-                # The source operation has no prerequisite, but we need to allow this rule to be executed
-                # in order to reach other transitions
-                name = _normalize_name(f"{target.label} -> X")
+            if target.label in roots.reliable or (not roots.reliable and target.label in roots.fallback):
+                name = _normalize_name(f"RANDOM -> {target.label}")
                 if len(schema.generation_config.modes) == 1:
                     case_strategy = target.as_strategy(generation_mode=schema.generation_config.modes[0])
                 else:
@@ -168,41 +207,75 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
     )
 
 
+def classify_root_transitions(operations: list[APIOperation], transitions: ApiTransitions) -> RootTransitions:
+    """Find operations that can serve as root transitions."""
+    roots = RootTransitions()
+
+    for operation in operations:
+        # Skip if operation has no outgoing transitions
+        operation_transitions = transitions.operations.get(operation.label)
+        if not operation_transitions or not operation_transitions.outgoing:
+            continue
+
+        if is_likely_root_transition(operation, operation_transitions):
+            roots.reliable.add(operation.label)
+        else:
+            roots.fallback.add(operation.label)
+
+    return roots
+
+
+def is_likely_root_transition(operation: APIOperation, transitions: OperationTransitions) -> bool:
+    """Check if operation is likely to succeed as a root transition."""
+    # POST operations with request bodies are likely to create resources
+    if operation.method == "post" and operation.body:
+        return True
+
+    # GET operations without path parameters are likely to return lists
+    if operation.method == "get" and not operation.path_parameters:
+        return True
+
+    return False
+
+
 def into_step_input(
     target: APIOperation, link: OpenApiLink, modes: list[GenerationMode]
 ) -> Callable[[StepOutput], st.SearchStrategy[StepInput]]:
     def builder(_output: StepOutput) -> st.SearchStrategy[StepInput]:
         @st.composite  # type: ignore[misc]
         def inner(draw: st.DrawFn, output: StepOutput) -> StepInput:
-            transition_data = link.extract(output)
+            transition = link.extract(output)
 
             kwargs: dict[str, Any] = {
                 container: {
                     name: extracted.value.ok()
                     for name, extracted in data.items()
-                    if isinstance(extracted.value, Ok) and extracted.value.ok() is not None
+                    if isinstance(extracted.value, Ok) and extracted.value.ok() not in (None, UNRESOLVABLE)
                 }
-                for container, data in transition_data.parameters.items()
+                for container, data in transition.parameters.items()
             }
+
             if (
-                transition_data.request_body is not None
-                and isinstance(transition_data.request_body.value, Ok)
+                transition.request_body is not None
+                and isinstance(transition.request_body.value, Ok)
+                and transition.request_body.value.ok() is not UNRESOLVABLE
                 and not link.merge_body
             ):
-                kwargs["body"] = transition_data.request_body.value.ok()
+                kwargs["body"] = transition.request_body.value.ok()
             cases = strategies.combine([target.as_strategy(generation_mode=mode, **kwargs) for mode in modes])
             case = draw(cases)
             if (
-                transition_data.request_body is not None
-                and isinstance(transition_data.request_body.value, Ok)
+                transition.request_body is not None
+                and isinstance(transition.request_body.value, Ok)
+                and transition.request_body.value.ok() is not UNRESOLVABLE
                 and link.merge_body
             ):
-                new = transition_data.request_body.value.ok()
+                new = transition.request_body.value.ok()
                 if isinstance(case.body, dict) and isinstance(new, dict):
                     case.body = {**case.body, **new}
                 else:
                     case.body = new
-            return StepInput(case=case, transition=transition_data)
+            return StepInput(case=case, transition=transition)
 
         return inner(output=_output)