schemathesis 3.33.2__py3-none-any.whl → 3.34.0__py3-none-any.whl

schemathesis/auths.py

@@ -14,6 +14,7 @@ from typing import (
     Generic,
     Protocol,
     TypeVar,
+    Union,
     overload,
     runtime_checkable,
 )
@@ -44,6 +45,9 @@ class AuthContext:
     app: Any | None
 
 
+CacheKeyFunction = Callable[["Case", "AuthContext"], Union[str, int]]
+
+
 @runtime_checkable
 class AuthProvider(Generic[Auth], Protocol):
     """Get authentication data for an API and set it on the generated test cases."""
@@ -99,16 +103,24 @@ class CachingAuthProvider(Generic[Auth]):
 
     def get(self, case: Case, context: AuthContext) -> Auth | None:
         """Get cached auth value."""
-        if self.cache_entry is None or self.timer() >= self.cache_entry.expires:
+        cache_entry = self._get_cache_entry(case, context)
+        if cache_entry is None or self.timer() >= cache_entry.expires:
             with self._refresh_lock:
-                if not (self.cache_entry is None or self.timer() >= self.cache_entry.expires):
+                cache_entry = self._get_cache_entry(case, context)
+                if not (cache_entry is None or self.timer() >= cache_entry.expires):
                     # Another thread updated the cache
-                    return self.cache_entry.data
+                    return cache_entry.data
                 # We know that optional auth is possible only inside a higher-level wrapper
                 data: Auth = _provider_get(self.provider, case, context)  # type: ignore[assignment]
-                self.cache_entry = CacheEntry(data=data, expires=self.timer() + self.refresh_interval)
+                self._set_cache_entry(data, case, context)
                 return data
-        return self.cache_entry.data
+        return cache_entry.data
+
+    def _get_cache_entry(self, case: Case, context: AuthContext) -> CacheEntry[Auth] | None:
+        return self.cache_entry
+
+    def _set_cache_entry(self, data: Auth, case: Case, context: AuthContext) -> None:
+        self.cache_entry = CacheEntry(data=data, expires=self.timer() + self.refresh_interval)
 
     def set(self, case: Case, data: Auth, context: AuthContext) -> None:
         """Set auth data on the `Case` instance.
@@ -118,6 +130,25 @@ class CachingAuthProvider(Generic[Auth]):
         self.provider.set(case, data, context)
 
 
+def _noop_key_function(case: Case, context: AuthContext) -> str:
+    # Never used
+    raise NotImplementedError
+
+
+@dataclass
+class KeyedCachingAuthProvider(CachingAuthProvider[Auth]):
+    cache_by_key: CacheKeyFunction = _noop_key_function
+    cache_entries: dict[str | int, CacheEntry[Auth] | None] = field(default_factory=dict)
+
+    def _get_cache_entry(self, case: Case, context: AuthContext) -> CacheEntry[Auth] | None:
+        key = self.cache_by_key(case, context)
+        return self.cache_entries.get(key)
+
+    def _set_cache_entry(self, data: Auth, case: Case, context: AuthContext) -> None:
+        key = self.cache_by_key(case, context)
+        self.cache_entries[key] = CacheEntry(data=data, expires=self.timer() + self.refresh_interval)
+
+
 class FilterableRegisterAuth(Protocol):
     """Protocol that adds filters to the return value of `register`."""
 
@@ -246,6 +277,7 @@ class AuthStorage(Generic[Auth]):
         self,
         *,
         refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
+        cache_by_key: CacheKeyFunction | None = None,
     ) -> FilterableRegisterAuth:
         pass
 
@@ -255,6 +287,7 @@ class AuthStorage(Generic[Auth]):
         provider_class: type[AuthProvider],
         *,
         refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
+        cache_by_key: CacheKeyFunction | None = None,
     ) -> FilterableApplyAuth:
         pass
 
@@ -263,10 +296,11 @@ class AuthStorage(Generic[Auth]):
         provider_class: type[AuthProvider] | None = None,
         *,
         refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
+        cache_by_key: CacheKeyFunction | None = None,
     ) -> FilterableRegisterAuth | FilterableApplyAuth:
         if provider_class is not None:
-            return self.apply(provider_class, refresh_interval=refresh_interval)
-        return self.register(refresh_interval=refresh_interval)
+            return self.apply(provider_class, refresh_interval=refresh_interval, cache_by_key=cache_by_key)
+        return self.register(refresh_interval=refresh_interval, cache_by_key=cache_by_key)
 
     def set_from_requests(self, auth: requests.auth.AuthBase) -> FilterableRequestsAuth:
         """Use `requests` auth instance as an auth provider."""
@@ -286,6 +320,7 @@ class AuthStorage(Generic[Auth]):
         *,
         provider_class: type[AuthProvider],
         refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
+        cache_by_key: CacheKeyFunction | None = None,
         filter_set: FilterSet,
     ) -> None:
         if not issubclass(provider_class, AuthProvider):
@@ -295,16 +330,27 @@ class AuthStorage(Generic[Auth]):
             )
         provider: AuthProvider
         # Apply caching if desired
+        instance = provider_class()
         if refresh_interval is not None:
-            provider = CachingAuthProvider(provider_class(), refresh_interval=refresh_interval)
+            if cache_by_key is None:
+                provider = CachingAuthProvider(instance, refresh_interval=refresh_interval)
+            else:
+                provider = KeyedCachingAuthProvider(
+                    instance, refresh_interval=refresh_interval, cache_by_key=cache_by_key
+                )
         else:
-            provider = provider_class()
+            provider = instance
         # Store filters if any
         if not filter_set.is_empty():
             provider = SelectiveAuthProvider(provider, filter_set)
         self.providers.append(provider)
 
-    def register(self, *, refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL) -> FilterableRegisterAuth:
+    def register(
+        self,
+        *,
+        refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
+        cache_by_key: CacheKeyFunction | None = None,
+    ) -> FilterableRegisterAuth:
         """Register a new auth provider.
 
         .. code-block:: python
