schemathesis 3.31.1__py3-none-any.whl → 3.32.1__py3-none-any.whl

schemathesis/checks.py

@@ -39,6 +39,10 @@ def not_a_server_error(response: GenericResponse, case: Case) -> bool | None:
     return None
 
 
+def _make_max_response_time_failure_message(elapsed_time: float, max_response_time: int) -> str:
+    return f"Actual: {elapsed_time:.2f}ms\nLimit: {max_response_time}.00ms"
+
+
 DEFAULT_CHECKS: tuple[CheckFunction, ...] = (not_a_server_error,)
 OPTIONAL_CHECKS = (
     status_code_conformance,

schemathesis/cli/__init__.py

@@ -47,6 +47,7 @@ from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
 from ..stateful import Stateful
 from ..targets import Target
+from ..transports import RequestConfig
 from ..transports.auth import get_requests_auth
 from ..types import Filter, PathLike, RequestCert
 from . import callbacks, cassettes, output
@@ -850,7 +851,7 @@ def run(
     _hypothesis_suppress_health_check: list[hypothesis.HealthCheck] | None = None
     if hypothesis_suppress_health_check is not None:
         _hypothesis_suppress_health_check = [
-            health_check.as_hypothesis() for health_check in hypothesis_suppress_health_check
+            entry for health_check in hypothesis_suppress_health_check for entry in health_check.as_hypothesis()
         ]
 
     if contrib_unique_data:
@@ -1073,6 +1074,7 @@ class LoaderConfig:
     wait_for_schema: float | None
     rate_limit: str | None
     output_config: OutputConfig
+    generation_config: generation.GenerationConfig
     # Network request parameters
     auth: tuple[str, str] | None
     auth_type: str | None
@@ -1151,6 +1153,7 @@ def into_event_stream(
             tag=tag or None,
             operation_id=operation_id or None,
             output_config=output_config,
+            generation_config=generation_config,
         )
         schema = load_schema(config)
         yield from runner.from_schema(
@@ -1179,9 +1182,12 @@ def into_event_stream(
             generation_config=generation_config,
             probe_config=probes.ProbeConfig(
                 base_url=config.base_url,
-                request_tls_verify=config.request_tls_verify,
-                request_proxy=config.request_proxy,
-                request_cert=config.request_cert,
+                request=RequestConfig(
+                    timeout=request_timeout,
+                    tls_verify=config.request_tls_verify,
+                    proxy=config.request_proxy,
+                    cert=config.request_cert,
+                ),
                 auth=config.auth,
                 auth_type=config.auth_type,
                 headers=config.headers,
@@ -1297,6 +1303,7 @@ def get_loader_kwargs(loader: Callable, config: LoaderConfig) -> dict[str, Any]:
         "data_generation_methods": config.data_generation_methods,
         "rate_limit": config.rate_limit,
         "output_config": config.output_config,
+        "generation_config": config.generation_config,
     }
     if loader not in (oas_loaders.from_path, oas_loaders.from_dict):
         kwargs["headers"] = config.headers

schemathesis/cli/cassettes.py

@@ -23,7 +23,6 @@ if TYPE_CHECKING:
     import click
     import requests
 
-    from ..generation import DataGenerationMethod
     from ..models import Request, Response
     from ..runner.serialization import SerializedCheck, SerializedInteraction
     from .context import ExecutionContext
@@ -90,10 +89,6 @@ class CassetteWriter(EventHandler):
                     seed=seed,
                     correlation_id=event.correlation_id,
                     thread_id=event.thread_id,
-                    # NOTE: For backward compatibility reasons AfterExecution stores a list of data generation methods
-                    # The list always contains one element - the method that was actually used for generation
-                    # This will change in the future
-                    data_generation_method=event.data_generation_method[0],
                     interactions=event.result.interactions,
                 )
             )
@@ -105,7 +100,6 @@ class CassetteWriter(EventHandler):
                     # Correlation ID is not used in stateful testing
                     correlation_id="",
                     thread_id=event.thread_id,
-                    data_generation_method=event.data_generation_method[0],
                     interactions=event.result.interactions,
                 )
             )
@@ -132,7 +126,6 @@ class Process:
     seed: int
     correlation_id: str
     thread_id: int
-    data_generation_method: DataGenerationMethod
     interactions: list[SerializedInteraction]
 
 
