schemathesis 3.29.2__py3-none-any.whl → 3.30.1__py3-none-any.whl

schemathesis/specs/openapi/loaders.py

@@ -1,37 +1,39 @@
 from __future__ import annotations
+
 import io
 import json
 import pathlib
 import re
-from typing import IO, Any, Callable, cast, TYPE_CHECKING
+from typing import IO, TYPE_CHECKING, Any, Callable, cast
 from urllib.parse import urljoin
 
 from ... import experimental, fixups
 from ...code_samples import CodeSampleStyle
+from ...constants import NOT_SET, WAIT_FOR_SCHEMA_INTERVAL
+from ...exceptions import SchemaError, SchemaErrorType
 from ...generation import (
     DEFAULT_DATA_GENERATION_METHODS,
-    DataGenerationMethodInput,
     DataGenerationMethod,
+    DataGenerationMethodInput,
     GenerationConfig,
 )
-from ...constants import WAIT_FOR_SCHEMA_INTERVAL
-from ...exceptions import SchemaError, SchemaErrorType
 from ...hooks import HookContext, dispatch
+from ...internal.output import OutputConfig
+from ...internal.validation import require_relative_url
 from ...loaders import load_schema_from_url, load_yaml
 from ...throttling import build_limiter
-from ...types import Filter, NotSet, PathLike
 from ...transports.content_types import is_json_media_type, is_yaml_media_type
 from ...transports.headers import setup_default_headers
-from ...internal.validation import require_relative_url
-from ...constants import NOT_SET
+from ...types import Filter, NotSet, PathLike
 from . import definitions, validation
 
 if TYPE_CHECKING:
-    from .schemas import BaseOpenAPISchema
-    from ...transports.responses import GenericResponse
     import jsonschema
     from pyrate_limiter import Limiter
+
     from ...lazy import LazySchema
+    from ...transports.responses import GenericResponse
+    from .schemas import BaseOpenAPISchema
 
 
 def _is_json_response(response: GenericResponse) -> bool:
@@ -78,6 +80,7 @@ def from_path(
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     encoding: str = "utf8",
@@ -102,6 +105,7 @@ def from_path(
             force_schema_version=force_schema_version,
             data_generation_methods=data_generation_methods,
             generation_config=generation_config,
+            output_config=output_config,
             code_sample_style=code_sample_style,
             location=pathlib.Path(path).absolute().as_uri(),
             rate_limit=rate_limit,
@@ -126,6 +130,7 @@ def from_uri(
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     wait_for_schema: float | None = None,
     rate_limit: str | None = None,
@@ -175,6 +180,7 @@ def from_uri(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         location=uri,
         rate_limit=rate_limit,
@@ -220,6 +226,7 @@ def from_file(
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     location: str | None = None,
     rate_limit: str | None = None,
@@ -266,6 +273,7 @@ def from_file(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         location=location,
         rate_limit=rate_limit,
@@ -294,6 +302,7 @@ def from_dict(
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     location: str | None = None,
     rate_limit: str | None = None,
@@ -303,8 +312,8 @@ def from_dict(
 
     :param dict raw_schema: A schema to load.
     """
-    from .schemas import OpenApi30, SwaggerV20
     from ... import transports
+    from .schemas import OpenApi30, SwaggerV20
 
     if not isinstance(raw_schema, dict):
         raise SchemaError(SchemaErrorType.OPEN_API_INVALID_SCHEMA, SCHEMA_INVALID_ERROR)
@@ -335,6 +344,7 @@ def from_dict(
             validate_schema=validate_schema,
             data_generation_methods=DataGenerationMethod.ensure_list(data_generation_methods),
             generation_config=generation_config or GenerationConfig(),
+            output_config=output_config or OutputConfig(),
             code_sample_style=_code_sample_style,
             location=location,
             rate_limiter=rate_limiter,
@@ -377,6 +387,7 @@ def from_dict(
             validate_schema=validate_schema,
             data_generation_methods=DataGenerationMethod.ensure_list(data_generation_methods),
             generation_config=generation_config or GenerationConfig(),
+            output_config=output_config or OutputConfig(),
             code_sample_style=_code_sample_style,
             location=location,
             rate_limiter=rate_limiter,
@@ -466,6 +477,7 @@ def from_pytest_fixture(
     validate_schema: bool = False,
     data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
     generation_config: GenerationConfig | NotSet = NOT_SET,
+    output_config: OutputConfig | NotSet = NOT_SET,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -503,6 +515,7 @@ def from_pytest_fixture(
         validate_schema=validate_schema,
         data_generation_methods=_data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=_code_sample_style,
         rate_limiter=rate_limiter,
         sanitize_output=sanitize_output,
@@ -523,6 +536,7 @@ def from_wsgi(
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -533,9 +547,10 @@ def from_wsgi(
     :param str schema_path: An in-app relative URL to the schema.
     :param app: A WSGI app instance.
     """
-    from ...transports.responses import WSGIResponse
     from werkzeug.test import Client
 
+    from ...transports.responses import WSGIResponse
+
     require_relative_url(schema_path)
     setup_default_headers(kwargs)
     client = Client(app, WSGIResponse)
@@ -553,6 +568,7 @@ def from_wsgi(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         location=schema_path,
         rate_limit=rate_limit,
@@ -585,6 +601,7 @@ def from_aiohttp(
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -612,6 +629,7 @@ def from_aiohttp(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         rate_limit=rate_limit,
         sanitize_output=sanitize_output,
@@ -633,6 +651,7 @@ def from_asgi(
     force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     generation_config: GenerationConfig | None = None,
+    output_config: OutputConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: str | None = None,
     sanitize_output: bool = True,
@@ -662,6 +681,7 @@ def from_asgi(
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
+        output_config=output_config,
         code_sample_style=code_sample_style,
         location=schema_path,
         rate_limit=rate_limit,

schemathesis/specs/openapi/negative/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from functools import lru_cache
 from typing import Any
@@ -8,10 +9,10 @@ import jsonschema
 from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
 
+from ....generation import GenerationConfig
 from ..constants import ALL_KEYWORDS
 from .mutations import MutationContext
 from .types import Draw, Schema
-from ....generation import GenerationConfig
 
 
 @dataclass

schemathesis/specs/openapi/negative/mutations.py

@@ -1,6 +1,7 @@
 """Schema mutations."""
 
 from __future__ import annotations
+
 import enum
 from dataclasses import dataclass
 from functools import wraps

schemathesis/specs/openapi/parameters.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import json
 from dataclasses import dataclass
 from typing import Any, ClassVar, Iterable

schemathesis/specs/openapi/schemas.py

@@ -40,7 +40,6 @@ from ...exceptions import (
     OperationSchemaError,
     SchemaError,
     SchemaErrorType,
-    UsageError,
     get_missing_content_type_error,
     get_response_parsing_error,
     get_schema_validation_error,
@@ -286,27 +285,28 @@ class BaseOpenAPISchema(BaseSchema):
                     continue
                 dispatch_hook("before_process_path", context, path, path_item)
                 scope, path_item = resolve_path_item(path_item)
-                shared_parameters = resolve_shared_parameters(path_item)
-                for method, entry in path_item.items():
-                    if method not in HTTP_METHODS:
-                        continue
-                    try:
-                        resolved = resolve_operation(entry)
-                        if should_skip(method, resolved):
-                            continue
-                        parameters = resolved.get("parameters", ())
-                        parameters = collect_parameters(itertools.chain(parameters, shared_parameters), resolved)
-                        operation = make_operation(path, method, parameters, entry, resolved, scope)
-                        context = HookContext(operation=operation)
-                        if (
-                            should_skip_operation(GLOBAL_HOOK_DISPATCHER, context)
-                            or should_skip_operation(hooks, context)
-                            or (hooks and should_skip_operation(hooks, context))
-                        ):
+                with in_scope(self.resolver, scope):
+                    shared_parameters = resolve_shared_parameters(path_item)
+                    for method, entry in path_item.items():
+                        if method not in HTTP_METHODS:
                             continue
-                        yield Ok(operation)
-                    except SCHEMA_PARSING_ERRORS as exc:
-                        yield self._into_err(exc, path, method)
+                        try:
+                            resolved = resolve_operation(entry)
+                            if should_skip(method, resolved):
+                                continue
+                            parameters = resolved.get("parameters", ())
+                            parameters = collect_parameters(itertools.chain(parameters, shared_parameters), resolved)
+                            operation = make_operation(path, method, parameters, entry, resolved, scope)
+                            context = HookContext(operation=operation)
+                            if (
+                                should_skip_operation(GLOBAL_HOOK_DISPATCHER, context)
+                                or should_skip_operation(hooks, context)
+                                or (hooks and should_skip_operation(hooks, context))
+                            ):
+                                continue
+                            yield Ok(operation)
+                        except SCHEMA_PARSING_ERRORS as exc:
+                            yield self._into_err(exc, path, method)
             except SCHEMA_PARSING_ERRORS as exc:
                 yield self._into_err(exc, path, method)
 
@@ -626,7 +626,7 @@ class BaseOpenAPISchema(BaseSchema):
             formatted_content_types = [f"\n- `{content_type}`" for content_type in media_types]
             message = f"The following media types are documented in the schema:{''.join(formatted_content_types)}"
             try:
-                raise get_missing_content_type_error()(
+                raise get_missing_content_type_error(operation.verbose_name)(
                     failures.MissingContentType.title,
                     context=failures.MissingContentType(message=message, media_types=media_types),
                 )
@@ -638,7 +638,7 @@ class BaseOpenAPISchema(BaseSchema):
         try:
             data = get_json(response)
         except JSONDecodeError as exc:
-            exc_class = get_response_parsing_error(exc)
+            exc_class = get_response_parsing_error(operation.verbose_name, exc)
             context = failures.JSONDecodeErrorContext.from_exception(exc)
             try:
                 raise exc_class(context.title, context=context) from exc
@@ -656,8 +656,8 @@ class BaseOpenAPISchema(BaseSchema):
             try:
                 jsonschema.validate(data, schema, cls=cls, resolver=resolver)
             except jsonschema.ValidationError as exc:
-                exc_class = get_schema_validation_error(exc)
-                ctx = failures.ValidationErrorContext.from_exception(exc)
+                exc_class = get_schema_validation_error(operation.verbose_name, exc)
+                ctx = failures.ValidationErrorContext.from_exception(exc, output_config=operation.schema.output_config)
                 try:
                     raise exc_class(ctx.title, context=ctx) from exc
                 except Exception as exc:
@@ -926,7 +926,7 @@ class SwaggerV20(BaseOpenAPISchema):
 
     def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        return get_strategies_from_examples(operation, self.examples_field)
+        return get_strategies_from_examples(operation)
 
     def get_response_schema(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any] | None]:
         scopes, definition = self.resolver.resolve_in_scope(definition, scope)
@@ -998,18 +998,7 @@ class SwaggerV20(BaseOpenAPISchema):
         media_type: str | None = None,
     ) -> C:
         if body is not NOT_SET and media_type is None:
-            # If the user wants to send payload, then there should be a media type, otherwise the payload is ignored
-            media_types = operation.get_request_payload_content_types()
-            if len(media_types) == 1:
-                # The only available option
-                media_type = media_types[0]
-            else:
-                media_types_repr = ", ".join(media_types)
-                raise UsageError(
-                    "Can not detect appropriate media type. "
-                    "You can either specify one of the defined media types "
-                    f"or pass any other media type available for serialization. Defined media types: {media_types_repr}"
-                )
+            media_type = operation._get_default_media_type()
         return case_cls(
             operation=operation,
             path_parameters=path_parameters,
@@ -1101,7 +1090,7 @@ class OpenApi30(SwaggerV20):
 
     def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        return get_strategies_from_examples(operation, self.examples_field)
+        return get_strategies_from_examples(operation)
 
     def get_content_types(self, operation: APIOperation, response: GenericResponse) -> list[str]:
         definitions = self._get_response_definitions(operation, response)

schemathesis/specs/openapi/security.py

@@ -1,6 +1,7 @@
 """Processing of ``securityDefinitions`` or ``securitySchemes`` keywords."""
 
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Any, ClassVar, Generator
 

schemathesis/specs/openapi/serialization.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import json
 from typing import Any, Callable, Dict, Generator, List
 

schemathesis/specs/openapi/stateful/__init__.py

@@ -1,28 +1,46 @@
 from __future__ import annotations
+
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, List, cast
+from functools import lru_cache
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Iterator
 
 from hypothesis import strategies as st
-from hypothesis.stateful import Bundle, Rule, precondition, rule
-from requests.structures import CaseInsensitiveDict
+from hypothesis.stateful import Bundle, Rule, rule
 
+from ....constants import NOT_SET
 from ....internal.result import Ok
 from ....stateful.state_machine import APIStateMachine, Direction, StepResult
-from ....utils import combine_strategies
+from ....types import NotSet
 from .. import expressions
-from .links import APIOperationConnections, Connection, apply
+from ..links import get_all_links
+from ..utils import expand_status_code
+from .statistic import OpenAPILinkStats
+from .types import FilterFunction, LinkName, StatusCode, TargetName
 
 if TYPE_CHECKING:
-    from ....models import APIOperation, Case
+    from ....models import Case
     from ..schemas import BaseOpenAPISchema
 
 
 class OpenAPIStateMachine(APIStateMachine):
+    _transition_stats_template: ClassVar[OpenAPILinkStats]
+    _response_matchers: dict[str, Callable[[StepResult], str | None]]
+
+    def _get_target_for_result(self, result: StepResult) -> str | None:
+        matcher = self._response_matchers.get(result.case.operation.verbose_name)
+        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())
+
 
 def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
     """Create a state machine class.
@@ -33,75 +51,146 @@ 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.
     """
-    # Bundles are special strategies, allowing us to draw responses from previous calls
-    bundles = init_bundles(schema)
-    connections: APIOperationConnections = defaultdict(list)
+    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]] = {}
+    # Statistic structure follows the links and count for each response status code
+    transitions = {}
     for operation in operations:
-        apply(operation, bundles, connections)
+        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}"
+            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] = {}
+            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)
+    rules = {}
+    catch_all = Bundle("catch_all")
+
+    for target in operations:
+        incoming = incoming_transitions.get(target.verbose_name)
+        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}")
+                rules[name] = transition(
+                    name=name,
+                    target=catch_all,
+                    previous=bundles[bundle_name],
+                    case=target.as_strategy(),
+                    link=st.just(link),
+                )
+        elif any(
+            incoming.operation.verbose_name == target.verbose_name
+            for transitions in incoming_transitions.values()
+            for incoming in transitions
+        ):
+            # No incoming transitions, but has at least one outgoing transition
+            # 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")
+            rules[name] = transition(
+                name=name,
+                target=catch_all,
+                previous=st.none(),
+                case=target.as_strategy(),
+            )
+
+    return type(
+        "APIWorkflow",
+        (OpenAPIStateMachine,),
+        {
+            "schema": schema,
+            "bundles": bundles,
+            "_transition_stats_template": OpenAPILinkStats(transitions=transitions),
+            "_response_matchers": _response_matchers,
+            **rules,
+        },
+    )
+
+
+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:
+        return APIStateMachine._step(*args_, **kwargs_)
+
+    step_function.__name__ = name
+
+    kwargs = {"target": target, "previous": previous, "case": case}
+    if not isinstance(link, NotSet):
+        kwargs["link"] = link
+
+    return rule(**kwargs)(step_function)
+
+
+def make_response_matcher(matchers: list[tuple[str, FilterFunction]]) -> Callable[[StepResult], str | None]:
+    def compare(result: StepResult) -> str | None:
+        for bundle_name, response_filter in matchers:
+            if response_filter(result):
+                return bundle_name
+        return None
+
+    return compare
+
+
+@lru_cache()
+def make_response_filter(status_code: str, all_status_codes: Iterator[str]) -> FilterFunction:
+    """Create a filter for stored responses.
+
+    This filter will decide whether some response is suitable to use as a source for requesting some API operation.
+    """
+    if status_code == "default":
+        return default_status_code(all_status_codes)
+    return match_status_code(status_code)
+
 
-    rules = make_all_rules(operations, bundles, connections)
+def match_status_code(status_code: str) -> FilterFunction:
+    """Create a filter function that matches all responses with the given status code.
 
-    kwargs: dict[str, Any] = {"bundles": bundles, "schema": schema}
-    return type("APIWorkflow", (OpenAPIStateMachine,), {**kwargs, **rules})
+    Note that the status code can contain "X", which means any digit.
+    For example, 50X will match all status codes from 500 to 509.
+    """
+    status_codes = set(expand_status_code(status_code))
+
+    def compare(result: StepResult) -> bool:
+        return result.response.status_code in status_codes
+
+    compare.__name__ = f"match_{status_code}_response"
+
+    return compare
 
 
-def init_bundles(schema: BaseOpenAPISchema) -> dict[str, CaseInsensitiveDict]:
-    """Create bundles for all operations in the given schema.
+def default_status_code(status_codes: Iterator[str]) -> FilterFunction:
+    """Create a filter that matches all "default" responses.
 
-    Each API operation has a bundle that stores all responses from that operation.
-    We need to create bundles first, so they can be referred when building connections between operations.
+    In Open API, the "default" response is the one that is used if no other options were matched.
+    Therefore, we need to match only responses that were not matched by other listed status codes.
     """
-    output: dict[str, CaseInsensitiveDict] = {}
-    for result in schema.get_all_operations():
-        if isinstance(result, Ok):
-            operation = result.ok()
-            output.setdefault(operation.path, CaseInsensitiveDict())
-            output[operation.path][operation.method.upper()] = Bundle(operation.verbose_name)  # type: ignore
-    return output
-
-
-def make_all_rules(
-    operations: list[APIOperation],
-    bundles: dict[str, CaseInsensitiveDict],
-    connections: APIOperationConnections,
-) -> dict[str, Rule]:
-    """Create rules for all API operations, based on the provided connections."""
-    rules = {}
-    for operation in operations:
-        new_rule = make_rule(operation, bundles[operation.path][operation.method.upper()], connections)
-        if new_rule is not None:
-            rules[f"rule {operation.verbose_name}"] = new_rule
-    return rules
-
-
-def make_rule(
-    operation: APIOperation,
-    bundle: Bundle,
-    connections: APIOperationConnections,
-) -> Rule | None:
-    """Create a rule for an API operation."""
-
-    def _make_rule(previous: st.SearchStrategy) -> Rule:
-        decorator = rule(target=bundle, previous=previous, case=operation.as_strategy())  # type: ignore
-        return decorator(APIStateMachine._step)
-
-    incoming = connections.get(operation.verbose_name)
-    if incoming is not None:
-        incoming_connections = cast(List[Connection], incoming)
-        strategies = [connection.strategy for connection in incoming_connections]
-        _rule = _make_rule(combine_strategies(strategies))
-
-        def has_source_response(self: OpenAPIStateMachine) -> bool:
-            # To trigger this transition, there should be matching responses from the source operations
-            return any(connection.source in self.bundles for connection in incoming_connections)
-
-        return precondition(has_source_response)(_rule)
-    # No incoming transitions - make rules only for operations that have at least one outgoing transition
-    if any(
-        connection.source == operation.verbose_name
-        for operation_connections in connections.values()
-        for connection in operation_connections
-    ):
-        return _make_rule(st.none())
-    return None
+    expanded_status_codes = {
+        status_code for value in status_codes if value != "default" for status_code in expand_status_code(value)
+    }
+
+    def match_default_response(result: StepResult) -> bool:
+        return result.response.status_code not in expanded_status_codes
+
+    return match_default_response