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

schemathesis/specs/openapi/links.py

@@ -1,17 +1,13 @@
-"""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, Callable, 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.errors import InvalidLinkDefinition, InvalidSchema, OperationNotFound
+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 +19,154 @@ 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)
-
+    source: APIOperation
+    target: APIOperation
+    parameters: list[NormalizedParameter]
+    body: dict[str, Any] | NotSet
+    merge_body: bool
 
-def normalize_parameter(
-    parameter: str, expression: str
-) -> tuple[Literal["path", "query", "header", "cookie", "body"] | None, str, str]:
-    """Normalize runtime expressions.
+    __slots__ = ("name", "status_code", "source", "target", "parameters", "body", "merge_body", "_cached_extract")
 
-    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 __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)
 
-def get_all_links(operation: APIOperation) -> Generator[tuple[str, OpenAPILink], None, None]:
+        get_operation: Callable[[str], APIOperation]
+        if "operationId" in definition:
+            operation_reference = definition["operationId"]
+            get_operation = source.schema.get_operation_by_id
+        else:
+            operation_reference = definition["operationRef"]
+            get_operation = source.schema.get_operation_by_reference
+
+        try:
+            self.target = get_operation(operation_reference)
+        except OperationNotFound as exc:
+            raise InvalidLinkDefinition(
+                f"Link '{name}' references non-existent operation '{operation_reference}' from {status_code} response of '{source.label}'"
+            ) from exc
+
+        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 InvalidSchema(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/patterns.py

@@ -66,9 +66,177 @@ def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, m
             )
             + trailing_anchor
         )
+    elif (
+        len(parsed) > 3
+        and parsed[0][0] == ANCHOR
+        and parsed[-1][0] == ANCHOR
+        and all(op == LITERAL or op in REPEATS for op, _ in parsed[1:-1])
+    ):
+        return _handle_anchored_pattern(parsed, pattern, min_length, max_length)
     return pattern
 
 