@@ -239,7 +232,7 @@ http_interactions:"""
   seed: '{item.seed}'
   thread_id: {item.thread_id}
   correlation_id: '{item.correlation_id}'
-  data_generation_method: '{item.data_generation_method.value}'
+  data_generation_method: '{interaction.data_generation_method.value}'
   elapsed: '{interaction.response.elapsed}'
   recorded_at: '{interaction.recorded_at}'
   checks:

schemathesis/cli/constants.py

@@ -42,11 +42,15 @@ class HealthCheck(IntEnum):
     filter_too_much = 2
     too_slow = 3
     large_base_example = 7
+    all = 8
 
-    def as_hypothesis(self) -> hypothesis.HealthCheck:
+    def as_hypothesis(self) -> list[hypothesis.HealthCheck]:
         from hypothesis import HealthCheck
 
-        return HealthCheck[self.name]
+        if self.name == "all":
+            return list(HealthCheck)
+
+        return [HealthCheck[self.name]]
 
 
 @unique

schemathesis/cli/output/default.py

@@ -143,7 +143,9 @@ def display_hypothesis_output(hypothesis_output: list[str]) -> None:
 
 def display_errors(context: ExecutionContext, event: events.Finished) -> None:
     """Display all errors in the test run."""
-    if not event.has_errors:
+    probes = context.probes or []
+    has_probe_errors = any(probe.outcome == ProbeOutcome.ERROR for probe in probes)
+    if not event.has_errors and not has_probe_errors:
         return
 
     display_section_name("ERRORS")
@@ -160,6 +162,12 @@ def display_errors(context: ExecutionContext, event: events.Finished) -> None:
         should_display_full_traceback_message |= display_single_error(context, result)
     if event.generic_errors:
         display_generic_errors(context, event.generic_errors)
+    if has_probe_errors:
+        display_section_name("API Probe errors", "_", fg="red")
+        for probe in probes:
+            if probe.error is not None:
+                error = SerializedError.from_exception(probe.error)
+                _display_error(context, error)
     if should_display_full_traceback_message and not context.show_trace:
         click.secho(
             "\nAdd this option to your command line parameters to see full tracebacks: --show-trace",
@@ -848,6 +856,10 @@ def handle_finished(context: ExecutionContext, event: events.Finished) -> None:
 
 def handle_interrupted(context: ExecutionContext, event: events.Interrupted) -> None:
     click.echo()
+    _handle_interrupted(context)
+
+
+def _handle_interrupted(context: ExecutionContext) -> None:
     context.is_interrupted = True
     display_section_name("KeyboardInterrupt", "!", bold=False)
 
@@ -863,12 +875,11 @@ def handle_stateful_event(context: ExecutionContext, event: events.StatefulEvent
         if not experimental.STATEFUL_ONLY.is_enabled:
             click.echo()
         click.secho("Stateful tests\n", bold=True)
-    elif (
-        isinstance(event.data, stateful_events.ScenarioFinished)
-        and not event.data.is_final
-        and event.data.status != stateful_events.ScenarioStatus.REJECTED
-    ):
-        display_execution_result(context, event.data.status.value)
+    elif isinstance(event.data, stateful_events.ScenarioFinished) and not event.data.is_final:
+        if event.data.status == stateful_events.ScenarioStatus.INTERRUPTED:
+            _handle_interrupted(context)
+        elif event.data.status != stateful_events.ScenarioStatus.REJECTED:
+            display_execution_result(context, event.data.status.value)
     elif isinstance(event.data, stateful_events.RunFinished):
         click.echo()
     # It is initialized in `RunStarted`

schemathesis/exceptions.py

@@ -520,6 +520,12 @@ def remove_ssl_line_number(text: str) -> str:
     return re.sub(r"\(_ssl\.c:\d+\)", "", text)
 
 
+def _clean_inner_request_message(message: Any) -> str:
+    if isinstance(message, str) and message.startswith("HTTPConnectionPool"):
+        return re.sub(r"HTTPConnectionPool\(.+?\): ", "", message).rstrip(".")
+    return str(message)
+
+
 def extract_requests_exception_details(exc: RequestException) -> tuple[str, list[str]]:
     from requests.exceptions import ChunkedEncodingError, ConnectionError, SSLError
     from urllib3.exceptions import MaxRetryError
@@ -542,7 +548,7 @@ def extract_requests_exception_details(exc: RequestException) -> tuple[str, list
                 reason = f"Max retries exceeded with url: {inner.url}"
             extra = [reason.strip()]
         else:
-            extra = [" ".join(map(str, inner.args))]
+            extra = [" ".join(map(_clean_inner_request_message, inner.args))]
     elif isinstance(exc, ChunkedEncodingError):
         message = "Connection broken. The server declared chunked encoding but sent an invalid chunk"
         extra = [str(exc.args[0].args[1])]

schemathesis/filters.py

@@ -8,6 +8,8 @@ from functools import partial
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Callable, List, Protocol, Union
 
+from .types import NotSet, Filter as FilterType
+
 from .exceptions import UsageError
 
 if TYPE_CHECKING:
@@ -58,7 +60,12 @@ class Matcher:
     def for_regex(cls, attribute: str, regex: RegexValue) -> Matcher:
         """Matcher that checks whether the specified attribute has the provided regex."""
         if isinstance(regex, str):
-            regex = re.compile(regex)
+            flags: re.RegexFlag | int
+            if attribute == "method":
+                flags = re.IGNORECASE
+            else:
+                flags = 0
+            regex = re.compile(regex, flags=flags)
         func = partial(by_regex, attribute=attribute, regex=regex)
         label = f"{attribute}_regex={repr(regex)}"
         return cls(func, label=label, _hash=hash(label))
@@ -71,6 +78,8 @@ class Matcher:
 def get_operation_attribute(operation: APIOperation, attribute: str) -> str | list[str] | None:
     if attribute == "tag":
         return operation.tags
+    if attribute == "operation_id":
+        return operation.definition.raw.get("operationId")
     # Just uppercase `method`
     value = getattr(operation, attribute)
     if attribute == "method":
@@ -101,8 +110,8 @@ def by_regex(ctx: HasAPIOperation, attribute: str, regex: re.Pattern) -> bool:
     if value is None:
         return False
     if isinstance(value, list):
-        return any(bool(regex.match(entry)) for entry in value)
-    return bool(regex.match(value))
+        return any(bool(regex.search(entry)) for entry in value)
+    return bool(regex.search(value))
 
 
 @dataclass(repr=False, frozen=True)
@@ -111,6 +120,8 @@ class Filter:
 
     matchers: tuple[Matcher, ...]
 
+    __slots__ = ("matchers",)
+
     def __repr__(self) -> str:
         inner = " && ".join(matcher.label for matcher in self.matchers)
         return f"<{self.__class__.__name__}: [{inner}]>"
@@ -127,8 +138,14 @@ class Filter:
 class FilterSet:
     """Combines multiple filters to apply inclusion and exclusion rules on API operations."""
 
-    _includes: set[Filter] = field(default_factory=set)
-    _excludes: set[Filter] = field(default_factory=set)
+    _includes: set[Filter]
+    _excludes: set[Filter]
+
+    __slots__ = ("_includes", "_excludes")
+
+    def __init__(self) -> None:
+        self._includes = set()
+        self._excludes = set()
 
     def apply_to(self, operations: list[APIOperation]) -> list[APIOperation]:
         """Get a filtered list of the given operations that match the filters."""
@@ -168,6 +185,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         """Add a new INCLUDE filter."""
         self._add_filter(
@@ -181,6 +200,8 @@ class FilterSet:
             path_regex=path_regex,
             tag=tag,
             tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
         )
 
     def exclude(
@@ -195,6 +216,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         """Add a new EXCLUDE filter."""
         self._add_filter(
@@ -208,6 +231,8 @@ class FilterSet:
             path_regex=path_regex,
             tag=tag,
             tag_regex=tag_regex,
+            operation_id=operation_id,
+            operation_id_regex=operation_id_regex,
         )
 
     def _add_filter(
@@ -223,6 +248,8 @@ class FilterSet:
         path_regex: RegexValue | None = None,
         tag: FilterValue | None = None,
         tag_regex: RegexValue | None = None,
+        operation_id: FilterValue | None = None,
+        operation_id_regex: RegexValue | None = None,
     ) -> None:
         matchers = []
         if func is not None:
@@ -232,6 +259,7 @@ class FilterSet:
             ("method", method, method_regex),
             ("path", path, path_regex),
             ("tag", tag, tag_regex),
+            ("operation_id", operation_id, operation_id_regex),
         ):
             if expected is not None and regex is not None:
                 # To match anything the regex should match the expected value, hence passing them together is useless
@@ -295,3 +323,74 @@ def attach_filter_chain(
     proxy.__name__ = attribute
 
     setattr(target, attribute, proxy)
+
+
+def filter_set_from_components(
+    *,
+    include: bool,
+    method: FilterType | None = None,
+    endpoint: FilterType | None = None,
+    tag: FilterType | None = None,
+    operation_id: FilterType | None = None,
+    skip_deprecated_operations: bool | None | NotSet = None,
+    parent: FilterSet | None = None,
+) -> FilterSet:
+    def _is_defined(x: FilterType | None) -> bool:
+        return x is not None and not isinstance(x, NotSet)
+
+    def _is_deprecated(ctx: HasAPIOperation) -> bool:
+        return ctx.operation.definition.raw.get("deprecated") is True
+
+    def _prepare_filter(filter_: FilterType | None) -> RegexValue | None:
+        if filter_ is None or isinstance(filter_, NotSet):
+            return None
+        if isinstance(filter_, str):
+            return filter_
+        return "|".join(f"({f})" for f in filter_)
+
+    new = FilterSet()
+
+    if _is_defined(method) or _is_defined(endpoint) or _is_defined(tag) or _is_defined(operation_id):
+        new._add_filter(
+            include,
+            method_regex=_prepare_filter(method),
+            path_regex=_prepare_filter(endpoint),
+            tag_regex=_prepare_filter(tag),
+            operation_id_regex=_prepare_filter(operation_id),
+        )
+    if skip_deprecated_operations is True and not any(
+        matcher.label == _is_deprecated.__name__ for exclude_ in new._excludes for matcher in exclude_.matchers
+    ):
+        new.exclude(func=_is_deprecated)
+    # Merge with the parent filter set
+    if parent is not None:
+        for include_ in parent._includes:
+            matchers = include_.matchers
+            ids = []
+            for idx, matcher in enumerate(matchers):
+                label = matcher.label
+                if (
+                    (not isinstance(method, NotSet) and label.startswith("method_regex="))
+                    or (not isinstance(endpoint, NotSet) and label.startswith("path_regex="))
+                    or (not isinstance(tag, NotSet) and matcher.label.startswith("tag_regex="))
+                    or (not isinstance(operation_id, NotSet) and matcher.label.startswith("operation_id_regex="))
+                ):
+                    ids.append(idx)
+            if ids:
+                matchers = tuple(matcher for idx, matcher in enumerate(matchers) if idx not in ids)
+            if matchers:
+                if new._includes:
+                    existing = new._includes.pop()
+                    matchers = existing.matchers + matchers
+                new._includes.add(Filter(matchers=matchers))
+        for exclude_ in parent._excludes:
+            matchers = exclude_.matchers
+            ids = []
+            for idx, matcher in enumerate(exclude_.matchers):
+                if skip_deprecated_operations is False and matcher.label == _is_deprecated.__name__:
+                    ids.append(idx)
+            if ids:
+                matchers = tuple(matcher for idx, matcher in enumerate(matchers) if idx not in ids)
+            if matchers:
+                new._excludes.add(exclude_)
+    return new

schemathesis/internal/copy.py

@@ -1,6 +1,9 @@
 from typing import Any
 
+from .extensions import extensible
 
+
+@extensible("SCHEMATHESIS_EXTENSION_FAST_DEEP_COPY")
 def fast_deepcopy(value: Any) -> Any:
     """A specialized version of `deepcopy` that copies only `dict` and `list` and does unrolling.
 

