schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/specs/openapi/links.py

@@ -1,334 +1,158 @@
-"""Open API links support.
-
-Based on https://swagger.io/docs/specification/links/
-"""
-
 from __future__ import annotations
 
-from dataclasses import dataclass, field
-from difflib import get_close_matches
-from types import SimpleNamespace
-from typing import TYPE_CHECKING, Any, Generator, Literal, NoReturn, Sequence, TypedDict, Union, cast
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import TYPE_CHECKING, Any, Generator, Literal, Union, cast
+
+from schemathesis.core import NOT_SET, NotSet
+from schemathesis.core.result import Err, Ok, Result
+from schemathesis.generation.stateful.state_machine import ExtractedParam, StepOutput, Transition
+from schemathesis.schemas import APIOperation
 
-from ...constants import NOT_SET
-from ...internal.copy import fast_deepcopy
-from ...models import APIOperation, Case, TransitionId
-from ...stateful import ParsedData, StatefulTest, UnresolvableLink
-from ...stateful.state_machine import Direction
 from . import expressions
 from .constants import LOCATION_TO_CONTAINER
-from .parameters import OpenAPI20Body, OpenAPI30Body, OpenAPIParameter
-from .references import RECURSION_DEPTH_LIMIT, Unresolvable
+from .references import RECURSION_DEPTH_LIMIT
 
 if TYPE_CHECKING:
-    from hypothesis.vendor.pretty import RepresentationPrinter
     from jsonschema import RefResolver
 
-    from ...parameters import ParameterSet
-    from ...transports.responses import GenericResponse
-    from ...types import NotSet
 
+SCHEMATHESIS_LINK_EXTENSION = "x-schemathesis"
+ParameterLocation = Literal["path", "query", "header", "cookie", "body"]
 
-@dataclass(repr=False)
-class Link(StatefulTest):
-    operation: APIOperation
-    parameters: dict[str, Any]
-    request_body: Any = NOT_SET
-    merge_body: bool = True
-
-    def __post_init__(self) -> None:
-        if self.request_body is not NOT_SET and not self.operation.body:
-            # Link defines `requestBody` for a parameter that does not accept one
-            raise ValueError(
-                f"Request body is not defined in API operation {self.operation.method.upper()} {self.operation.path}"
-            )
-
-    @classmethod
-    def from_definition(cls, name: str, definition: dict[str, dict[str, Any]], source_operation: APIOperation) -> Link:
-        # Links can be behind a reference
-        _, definition = source_operation.schema.resolver.resolve_in_scope(  # type: ignore
-            definition, source_operation.definition.scope
-        )
-        if "operationId" in definition:
-            # source_operation.schema is `BaseOpenAPISchema` and has this method
-            operation = source_operation.schema.get_operation_by_id(definition["operationId"])  # type: ignore
-        else:
-            operation = source_operation.schema.get_operation_by_reference(definition["operationRef"])  # type: ignore
-        extension = definition.get(SCHEMATHESIS_LINK_EXTENSION)
-        return cls(
-            # Pylint can't detect that the API operation is always defined at this point
-            # E.g. if there is no matching operation or no operations at all, then a ValueError will be risen
-            name=name,
-            operation=operation,
-            parameters=definition.get("parameters", {}),
-            request_body=definition.get("requestBody", NOT_SET),  # `None` might be a valid value - `null`
-            merge_body=extension.get("merge_body", True) if extension is not None else True,
-        )
 