@@ -326,7 +372,12 @@ class AuthStorage(Generic[Auth]):
         filter_set = FilterSet()
 
         def wrapper(provider_class: type[AuthProvider]) -> type[AuthProvider]:
-            self._set_provider(provider_class=provider_class, refresh_interval=refresh_interval, filter_set=filter_set)
+            self._set_provider(
+                provider_class=provider_class,
+                refresh_interval=refresh_interval,
+                filter_set=filter_set,
+                cache_by_key=cache_by_key,
+            )
             return provider_class
 
         attach_filter_chain(wrapper, "apply_to", filter_set.include)
@@ -342,7 +393,11 @@ class AuthStorage(Generic[Auth]):
         self.providers = []
 
     def apply(
-        self, provider_class: type[AuthProvider], *, refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL
+        self,
+        provider_class: type[AuthProvider],
+        *,
+        refresh_interval: int | None = DEFAULT_REFRESH_INTERVAL,
+        cache_by_key: CacheKeyFunction | None = None,
     ) -> FilterableApplyAuth:
         """Register auth provider only on one test function.
 
@@ -366,7 +421,10 @@ class AuthStorage(Generic[Auth]):
         def wrapper(test: GenericTest) -> GenericTest:
             auth_storage = self.add_auth_storage(test)
             auth_storage._set_provider(
-                provider_class=provider_class, refresh_interval=refresh_interval, filter_set=filter_set
+                provider_class=provider_class,
+                refresh_interval=refresh_interval,
+                filter_set=filter_set,
+                cache_by_key=cache_by_key,
             )
             return test
 

schemathesis/checks.py

@@ -7,6 +7,7 @@ from . import failures
 from .exceptions import get_response_parsing_error, get_server_error
 from .specs.openapi.checks import (
     content_type_conformance,
+    ignored_auth,
     negative_data_rejection,
     response_headers_conformance,
     response_schema_conformance,
@@ -50,6 +51,7 @@ OPTIONAL_CHECKS = (
     response_headers_conformance,
     response_schema_conformance,
     negative_data_rejection,
+    ignored_auth,
 )
 ALL_CHECKS: tuple[CheckFunction, ...] = DEFAULT_CHECKS + OPTIONAL_CHECKS
 

schemathesis/cli/__init__.py

@@ -795,6 +795,14 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
     show_default=True,
     callback=callbacks.convert_boolean_string,
 )
+@click.option(
+    "--generation-graphql-allow-null",
+    help="Whether `null` values should be used for optional arguments in GraphQL queries.",
+    type=str,
+    default="true",
+    show_default=True,
+    callback=callbacks.convert_boolean_string,
+)
 @click.option(
     "--schemathesis-io-token",
     help="Schemathesis.io authentication token.",
@@ -911,6 +919,7 @@ def run(
     no_color: bool = False,
     report_value: str | None = None,
     generation_allow_x00: bool = True,
+    generation_graphql_allow_null: bool = True,
     generation_with_security_parameters: bool = True,
     generation_codec: str = "utf-8",
     schemathesis_io_token: str | None = None,
@@ -953,6 +962,7 @@ def run(
 
     generation_config = generation.GenerationConfig(
         allow_x00=generation_allow_x00,
+        graphql_allow_null=generation_graphql_allow_null,
         codec=generation_codec,
         with_security_parameters=generation_with_security_parameters,
     )

schemathesis/cli/callbacks.py

@@ -15,9 +15,10 @@ from click.types import LazyFile  # type: ignore
 
 from .. import exceptions, experimental, throttling
 from ..code_samples import CodeSampleStyle
-from ..constants import FALSE_VALUES, TRUE_VALUES
+from ..constants import TRUE_VALUES
 from ..exceptions import extract_nth_traceback
 from ..generation import DataGenerationMethod
+from ..internal.transformation import convert_boolean_string as _convert_boolean_string
 from ..internal.validation import file_exists, is_filename, is_illegal_surrogate
 from ..loaders import load_app
 from ..service.hosts import get_temporary_hosts_file
@@ -378,11 +379,7 @@ def convert_hosts_file(ctx: click.core.Context, param: click.core.Parameter, val
 
 
 def convert_boolean_string(ctx: click.core.Context, param: click.core.Parameter, value: str) -> str | bool:
-    if value.lower() in TRUE_VALUES:
-        return True
-    if value.lower() in FALSE_VALUES:
-        return False
-    return value
+    return _convert_boolean_string(value)
 
 
 def convert_report(ctx: click.core.Context, param: click.core.Option, value: LazyFile) -> LazyFile:

schemathesis/cli/junitxml.py

@@ -27,28 +27,31 @@ class JunitXMLHandler(EventHandler):
     test_cases: list = field(default_factory=list)
 
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
-        if isinstance(event, events.AfterExecution):
-            test_case = TestCase(
-                f"{event.result.method} {event.result.path}",
-                elapsed_sec=event.elapsed_time,
-                allow_multiple_subelements=True,
-            )
-            if event.status == Status.failure:
-                for idx, (code_sample, group) in enumerate(
-                    group_by_case(event.result.checks, context.code_sample_style), 1
-                ):
-                    checks = sorted(group, key=lambda c: c.name != "not_a_server_error")
-                    test_case.add_failure_info(message=build_failure_message(context, idx, code_sample, checks))
-            elif event.status == Status.error:
-                test_case.add_error_info(message=build_error_message(context, event.result.errors[-1]))
-            elif event.status == Status.skip:
-                test_case.add_skipped_info(message=event.result.skip_reason)
+        if isinstance(event, (events.AfterExecution, events.AfterStatefulExecution)):
+            event_: events.AfterExecution | events.AfterStatefulExecution = event
+            if isinstance(event_, events.AfterExecution):
+                name = f"{event_.result.method} {event_.result.path}"
+            else:
+                name = event_.result.verbose_name
+            test_case = TestCase(name, elapsed_sec=event_.elapsed_time, allow_multiple_subelements=True)
+            if event_.status == Status.failure:
+                _add_failure(test_case, event_.result.checks, context)
+            elif event_.status == Status.error:
+                test_case.add_error_info(message=build_error_message(context, event_.result.errors[-1]))
+            elif event_.status == Status.skip:
+                test_case.add_skipped_info(message=event_.result.skip_reason)
             self.test_cases.append(test_case)
-        if isinstance(event, events.Finished):
+        elif isinstance(event, events.Finished):
             test_suites = [TestSuite("schemathesis", test_cases=self.test_cases, hostname=platform.node())]
             to_xml_report_file(file_descriptor=self.file_handle, test_suites=test_suites, prettyprint=True)
 
 
+def _add_failure(test_case: TestCase, checks: list[SerializedCheck], context: ExecutionContext) -> None:
+    for idx, (code_sample, group) in enumerate(group_by_case(checks, context.code_sample_style), 1):
+        checks = sorted(group, key=lambda c: c.name != "not_a_server_error")
+        test_case.add_failure_info(message=build_failure_message(context, idx, code_sample, checks))
+
+
 def build_failure_message(context: ExecutionContext, idx: int, code_sample: str, checks: list[SerializedCheck]) -> str:
     from ..transports.responses import get_reason
 

schemathesis/cli/sanitization.py

@@ -19,3 +19,8 @@ class SanitizationHandler(EventHandler):
                 sanitize_serialized_check(check)
             for interaction in event.result.interactions:
                 sanitize_serialized_interaction(interaction)
+        elif isinstance(event, events.AfterStatefulExecution):
+            for check in event.result.checks:
+                sanitize_serialized_check(check)
+            for interaction in event.result.interactions:
+                sanitize_serialized_interaction(interaction)

schemathesis/exceptions.py

@@ -151,6 +151,14 @@ def get_use_after_free_error(free: str) -> type[CheckFailed]:
     return _get_hashed_exception("UseAfterFreeError", free)
 
 
+def get_ensure_resource_availability_error(operation: str) -> type[CheckFailed]:
+    return _get_hashed_exception("EnsureResourceAvailabilityError", operation)
+
+
+def get_ignored_auth_error(operation: str) -> type[CheckFailed]:
+    return _get_hashed_exception("IgnoredAuthError", operation)
+
+
 def get_timeout_error(prefix: str, deadline: float | int) -> type[CheckFailed]:
     """Request took too long."""
     return _get_hashed_exception(f"TimeoutError{prefix}", str(deadline))

schemathesis/failures.py

@@ -151,6 +151,26 @@ class UseAfterFree(FailureContext):
     type: str = "use_after_free"
 
 
+@dataclass(repr=False)
+class EnsureResourceAvailability(FailureContext):
+    """Resource is not available immediately after creation."""
+
+    message: str
+    created_with: str
+    not_available_with: str
+    title: str = "Resource is not available after creation"
+    type: str = "ensure_resource_availability"
+
+
+@dataclass(repr=False)
+class IgnoredAuth(FailureContext):
+    """The API operation does not check the specified authentication."""
+
+    message: str
+    title: str = "Authentication declared but not enforced for this operation"
+    type: str = "ignored_auth"
+
+
 @dataclass(repr=False)
 class UndefinedStatusCode(FailureContext):
     """Response has a status code that is not defined in the schema."""

schemathesis/generation/__init__.py

@@ -75,6 +75,8 @@ class GenerationConfig:
 
     # Allow generating `\x00` bytes in strings
     allow_x00: bool = True
+    # Allowing using `null` for optional arguments in GraphQL queries
+    graphql_allow_null: bool = True
     # Generate strings using the given codec
     codec: str | None = "utf-8"
     # Whether to generate security parameters

schemathesis/hooks.py

@@ -8,6 +8,7 @@ from enum import Enum, unique
 from functools import partial
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, DefaultDict, cast
 
+from .filters import FilterSet, attach_filter_chain
 from .internal.deprecation import deprecated_property
 from .types import GenericTest
 
@@ -47,6 +48,58 @@ class HookContext:
         return self.operation
 
 
+def to_filterable_hook(dispatcher: HookDispatcher) -> Callable:
+    filter_used = False
+    filter_set = FilterSet()
+
+    def register(hook: str | Callable) -> Callable:
+        nonlocal filter_set
+
+        if filter_used:
+            validate_filterable_hook(hook)
+
+        if isinstance(hook, str):
+
+            def decorator(func: Callable) -> Callable:
+                hook_name = cast(str, hook)
+                if filter_used:
+                    validate_filterable_hook(hook)
+                func.filter_set = filter_set  # type: ignore[attr-defined]
+                return dispatcher.register_hook_with_name(func, hook_name)
+
+            init_filter_set(decorator)
+            return decorator
+
+        hook.filter_set = filter_set  # type: ignore[attr-defined]
+        init_filter_set(register)
+        return dispatcher.register_hook_with_name(hook, hook.__name__)
+
+    def init_filter_set(target: Callable) -> FilterSet:
+        nonlocal filter_used
+
+        filter_used = False
+        filter_set = FilterSet()
+
+        def include(*args: Any, **kwargs: Any) -> None:
+            nonlocal filter_used
+
+            filter_used = True
+            filter_set.include(*args, **kwargs)
+
+        def exclude(*args: Any, **kwargs: Any) -> None:
+            nonlocal filter_used
+
+            filter_used = True
+            filter_set.exclude(*args, **kwargs)
+
+        attach_filter_chain(target, "apply_to", include)
+        attach_filter_chain(target, "skip_for", exclude)
+        return filter_set
+
+    filter_set = init_filter_set(register)
+    return register
+
+
 @dataclass
 class HookDispatcher:
     """Generic hook dispatcher.
