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

schemathesis/specs/openapi/security.py

@@ -10,7 +10,7 @@ from .parameters import OpenAPI20Parameter, OpenAPI30Parameter, OpenAPIParameter
 if TYPE_CHECKING:
     from jsonschema import RefResolver
 
-    from ...models import APIOperation
+    from schemathesis.schemas import APIOperation
 
 
 @dataclass

schemathesis/specs/openapi/serialization.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 import json
 from typing import Any, Callable, Dict, Generator, List
 
-from ...utils import compose
-
 Generated = Dict[str, Any]
 Definition = Dict[str, Any]
 DefinitionList = List[Definition]
@@ -17,10 +15,16 @@ def make_serializer(
     """A maker function to avoid code duplication."""
 
     def _wrapper(definitions: DefinitionList) -> Callable | None:
-        conversions = list(func(definitions))
-        if conversions:
-            return compose(*[conv for conv in conversions if conv is not None])
-        return None
+        functions = list(func(definitions))
+
+        def composed(x: Any) -> Any:
+            result = x
+            for func in reversed(functions):
+                if func is not None:
+                    result = func(result)
+            return result
+
+        return composed
 
     return _wrapper
 

schemathesis/specs/openapi/stateful/__init__.py

@@ -2,46 +2,38 @@ from __future__ import annotations
 
 from collections import defaultdict
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Iterator
+from typing import TYPE_CHECKING, Any, Callable, Iterator
 
 from hypothesis import strategies as st
 from hypothesis.stateful import Bundle, Rule, precondition, rule
 
-from ....constants import NOT_SET
-from ....generation import DataGenerationMethod, combine_strategies
-from ....internal.result import Ok
-from ....stateful.state_machine import APIStateMachine, Direction, StepResult
-from ....types import NotSet
-from .. import expressions
-from ..links import get_all_links
+from schemathesis.core.result import Ok
+from schemathesis.generation.case import Case
+from schemathesis.generation.hypothesis import strategies
+from schemathesis.generation.stateful.state_machine import APIStateMachine, StepInput, StepOutput, _normalize_name
+from schemathesis.schemas import APIOperation
+
+from ....generation import GenerationMode
+from ..links import OpenApiLink, get_all_links
 from ..utils import expand_status_code
-from .statistic import OpenAPILinkStats
 
 if TYPE_CHECKING:
-    from ....models import Case
+    from schemathesis.generation.stateful.state_machine import StepOutput
+
     from ..schemas import BaseOpenAPISchema
-    from .types import FilterFunction, LinkName, StatusCode, TargetName
+
+FilterFunction = Callable[["StepOutput"], bool]
 
 
 class OpenAPIStateMachine(APIStateMachine):
-    _transition_stats_template: ClassVar[OpenAPILinkStats]
-    _response_matchers: dict[str, Callable[[StepResult], str | None]]
+    _response_matchers: dict[str, Callable[[StepOutput], str | None]]
 
-    def _get_target_for_result(self, result: StepResult) -> str | None:
-        matcher = self._response_matchers.get(result.case.operation.verbose_name)
+    def _get_target_for_result(self, result: StepOutput) -> str | None:
+        matcher = self._response_matchers.get(result.case.operation.label)
         if matcher is None:
             return None
         return matcher(result)
 
-    def transform(self, result: StepResult, direction: Direction, case: Case) -> Case:
-        context = expressions.ExpressionContext(case=result.case, response=result.response)
-        direction.set_data(case, elapsed=result.elapsed, context=context)
-        return case
-
-    @classmethod
-    def format_rules(cls) -> str:
-        return "\n".join(item.line for item in cls._transition_stats_template.iter_with_format())
-
 
 # The proportion of negative tests generated for "root" transitions
 NEGATIVE_TEST_CASES_THRESHOLD = 20
@@ -56,57 +48,41 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
 
     This state machine won't make calls to (2) without having a proper response from (1) first.
     """
-    from ....stateful.state_machine import _normalize_name
-
     operations = [result.ok() for result in schema.get_all_operations() if isinstance(result, Ok)]
     bundles = {}
     incoming_transitions = defaultdict(list)
-    _response_matchers: dict[str, Callable[[StepResult], str | None]] = {}
+    _response_matchers: dict[str, Callable[[StepOutput], str | None]] = {}
     # Statistic structure follows the links and count for each response status code
-    transitions = {}
     for operation in operations:
-        operation_links: dict[StatusCode, dict[TargetName, dict[LinkName, dict[int | None, int]]]] = {}
         all_status_codes = tuple(operation.definition.raw["responses"])
         bundle_matchers = []
         for _, link in get_all_links(operation):
-            bundle_name = f"{operation.verbose_name} -> {link.status_code}"
+            bundle_name = f"{operation.label} -> {link.status_code}"
             bundles[bundle_name] = Bundle(bundle_name)
-            target_operation = link.get_target_operation()
-            incoming_transitions[target_operation.verbose_name].append(link)
-            response_targets = operation_links.setdefault(link.status_code, {})
-            target_links = response_targets.setdefault(target_operation.verbose_name, {})
-            target_links[link.name] = {}
+            incoming_transitions[link.target.label].append(link)
             bundle_matchers.append((bundle_name, make_response_filter(link.status_code, all_status_codes)))
-        if operation_links:
-            transitions[operation.verbose_name] = operation_links
         if bundle_matchers:
-            _response_matchers[operation.verbose_name] = make_response_matcher(bundle_matchers)
+            _response_matchers[operation.label] = make_response_matcher(bundle_matchers)
     rules = {}
     catch_all = Bundle("catch_all")
 
     for target in operations:
-        incoming = incoming_transitions.get(target.verbose_name)
+        incoming = incoming_transitions.get(target.label)
         if incoming is not None:
             for link in incoming:
-                source = link.operation
-                bundle_name = f"{source.verbose_name} -> {link.status_code}"
-                name = _normalize_name(f"{target.verbose_name} -> {link.status_code}")
-                case_strategy = combine_strategies(
-                    [
-                        target.as_strategy(data_generation_method=data_generation_method)
-                        for data_generation_method in schema.data_generation_methods
-                    ]
-                )
-                bundle = bundles[bundle_name]
-                rules[name] = transition(
-                    name=name,
-                    target=catch_all,
-                    previous=bundle,
-                    case=case_strategy,
-                    link=st.just(link),
+                bundle_name = f"{link.source.label} -> {link.status_code}"
+                name = _normalize_name(f"{link.status_code} -> {target.label}")
+                rules[name] = precondition(ensure_non_empty_bundle(bundle_name))(
+                    transition(
+                        name=name,
+                        target=catch_all,
+                        input=bundles[bundle_name].flatmap(
+                            into_step_input(target=target, link=link, modes=schema.generation_config.modes)
+                        ),
+                    )
                 )
         elif any(
-            incoming.operation.verbose_name == target.verbose_name
+            incoming.source.label == target.label
             for transitions in incoming_transitions.values()
             for incoming in transitions
         ):
@@ -114,32 +90,26 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
             # For example, POST /users/ -> GET /users/{id}/
             # The source operation has no prerequisite, but we need to allow this rule to be executed
             # in order to reach other transitions
-            name = _normalize_name(f"{target.verbose_name} -> X")
-            if len(schema.data_generation_methods) == 1:
-                case_strategy = target.as_strategy(data_generation_method=schema.data_generation_methods[0])
+            name = _normalize_name(f"{target.label} -> X")
+            if len(schema.generation_config.modes) == 1:
+                case_strategy = target.as_strategy(generation_mode=schema.generation_config.modes[0])
             else:
-                strategies = {
-                    method: target.as_strategy(data_generation_method=method)
-                    for method in schema.data_generation_methods
+                _strategies = {
+                    method: target.as_strategy(generation_mode=method) for method in schema.generation_config.modes
                 }
 
                 @st.composite  # type: ignore[misc]
                 def case_strategy_factory(
-                    draw: st.DrawFn, strategies: dict[DataGenerationMethod, st.SearchStrategy] = strategies
+                    draw: st.DrawFn, strategies: dict[GenerationMode, st.SearchStrategy] = _strategies
                 ) -> Case:
                     if draw(st.integers(min_value=0, max_value=99)) < NEGATIVE_TEST_CASES_THRESHOLD:
-                        return draw(strategies[DataGenerationMethod.negative])
-                    return draw(strategies[DataGenerationMethod.positive])
+                        return draw(strategies[GenerationMode.NEGATIVE])
+                    return draw(strategies[GenerationMode.POSITIVE])
 
                 case_strategy = case_strategy_factory()
 
             rules[name] = precondition(ensure_links_followed)(
-                transition(
-                    name=name,
-                    target=catch_all,
-                    previous=st.none(),
-                    case=case_strategy,
-                )
+                transition(name=name, target=catch_all, input=case_strategy.map(StepInput.initial))
             )
 
     return type(
@@ -148,13 +118,60 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
         {
             "schema": schema,
             "bundles": bundles,
-            "_transition_stats_template": OpenAPILinkStats(transitions=transitions),
             "_response_matchers": _response_matchers,
             **rules,
         },
     )
 
 
+def into_step_input(
+    target: APIOperation, link: OpenApiLink, modes: list[GenerationMode]
+) -> Callable[[StepOutput], st.SearchStrategy[StepInput]]:
+    def builder(_output: StepOutput) -> st.SearchStrategy[StepInput]:
+        @st.composite  # type: ignore[misc]
+        def inner(draw: st.DrawFn, output: StepOutput) -> StepInput:
+            transition_data = link.extract(output)
+
+            kwargs: dict[str, Any] = {
+                container: {
+                    name: extracted.value.ok()
+                    for name, extracted in data.items()
+                    if isinstance(extracted.value, Ok) and extracted.value.ok() is not None
+                }
+                for container, data in transition_data.parameters.items()
+            }
+            if (
+                transition_data.request_body is not None
+                and isinstance(transition_data.request_body.value, Ok)
+                and not link.merge_body
+            ):
+                kwargs["body"] = transition_data.request_body.value.ok()
+            cases = strategies.combine([target.as_strategy(generation_mode=mode, **kwargs) for mode in modes])
+            case = draw(cases)
+            if (
+                transition_data.request_body is not None
+                and isinstance(transition_data.request_body.value, Ok)
+                and link.merge_body
+            ):
+                new = transition_data.request_body.value.ok()
+                if isinstance(case.body, dict) and isinstance(new, dict):
+                    case.body = {**case.body, **new}
+                else:
+                    case.body = new
+            return StepInput(case=case, transition=transition_data)
+
+        return inner(output=_output)
+
+    return builder
+
+
+def ensure_non_empty_bundle(bundle_name: str) -> Callable[[APIStateMachine], bool]:
+    def inner(machine: APIStateMachine) -> bool:
+        return bool(machine.bundles.get(bundle_name))
+
+    return inner
+
+
 def ensure_links_followed(machine: APIStateMachine) -> bool:
     # If there are responses that have links to follow, reject any rule without incoming transitions
     for bundle in machine.bundles.values():
@@ -163,28 +180,17 @@ def ensure_links_followed(machine: APIStateMachine) -> bool:
     return True
 
 
-def transition(
-    *,
-    name: str,
-    target: Bundle,
-    previous: Bundle | st.SearchStrategy,
-    case: st.SearchStrategy,
-    link: st.SearchStrategy | NotSet = NOT_SET,
-) -> Callable[[Callable], Rule]:
-    def step_function(*args_: Any, **kwargs_: Any) -> StepResult | None:
-        return APIStateMachine._step(*args_, **kwargs_)
+def transition(*, name: str, target: Bundle, input: st.SearchStrategy[StepInput]) -> Callable[[Callable], Rule]:
+    def step_function(self: APIStateMachine, input: StepInput) -> StepOutput | None:
+        return APIStateMachine._step(self, input=input)
 
     step_function.__name__ = name
 
-    kwargs = {"target": target, "previous": previous, "case": case}
-    if not isinstance(link, NotSet):
-        kwargs["link"] = link
-
-    return rule(**kwargs)(step_function)
+    return rule(target=target, input=input)(step_function)
 
 
-def make_response_matcher(matchers: list[tuple[str, FilterFunction]]) -> Callable[[StepResult], str | None]:
-    def compare(result: StepResult) -> str | None:
+def make_response_matcher(matchers: list[tuple[str, FilterFunction]]) -> Callable[[StepOutput], str | None]:
+    def compare(result: StepOutput) -> str | None:
         for bundle_name, response_filter in matchers:
             if response_filter(result):
                 return bundle_name
@@ -212,7 +218,7 @@ def match_status_code(status_code: str) -> FilterFunction:
     """
     status_codes = set(expand_status_code(status_code))
 
-    def compare(result: StepResult) -> bool:
+    def compare(result: StepOutput) -> bool:
         return result.response.status_code in status_codes
 
     compare.__name__ = f"match_{status_code}_response"
@@ -230,7 +236,7 @@ def default_status_code(status_codes: Iterator[str]) -> FilterFunction:
         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:
+    def match_default_response(result: StepOutput) -> bool:
         return result.response.status_code not in expanded_status_codes
 
     return match_default_response

schemathesis/transport/__init__.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from inspect import iscoroutinefunction
+from typing import Any, Callable, Generic, Iterator, TypeVar
+
+from schemathesis.core import media_types
+from schemathesis.core.errors import SerializationNotPossible
+
+
+def get(app: Any) -> BaseTransport:
+    """Get transport to send the data to the application."""
+    from schemathesis.transport.asgi import ASGI_TRANSPORT
+    from schemathesis.transport.requests import REQUESTS_TRANSPORT
+    from schemathesis.transport.wsgi import WSGI_TRANSPORT
+
+    if app is None:
+        return REQUESTS_TRANSPORT
+    if iscoroutinefunction(app) or (
+        hasattr(app, "__call__") and iscoroutinefunction(app.__call__)  # noqa: B004
+    ):
+        return ASGI_TRANSPORT
+    return WSGI_TRANSPORT
+
+
+C = TypeVar("C", contravariant=True)
+R = TypeVar("R", covariant=True)
+S = TypeVar("S", contravariant=True)
+
+
+@dataclass
+class SerializationContext(Generic[C]):
+    """Generic context for serialization process."""
+
+    case: C
+
+    __slots__ = ("case",)
+
+
+Serializer = Callable[[SerializationContext[C], Any], Any]
+
+
+class BaseTransport(Generic[C, R, S]):
+    """Base implementation with serializer registration."""
+
+    def __init__(self) -> None:
+        self._serializers: dict[str, Serializer[C]] = {}
+
+    def serialize_case(self, case: C, **kwargs: Any) -> dict[str, Any]:
+        """Prepare the case for sending."""
+        raise NotImplementedError
+
+    def send(self, case: C, *, session: S | None = None, **kwargs: Any) -> R:
+        """Send the case using this transport."""
+        raise NotImplementedError
+
+    def serializer(self, *media_types: str) -> Callable[[Serializer[C]], Serializer[C]]:
+        """Register a serializer for given media types."""
+
+        def decorator(func: Serializer[C]) -> Serializer[C]:
+            for media_type in media_types:
+                self._serializers[media_type] = func
+            return func
+
+        return decorator
+
+    def unregister_serializer(self, *media_types: str) -> None:
+        for media_type in media_types:
+            self._serializers.pop(media_type, None)
+
+    def _copy_serializers_from(self, transport: BaseTransport) -> None:
+        self._serializers.update(transport._serializers)
+
+    def get_first_matching_media_type(self, media_type: str) -> tuple[str, Serializer[C]] | None:
+        return next(self.get_matching_media_types(media_type), None)
+
+    def get_matching_media_types(self, media_type: str) -> Iterator[tuple[str, Serializer[C]]]:
+        """Get all registered media types matching the given media type."""
+        if media_type == "*/*":
+            # Shortcut to avoid comparing all values
+            yield from iter(self._serializers.items())
+        else:
+            main, sub = media_types.parse(media_type)
+            checks = [
+                media_types.is_json,
+                media_types.is_xml,
+                media_types.is_plain_text,
+                media_types.is_yaml,
+            ]
+            for registered_media_type, serializer in self._serializers.items():
+                # Try known variations for popular media types and fallback to comparison
+                if any(check(media_type) and check(registered_media_type) for check in checks):
+                    yield media_type, serializer
+                else:
+                    target_main, target_sub = media_types.parse(registered_media_type)
+                    if main in ("*", target_main) and sub in ("*", target_sub):
+                        yield registered_media_type, serializer
+
+    def _get_serializer(self, input_media_type: str) -> Serializer[C]:
+        pair = self.get_first_matching_media_type(input_media_type)
+        if pair is None:
+            # This media type is set manually. Otherwise, it should have been rejected during the data generation
+            raise SerializationNotPossible.for_media_type(input_media_type)
+        return pair[1]

schemathesis/transport/asgi.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.core.transport import Response
+from schemathesis.generation.case import Case
+from schemathesis.python import asgi
+from schemathesis.transport.prepare import normalize_base_url
+from schemathesis.transport.requests import REQUESTS_TRANSPORT, RequestsTransport
+
+if TYPE_CHECKING:
+    import requests
+
+
+class ASGITransport(RequestsTransport):
+    def send(self, case: Case, *, session: requests.Session | None = None, **kwargs: Any) -> Response:
+        if kwargs.get("base_url") is None:
+            kwargs["base_url"] = normalize_base_url(case.operation.base_url)
+        application = kwargs.pop("app", case.operation.app)
+
+        with asgi.get_client(application) as client:
+            return super().send(case, session=client, **kwargs)
+
+
+ASGI_TRANSPORT = ASGITransport()
+ASGI_TRANSPORT._copy_serializers_from(REQUESTS_TRANSPORT)

schemathesis/transport/prepare.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Mapping, cast
+from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
+
+from schemathesis.core import SCHEMATHESIS_TEST_CASE_HEADER, NotSet
+from schemathesis.core.errors import InvalidSchema
+from schemathesis.core.output.sanitization import sanitize_url, sanitize_value
+from schemathesis.core.transport import USER_AGENT
+
+if TYPE_CHECKING:
+    from requests import PreparedRequest
+    from requests.structures import CaseInsensitiveDict
+
+    from schemathesis.generation.case import Case
+
+
+def prepare_headers(case: Case, headers: dict[str, str] | None = None) -> CaseInsensitiveDict:
+    from requests.structures import CaseInsensitiveDict
+
+    final_headers = case.headers.copy() if case.headers is not None else CaseInsensitiveDict()
+    if headers:
+        final_headers.update(headers)
+    final_headers.setdefault("User-Agent", USER_AGENT)
+    final_headers.setdefault(SCHEMATHESIS_TEST_CASE_HEADER, case.id)
+    return final_headers
+
+
+def prepare_url(case: Case, base_url: str | None) -> str:
+    """Prepare URL based on case type."""
+    from schemathesis.specs.graphql.schemas import GraphQLSchema
+
+    base_url = base_url or case.operation.base_url
+    assert base_url is not None
+    path = prepare_path(case.path, case.path_parameters)
+
+    if isinstance(case.operation.schema, GraphQLSchema):
+        parts = list(urlsplit(base_url))
+        parts[2] = path
+        return urlunsplit(parts)
+    else:
+        path = path.lstrip("/")
+        if not base_url.endswith("/"):
+            base_url += "/"
+        return unquote(urljoin(base_url, quote(path)))
+
+
+def prepare_body(case: Case) -> list | dict[str, Any] | str | int | float | bool | bytes | NotSet:
+    """Prepare body based on case type."""
+    from schemathesis.specs.graphql.schemas import GraphQLSchema
+
+    if isinstance(case.operation.schema, GraphQLSchema):
+        return case.body if isinstance(case.body, (NotSet, bytes)) else {"query": case.body}
+    return case.body
+
+
+def normalize_base_url(base_url: str | None) -> str | None:
+    """Normalize base URL by ensuring proper hostname for local URLs.
+
+    If URL has no hostname (typical for WSGI apps), adds "localhost" as default hostname.
+    """
+    if base_url is None:
+        return None
+    parts = urlsplit(base_url)
+    if not parts.hostname:
+        path = cast(str, parts.path or "")
+        return urlunsplit(("http", "localhost", path or "", "", ""))
+    return base_url
+
+
+def prepare_path(path: str, parameters: dict[str, Any] | None) -> str:
+    try:
+        return path.format(**parameters or {})
+    except KeyError as exc:
+        # This may happen when a path template has a placeholder for variable "X", but parameter "X" is not defined
+        # in the parameters list.
+        # When `exc` is formatted, it is the missing key name in quotes. E.g. 'id'
+        raise InvalidSchema(f"Path parameter {exc} is not defined") from exc
+    except (IndexError, ValueError) as exc:
+        # A single unmatched `}` inside the path template may cause this
+        raise InvalidSchema(f"Malformed path template: `{path}`\n\n  {exc}") from exc
+
+
+def prepare_request(case: Case, headers: Mapping[str, Any] | None, sanitize: bool) -> PreparedRequest:
+    import requests
+
+    from schemathesis.transport.requests import REQUESTS_TRANSPORT
+
+    base_url = normalize_base_url(case.operation.base_url)
+    kwargs = REQUESTS_TRANSPORT.serialize_case(case, base_url=base_url, headers=headers)
+    if sanitize:
+        kwargs["url"] = sanitize_url(kwargs["url"])
+        sanitize_value(kwargs["headers"])
+        if kwargs["cookies"]:
+            sanitize_value(kwargs["cookies"])
+        if kwargs["params"]:
+            sanitize_value(kwargs["params"])
+
+    return requests.Request(**kwargs).prepare()