schemathesis 3.15.4__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/specs/openapi/stateful/links.py

@@ -1,80 +1,221 @@
-from typing import TYPE_CHECKING, Callable, Dict, List, Tuple
-
-import hypothesis.strategies as st
-from requests.structures import CaseInsensitiveDict
-
-from ....stateful import StepResult
-from ..links import OpenAPILink, get_all_links
-from ..utils import expand_status_code
-
-if TYPE_CHECKING:
-    from ....models import APIOperation
-
-FilterFunction = Callable[[StepResult], bool]
-
-
-def apply(
-    operation: "APIOperation",
-    bundles: Dict[str, CaseInsensitiveDict],
-    connections: Dict[str, List[st.SearchStrategy[Tuple[StepResult, OpenAPILink]]]],
-) -> None:
-    """Gather all connections based on Open API links definitions."""
-    all_status_codes = list(operation.definition.resolved["responses"])
-    for status_code, link in get_all_links(operation):
-        target_operation = link.get_target_operation()
-        strategy = bundles[operation.path][operation.method.upper()].filter(
-            make_response_filter(status_code, all_status_codes)
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import Any, Callable
+
+from schemathesis.core import NOT_SET, NotSet
+from schemathesis.core.errors import InvalidTransition, OperationNotFound, TransitionValidationError, format_transition
+from schemathesis.core.parameters import ParameterLocation
+from schemathesis.core.result import Err, Ok, Result
+from schemathesis.generation.stateful.state_machine import ExtractedParam, StepOutput, Transition
+from schemathesis.schemas import APIOperation
+from schemathesis.specs.openapi import expressions
+
+SCHEMATHESIS_LINK_EXTENSION = "x-schemathesis"
+
+
+@dataclass
+class NormalizedParameter:
+    """Processed link parameter with resolved container information."""
+
+    location: ParameterLocation | None
+    name: str
+    expression: str
+    container_name: str
+    is_required: bool
+
+    __slots__ = ("location", "name", "expression", "container_name", "is_required")
+
+
+@dataclass(repr=False)
+class OpenApiLink:
+    """Represents an OpenAPI link between operations."""
+
+    name: str
+    status_code: str
+    source: APIOperation
+    target: APIOperation
+    parameters: list[NormalizedParameter]
+    body: dict[str, Any] | NotSet
+    merge_body: bool
+    is_inferred: bool
+
+    __slots__ = (
+        "name",
+        "status_code",
+        "source",
+        "target",
+        "parameters",
+        "body",
+        "merge_body",
+        "is_inferred",
+        "_cached_extract",
+    )
+
+    def __init__(self, name: str, status_code: str, definition: dict[str, Any], source: APIOperation):
+        from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+
+        self.name = name
+        self.status_code = status_code
+        self.source = source
+        assert isinstance(source.schema, BaseOpenAPISchema)
+        errors = []
+
+        get_operation: Callable[[str], APIOperation]
+        if "operationId" in definition:
+            operation_reference = definition["operationId"]
+            get_operation = source.schema.find_operation_by_id
+        else:
+            operation_reference = definition["operationRef"]
+            get_operation = source.schema.find_operation_by_reference
+
+        try:
+            self.target = get_operation(operation_reference)
+            target = self.target.label
+        except OperationNotFound:
+            target = operation_reference
+            errors.append(TransitionValidationError(f"Operation '{operation_reference}' not found"))
+
+        extension = definition.get(SCHEMATHESIS_LINK_EXTENSION)
+        self.parameters = self._normalize_parameters(definition.get("parameters", {}), errors)
+        self.body = definition.get("requestBody", NOT_SET)
+        self.merge_body = extension.get("merge_body", True) if extension else True
+        self.is_inferred = extension.get("is_inferred", False) if extension else False
+
+        if errors:
+            raise InvalidTransition(
+                name=self.name,
+                source=self.source.label,
+                target=target,
+                status_code=self.status_code,
+                errors=errors,
+            )
+
+        self._cached_extract = lru_cache(8)(self._extract_impl)
+
+    @property
+    def full_name(self) -> str:
+        return format_transition(self.source.label, self.status_code, self.name, self.target.label)
+
+    def _normalize_parameters(
+        self, parameters: dict[str, str], errors: list[TransitionValidationError]
+    ) -> list[NormalizedParameter]:
+        """Process link parameters and resolve their container locations.
+
+        Handles both explicit locations (e.g., "path.id") and implicit ones resolved from target operation.
+        """
+        result = []
+        for parameter, expression in parameters.items():
+            location: ParameterLocation | None
+            try:
+                # The parameter name is prefixed with its location. Example: `path.id`
+                _location, name = tuple(parameter.split("."))
+                location = ParameterLocation(_location)
+            except ValueError:
+                location = None
+                name = parameter
+
+            if isinstance(expression, str):
+                try:
+                    parsed = expressions.parser.parse(expression)
+                    # Find NonBodyRequest nodes that reference source parameters
+                    for node in parsed:
+                        if isinstance(node, expressions.nodes.NonBodyRequest):
+                            # Check if parameter exists in source operation
+                            if not any(
+                                p.name == node.parameter and p.location == node.location
+                                for p in self.source.iter_parameters()
+                            ):
+                                errors.append(
+                                    TransitionValidationError(
+                                        f"Expression `{expression}` references non-existent {node.location} parameter "
+                                        f"`{node.parameter}` in `{self.source.label}`"
+                                    )
+                                )
+                except Exception as exc:
+                    errors.append(TransitionValidationError(str(exc)))
+
+            is_required = False
+            if hasattr(self, "target"):
+                try:
+                    container_name = self._get_parameter_container(location, name)
+                except TransitionValidationError as exc:
+                    errors.append(exc)
+                    continue
+
+                for param in self.target.iter_parameters():
+                    if param.name == name:
+                        is_required = param.is_required
+                        break
+            else:
+                continue
+            result.append(NormalizedParameter(location, name, expression, container_name, is_required=is_required))
+        return result
+
+    def _get_parameter_container(self, location: ParameterLocation | None, name: str) -> str:
+        """Resolve parameter container either from explicit location or by looking up in target operation."""
+        if location:
+            return location.container_name
+
+        for param in self.target.iter_parameters():
+            if param.name == name:
+                return param.location.container_name
+        raise TransitionValidationError(f"Parameter `{name}` is not defined in API operation `{self.target.label}`")
+
+    def extract(self, output: StepOutput) -> Transition:
+        return self._cached_extract(StepOutputWrapper(output))
+
+    def _extract_impl(self, wrapper: StepOutputWrapper) -> Transition:
+        output = wrapper.output
+        return Transition(
+            id=self.full_name,
+            parent_id=output.case.id,
+            is_inferred=self.is_inferred,
+            parameters=self.extract_parameters(output),
+            request_body=self.extract_body(output),
         )
-        connections[target_operation.verbose_name].append(_convert_strategy(strategy, link))
-
-
-def _convert_strategy(
-    strategy: st.SearchStrategy[StepResult], link: OpenAPILink
-) -> st.SearchStrategy[Tuple[StepResult, OpenAPILink]]:
-    # This function is required to capture values properly (it won't work properly when lambda is defined in a loop)
-    return strategy.map(lambda out: (out, link))
-
-
-def make_response_filter(status_code: str, all_status_codes: List[str]) -> FilterFunction:
-    """Create a filter for stored responses.
-
-    This filter will decide whether some response is suitable to use as a source for requesting some API operation.
-    """
-    if status_code == "default":
-        return default_status_code(all_status_codes)
-    return match_status_code(status_code)
-
-
-def match_status_code(status_code: str) -> FilterFunction:
-    """Create a filter function that matches all responses with the given status code.
-
-    Note that the status code can contain "X", which means any digit.
-    For example, 50X will match all status codes from 500 to 509.
-    """
-    status_codes = set(expand_status_code(status_code))
-
-    def compare(result: StepResult) -> bool:
-        return result.response.status_code in status_codes
-
-    # This name is displayed in the resulting strategy representation. For example, if you run your tests with
-    # `--hypothesis-show-statistics`, then you can see `Bundle(name='GET /users/{user_id}').filter(match_200_response)`
-    # which gives you information about the particularly used filter.
-    compare.__name__ = f"match_{status_code}_response"
-
-    return compare
-
-
-def default_status_code(status_codes: List[str]) -> FilterFunction:
-    """Create a filter that matches all "default" responses.
-
-    In Open API, the "default" response is the one that is used if no other options were matched.
-    Therefore we need to match only responses that were not matched by other listed status codes.
-    """
-    expanded_status_codes = {
-        status_code for value in status_codes if value != "default" for status_code in expand_status_code(value)
-    }
-
-    def match_default_response(result: StepResult) -> bool:
-        return result.response.status_code not in expanded_status_codes
 
-    return match_default_response
+    def extract_parameters(self, output: StepOutput) -> dict[str, dict[str, ExtractedParam]]:
+        """Extract parameters using runtime expressions.
+
+        Returns a two-level dictionary: container -> parameter name -> extracted value
+        """
+        extracted: dict[str, dict[str, ExtractedParam]] = {}
+        for parameter in self.parameters:
+            container = extracted.setdefault(parameter.container_name, {})
+            value: Result[Any, Exception]
+            try:
+                value = Ok(expressions.evaluate(parameter.expression, output))
+            except Exception as exc:
+                value = Err(exc)
+            container[parameter.name] = ExtractedParam(
+                definition=parameter.expression, value=value, is_required=parameter.is_required
+            )
+        return extracted
+
+    def extract_body(self, output: StepOutput) -> ExtractedParam | None:
+        if not isinstance(self.body, NotSet):
+            value: Result[Any, Exception]
+            try:
+                value = Ok(expressions.evaluate(self.body, output, evaluate_nested=True))
+            except Exception as exc:
+                value = Err(exc)
+            return ExtractedParam(definition=self.body, value=value, is_required=True)
+        return None
+
+
+@dataclass
+class StepOutputWrapper:
+    """Wrapper for StepOutput that uses only case_id for hash-based caching."""
+
+    output: StepOutput
+
+    __slots__ = ("output",)
+
+    def __hash__(self) -> int:
+        return hash(self.output.case.id)
+
+    def __eq__(self, other: object) -> bool:
+        assert isinstance(other, StepOutputWrapper)
+        return self.output.case.id == other.output.case.id

schemathesis/specs/openapi/types/__init__.py

@@ -0,0 +1,3 @@
+from schemathesis.specs.openapi.types import common, v2, v3
+
+__all__ = ["common", "v2", "v3"]

schemathesis/specs/openapi/types/common.py

@@ -0,0 +1,23 @@
+"""Common type definitions shared across OpenAPI versions."""
+
+from __future__ import annotations
+
+from typing import Any, Mapping, Union
+
+from typing_extensions import NotRequired, TypeAlias, TypedDict
+
+Reference = TypedDict("Reference", {"$ref": str})
+"""JSON Reference object with $ref key."""
+
+SchemaObject = TypedDict("SchemaObject", {"$ref": str})
+"""Schema object that may be a reference."""
+
+_SecurityTypeKey = TypedDict("_SecurityTypeKey", {"x-original-security-type": NotRequired[str]})
+"""Type for x-original-security-type extension added by Schemathesis."""
+
+# Type aliases for commonly used patterns
+Schema: TypeAlias = Union[SchemaObject, bool]
+"""JSON Schema can be an object or boolean."""
+
+SchemaOrRef: TypeAlias = Union[Mapping[str, Any], Reference]
+"""Schema definition that may be a reference or inline object."""

schemathesis/specs/openapi/types/v2.py

@@ -0,0 +1,129 @@
+"""Swagger 2.0 type definitions."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Mapping, Union
+
+from typing_extensions import NotRequired, TypeAlias, TypedDict
+
+from schemathesis.specs.openapi.types.common import Reference, SchemaOrRef, _SecurityTypeKey
+
+
+class BodyParameter(TypedDict):
+    """Swagger 2.0 body parameter."""
+
+    name: str
+    description: NotRequired[str]
+    required: NotRequired[bool]
+    schema: SchemaOrRef
+
+
+_BodyParameterIn = TypedDict("_BodyParameterIn", {"in": Literal["body"]})
+
+
+class BodyParameterWithIn(BodyParameter, _BodyParameterIn):
+    """Body parameter with 'in' field."""
+
+    pass
+
+
+class NonBodyParameter(TypedDict):
+    """Swagger 2.0 non-body parameter (path/query/header/formData)."""
+
+    name: str
+    description: NotRequired[str]
+    required: NotRequired[bool]
+    type: NotRequired[Literal["string", "number", "integer", "boolean", "array", "file"]]
+    format: NotRequired[str]
+    items: NotRequired[SchemaOrRef]
+    collectionFormat: NotRequired[Literal["csv", "ssv", "tsv", "pipes"]]
+    default: NotRequired[Any]
+    maximum: NotRequired[float]
+    exclusiveMaximum: NotRequired[bool]
+    minimum: NotRequired[float]
+    exclusiveMinimum: NotRequired[bool]
+    maxLength: NotRequired[int]
+    minLength: NotRequired[int]
+    pattern: NotRequired[str]
+    maxItems: NotRequired[int]
+    minItems: NotRequired[int]
+    uniqueItems: NotRequired[bool]
+    enum: NotRequired[list[Any]]
+    multipleOf: NotRequired[float]
+
+
+_NonBodyParameterIn = TypedDict("_NonBodyParameterIn", {"in": Literal["path", "query", "header", "formData"]})
+
+
+class NonBodyParameterWithIn(NonBodyParameter, _NonBodyParameterIn):
+    """Non-body parameter with 'in' field."""
+
+    pass
+
+
+Parameter: TypeAlias = Union[BodyParameterWithIn, NonBodyParameterWithIn, Reference]
+"""Swagger 2.0 parameter (body, non-body, or reference)."""
+
+
+class Header(TypedDict):
+    """Swagger 2.0 response header."""
+
+    type: Literal["string", "number", "integer", "boolean", "array"]
+    description: NotRequired[str]
+    format: NotRequired[str]
+    items: NotRequired[SchemaOrRef]
+    collectionFormat: NotRequired[Literal["csv", "ssv", "tsv", "pipes"]]
+    default: NotRequired[Any]
+    maximum: NotRequired[float]
+    exclusiveMaximum: NotRequired[bool]
+    minimum: NotRequired[float]
+    exclusiveMinimum: NotRequired[bool]
+    maxLength: NotRequired[int]
+    minLength: NotRequired[int]
+    pattern: NotRequired[str]
+    maxItems: NotRequired[int]
+    minItems: NotRequired[int]
+    uniqueItems: NotRequired[bool]
+    enum: NotRequired[list[Any]]
+    multipleOf: NotRequired[float]
+
+
+HeaderOrRef: TypeAlias = Union[Header, Reference]
+"""Header definition or reference."""
+
+Headers: TypeAlias = Mapping[str, HeaderOrRef]
+"""Mapping from header name to header definition."""
+
+
+class Response(TypedDict):
+    """Swagger 2.0 response object."""
+
+    description: str
+    schema: NotRequired[SchemaOrRef]
+    headers: NotRequired[dict[str, HeaderOrRef]]
+    examples: NotRequired[dict[str, Any]]
+
+
+ResponseOrRef: TypeAlias = Union[Response, Reference]
+"""Response definition or reference."""
+
+Responses: TypeAlias = Mapping[str, ResponseOrRef]
+"""Mapping from status code to response definition."""
+
+
+class Operation(TypedDict):
+    responses: Responses
+    parameters: NotRequired[list[Parameter]]
+    consumes: NotRequired[list[str]]
+    produces: NotRequired[list[str]]
+
+
+# Security parameter types
+class SecurityParameter(NonBodyParameter, _SecurityTypeKey):
+    """Swagger 2.0 synthetic security parameter.
+
+    Created from security definitions (apiKey or basic auth).
+    Follows the same structure as NonBodyParameter since v2 has inline types.
+    """
+
+    pass

schemathesis/specs/openapi/types/v3.py

@@ -0,0 +1,134 @@
+"""OpenAPI 3.0 and 3.1 type definitions."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Mapping, Union
+
+from typing_extensions import NotRequired, TypeAlias, TypedDict
+
+from schemathesis.specs.openapi.types.common import Reference, SchemaOrRef, _SecurityTypeKey
+
+
+class Example(TypedDict):
+    value: NotRequired[Any]
+    externalValue: NotRequired[str]
+
+
+class MediaType(TypedDict):
+    schema: SchemaOrRef
+    example: NotRequired[Any]
+
+
+class Link(TypedDict):
+    operationId: NotRequired[str]
+    operationRef: NotRequired[str]
+    parameters: NotRequired[dict[str, Any]]
+    requestBody: NotRequired[Any]
+    server: NotRequired[Any]
+
+
+class Header(TypedDict):
+    required: NotRequired[bool]
+
+
+class Response(TypedDict):
+    headers: NotRequired[dict[str, HeaderOrRef]]
+    content: NotRequired[dict[str, MediaType]]
+    links: NotRequired[dict[str, LinkOrRef]]
+
+
+class RequestBody(TypedDict):
+    content: dict[str, MediaType]
+    required: NotRequired[bool]
+
+
+_ResponsesBase = Mapping[str, Union[Response, Reference]]
+
+
+class Responses(_ResponsesBase):
+    pass
+
+
+_HeadersBase = Mapping[str, Union[Header, Reference]]
+
+
+class Headers(_HeadersBase):
+    pass
+
+
+ExampleOrRef: TypeAlias = Union[Example, Reference]
+"""Example definition or reference."""
+
+HeaderOrRef: TypeAlias = Union[Header, Reference]
+"""Header definition or reference."""
+
+LinkOrRef: TypeAlias = Union[Link, Reference]
+"""Link definition or reference."""
+
+ResponseOrRef: TypeAlias = Union[Response, Reference]
+"""Response definition or reference."""
+
+RequestBodyOrRef: TypeAlias = Union[RequestBody, Reference]
+"""Request body definition or reference."""
+
+
+class ParameterWithSchema(TypedDict):
+    """OpenAPI 3.0/3.1 parameter with schema."""
+
+    name: str
+    description: NotRequired[str]
+    required: NotRequired[bool]
+    deprecated: NotRequired[bool]
+    allowEmptyValue: NotRequired[bool]
+    schema: SchemaOrRef
+    style: NotRequired[str]
+    explode: NotRequired[bool]
+    allowReserved: NotRequired[bool]
+    example: NotRequired[Any]
+    examples: NotRequired[dict[str, ExampleOrRef]]
+
+
+_ParameterIn = TypedDict("_ParameterIn", {"in": Literal["path", "query", "header", "cookie"]})
+
+
+class ParameterWithSchemaAndIn(ParameterWithSchema, _ParameterIn):
+    """Parameter with schema and 'in' field."""
+
+    pass
+
+
+class ParameterWithContent(TypedDict):
+    """OpenAPI 3.0/3.1 parameter with content."""
+
+    name: str
+    description: NotRequired[str]
+    required: NotRequired[bool]
+    deprecated: NotRequired[bool]
+    content: dict[str, MediaType]
+
+
+class ParameterWithContentAndIn(ParameterWithContent, _ParameterIn):
+    """Parameter with content and 'in' field."""
+
+    pass
+
+
+Parameter: TypeAlias = Union[ParameterWithSchemaAndIn, ParameterWithContentAndIn, Reference]
+"""OpenAPI 3.x parameter (with schema, with content, or reference)."""
+
+
+class Operation(TypedDict):
+    responses: Responses
+    requestBody: NotRequired[RequestBodyOrRef]
+    parameters: NotRequired[list[Parameter]]
+
+
+# Security parameter types
+class SecurityParameter(ParameterWithSchema, _SecurityTypeKey):
+    """OpenAPI 3.x synthetic security parameter.
+
+    Created from security schemes (apiKey or http auth).
+    Follows the same structure as ParameterWithSchema since v3 uses nested schema.
+    """
+
+    pass

schemathesis/specs/openapi/utils.py

@@ -1,14 +1,15 @@
+from __future__ import annotations
+
 import string
-from itertools import product
-from typing import Generator, Union
+from itertools import chain, product
+from typing import Generator
 
 
-def expand_status_code(status_code: Union[str, int]) -> Generator[int, None, None]:
+def expand_status_code(status_code: str | int) -> Generator[int, None, None]:
     chars = [list(string.digits) if digit == "X" else [digit] for digit in str(status_code).upper()]
     for expanded in product(*chars):
         yield int("".join(expanded))
 
 
-def is_header_location(location: str) -> bool:
-    """Whether this location affects HTTP headers."""
-    return location in ("header", "cookie")
+def expand_status_codes(status_codes: list[str]) -> set[int]:
+    return set(chain.from_iterable(expand_status_code(code) for code in status_codes))

schemathesis/specs/openapi/warnings.py

@@ -0,0 +1,75 @@
+"""OpenAPI-specific static schema warnings."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from schemathesis.config import SchemathesisWarning
+from schemathesis.core import deserialization
+from schemathesis.core.errors import MalformedMediaType
+from schemathesis.core.jsonschema.types import get_type
+
+if TYPE_CHECKING:
+    from schemathesis.schemas import APIOperation
+
+
+@dataclass
+class MissingDeserializerWarning:
+    """Warning for responses with structured schemas but no registered deserializer."""
+
+    operation_label: str
+    """Label of the operation (e.g., 'GET /users')."""
+
+    status_code: str
+    """HTTP status code for the response."""
+
+    content_type: str
+    """Media type that has no deserializer."""
+
+    __slots__ = ("operation_label", "status_code", "content_type")
+
+    @property
+    def kind(self) -> SchemathesisWarning:
+        """The warning kind for configuration matching."""
+        return SchemathesisWarning.MISSING_DESERIALIZER
+
+    @property
+    def message(self) -> str:
+        """Human-readable description of the warning."""
+        return f"Cannot validate response {self.status_code}: no deserializer registered for {self.content_type}"
+
+
+def detect_missing_deserializers(operation: APIOperation) -> list[MissingDeserializerWarning]:
+    """Detect responses with structured schemas but no registered deserializer."""
+    warnings: list[MissingDeserializerWarning] = []
+
+    for status_code, response in operation.responses.items():
+        raw_schema = getattr(response, "get_raw_schema", lambda: None)()
+        if raw_schema is None:
+            continue
+
+        schema_types = get_type(raw_schema)
+        is_structured = any(t in ("object", "array") for t in schema_types)
+
+        if not is_structured:
+            continue
+
+        content_types = response.definition.get("content", {}).keys() if response.definition else []
+
+        for content_type in content_types:
+            try:
+                has_deserializer = deserialization.has_deserializer(content_type)
+            except MalformedMediaType:
+                continue
+
+            if not has_deserializer:
+                warnings.append(
+                    MissingDeserializerWarning(
+                        operation_label=operation.label,
+                        status_code=status_code,
+                        content_type=content_type,
+                    )
+                )
+
+    return warnings