@@ -58,6 +111,9 @@ class HookDispatcher:
     _hooks: DefaultDict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
     _specs: ClassVar[dict[str, RegisteredHook]] = {}
 
+    def __post_init__(self) -> None:
+        self.register = to_filterable_hook(self)  # type: ignore[method-assign]
+
     def register(self, hook: str | Callable) -> Callable:
         """Register a new hook.
 
@@ -80,14 +136,7 @@ class HookDispatcher:
             def hook(context, strategy):
                 ...
         """
-        if isinstance(hook, str):
-
-            def decorator(func: Callable) -> Callable:
-                hook_name = cast(str, hook)
-                return self.register_hook_with_name(func, hook_name)
-
-            return decorator
-        return self.register_hook_with_name(hook, hook.__name__)
+        raise NotImplementedError
 
     def merge(self, other: HookDispatcher) -> HookDispatcher:
         """Merge two dispatches together.
@@ -192,14 +241,22 @@ class HookDispatcher:
         self, strategy: st.SearchStrategy, container: str, context: HookContext
     ) -> st.SearchStrategy:
         for hook in self.get_all_by_name(f"before_generate_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             strategy = hook(context, strategy)
         for hook in self.get_all_by_name(f"filter_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             hook = partial(hook, context)
             strategy = strategy.filter(hook)
         for hook in self.get_all_by_name(f"map_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             hook = partial(hook, context)
             strategy = strategy.map(hook)
         for hook in self.get_all_by_name(f"flatmap_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             hook = partial(hook, context)
             strategy = strategy.flatmap(hook)
         return strategy
@@ -207,6 +264,8 @@ class HookDispatcher:
     def dispatch(self, name: str, context: HookContext, *args: Any, **kwargs: Any) -> None:
         """Run all hooks for the given name."""
         for hook in self.get_all_by_name(name):
+            if _should_skip_hook(hook, context):
+                continue
             hook(context, *args, **kwargs)
 
     def unregister(self, hook: Callable) -> None:
@@ -226,6 +285,11 @@ class HookDispatcher:
         self._hooks = defaultdict(list)
 
 
+def _should_skip_hook(hook: Callable, context: HookContext) -> bool:
+    filter_set = getattr(hook, "filter_set", None)
+    return filter_set is not None and not filter_set.match(context)
+
+
 def apply_to_all_dispatchers(
     operation: APIOperation,
     context: HookContext,
@@ -248,6 +312,15 @@ def should_skip_operation(dispatcher: HookDispatcher, context: HookContext) -> b
     return False
 
 
+def validate_filterable_hook(hook: str | Callable) -> None:
+    if callable(hook):
+        name = hook.__name__
+    else:
+        name = hook
+    if name in ("before_process_path", "before_load_schema", "after_load_schema", "after_init_cli_run_handlers"):
+        raise ValueError(f"Filters are not applicable to this hook: `{name}`")
+
+
 all_scopes = HookDispatcher.register_spec(list(HookScope))
 
 

schemathesis/internal/transformation.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import Any
 
+from ..constants import FALSE_VALUES, TRUE_VALUES
+
 
 def merge_recursively(a: dict[str, Any], b: dict[str, Any]) -> dict[str, Any]:
     """Merge two dictionaries recursively."""
@@ -14,3 +16,11 @@ def merge_recursively(a: dict[str, Any], b: dict[str, Any]) -> dict[str, Any]:
         else:
             a[key] = b[key]
     return a
+
+
+def convert_boolean_string(value: str) -> str | bool:
+    if value.lower() in TRUE_VALUES:
+        return True
+    if value.lower() in FALSE_VALUES:
+        return False
+    return value

schemathesis/models.py

@@ -24,7 +24,7 @@ from typing import (
     TypeVar,
     cast,
 )
-from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
+from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
 
 from . import serializers
 from ._dependency_versions import IS_WERKZEUG_ABOVE_3
@@ -78,9 +78,15 @@ class CaseSource:
     case: Case
     response: GenericResponse
     elapsed: float
+    overrides_all_parameters: bool
 
     def partial_deepcopy(self) -> CaseSource:
-        return self.__class__(case=self.case.partial_deepcopy(), response=self.response, elapsed=self.elapsed)
+        return self.__class__(
+            case=self.case.partial_deepcopy(),
+            response=self.response,
+            elapsed=self.elapsed,
+            overrides_all_parameters=self.overrides_all_parameters,
+        )
 
 
 def cant_serialize(media_type: str) -> NoReturn:  # type: ignore
@@ -198,8 +204,10 @@ class Case:
     def app(self) -> Any:
         return self.operation.app
 
-    def set_source(self, response: GenericResponse, case: Case, elapsed: float) -> None:
-        self.source = CaseSource(case=case, response=response, elapsed=elapsed)
+    def set_source(self, response: GenericResponse, case: Case, elapsed: float, overrides_all_parameters: bool) -> None:
+        self.source = CaseSource(
+            case=case, response=response, elapsed=elapsed, overrides_all_parameters=overrides_all_parameters
+        )
 
     @property
     def formatted_path(self) -> str:
@@ -511,28 +519,6 @@ class Case:
         )
 
 
-def _merge_dict_to(data: dict[str, Any], data_key: str, new: dict[str, Any]) -> None:
-    original = data[data_key] or {}
-    for key, value in new.items():
-        original[key] = value
-    data[data_key] = original
-
-
-def validate_vanilla_requests_kwargs(data: dict[str, Any]) -> None:
-    """Check arguments for `requests.Session.request`.
-
-    Some arguments can be valid for cases like ASGI integration, but at the same time they won't work for the regular
-    `requests` calls. In such cases we need to avoid an obscure error message, that comes from `requests`.
-    """
-    url = data["url"]
-    if not urlparse(url).netloc:
-        raise RuntimeError(
-            "The URL should be absolute, so Schemathesis knows where to send the data. \n"
-            f"If you use the ASGI integration, please supply your test client "
-            f"as the `session` argument to `call`.\nURL: {url}"
-        )
-
-
 @contextmanager
 def cookie_handler(client: werkzeug.Client, cookies: Cookies | None) -> Generator[None, None, None]:
     """Set cookies required for a call."""

schemathesis/runner/events.py

@@ -325,6 +325,7 @@ class AfterStatefulExecution(ExecutionEvent):
 
     status: Status
     result: SerializedTestResult
+    elapsed_time: float
     data_generation_method: list[DataGenerationMethod]
     thread_id: int = field(default_factory=threading.get_ident)
 

schemathesis/runner/impl/core.py

@@ -299,12 +299,19 @@ class BaseRunner:
                 def on_step_finished(event: stateful_events.StepFinished) -> None:
                     return None
 
+            test_start_time: float | None = None
+            test_elapsed_time: float | None = None
+
             for stateful_event in runner.execute():
                 if isinstance(stateful_event, stateful_events.SuiteFinished):
                     if stateful_event.failures and status != Status.error:
                         status = Status.failure
                     for failure in stateful_event.failures:
                         result.checks.append(failure)
+                elif isinstance(stateful_event, stateful_events.RunStarted):
+                    test_start_time = stateful_event.timestamp
+                elif isinstance(stateful_event, stateful_events.RunFinished):
+                    test_elapsed_time = stateful_event.timestamp - cast(float, test_start_time)
                 elif isinstance(stateful_event, stateful_events.StepFinished):
                     on_step_finished(stateful_event)
                 elif isinstance(stateful_event, stateful_events.Errored):
@@ -315,6 +322,7 @@ class BaseRunner:
             yield events.AfterStatefulExecution(
                 status=status,
                 result=SerializedTestResult.from_test_result(result),
+                elapsed_time=cast(float, test_elapsed_time),
                 data_generation_method=self.schema.data_generation_methods,
             )
 
@@ -605,8 +613,12 @@ def run_test(
         status = Status.error
         try:
             operation.schema.validate()
+            msg = "Unexpected error during testing of this API operation"
+            exc_msg = str(exc)
+            if exc_msg:
+                msg += f": {exc_msg}"
             try:
-                raise InternalError(f"Unexpected error during testing of this API operation: {exc}") from exc
+                raise InternalError(msg) from exc
             except InternalError as exc:
                 error = exc
         except ValidationError as exc:

schemathesis/sanitization.py

@@ -238,6 +238,7 @@ def sanitize_serialized_check(check: SerializedCheck, *, config: Config | None =
 
 
 def sanitize_serialized_case(case: SerializedCase, *, config: Config | None = None) -> None:
+    case.url = sanitize_url(case.url, config=config)
     for value in (case.path_parameters, case.headers, case.cookies, case.query, case.extra_headers):
         if value is not None:
             sanitize_value(value, config=config)