+def _handle_anchored_pattern(parsed: list, pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Update regex pattern with multiple quantified patterns to satisfy length constraints."""
+    # Extract anchors
+    leading_anchor_length = _get_anchor_length(parsed[0][1])
+    trailing_anchor_length = _get_anchor_length(parsed[-1][1])
+    leading_anchor = pattern[:leading_anchor_length]
+    trailing_anchor = pattern[-trailing_anchor_length:]
+
+    pattern_parts = parsed[1:-1]
+
+    # Adjust length constraints by subtracting fixed literals length
+    fixed_length = sum(1 for op, _ in pattern_parts if op == LITERAL)
+    if min_length is not None:
+        min_length -= fixed_length
+        if min_length < 0:
+            return pattern
+    if max_length is not None:
+        max_length -= fixed_length
+        if max_length < 0:
+            return pattern
+
+    # Extract only min/max bounds from quantified parts
+    quantifier_bounds = [value[:2] for op, value in pattern_parts if op in REPEATS]
+
+    if not quantifier_bounds:
+        return pattern
+
+    length_distribution = _distribute_length_constraints(quantifier_bounds, min_length, max_length)
+    if not length_distribution:
+        return pattern
+
+    # Rebuild pattern with updated quantifiers
+    result = leading_anchor
+    current_position = leading_anchor_length
+    distribution_idx = 0
+
+    for op, value in pattern_parts:
+        if op == LITERAL:
+            if pattern[current_position] == "\\":
+                # Escaped value
+                current_position += 2
+                result += "\\"
+            else:
+                current_position += 1
+            result += chr(value)
+        else:
+            new_min, new_max = length_distribution[distribution_idx]
+            next_position = _find_quantified_end(pattern, current_position)
+            quantified_segment = pattern[current_position:next_position]
+            _, _, subpattern = value
+            new_value = (new_min, new_max, subpattern)
+
+            result += _update_quantifier(op, new_value, quantified_segment, new_min, new_max)
+            current_position = next_position
+            distribution_idx += 1
+
+    return result + trailing_anchor
+
+
+def _find_quantified_end(pattern: str, start: int) -> int:
+    """Find the end position of current quantified part."""
+    char_class_level = 0
+    group_level = 0
+
+    for i in range(start, len(pattern)):
+        char = pattern[i]
+
+        # Handle character class nesting
+        if char == "[":
+            char_class_level += 1
+        elif char == "]":
+            char_class_level -= 1
+
+        # Handle group nesting
+        elif char == "(":
+            group_level += 1
+        elif char == ")":
+            group_level -= 1
+
+        # Only process quantifiers when we're not inside any nested structure
+        elif char_class_level == 0 and group_level == 0:
+            if char in "*+?":
+                return i + 1
+            elif char == "{":
+                # Find matching }
+                while i < len(pattern) and pattern[i] != "}":
+                    i += 1
+                return i + 1
+
+    return len(pattern)
+
+
+def _distribute_length_constraints(
+    bounds: list[tuple[int, int]], min_length: int | None, max_length: int | None
+) -> list[tuple[int, int]] | None:
+    """Distribute length constraints among quantified pattern parts."""
+    # Handle exact length case with dynamic programming
+    if min_length == max_length:
+        assert min_length is not None
+        target = min_length
+        dp: dict[tuple[int, int], list[tuple[int, ...]] | None] = {}
+
+        def find_valid_combination(pos: int, remaining: int) -> list[tuple[int, ...]] | None:
+            if (pos, remaining) in dp:
+                return dp[(pos, remaining)]
+
+            if pos == len(bounds):
+                return [()] if remaining == 0 else None
+
+            max_len: int
+            min_len, max_len = bounds[pos]
+            if max_len == MAXREPEAT:
+                max_len = remaining + 1
+            else:
+                max_len += 1
+
+            # Try each possible length for current quantifier
+            for length in range(min_len, max_len):
+                rest = find_valid_combination(pos + 1, remaining - length)
+                if rest is not None:
+                    dp[(pos, remaining)] = [(length,) + r for r in rest]
+                    return dp[(pos, remaining)]
+
+            dp[(pos, remaining)] = None
+            return None
+
+        distribution = find_valid_combination(0, target)
+        if distribution:
+            return [(length, length) for length in distribution[0]]
+        return None
+
+    # Handle range case by distributing min/max bounds
+    result = []
+    remaining_min = min_length or 0
+    remaining_max = max_length or MAXREPEAT
+
+    for min_repeat, max_repeat in bounds:
+        if remaining_min > 0:
+            part_min = min(max_repeat, max(min_repeat, remaining_min))
+        else:
+            part_min = min_repeat
+
+        if remaining_max < MAXREPEAT:
+            part_max = min(max_repeat, remaining_max)
+        else:
+            part_max = max_repeat
+
+        if part_min > part_max:
+            return None
+
+        result.append((part_min, part_max))
+
+        remaining_min = max(0, remaining_min - part_min)
+        remaining_max -= part_max if part_max != MAXREPEAT else 0
+
+    if remaining_min > 0 or remaining_max < 0:
+        return None
+
+    return result
+
+
 def _get_anchor_length(node_type: int) -> int:
     """Determine the length of the anchor based on its type."""
     if node_type in {sre.AT_BEGINNING_STRING, sre.AT_END_STRING, sre.AT_BOUNDARY, sre.AT_NON_BOUNDARY}:
@@ -93,13 +261,13 @@ def _handle_repeat_quantifier(
     min_length, max_length = _build_size(min_repeat, max_repeat, min_length, max_length)
     if min_length > max_length:
         return pattern
-    return f"({_strip_quantifier(pattern)})" + _build_quantifier(min_length, max_length)
+    return f"({_strip_quantifier(pattern).strip(')(')})" + _build_quantifier(min_length, max_length)
 
 
 def _handle_literal_or_in_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
     """Handle literal or character class quantifiers."""
     min_length = 1 if min_length is None else max(min_length, 1)
-    return f"({pattern})" + _build_quantifier(min_length, max_length)
+    return f"({pattern.strip(')(')})" + _build_quantifier(min_length, max_length)
 
 
 def _build_quantifier(minimum: int | None, maximum: int | None) -> str:

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
@@ -66,8 +66,8 @@ from .stateful import create_state_machine
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy
 
-    from ...auths import AuthStorage
-    from ...stateful.state_machine import APIStateMachine
+    from schemathesis.auths import AuthStorage
+    from schemathesis.generation.stateful import APIStateMachine
 
 HTTP_METHODS = frozenset({"get", "put", "post", "delete", "options", "head", "patch", "trace"})
 SCHEMA_ERROR_MESSAGE = "Ensure that the definition complies with the OpenAPI specification"
@@ -166,29 +166,73 @@ 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
+        resolve_path_item = self._resolve_path_item
         should_skip = self._should_skip
+        links_field = self.links_field
+
+        # For operationId lookup
+        selected_operations_by_id: set[str] = set()
+        # Tuples of (method, path)
+        selected_operations_by_path: set[tuple[str, str]] = set()
+        collected_links: list[dict] = []
 
         for path, path_item in paths.items():
             try:
-                if "$ref" in path_item:
-                    _, path_item = resolve(path_item["$ref"])
-                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
+                scope, path_item = resolve_path_item(path_item)
+                self.resolver.push_scope(scope)
+                try:
+                    for method, definition in path_item.items():
+                        if method not in HTTP_METHODS:
+                            continue
+                        statistic.operations.total += 1
+                        is_selected = not should_skip(path, method, definition)
+                        if is_selected:
+                            statistic.operations.selected += 1
+                            # Store both identifiers
+                            if "operationId" in definition:
+                                selected_operations_by_id.add(definition["operationId"])
+                            selected_operations_by_path.add((method, path))
+                        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:
+                                    collected_links.extend(defined_links.values())
+                finally:
+                    self.resolver.pop_scope()
             except SCHEMA_PARSING_ERRORS:
                 continue
-        return counter
+
+        def is_link_selected(link: dict) -> bool:
+            if "$ref" in link:
+                _, link = resolve(link["$ref"])
+
+            if "operationId" in link:
+                return link["operationId"] in selected_operations_by_id
+            else:
+                try:
+                    scope, _ = resolve(link["operationRef"])
+                    path, method = scope.rsplit("/", maxsplit=2)[-2:]
+                    path = path.replace("~1", "/").replace("~0", "~")
+                    return (method, path) in selected_operations_by_path
+                except Exception:
+                    return False
+
+        for link in collected_links:
+            if is_link_selected(link):
+                statistic.links.selected += 1
+
+        return statistic
 
     def _operation_iter(self) -> Generator[dict[str, Any], None, None]:
         try:
@@ -210,20 +254,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,
         *,
@@ -573,13 +603,7 @@ class BaseOpenAPISchema(BaseSchema):
         return scopes, definitions.get("headers")
 
     def as_state_machine(self) -> type[APIStateMachine]:
-        try:
-            return create_state_machine(self)
-        except OperationNotFound as exc:
-            raise LoaderError(
-                kind=LoaderErrorKind.OPEN_API_INVALID_SCHEMA,
-                message=f"Invalid Open API link definition: Operation `{exc.item}` not found",
-            ) from exc
+        return create_state_machine(self)
 
     def add_link(
         self,