schemathesis/internal/extensions.py

@@ -0,0 +1,27 @@
+import os
+from typing import Any, Callable
+
+
+class ExtensionLoadingError(ImportError):
+    """Raised when an extension cannot be loaded."""
+
+
+def import_extension(path: str) -> Any:
+    try:
+        module, item = path.rsplit(".", 1)
+        imported = __import__(module, fromlist=[item])
+        return getattr(imported, item)
+    except ValueError as exc:
+        raise ExtensionLoadingError(f"Invalid path: {path}") from exc
+    except (ImportError, AttributeError) as exc:
+        raise ExtensionLoadingError(f"Could not import {path}") from exc
+
+
+def extensible(env_var: str) -> Callable[[Any], Any]:
+    def decorator(item: Any) -> Any:
+        path = os.getenv(env_var)
+        if path is not None:
+            return import_extension(path)
+        return item
+
+    return decorator

schemathesis/lazy.py

@@ -19,6 +19,7 @@ from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
 from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
 from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
+from .filters import filter_set_from_components
 from .generation import DataGenerationMethodInput, GenerationConfig
 from .hooks import HookDispatcher, HookScope
 from .internal.output import OutputConfig
@@ -341,18 +342,24 @@ def get_schema(
     schema = request.getfixturevalue(name)
     if not isinstance(schema, BaseSchema):
         raise ValueError(f"The given schema must be an instance of BaseSchema, got: {type(schema)}")
-    return schema.clone(
-        base_url=base_url,
+
+    filter_set = filter_set_from_components(
+        include=True,
         method=method,
         endpoint=endpoint,
         tag=tag,
         operation_id=operation_id,
+        skip_deprecated_operations=skip_deprecated_operations,
+        parent=schema.filter_set,
+    )
+    return schema.clone(
+        base_url=base_url,
+        filter_set=filter_set,
         app=app,
         test_function=test_function,
         hooks=schema.hooks.merge(hooks),
         auth=auth,
         validate_schema=validate_schema,
-        skip_deprecated_operations=skip_deprecated_operations,
         data_generation_methods=data_generation_methods,
         generation_config=generation_config,
         output_config=output_config,

schemathesis/runner/__init__.py

@@ -19,6 +19,7 @@ from ..loaders import load_app
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
 from ..targets import DEFAULT_TARGETS, Target
+from ..transports import RequestConfig
 from ..transports.auth import get_requests_auth
 from ..types import Filter, NotSet, RawAuth, RequestCert
 from .probes import ProbeConfig
@@ -373,6 +374,12 @@ def from_schema(
 
     hypothesis_settings = hypothesis_settings or hypothesis.settings(deadline=DEFAULT_DEADLINE)
     generation_config = generation_config or GenerationConfig()
+    request_config = RequestConfig(
+        timeout=request_timeout,
+        tls_verify=request_tls_verify,
+        proxy=request_proxy,
+        cert=request_cert,
+    )
 
     # Use the same seed for all tests unless `derandomize=True` is used
     if seed is None and not hypothesis_settings.derandomize:
@@ -394,10 +401,7 @@ def from_schema(
                 headers=headers,
                 seed=seed,
                 workers_num=workers_num,
-                request_timeout=request_timeout,
-                request_tls_verify=request_tls_verify,
-                request_proxy=request_proxy,
-                request_cert=request_cert,
+                request_config=request_config,
                 exit_first=exit_first,
                 max_failures=max_failures,
                 started_at=started_at,
@@ -473,10 +477,7 @@ def from_schema(
             override=override,
             headers=headers,
             seed=seed,
-            request_timeout=request_timeout,
-            request_tls_verify=request_tls_verify,
-            request_proxy=request_proxy,
-            request_cert=request_cert,
+            request_config=request_config,
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,

schemathesis/runner/events.py

@@ -9,7 +9,8 @@ from typing import TYPE_CHECKING, Any
 from ..exceptions import RuntimeErrorType, SchemaError, SchemaErrorType, format_exception
 from ..generation import DataGenerationMethod
 from ..internal.datetime import current_datetime
-from ..internal.result import Result
+from ..internal.result import Err, Ok, Result
+from ..service.models import AnalysisSuccess
 from .serialization import SerializedError, SerializedTestResult
 
 if TYPE_CHECKING:
@@ -105,6 +106,23 @@ class BeforeAnalysis(ExecutionEvent):
 class AfterAnalysis(ExecutionEvent):
     analysis: Result[AnalysisResult, Exception] | None
 
+    def _serialize(self) -> dict[str, Any]:
+        data = {}
+        if isinstance(self.analysis, Ok):
+            result = self.analysis.ok()
+            if isinstance(result, AnalysisSuccess):
+                data["analysis_id"] = result.id
+            else:
+                data["error"] = result.message
+        elif isinstance(self.analysis, Err):
+            data["error"] = format_exception(self.analysis.err())
+        return data
+
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        data = self._serialize()
+        data["event_type"] = self.__class__.__name__
+        return data
+
 
 class CurrentOperationMixin:
     method: str
@@ -296,6 +314,9 @@ class StatefulEvent(ExecutionEvent):
 
     __slots__ = ("data",)
 
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        return {"data": self.data.asdict(**kwargs), "event_type": self.__class__.__name__}
+
 
 @dataclass
 class AfterStatefulExecution(ExecutionEvent):