schemathesis 3.25.6__py3-none-any.whl → 3.26.1__py3-none-any.whl

schemathesis/_dependency_versions.py

@@ -1,4 +1,5 @@
 """Compatibility flags based on installed dependency versions."""
+
 from packaging import version
 
 from importlib import metadata

schemathesis/_hypothesis.py

@@ -1,4 +1,5 @@
 """High-level API for creating Hypothesis tests."""
+
 from __future__ import annotations
 
 import asyncio
@@ -76,7 +77,16 @@ def create_test(
             wrapped_test.hypothesis.inner_test = make_async_test(test)  # type: ignore
     setup_default_deadline(wrapped_test)
     if settings is not None:
-        wrapped_test = settings(wrapped_test)
+        existing_settings = _get_hypothesis_settings(wrapped_test)
+        if existing_settings is not None:
+            # Merge the user-provided settings with the current ones
+            default = hypothesis.settings.default
+            wrapped_test._hypothesis_internal_use_settings = hypothesis.settings(
+                wrapped_test._hypothesis_internal_use_settings,
+                **{item: value for item, value in settings.__dict__.items() if value != getattr(default, item)},
+            )
+        else:
+            wrapped_test = settings(wrapped_test)
     existing_settings = _get_hypothesis_settings(wrapped_test)
     if existing_settings is not None:
         existing_settings = remove_explain_phase(existing_settings)

schemathesis/_xml.py

@@ -1,4 +1,5 @@
 """XML serialization."""
+
 from __future__ import annotations
 from io import StringIO
 from typing import Any, Dict, List, Union

schemathesis/auths.py

@@ -1,4 +1,5 @@
 """Support for custom API authentication mechanisms."""
+
 from __future__ import annotations
 import inspect
 import threading

schemathesis/cli/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import base64
 import enum
 import io
@@ -10,47 +11,45 @@ from collections import defaultdict
 from dataclasses import dataclass
 from enum import Enum
 from queue import Queue
-from typing import Any, Callable, Generator, Iterable, NoReturn, cast, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable, NoReturn, cast
 from urllib.parse import urlparse
 
 import click
 
 from .. import checks as checks_module
-from .. import contrib, experimental, generation
+from .. import contrib, experimental, generation, runner, service
 from .. import fixups as _fixups
-from .. import runner, service
 from .. import targets as targets_module
+from .._override import CaseOverride
 from ..code_samples import CodeSampleStyle
-from .constants import HealthCheck, Phase, Verbosity
-from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod
 from ..constants import (
     API_NAME_ENV_VAR,
     BASE_URL_ENV_VAR,
     DEFAULT_RESPONSE_TIMEOUT,
     DEFAULT_STATEFUL_RECURSION_LIMIT,
+    EXTENSIONS_DOCUMENTATION_URL,
     HOOKS_MODULE_ENV_VAR,
     HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER,
-    WAIT_FOR_SCHEMA_ENV_VAR,
-    EXTENSIONS_DOCUMENTATION_URL,
     ISSUE_TRACKER_URL,
+    WAIT_FOR_SCHEMA_ENV_VAR,
 )
-from ..exceptions import SchemaError, extract_nth_traceback, SchemaErrorType
+from ..exceptions import SchemaError, SchemaErrorType, extract_nth_traceback
 from ..fixups import ALL_FIXUPS
-from ..loaders import load_app, load_yaml
-from .._override import CaseOverride
-from ..transports.auth import get_requests_auth
+from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod
 from ..hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScope
+from ..internal.datetime import current_datetime
+from ..internal.validation import file_exists
+from ..loaders import load_app, load_yaml
 from ..models import Case, CheckFunction
 from ..runner import events, prepare_hypothesis_settings, probes
 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.auth import get_requests_auth
 from ..types import Filter, PathLike, RequestCert
-from ..internal.datetime import current_datetime
-from ..internal.validation import file_exists
 from . import callbacks, cassettes, output
-from .constants import DEFAULT_WORKERS, MAX_WORKERS, MIN_WORKERS
+from .constants import DEFAULT_WORKERS, MAX_WORKERS, MIN_WORKERS, HealthCheck, Phase, Verbosity
 from .context import ExecutionContext, FileReportContext, ServiceReportContext
 from .debug import DebugOutputHandler
 from .junitxml import JunitXMLHandler
@@ -60,8 +59,9 @@ from .sanitization import SanitizationHandler
 if TYPE_CHECKING:
     import hypothesis
     import requests
-    from ..service.client import ServiceClient
+
     from ..schemas import BaseSchema
+    from ..service.client import ServiceClient
     from ..specs.graphql.schemas import GraphQLSchema
     from .handlers import EventHandler
 
@@ -681,8 +681,9 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
 @click.option("--force-color", help="Explicitly tells to enable ANSI color escape codes.", type=bool, is_flag=True)
 @click.option(
     "--experimental",
+    "experiments",
     help="Enable experimental support for specific features.",
-    type=click.Choice([experimental.OPEN_API_3_1.name]),
+    type=click.Choice([experimental.OPEN_API_3_1.name, experimental.SCHEMA_ANALYSIS.name]),
     callback=callbacks.convert_experimental,
     multiple=True,
 )
@@ -737,7 +738,7 @@ def run(
     set_header: dict[str, str],
     set_cookie: dict[str, str],
     set_path: dict[str, str],
-    experimental: list,
+    experiments: list,
     checks: Iterable[str] = DEFAULT_CHECKS_NAMES,
     exclude_checks: Iterable[str] = (),
     data_generation_methods: tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
@@ -826,7 +827,7 @@ def run(
         show_trace = show_errors_tracebacks
 
     # Enable selected experiments
-    for experiment in experimental:
+    for experiment in experiments:
         experiment.enable()
 
     override = CaseOverride(query=set_query, headers=set_header, cookies=set_cookie, path_parameters=set_path)
@@ -901,6 +902,10 @@ def run(
         from ..service.client import ServiceClient
 
         # Upload without connecting data to a certain API
+        client = ServiceClient(base_url=schemathesis_io_url, token=token)
+    if experimental.SCHEMA_ANALYSIS.is_enabled and not client:
+        from ..service.client import ServiceClient
+
         client = ServiceClient(base_url=schemathesis_io_url, token=token)
     host_data = service.hosts.HostData(schemathesis_io_hostname, hosts_file)
 
@@ -970,6 +975,7 @@ def run(
         stateful_recursion_limit=stateful_recursion_limit,
         hypothesis_settings=hypothesis_settings,
         generation_config=generation_config,
+        service_client=client,
     )
     execute(
         event_stream,
@@ -1074,6 +1080,7 @@ def into_event_stream(
     store_interactions: bool,
     stateful: Stateful | None,
     stateful_recursion_limit: int,
+    service_client: ServiceClient | None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     try:
         if app is not None:
@@ -1133,6 +1140,7 @@ def into_event_stream(
                 auth_type=config.auth_type,
                 headers=config.headers,
             ),
+            service_client=service_client,
         ).execute()
     except SchemaError as error:
         yield events.InternalError.from_schema_error(error)

schemathesis/cli/cassettes.py

@@ -254,8 +254,8 @@ def write_double_quoted(stream: IO, text: str) -> None:
             ch = text[end]
         if (
             ch is None
-            or ch in '"\\\x85\u2028\u2029\uFEFF'
-            or not ("\x20" <= ch <= "\x7E" or ("\xA0" <= ch <= "\uD7FF" or "\uE000" <= ch <= "\uFFFD"))
+            or ch in '"\\\x85\u2028\u2029\ufeff'
+            or not ("\x20" <= ch <= "\x7e" or ("\xa0" <= ch <= "\ud7ff" or "\ue000" <= ch <= "\ufffd"))
         ):
             if start < end:
                 stream.write(text[start:end])
@@ -264,9 +264,9 @@ def write_double_quoted(stream: IO, text: str) -> None:
                 # Escape character
                 if ch in Emitter.ESCAPE_REPLACEMENTS:
                     data = "\\" + Emitter.ESCAPE_REPLACEMENTS[ch]
-                elif ch <= "\xFF":
+                elif ch <= "\xff":
                     data = "\\x%02X" % ord(ch)
-                elif ch <= "\uFFFF":
+                elif ch <= "\uffff":
                     data = "\\u%04X" % ord(ch)
                 else:
                     data = "\\U%08X" % ord(ch)

schemathesis/cli/context.py

@@ -8,8 +8,10 @@ from typing import TYPE_CHECKING
 
 from ..code_samples import CodeSampleStyle
 from ..internal.deprecation import deprecated_property
-from ..runner.serialization import SerializedTestResult
+from ..internal.result import Result
 from ..runner.probes import ProbeRun
+from ..runner.serialization import SerializedTestResult
+from ..service.models import AnalysisResult
 
 if TYPE_CHECKING:
     import hypothesis
@@ -52,6 +54,7 @@ class ExecutionContext:
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
     report: ServiceReportContext | FileReportContext | None = None
     probes: list[ProbeRun] | None = None
+    analysis: Result[AnalysisResult, Exception] | None = None
 
     @deprecated_property(removed_in="4.0", replacement="show_trace")
     def show_errors_tracebacks(self) -> bool:

schemathesis/cli/output/default.py

@@ -9,7 +9,7 @@ import time
 from importlib import metadata
 from itertools import groupby
 from queue import Queue
-from typing import Any, Generator, cast
+from typing import Any, Generator, cast, TYPE_CHECKING
 
 import click
 
@@ -25,16 +25,26 @@ from ...constants import (
     SCHEMATHESIS_TEST_CASE_HEADER,
     SCHEMATHESIS_VERSION,
 )
-from ...exceptions import RuntimeErrorType, prepare_response_payload
+from ...exceptions import (
+    RuntimeErrorType,
+    format_exception,
+    prepare_response_payload,
+    extract_requests_exception_details,
+)
 from ...experimental import GLOBAL_EXPERIMENTS
+from ...internal.result import Ok
 from ...models import Status
 from ...runner import events
 from ...runner.events import InternalErrorType, SchemaErrorType
 from ...runner.probes import ProbeOutcome
 from ...runner.serialization import SerializedCheck, SerializedError, SerializedTestResult, deduplicate_failures
+from ...service.models import AnalysisSuccess, UnknownExtension, ErrorState
 from ..context import ExecutionContext, FileReportContext, ServiceReportContext
 from ..handlers import EventHandler
 
+if TYPE_CHECKING:
+    import requests
+
 SPINNER_REPETITION_NUMBER = 10
 
 
@@ -181,16 +191,19 @@ def display_generic_errors(context: ExecutionContext, errors: list[SerializedErr
 
 def display_full_traceback_message(error: SerializedError) -> bool:
     # Some errors should not trigger the message that suggests to show full tracebacks to the user
-    return not error.exception.startswith(
-        (
-            "DeadlineExceeded",
-            "OperationSchemaError",
-            "requests.exceptions",
-            "SerializationNotPossible",
-            "hypothesis.errors.FailedHealthCheck",
-            "hypothesis.errors.InvalidArgument: Scalar ",
-            "hypothesis.errors.InvalidArgument: min_size=",
+    return (
+        not error.exception.startswith(
+            (
+                "DeadlineExceeded",
+                "OperationSchemaError",
+                "requests.exceptions",
+                "SerializationNotPossible",
+                "hypothesis.errors.FailedHealthCheck",
+                "hypothesis.errors.InvalidArgument: Scalar ",
+                "hypothesis.errors.InvalidArgument: min_size=",
+            )
         )
+        and "can never generate an example, because min_size is larger than Hypothesis supports." not in error.exception
     )
 
 
@@ -359,6 +372,81 @@ def display_single_log(result: SerializedTestResult) -> None:
     click.echo("\n\n".join(result.logs))
 
 
+def display_analysis(context: ExecutionContext) -> None:
+    """Display schema analysis details."""
+    import requests.exceptions
+
+    if context.analysis is None:
+        return
+    display_section_name("SCHEMA ANALYSIS")
+    if isinstance(context.analysis, Ok):
+        analysis = context.analysis.ok()
+        click.echo()
+        if isinstance(analysis, AnalysisSuccess):
+            click.secho(analysis.message, bold=True)
+            click.echo("\nAnalysis took: {:.2f}ms".format(analysis.elapsed))
+            if analysis.extensions:
+                known = []
+                failed = []
+                unknown = []
+                for extension in analysis.extensions:
+                    if isinstance(extension, UnknownExtension):
+                        unknown.append(extension)
+                    elif isinstance(extension.state, ErrorState):
+                        failed.append(extension)
+                    else:
+                        known.append(extension)
+                if known:
+                    click.echo("\nThe following extensions have been applied:\n")
+                    for extension in known:
+                        click.echo(f"  - {extension.summary}")
+                if failed:
+                    click.echo("\nThe following extensions errored:\n")
+                    for extension in failed:
+                        click.echo(f"  - {extension.summary}")
+                    suggestion = f"Please, consider reporting this to our issue tracker:\n\n  {ISSUE_TRACKER_URL}"
+                    click.secho(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}")
+                if unknown:
+                    noun = "extension" if len(unknown) == 1 else "extensions"
+                    specific_noun = "this extension" if len(unknown) == 1 else "these extensions"
+                    title = click.style("Compatibility Notice", bold=True)
+                    click.secho(f"\n{title}: {len(unknown)} {noun} not recognized:\n")
+                    for extension in unknown:
+                        click.echo(f"  - {extension.summary}")
+                    suggestion = f"Consider updating the CLI to add support for {specific_noun}."
+                    click.secho(f"\n{click.style('Tip:', bold=True, fg='green')} {suggestion}")
+            else:
+                click.echo("\nNo extensions have been applied.")
+        else:
+            click.echo("An error happened during schema analysis:\n")
+            click.secho(f"  {analysis.message}", bold=True)
+        click.echo()
+    else:
+        exception = context.analysis.err()
+        suggestion = None
+        if isinstance(exception, requests.exceptions.HTTPError):
+            response = exception.response
+            click.secho("Error\n", fg="red", bold=True)
+            _display_service_network_error(response)
+            click.echo()
+            return None
+        elif isinstance(exception, requests.RequestException):
+            message, extras = extract_requests_exception_details(exception)
+            suggestion = "Please check your network connection and try again."
+            title = "Network Error"
+        else:
+            traceback = format_exception(exception, True)
+            extras = _split_traceback(traceback)
+            title = "Internal Error"
+            message = f"We apologize for the inconvenience. This appears to be an internal issue.\nPlease, consider reporting the following details to our issue tracker:\n\n  {ISSUE_TRACKER_URL}"
+            suggestion = "Please update your CLI to the latest version and try again."
+        click.secho(f"{title}\n", fg="red", bold=True)
+        click.echo(message)
+        _display_extras(extras)
+        _maybe_display_tip(suggestion)
+        click.echo()
+
+
 def display_statistic(context: ExecutionContext, event: events.Finished) -> None:
     """Format and print statistic collected by :obj:`models.TestResult`."""
     display_section_name("SUMMARY")
@@ -493,39 +581,45 @@ def display_service_error(event: service.Error, message_prefix: str = "") -> Non
 
     if isinstance(event.exception, HTTPError):
         response = cast(Response, event.exception.response)
-        status_code = response.status_code
-        if 500 <= status_code <= 599:
-            click.secho(f"Schemathesis.io responded with HTTP {status_code}", fg="red")
-            # Server error, should be resolved soon
-            click.secho(
-                "\nIt is likely that we are already notified about the issue and working on a fix\n"
-                "Please, try again in 30 minutes",
-                fg="red",
-            )
-        elif status_code == 401:
-            # Likely an invalid token
-            click.echo("Your CLI is not authenticated.")
-            display_service_unauthorized("schemathesis.io")
-        else:
-            try:
-                data = response.json()
-                detail = data["detail"]
-                click.secho(f"{message_prefix}{detail}", fg="red")
-            except Exception:
-                # Other client-side errors are likely caused by a bug on the CLI side
-                click.secho(
-                    "We apologize for the inconvenience. This appears to be an internal issue.\n"
-                    "Please, consider reporting the following details to our issue "
-                    f"tracker:\n\n  {ISSUE_TRACKER_URL}\n\nResponse: {response.text!r}\n"
-                    f"Headers: {response.headers!r}",
-                    fg="red",
-                )
+        _display_service_network_error(response, message_prefix)
     elif isinstance(event.exception, RequestException):
         ask_to_report(event, report_to_issues=False)
     else:
         ask_to_report(event)
 
 
+def _display_service_network_error(response: requests.Response, message_prefix: str = "") -> None:
+    status_code = response.status_code
+    if 500 <= status_code <= 599:
+        click.secho(f"Schemathesis.io responded with HTTP {status_code}", fg="red")
+        # Server error, should be resolved soon
+        click.secho(
+            "\nIt is likely that we are already notified about the issue and working on a fix\n"
+            "Please, try again in 30 minutes",
+            fg="red",
+        )
+    elif status_code == 401:
+        # Likely an invalid token
+        click.echo("Your CLI is not authenticated.")
+        display_service_unauthorized("schemathesis.io")
+    else:
+        try:
+            data = response.json()
+            detail = data["detail"]
+            click.secho(f"{message_prefix}{detail}", fg="red")
+        except Exception:
+            # Other client-side errors are likely caused by a bug on the CLI side
+            click.secho(
+                "We apologize for the inconvenience. This appears to be an internal issue.\n"
+                "Please, consider reporting the following details to our issue "
+                f"tracker:\n\n  {ISSUE_TRACKER_URL}\n\nResponse: {response.text!r}\n"
+                f"Status: {response.status_code}\n"
+                f"Headers: {response.headers!r}",
+                fg="red",
+            )
+            _maybe_display_tip("Please update your CLI to the latest version and try again.")
+
+
 SERVICE_ERROR_MESSAGE = "An error happened during uploading reports to Schemathesis.io"
 
 
@@ -712,7 +806,23 @@ def handle_after_probing(context: ExecutionContext, event: events.AfterProbing)
                 status = "SUCCESS"
             elif probe.outcome == ProbeOutcome.ERROR:
                 status = "ERROR"
-    click.secho(f"API probing: {status}\r", bold=True, nl=False)
+    click.secho(f"API probing: {status}", bold=True, nl=False)
+    click.echo()
+
+
+def handle_before_analysis(context: ExecutionContext, event: events.BeforeAnalysis) -> None:
+    click.secho("Schema analysis: ...\r", bold=True, nl=False)
+
+
+def handle_after_analysis(context: ExecutionContext, event: events.AfterAnalysis) -> None:
+    context.analysis = event.analysis
+    status = "SKIP"
+    if event.analysis is not None:
+        if isinstance(event.analysis, Ok) and isinstance(event.analysis.ok(), AnalysisSuccess):
+            status = "SUCCESS"
+        else:
+            status = "ERROR"
+    click.secho(f"Schema analysis: {status}", bold=True, nl=False)
     click.echo()
     operations_count = cast(int, context.operations_count)  # INVARIANT: should not be `None`
     if operations_count >= 1:
@@ -752,6 +862,7 @@ def handle_finished(context: ExecutionContext, event: events.Finished) -> None:
     display_errors(context, event)
     display_failures(context, event)
     display_application_logs(context, event)
+    display_analysis(context)
     display_statistic(context, event)
     click.echo()
     display_summary(event)
@@ -777,6 +888,10 @@ class DefaultOutputStyleHandler(EventHandler):
             handle_before_probing(context, event)
         if isinstance(event, events.AfterProbing):
             handle_after_probing(context, event)
+        if isinstance(event, events.BeforeAnalysis):
+            handle_before_analysis(context, event)
+        if isinstance(event, events.AfterAnalysis):
+            handle_after_analysis(context, event)
         if isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
         if isinstance(event, events.AfterExecution):

schemathesis/cli/output/short.py

@@ -30,6 +30,10 @@ class ShortOutputStyleHandler(EventHandler):
             default.handle_before_probing(context, event)
         if isinstance(event, events.AfterProbing):
             default.handle_after_probing(context, event)
+        if isinstance(event, events.BeforeAnalysis):
+            default.handle_before_analysis(context, event)
+        if isinstance(event, events.AfterAnalysis):
+            default.handle_after_analysis(context, event)
         if isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
         if isinstance(event, events.AfterExecution):

schemathesis/experimental/__init__.py

@@ -72,3 +72,10 @@ OPEN_API_3_1 = GLOBAL_EXPERIMENTS.create_experiment(
     description="Support for response validation",
     discussion_url="https://github.com/schemathesis/schemathesis/discussions/1822",
 )
+SCHEMA_ANALYSIS = GLOBAL_EXPERIMENTS.create_experiment(
+    name="schema-analysis",
+    verbose_name="Schema Analysis",
+    env_var="SCHEMA_ANALYSIS",
+    description="Analyzing API schemas via Schemathesis.io",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2056",
+)

schemathesis/filters.py

@@ -1,4 +1,5 @@
 """Filtering system that allows users to filter API operations based on certain criteria."""
+
 from __future__ import annotations
 import re
 from dataclasses import dataclass, field

schemathesis/models.py

@@ -125,6 +125,8 @@ class Case:
     """A single test case parameters."""
 
     operation: APIOperation
+    # Time spent on generation of this test case
+    generation_time: float
     # Unique test case identifier
     id: str = field(default_factory=generate_random_case_id, compare=False)
     path_parameters: PathParameters | None = None
@@ -579,6 +581,7 @@ class Case:
             cookies=fast_deepcopy(self.cookies),
             query=fast_deepcopy(self.query),
             body=fast_deepcopy(self.body),
+            generation_time=self.generation_time,
         )
 
 

schemathesis/parameters.py

@@ -2,6 +2,7 @@
 
 These are basic entities that describe what data could be sent to the API.
 """
+
 from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Generator, Generic, TypeVar

schemathesis/runner/__init__.py

@@ -31,6 +31,7 @@ if TYPE_CHECKING:
     from ..stateful import Stateful
     from . import events
     from .impl import BaseRunner
+    from ..service.client import ServiceClient
 
 
 @deprecated_function(removed_in="4.0", replacement="schemathesis.runner.from_schema")
@@ -78,6 +79,7 @@ def prepare(
     hypothesis_suppress_health_check: list[hypothesis.HealthCheck] | None = None,
     hypothesis_verbosity: hypothesis.Verbosity | None = None,
     probe_config: ProbeConfig | None = None,
+    service_client: ServiceClient | None = None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     """Prepare a generator that will run test cases against the given API definition."""
     from ..checks import DEFAULT_CHECKS
@@ -132,6 +134,7 @@ def prepare(
         count_operations=count_operations,
         count_links=count_links,
         probe_config=probe_config,
+        service_client=service_client,
     )
 
 
@@ -193,6 +196,7 @@ def execute_from_schema(
     count_operations: bool = True,
     count_links: bool = True,
     probe_config: ProbeConfig | None = None,
+    service_client: ServiceClient | None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     """Execute tests for the given schema.
 
@@ -243,6 +247,7 @@ def execute_from_schema(
             count_operations=count_operations,
             count_links=count_links,
             probe_config=probe_config,
+            service_client=service_client,
         ).execute()
     except SchemaError as error:
         yield events.InternalError.from_schema_error(error)
@@ -348,6 +353,7 @@ def from_schema(
     count_operations: bool = True,
     count_links: bool = True,
     probe_config: ProbeConfig | None = None,
+    service_client: ServiceClient | None = None,
 ) -> BaseRunner:
     import hypothesis
     from starlette.applications import Starlette
@@ -402,6 +408,7 @@ def from_schema(
                 count_operations=count_operations,
                 count_links=count_links,
                 probe_config=probe_config,
+                service_client=service_client,
             )
         if isinstance(schema.app, Starlette):
             return ThreadPoolASGIRunner(
@@ -426,6 +433,7 @@ def from_schema(
                 count_operations=count_operations,
                 count_links=count_links,
                 probe_config=probe_config,
+                service_client=service_client,
             )
         return ThreadPoolWSGIRunner(
             schema=schema,
@@ -450,6 +458,7 @@ def from_schema(
             count_operations=count_operations,
             count_links=count_links,
             probe_config=probe_config,
+            service_client=service_client,
         )
     if not schema.app:
         return SingleThreadRunner(
@@ -478,6 +487,7 @@ def from_schema(
             count_operations=count_operations,
             count_links=count_links,
             probe_config=probe_config,
+            service_client=service_client,
         )
     if isinstance(schema.app, Starlette):
         return SingleThreadASGIRunner(
@@ -502,6 +512,7 @@ def from_schema(
             count_operations=count_operations,
             count_links=count_links,
             probe_config=probe_config,
+            service_client=service_client,
         )
     return SingleThreadWSGIRunner(
         schema=schema,
@@ -525,6 +536,7 @@ def from_schema(
         count_operations=count_operations,
         count_links=count_links,
         probe_config=probe_config,
+        service_client=service_client,
     )
 
 

schemathesis/runner/events.py

@@ -6,6 +6,7 @@ from dataclasses import asdict, dataclass, field
 from typing import Any, TYPE_CHECKING
 
 from ..internal.datetime import current_datetime
+from ..internal.result import Result
 from ..generation import DataGenerationMethod
 from ..exceptions import SchemaError, SchemaErrorType, format_exception, RuntimeErrorType
 from .serialization import SerializedError, SerializedTestResult
@@ -14,6 +15,7 @@ from .serialization import SerializedError, SerializedTestResult
 if TYPE_CHECKING:
     from ..models import APIOperation, Status, TestResult, TestResultSet
     from ..schemas import BaseSchema
+    from ..service.models import AnalysisResult
     from . import probes
 
 
@@ -93,6 +95,16 @@ class AfterProbing(ExecutionEvent):
         return {"probes": [probe.serialize() for probe in probes], "events_type": self.__class__.__name__}
 
 
+@dataclass
+class BeforeAnalysis(ExecutionEvent):
+    pass
+
+
+@dataclass
+class AfterAnalysis(ExecutionEvent):
+    analysis: Result[AnalysisResult, Exception] | None
+
+
 class CurrentOperationMixin:
     method: str
     path: str