-    def parse(self, case: Case, response: GenericResponse) -> ParsedData:
-        """Parse data into a structure expected by links definition."""
-        context = expressions.ExpressionContext(case=case, response=response)
-        parameters = {}
-        for parameter, expression in self.parameters.items():
-            evaluated = expressions.evaluate(expression, context)
-            if isinstance(evaluated, Unresolvable):
-                raise UnresolvableLink(f"Unresolvable reference in the link: {expression}")
-            parameters[parameter] = evaluated
-        body = expressions.evaluate(self.request_body, context, evaluate_nested=True)
-        if self.merge_body:
-            body = merge_body(case.body, body)
-        return ParsedData(parameters=parameters, body=body)
-
-    def is_match(self) -> bool:
-        return self.operation.schema.filter_set.match(SimpleNamespace(operation=self.operation))
-
-    def make_operation(self, collected: list[ParsedData]) -> APIOperation:
-        """Create a modified version of the original API operation with additional data merged in."""
-        # We split the gathered data among all locations & store the original parameter
-        containers = {
-            location: {
-                parameter.name: {"options": [], "parameter": parameter}
-                for parameter in getattr(self.operation, container_name)
-            }
-            for location, container_name in LOCATION_TO_CONTAINER.items()
-        }
-        # There might be duplicates in the data
-        for item in set(collected):
-            for name, value in item.parameters.items():
-                container = self._get_container_by_parameter_name(name, containers)
-                container.append(value)
-            if "body" in containers["body"] and item.body is not NOT_SET:
-                containers["body"]["body"]["options"].append(item.body)
-        # These are the final `path_parameters`, `query`, and other API operation components
-        components: dict[str, ParameterSet] = {
-            container_name: getattr(self.operation, container_name).__class__()
-            for location, container_name in LOCATION_TO_CONTAINER.items()
-        }
-        # Here are all components that are filled with parameters
-        for location, parameters in containers.items():
-            for parameter_data in parameters.values():
-                parameter = parameter_data["parameter"]
-                if parameter_data["options"]:
-                    definition = fast_deepcopy(parameter.definition)
-                    if "schema" in definition:
-                        # The actual schema doesn't matter since we have a list of allowed values
-                        definition["schema"] = {"enum": parameter_data["options"]}
-                    else:
-                        # Other schema-related keywords will be ignored later, during the canonicalisation step
-                        # inside `hypothesis-jsonschema`
-                        definition["enum"] = parameter_data["options"]
-                    new_parameter: OpenAPIParameter
-                    if isinstance(parameter, OpenAPI30Body):
-                        new_parameter = parameter.__class__(
-                            definition, media_type=parameter.media_type, required=parameter.required
-                        )
-                    elif isinstance(parameter, OpenAPI20Body):
-                        new_parameter = parameter.__class__(definition, media_type=parameter.media_type)
-                    else:
-                        new_parameter = parameter.__class__(definition)
-                    components[LOCATION_TO_CONTAINER[location]].add(new_parameter)
-                else:
-                    # No options were gathered for this parameter - use the original one
-                    components[LOCATION_TO_CONTAINER[location]].add(parameter)
-        return self.operation.clone(**components)
-
-    def _get_container_by_parameter_name(self, full_name: str, templates: dict[str, dict[str, dict[str, Any]]]) -> list:
-        """Detect in what request part the parameters is defined."""
-        location: str | None
-        try:
-            # The parameter name is prefixed with its location. Example: `path.id`
-            location, name = full_name.split(".")
-        except ValueError:
-            location, name = None, full_name
-        if location:
-            try:
-                parameters = templates[location]
-            except KeyError:
-                self._unknown_parameter(full_name)
-        else:
-            for parameters in templates.values():
-                if name in parameters:
-                    break
-            else:
-                self._unknown_parameter(full_name)
-        if not parameters:
-            self._unknown_parameter(full_name)
-        return parameters[name]["options"]
-
-    def _unknown_parameter(self, name: str) -> NoReturn:
-        raise ValueError(
-            f"Parameter `{name}` is not defined in API operation {self.operation.method.upper()} {self.operation.path}"
-        )
+@dataclass
+class NormalizedParameter:
+    """Processed link parameter with resolved container information."""
 
+    location: ParameterLocation | None
+    name: str
+    expression: str
+    container_name: str
 
-def get_links(response: GenericResponse, operation: APIOperation, field: str) -> Sequence[Link]:
-    """Get `x-links` / `links` definitions from the schema."""
-    responses = operation.definition.raw["responses"]
-    if str(response.status_code) in responses:
-        definition = responses[str(response.status_code)]
-    elif response.status_code in responses:
-        definition = responses[response.status_code]
-    else:
-        definition = responses.get("default", {})
-    if not definition:
-        return []
-    _, definition = operation.schema.resolver.resolve_in_scope(definition, operation.definition.scope)  # type: ignore[attr-defined]
-    links = definition.get(field, {})
-    return [Link.from_definition(name, definition, operation) for name, definition in links.items()]
-
+    __slots__ = ("location", "name", "expression", "container_name")
 
-SCHEMATHESIS_LINK_EXTENSION = "x-schemathesis"
 
+@dataclass(repr=False)
+class OpenApiLink:
+    """Represents an OpenAPI link between operations."""
 
-class SchemathesisLink(TypedDict):
+    name: str
+    status_code: str
+    source: APIOperation
+    target: APIOperation
+    parameters: list[NormalizedParameter]
+    body: dict[str, Any] | NotSet
     merge_body: bool
 
+    __slots__ = ("name", "status_code", "source", "target", "parameters", "body", "merge_body", "_cached_extract")
 
