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

schemathesis/specs/openapi/links.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from difflib import get_close_matches
-from typing import TYPE_CHECKING, Any, Generator, NoReturn, Sequence, Union
+from typing import TYPE_CHECKING, Any, Generator, NoReturn, Sequence, TypedDict, Union
 
 from jsonschema import RefResolver
 
@@ -21,7 +21,7 @@ from ...types import NotSet
 from . import expressions
 from .constants import LOCATION_TO_CONTAINER
 from .parameters import OpenAPI20Body, OpenAPI30Body, OpenAPIParameter
-from .references import Unresolvable, RECURSION_DEPTH_LIMIT
+from .references import RECURSION_DEPTH_LIMIT, Unresolvable
 
 if TYPE_CHECKING:
     from ...transports.responses import GenericResponse
@@ -32,6 +32,7 @@ class Link(StatefulTest):
     operation: APIOperation
     parameters: dict[str, Any]
     request_body: Any = NOT_SET
+    merge_body: bool = True
 
     def __post_init__(self) -> None:
         if self.request_body is not NOT_SET and not self.operation.body:
@@ -51,6 +52,7 @@ class Link(StatefulTest):
             operation = source_operation.schema.get_operation_by_id(definition["operationId"])  # type: ignore
         else:
             operation = source_operation.schema.get_operation_by_reference(definition["operationRef"])  # type: ignore
+        extension = definition.get(SCHEMATHESIS_LINK_EXTENSION)
         return cls(
             # Pylint can't detect that the API operation is always defined at this point
             # E.g. if there is no matching operation or no operations at all, then a ValueError will be risen
@@ -58,6 +60,7 @@ class Link(StatefulTest):
             operation=operation,
             parameters=definition.get("parameters", {}),
             request_body=definition.get("requestBody", NOT_SET),  # `None` might be a valid value - `null`
+            merge_body=extension.get("merge_body", True) if extension is not None else True,
         )
 
     def parse(self, case: Case, response: GenericResponse) -> ParsedData:
@@ -69,10 +72,9 @@ class Link(StatefulTest):
             if isinstance(evaluated, Unresolvable):
                 raise UnresolvableLink(f"Unresolvable reference in the link: {expression}")
             parameters[parameter] = evaluated
-        # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#link-object
-        # > A literal value or {expression} to use as a request body when calling the target operation.
-        # In this case all literals will be passed as is, and expressions will be evaluated
-        body = expressions.evaluate(self.request_body, context)
+        body = expressions.evaluate(self.request_body, context, evaluate_nested=True)
+        if self.merge_body:
+            body = merge_body(case.body, body)
         return ParsedData(parameters=parameters, body=body)
 
     def make_operation(self, collected: list[ParsedData]) -> APIOperation:
@@ -170,6 +172,13 @@ def get_links(response: GenericResponse, operation: APIOperation, field: str) ->
     return [Link.from_definition(name, definition, operation) for name, definition in links.items()]
 
 
+SCHEMATHESIS_LINK_EXTENSION = "x-schemathesis"
+
+
+class SchemathesisLink(TypedDict):
+    merge_body: bool
+
+
 @dataclass(repr=False)
 class OpenAPILink(Direction):
     """Alternative approach to link processing.
@@ -183,13 +192,22 @@ class OpenAPILink(Direction):
     operation: APIOperation
     parameters: list[tuple[str | 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, elapsed: float, **kwargs: Any) -> None:
         """Assign all linked definitions to the new case instance."""
@@ -215,7 +233,11 @@ class OpenAPILink(Direction):
 
     def set_body(self, case: Case, context: expressions.ExpressionContext) -> None:
         if self.body is not NOT_SET:
-            case.body = expressions.evaluate(self.body, context)
+            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:
@@ -223,6 +245,12 @@ class OpenAPILink(Direction):
         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: str | None, name: str) -> dict[str, Any] | None:
     """Get a container that suppose to store the given parameter."""
     if location:

schemathesis/specs/openapi/loaders.py

@@ -1,37 +1,38 @@
 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.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:
@@ -303,8 +304,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)
@@ -533,9 +534,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)

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,7 +656,7 @@ class BaseOpenAPISchema(BaseSchema):
             try:
                 jsonschema.validate(data, schema, cls=cls, resolver=resolver)
             except jsonschema.ValidationError as exc:
-                exc_class = get_schema_validation_error(exc)
+                exc_class = get_schema_validation_error(operation.verbose_name, exc)
                 ctx = failures.ValidationErrorContext.from_exception(exc)
                 try:
                     raise exc_class(ctx.title, context=ctx) from 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