schemathesis 4.0.0a1__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/specs/openapi/expressions/nodes.py

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

schemathesis/specs/openapi/links.py

@@ -1,17 +1,12 @@
-"""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 typing import TYPE_CHECKING, Any, Generator, Literal, 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.generation.case import Case
-from schemathesis.generation.stateful.state_machine import Direction
+from schemathesis.core.result import Err, Ok, Result
+from schemathesis.generation.stateful.state_machine import ExtractedParam, StepOutput, Transition
 from schemathesis.schemas import APIOperation
 
 from . import expressions
@@ -23,129 +18,141 @@ if TYPE_CHECKING:
 
 
 SCHEMATHESIS_LINK_EXTENSION = "x-schemathesis"
+ParameterLocation = Literal["path", "query", "header", "cookie", "body"]
 
 
-class SchemathesisLink(TypedDict):
-    merge_body: bool
+@dataclass
+class NormalizedParameter:
+    """Processed link parameter with resolved container information."""
+
+    location: ParameterLocation | None
+    name: str
+    expression: str
+    container_name: str
 
+    __slots__ = ("location", "name", "expression", "container_name")
 
-@dataclass(repr=False)
-class OpenAPILink(Direction):
-    """Alternative approach to link processing.
 
-    NOTE. This class will replace `Link` in the future.
-    """
+@dataclass(repr=False)
+class OpenApiLink:
+    """Represents an OpenAPI link between operations."""
 
     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 __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, **kwargs: Any) -> None:
-        """Assign all linked definitions to the new case instance."""
-        context = kwargs["context"]
-        self.set_parameters(case, context)
-        self.set_body(case, context)
-
-    def set_parameters(self, case: Case, context: expressions.ExpressionContext) -> None:
-        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
-
-    def set_body(
-        self,
-        case: Case,
-        context: expressions.ExpressionContext,
-    ) -> None:
-        if self.body is not NOT_SET:
-            evaluated = expressions.evaluate(self.body, context, evaluate_nested=True)
-            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():
-            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.label}`")
-    return location, getattr(case, container_name)
-
-
-def normalize_parameter(
-    parameter: str, expression: str
-) -> tuple[Literal["path", "query", "header", "cookie", "body"] | None, str, str]:
-    """Normalize runtime expressions.
+    source: APIOperation
+    target: APIOperation
+    parameters: list[NormalizedParameter]
+    body: dict[str, Any] | NotSet
+    merge_body: bool
 
-    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
+    __slots__ = ("name", "status_code", "source", "target", "parameters", "body", "merge_body", "_cached_extract")
 
+    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
 
-def get_all_links(operation: APIOperation) -> Generator[tuple[str, OpenAPILink], None, None]:
+        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
+
+        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
+
+        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:
+                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 __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
+
+
+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/schemas.py

@@ -44,7 +44,7 @@ from schemathesis.openapi.checks import JsonSchemaError, MissingContentType
 
 from ...generation import GenerationConfig, GenerationMode
 from ...hooks import HookContext, HookDispatcher
-from ...schemas import APIOperation, APIOperationMap, ApiOperationsCount, BaseSchema, OperationDefinition
+from ...schemas import APIOperation, APIOperationMap, ApiStatistic, BaseSchema, OperationDefinition
 from . import links, serialization
 from ._cache import OperationCache
 from ._hypothesis import openapi_cases
@@ -166,15 +166,16 @@ class BaseOpenAPISchema(BaseSchema):
         operation.schema = self
         return not self.filter_set.match(_ctx_cache)
 
-    def _do_count_operations(self) -> ApiOperationsCount:
-        counter = ApiOperationsCount()
+    def _measure_statistic(self) -> ApiStatistic:
+        statistic = ApiStatistic()
         try:
             paths = self.raw_schema["paths"]
         except KeyError:
-            return counter
+            return statistic
 
         resolve = self.resolver.resolve
         should_skip = self._should_skip
+        links_field = self.links_field
 
         for path, path_item in paths.items():
             try:
@@ -183,12 +184,21 @@ class BaseOpenAPISchema(BaseSchema):
                 for method, definition in path_item.items():
                     if method not in HTTP_METHODS:
                         continue
-                    counter.total += 1
-                    if not should_skip(path, method, definition):
-                        counter.selected += 1
+                    statistic.operations.total += 1
+                    is_selected = not should_skip(path, method, definition)
+                    if is_selected:
+                        statistic.operations.selected += 1
+                    for response in definition.get("responses", {}).values():
+                        if "$ref" in response:
+                            _, response = resolve(response["$ref"])
+                        defined_links = response.get(links_field)
+                        if defined_links is not None:
+                            statistic.links.total += len(defined_links)
+                            if is_selected:
+                                statistic.links.selected = len(defined_links)
             except SCHEMA_PARSING_ERRORS:
                 continue
-        return counter
+        return statistic
 
     def _operation_iter(self) -> Generator[dict[str, Any], None, None]:
         try:
@@ -210,20 +220,6 @@ class BaseOpenAPISchema(BaseSchema):
                 # Ignore errors
                 continue
 
-    @property
-    def links_count(self) -> int:
-        total = 0
-        resolve = self.resolver.resolve
-        links_field = self.links_field
-        for definition in self._operation_iter():
-            for response in definition.get("responses", {}).values():
-                if "$ref" in response:
-                    _, response = resolve(response["$ref"])
-                defined_links = response.get(links_field)
-                if defined_links is not None:
-                    total += len(defined_links)
-        return total
-
     def override(
         self,
         *,