-@dataclass(repr=False)
-class OpenAPILink(Direction):
-    """Alternative approach to link processing.
+    def __init__(self, name: str, status_code: str, definition: dict[str, Any], source: APIOperation):
+        self.name = name
+        self.status_code = status_code
+        self.source = source
 
-    NOTE. This class will replace `Link` in the future.
-    """
+        if "operationId" in definition:
+            self.target = source.schema.get_operation_by_id(definition["operationId"])  # type: ignore
+        else:
+            self.target = source.schema.get_operation_by_reference(definition["operationRef"])  # type: ignore
 
-    name: str
-    status_code: str
-    definition: dict[str, Any]
-    operation: APIOperation
-    parameters: list[tuple[Literal["path", "query", "header", "cookie", "body"] | None, str, str]] = field(init=False)
-    body: dict[str, Any] | NotSet = field(init=False)
-    merge_body: bool = True
-
-    def __repr__(self) -> str:
-        path = self.operation.path
-        method = self.operation.method
-        return f"state.schema['{path}']['{method}'].links['{self.status_code}']['{self.name}']"
-
-    def _repr_pretty_(self, printer: RepresentationPrinter, cycle: bool) -> None:
-        return printer.text(repr(self))
-
-    def __post_init__(self) -> None:
-        extension = self.definition.get(SCHEMATHESIS_LINK_EXTENSION)
-        self.parameters = [
-            normalize_parameter(parameter, expression)
-            for parameter, expression in self.definition.get("parameters", {}).items()
-        ]
-        self.body = self.definition.get("requestBody", NOT_SET)
-        if extension is not None:
-            self.merge_body = extension.get("merge_body", True)
-
-    def set_data(self, case: Case, elapsed: float, **kwargs: Any) -> None:
-        """Assign all linked definitions to the new case instance."""
-        context = kwargs["context"]
-        overrides = self.set_parameters(case, context)
-        self.set_body(case, context, overrides)
-        overrides_all_parameters = True
-        if case.operation.body and "body" not in overrides.get("body", []):
-            overrides_all_parameters = False
-        if overrides_all_parameters:
-            for parameter in case.operation.iter_parameters():
-                if parameter.name not in overrides.get(parameter.location, []):
-                    overrides_all_parameters = False
-                    break
-        case.set_source(
-            context.response,
-            context.case,
-            elapsed,
-            overrides_all_parameters,
-            transition_id=TransitionId(
-                name=self.name,
-                status_code=self.status_code,
-            ),
-        )
+        extension = definition.get(SCHEMATHESIS_LINK_EXTENSION)
+        self.parameters = self._normalize_parameters(definition.get("parameters", {}))
+        self.body = definition.get("requestBody", NOT_SET)
+        self.merge_body = extension.get("merge_body", True) if extension else True
 
-    def set_parameters(
-        self, case: Case, context: expressions.ExpressionContext
-    ) -> dict[Literal["path", "query", "header", "cookie", "body"], list[str]]:
-        overrides: dict[Literal["path", "query", "header", "cookie", "body"], list[str]] = {}
-        for location, name, expression in self.parameters:
-            location, container = get_container(case, location, name)
-            # Might happen if there is directly specified container,
-            # but the schema has no parameters of such type at all.
-            # Therefore the container is empty, otherwise it will be at least an empty object
-            if container is None:
-                message = f"No such parameter in `{case.operation.method.upper()} {case.operation.path}`: `{name}`."
-                possibilities = [param.name for param in case.operation.iter_parameters()]
-                matches = get_close_matches(name, possibilities)
-                if matches:
-                    message += f" Did you mean `{matches[0]}`?"
-                raise ValueError(message)
-            value = expressions.evaluate(expression, context)
-            if value is not None:
-                container[name] = value
-                overrides.setdefault(location, []).append(name)
-        return overrides
-
-    def set_body(
-        self,
-        case: Case,
-        context: expressions.ExpressionContext,
-        overrides: dict[Literal["path", "query", "header", "cookie", "body"], list[str]],
-    ) -> None:
-        if self.body is not NOT_SET:
-            evaluated = expressions.evaluate(self.body, context, evaluate_nested=True)
-            overrides["body"] = ["body"]
-            if self.merge_body:
-                case.body = merge_body(case.body, evaluated)
-            else:
-                case.body = evaluated
-
-    def get_target_operation(self) -> APIOperation:
-        if "operationId" in self.definition:
-            return self.operation.schema.get_operation_by_id(self.definition["operationId"])  # type: ignore
-        return self.operation.schema.get_operation_by_reference(self.definition["operationRef"])  # type: ignore
-
-
-def merge_body(old: Any, new: Any) -> Any:
-    if isinstance(old, dict) and isinstance(new, dict):
-        return {**old, **new}
-    return new
-
-
-def get_container(
-    case: Case, location: Literal["path", "query", "header", "cookie", "body"] | None, name: str
-) -> tuple[Literal["path", "query", "header", "cookie", "body"], dict[str, Any] | None]:
-    """Get a container that suppose to store the given parameter."""
-    if location:
-        container_name = LOCATION_TO_CONTAINER[location]
-    else:
-        for param in case.operation.iter_parameters():
+        self._cached_extract = lru_cache(8)(self._extract_impl)
+
+    def _normalize_parameters(self, parameters: dict[str, str]) -> 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 = cast(ParameterLocation, _location)
+            except ValueError:
+                location = None
+                name = parameter
+
+            container_name = self._get_parameter_container(location, name)
+            result.append(NormalizedParameter(location, name, expression, container_name))
+        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_TO_CONTAINER[location]
+
+        for param in self.target.iter_parameters():
             if param.name == name:
-                location = param.location
-                container_name = LOCATION_TO_CONTAINER[param.location]
-                break
-        else:
-            raise ValueError(f"Parameter `{name}` is not defined in API operation `{case.operation.verbose_name}`")
-    return location, getattr(case, container_name)
+                return LOCATION_TO_CONTAINER[param.location]
+        raise ValueError(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=f"{self.source.label} - {self.status_code} - {self.name}",
+            parent_id=output.case.id,
+            parameters=self.extract_parameters(output),
+            request_body=self.extract_body(output),
+        )
+
+    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)
+        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)
+        return None
+
+
+@dataclass
+class StepOutputWrapper:
+    """Wrapper for StepOutput that uses only case_id for hash-based caching."""
 
+    output: StepOutput
+    __slots__ = ("output",)
 
-def normalize_parameter(
-    parameter: str, expression: str
-) -> tuple[Literal["path", "query", "header", "cookie", "body"] | None, str, str]:
-    """Normalize runtime expressions.
+    def __hash__(self) -> int:
+        return hash(self.output.case.id)
 
-    Runtime expressions may have parameter names prefixed with their location - `path.id`.
-    At the same time, parameters could be defined without a prefix - `id`.
-    We need to normalize all parameters to the same form to simplify working with them.
-    """
-    try:
-        # The parameter name is prefixed with its location. Example: `path.id`
-        location, name = tuple(parameter.split("."))
-        _location = cast(Literal["path", "query", "header", "cookie", "body"], location)
-        return _location, name, expression
-    except ValueError:
-        return None, parameter, expression
+    def __eq__(self, other: object) -> bool:
+        assert isinstance(other, StepOutputWrapper)
+        return self.output.case.id == other.output.case.id
 
 
-def get_all_links(operation: APIOperation) -> Generator[tuple[str, OpenAPILink], None, None]:
+def get_all_links(operation: APIOperation) -> Generator[tuple[str, OpenApiLink], None, None]:
     for status_code, definition in operation.definition.raw["responses"].items():
         definition = operation.schema.resolver.resolve_all(definition, RECURSION_DEPTH_LIMIT - 8)  # type: ignore[attr-defined]
         for name, link_definition in definition.get(operation.schema.links_field, {}).items():  # type: ignore
-            yield status_code, OpenAPILink(name, status_code, link_definition, operation)
+            yield status_code, OpenApiLink(name, status_code, link_definition, operation)
 
 
 StatusCode = Union[str, int]

schemathesis/specs/openapi/media_types.py

@@ -2,6 +2,11 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Collection
 
+from schemathesis.transport import SerializationContext
+from schemathesis.transport.asgi import ASGI_TRANSPORT
+from schemathesis.transport.requests import REQUESTS_TRANSPORT
+from schemathesis.transport.wsgi import WSGI_TRANSPORT
+
 if TYPE_CHECKING:
     from hypothesis import strategies as st
 
@@ -11,15 +16,12 @@ MEDIA_TYPES: dict[str, st.SearchStrategy[bytes]] = {}
 
 def register_media_type(name: str, strategy: st.SearchStrategy[bytes], *, aliases: Collection[str] = ()) -> None:
     """Register a strategy for the given media type."""
-    from ...serializers import SerializerContext, register
-
-    @register(name, aliases=aliases)
-    class MediaTypeSerializer:
-        def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-            return {"data": value}
 
-        def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-            return {"data": value}
+    @REQUESTS_TRANSPORT.serializer(name, *aliases)
+    @ASGI_TRANSPORT.serializer(name, *aliases)
+    @WSGI_TRANSPORT.serializer(name, *aliases)
+    def serialize(ctx: SerializationContext, value: Any) -> dict[str, Any]:
+        return {"data": value}
 
     MEDIA_TYPES[name] = strategy
     for alias in aliases:
@@ -27,8 +29,4 @@ def register_media_type(name: str, strategy: st.SearchStrategy[bytes], *, aliase
 
 
 def unregister_all() -> None:
-    from ...serializers import unregister
-
-    for media_type in MEDIA_TYPES:
-        unregister(media_type)
     MEDIA_TYPES.clear()

schemathesis/specs/openapi/negative/__init__.py

@@ -13,7 +13,8 @@ from ..constants import ALL_KEYWORDS
 from .mutations import MutationContext
 
 if TYPE_CHECKING:
-    from ....generation import GenerationConfig
+    from schemathesis.generation import GenerationConfig
+
     from .types import Draw, Schema
 
 

schemathesis/specs/openapi/negative/mutations.py

@@ -11,7 +11,8 @@ from hypothesis import reject
 from hypothesis import strategies as st
 from hypothesis.strategies._internal.featureflags import FeatureStrategy
 
-from ....internal.copy import fast_deepcopy
+from schemathesis.core.transforms import deepclone
+
 from ..utils import get_type, is_header_location
 from .types import Draw, Schema
 from .utils import can_negate
@@ -111,7 +112,7 @@ class MutationContext:
             # Body can be of any type and does not have any specific type semantic.
             mutations = draw(ordered(get_mutations(draw, self.keywords)))
         # Deep copy all keywords to avoid modifying the original schema
-        new_schema = fast_deepcopy(self.keywords)
+        new_schema = deepclone(self.keywords)
         enabled_mutations = draw(st.shared(FeatureStrategy(), key="mutations"))  # type: ignore
         # Always apply at least one mutation, otherwise everything is rejected, and we'd like to avoid it
         # for performance reasons

schemathesis/specs/openapi/parameters.py

@@ -4,12 +4,13 @@ import json
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, ClassVar, Iterable
 
-from ...exceptions import OperationSchemaError
-from ...parameters import Parameter
+from schemathesis.core.errors import InvalidSchema
+from schemathesis.schemas import Parameter
+
 from .converter import to_json_schema_recursive
 
 if TYPE_CHECKING:
-    from ...models import APIOperation
+    from ...schemas import APIOperation
 
 
 @dataclass(eq=False)
@@ -22,6 +23,7 @@ class OpenAPIParameter(Parameter):
     supported_jsonschema_keywords: ClassVar[tuple[str, ...]]
 
     def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
     @property
     def description(self) -> str | None:
         """A brief parameter description."""
@@ -359,7 +361,7 @@ MISSING_SCHEMA_OR_CONTENT_MESSAGE = (
 )
 
 INVALID_SCHEMA_MESSAGE = (
-    'Can not generate data for {location} parameter "{name}"! ' "Its schema should be an object, got {schema}"
+    'Can not generate data for {location} parameter "{name}"! Its schema should be an object, got {schema}'
 )
 
 
@@ -368,7 +370,7 @@ def get_parameter_schema(operation: APIOperation, data: dict[str, Any]) -> dict[
     # In Open API 3.0, there could be "schema" or "content" field. They are mutually exclusive.
     if "schema" in data:
         if not isinstance(data["schema"], dict):
-            raise OperationSchemaError(
+            raise InvalidSchema(
                 INVALID_SCHEMA_MESSAGE.format(
                     location=data.get("in", ""), name=data.get("name", "<UNKNOWN>"), schema=data["schema"]
                 ),
@@ -382,7 +384,7 @@ def get_parameter_schema(operation: APIOperation, data: dict[str, Any]) -> dict[
     try:
         content = data["content"]
     except KeyError as exc:
-        raise OperationSchemaError(
+        raise InvalidSchema(
             MISSING_SCHEMA_OR_CONTENT_MESSAGE.format(location=data.get("in", ""), name=data.get("name", "<UNKNOWN>")),
             path=operation.path,
             method=operation.method,

schemathesis/specs/openapi/patterns.py

@@ -21,7 +21,7 @@ IN = sre.IN
 MAXREPEAT = sre_parse.MAXREPEAT
 
 
-@lru_cache()
+@lru_cache
 def update_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
     """Update the quantifier of a regular expression based on given min and max lengths."""
     if not pattern or (min_length in (None, 0) and max_length is None):