schemathesis 3.31.0__py3-none-any.whl → 3.32.0__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/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/models.py

@@ -119,6 +119,19 @@ def prepare_request_data(kwargs: dict[str, Any]) -> PreparedRequestData:
     )
 
 
+@dataclass
+class GenerationMetadata:
+    """Stores various information about how data is generated."""
+
+    query: DataGenerationMethod | None
+    path_parameters: DataGenerationMethod | None
+    headers: DataGenerationMethod | None
+    cookies: DataGenerationMethod | None
+    body: DataGenerationMethod | None
+
+    __slots__ = ("query", "path_parameters", "headers", "cookies", "body")
+
+
 @dataclass(repr=False)
 class Case:
     """A single test case parameters."""
@@ -139,6 +152,8 @@ class Case:
     media_type: str | None = None
     source: CaseSource | None = None
 
+    meta: GenerationMetadata | None = None
+
     # The way the case was generated (None for manually crafted ones)
     data_generation_method: DataGenerationMethod | None = None
     _auth: requests.auth.AuthBase | None = None

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/impl/core.py

@@ -20,7 +20,7 @@ from hypothesis.errors import HypothesisException, InvalidArgument
 from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
 from jsonschema.exceptions import SchemaError as JsonSchemaError
 from jsonschema.exceptions import ValidationError
-from requests.auth import HTTPDigestAuth, _basic_auth_str
+from requests.auth import HTTPDigestAuth
 from urllib3.exceptions import InsecureRequestWarning
 
 from ... import experimental, failures, hooks
@@ -33,6 +33,7 @@ from ..._hypothesis import (
 )
 from ..._override import CaseOverride
 from ...auths import unregister as unregister_auth
+from ...checks import _make_max_response_time_failure_message
 from ...constants import (
     DEFAULT_STATEFUL_RECURSION_LIMIT,
     RECURSIVE_REFERENCE_ERROR_MESSAGE,
@@ -68,8 +69,9 @@ from ...stateful import Feedback, Stateful
 from ...stateful import events as stateful_events
 from ...stateful import runner as stateful_runner
 from ...targets import Target, TargetContext
-from ...transports import RequestsTransport, prepare_timeout
-from ...types import RawAuth, RequestCert
+from ...transports import RequestConfig, RequestsTransport
+from ...transports.auth import get_requests_auth, prepare_wsgi_headers
+from ...types import RawAuth
 from ...utils import capture_hypothesis_output
 from .. import probes
 from ..serialization import SerializedTestResult
@@ -92,11 +94,11 @@ class BaseRunner:
     hypothesis_settings: hypothesis.settings
     generation_config: GenerationConfig
     probe_config: probes.ProbeConfig
+    request_config: RequestConfig = field(default_factory=RequestConfig)
     override: CaseOverride | None = None
     auth: RawAuth | None = None
     auth_type: str | None = None
     headers: dict[str, Any] | None = None
-    request_timeout: int | None = None
     store_interactions: bool = False
     seed: int | None = None
     exit_first: bool = False
@@ -109,6 +111,7 @@ class BaseRunner:
     count_links: bool = True
     service_client: ServiceClient | None = None
     _failures_counter: int = 0
+    _is_stopping_due_to_failure_limit: bool = False
 
     def execute(self) -> EventStream:
         """Common logic for all runners."""
@@ -197,13 +200,20 @@ class BaseRunner:
             warnings.simplefilter("ignore", InsecureRequestWarning)
             if not experimental.STATEFUL_ONLY.is_enabled:
                 yield from self._execute(results, stop_event)
-            yield from self._run_stateful_tests(results)
+            if not self._is_stopping_due_to_failure_limit:
+                yield from self._run_stateful_tests(results)
         except KeyboardInterrupt:
             yield events.Interrupted()
 
         yield _finish()
 
     def _should_stop(self, event: events.ExecutionEvent) -> bool:
+        result = self.__should_stop(event)
+        if result:
+            self._is_stopping_due_to_failure_limit = True
+        return result
+
+    def __should_stop(self, event: events.ExecutionEvent) -> bool:
         if _should_count_towards_stop(event):
             if self.exit_first:
                 return True
@@ -224,14 +234,25 @@ class BaseRunner:
                 method="",
                 path="",
                 verbose_name="Stateful tests",
+                seed=self.seed,
                 data_generation_method=self.schema.data_generation_methods,
             )
+            headers = self.headers or {}
+            if isinstance(self.schema.transport, RequestsTransport):
+                auth = get_requests_auth(self.auth, self.auth_type)
+            else:
+                auth = None
+                headers = prepare_wsgi_headers(headers, self.auth, self.auth_type)
             config = stateful_runner.StatefulTestRunnerConfig(
                 checks=tuple(self.checks),
-                headers=self.headers or {},
+                headers=headers,
                 hypothesis_settings=self.hypothesis_settings,
                 exit_first=self.exit_first,
-                request_timeout=self.request_timeout,
+                max_failures=None if self.max_failures is None else self.max_failures - self._failures_counter,
+                request=self.request_config,
+                auth=auth,
+                seed=self.seed,
+                override=self.override,
             )
             state_machine = self.schema.as_state_machine()
             runner = state_machine.runner(config=config)
@@ -249,7 +270,7 @@ class BaseRunner:
                 if isinstance(state_machine.schema.transport, RequestsTransport):
 
                     def on_step_finished(event: stateful_events.StepFinished) -> None:
-                        if event.response is not None:
+                        if event.response is not None and event.status is not None:
                             response = cast(requests.Response, event.response)
                             result.store_requests_response(
                                 status=from_step_status(event.status),
@@ -261,13 +282,15 @@ class BaseRunner:
                 else:
 
                     def on_step_finished(event: stateful_events.StepFinished) -> None:
-                        if event.response is not None:
+                        from ...transports.responses import WSGIResponse
+
+                        if event.response is not None and event.status is not None:
                             response = cast(WSGIResponse, event.response)
                             result.store_wsgi_response(
                                 status=from_step_status(event.status),
                                 case=event.case,
                                 response=response,
-                                headers=self.headers or {},
+                                headers=headers,
                                 elapsed=response.elapsed.total_seconds(),
                                 checks=event.checks,
                             )
@@ -286,6 +309,7 @@ class BaseRunner:
                     on_step_finished(stateful_event)
                 elif isinstance(stateful_event, stateful_events.Errored):
                     status = Status.error
+                    result.add_error(stateful_event.exception)
                 yield events.StatefulEvent(data=stateful_event)
             results.append(result)
             yield events.AfterStatefulExecution(
@@ -506,6 +530,26 @@ def run_test(
     errors: list[Exception] = []
     test_start_time = time.monotonic()
     setup_hypothesis_database_key(test, operation)
+
+    def _on_flaky(exc: Exception) -> Status:
+        if isinstance(exc.__cause__, hypothesis.errors.DeadlineExceeded):
+            status = Status.error
+            result.add_error(DeadlineExceeded.from_exc(exc.__cause__))
+        elif isinstance(exc, hypothesis.errors.FlakyFailure) and any(
+            isinstance(subexc, hypothesis.errors.DeadlineExceeded) for subexc in exc.exceptions
+        ):
+            for sub_exc in exc.exceptions:
+                if isinstance(sub_exc, hypothesis.errors.DeadlineExceeded):
+                    result.add_error(DeadlineExceeded.from_exc(sub_exc))
+            status = Status.error
+        elif errors:
+            status = Status.error
+            add_errors(result, errors)
+        else:
+            status = Status.failure
+            result.mark_flaky()
+        return status
+
     try:
         with catch_warnings(record=True) as warnings, capture_hypothesis_output() as hypothesis_output:
             test(
@@ -535,6 +579,9 @@ def run_test(
         result.mark_errored()
         for error in deduplicate_errors(errors):
             result.add_error(error)
+    except hypothesis.errors.FlakyFailure as exc:
+        # Hypothesis >= 6.108.0
+        status = _on_flaky(exc)
     except MultipleFailures:
         # Schemathesis may detect multiple errors that come from different check results
         # They raise different "grouped" exceptions
@@ -544,15 +591,7 @@ def run_test(
         else:
             status = Status.failure
     except hypothesis.errors.Flaky as exc:
-        if isinstance(exc.__cause__, hypothesis.errors.DeadlineExceeded):
-            status = Status.error
-            result.add_error(DeadlineExceeded.from_exc(exc.__cause__))
-        elif errors:
-            status = Status.error
-            add_errors(result, errors)
-        else:
-            status = Status.failure
-            result.mark_flaky()
+        status = _on_flaky(exc)
     except hypothesis.errors.Unsatisfiable:
         # We need more clear error message here
         status = Status.error
@@ -789,7 +828,7 @@ def run_checks(
 
     if max_response_time:
         if elapsed_time > max_response_time:
-            message = f"Actual: {elapsed_time:.2f}ms\nLimit: {max_response_time}.00ms"
+            message = _make_max_response_time_failure_message(elapsed_time, max_response_time)
             errors.append(AssertionError(message))
             result.add_failure(
                 "max_response_time",
@@ -869,10 +908,7 @@ def network_test(
     targets: Iterable[Target],
     result: TestResult,
     session: requests.Session,
-    request_timeout: int | None,
-    request_tls_verify: bool,
-    request_proxy: str | None,
-    request_cert: RequestCert | None,
+    request_config: RequestConfig,
     store_interactions: bool,
     headers: dict[str, Any] | None,
     feedback: Feedback | None,
@@ -888,20 +924,16 @@ def network_test(
         headers = headers or {}
         if "user-agent" not in {header.lower() for header in headers}:
             headers["User-Agent"] = USER_AGENT
-        timeout = prepare_timeout(request_timeout)
         if not dry_run:
             args = (
                 checks,
                 targets,
                 result,
                 session,
-                timeout,
+                request_config,
                 store_interactions,
                 headers,
                 feedback,
-                request_tls_verify,
-                request_proxy,
-                request_cert,
                 max_response_time,
             )
             response = _network_test(case, *args)
@@ -914,13 +946,10 @@ def _network_test(
     targets: Iterable[Target],
     result: TestResult,
     session: requests.Session,
-    timeout: float | None,
+    request_config: RequestConfig,
     store_interactions: bool,
     headers: dict[str, Any] | None,
     feedback: Feedback | None,
-    request_tls_verify: bool,
-    request_proxy: str | None,
-    request_cert: RequestCert | None,
     max_response_time: int | None,
 ) -> requests.Response:
     check_results: list[Check] = []
@@ -929,19 +958,21 @@ def _network_test(
         kwargs: dict[str, Any] = {
             "session": session,
             "headers": headers,
-            "timeout": timeout,
-            "verify": request_tls_verify,
-            "cert": request_cert,
+            "timeout": request_config.prepared_timeout,
+            "verify": request_config.tls_verify,
+            "cert": request_config.cert,
         }
-        if request_proxy is not None:
-            kwargs["proxies"] = {"all": request_proxy}
+        if request_config.proxy is not None:
+            kwargs["proxies"] = {"all": request_config.proxy}
         hooks.dispatch("process_call_kwargs", hook_context, case, kwargs)
         response = case.call(**kwargs)
     except CheckFailed as exc:
         check_name = "request_timeout"
         requests_kwargs = RequestsTransport().serialize_case(case, base_url=case.get_full_base_url(), headers=headers)
         request = requests.Request(**requests_kwargs).prepare()
-        elapsed = cast(float, timeout)  # It is defined and not empty, since the exception happened
+        elapsed = cast(
+            float, request_config.prepared_timeout
+        )  # It is defined and not empty, since the exception happened
         check_result = result.add_failure(
             check_name, case, None, elapsed, f"Response timed out after {1000 * elapsed:.2f}ms", exc.context, request
         )
@@ -997,7 +1028,7 @@ def wsgi_test(
     with ErrorCollector(errors):
         _force_data_generation_method(data_generation_methods, case)
         result.mark_executed()
-        headers = _prepare_wsgi_headers(headers, auth, auth_type)
+        headers = prepare_wsgi_headers(headers, auth, auth_type)
         if not dry_run:
             args = (
                 checks,
@@ -1055,26 +1086,6 @@ def _wsgi_test(
     return response
 
 
-def _prepare_wsgi_headers(
-    headers: dict[str, Any] | None, auth: RawAuth | None, auth_type: str | None
-) -> dict[str, Any]:
-    headers = headers or {}
-    if "user-agent" not in {header.lower() for header in headers}:
-        headers["User-Agent"] = USER_AGENT
-    wsgi_auth = get_wsgi_auth(auth, auth_type)
-    if wsgi_auth:
-        headers["Authorization"] = wsgi_auth
-    return headers
-
-
-def get_wsgi_auth(auth: RawAuth | None, auth_type: str | None) -> str | None:
-    if auth:
-        if auth_type == "digest":
-            raise ValueError("Digest auth is not supported for WSGI apps")
-        return _basic_auth_str(*auth)
-    return None
-
-
 def asgi_test(
     case: Case,
     checks: Iterable[CheckFunction],

schemathesis/runner/impl/solo.py

@@ -6,7 +6,6 @@ from typing import Generator
 
 from ...models import TestResultSet
 from ...transports.auth import get_requests_auth
-from ...types import RequestCert
 from .. import events
 from .core import BaseRunner, asgi_test, get_session, network_test, wsgi_test
 
@@ -15,10 +14,6 @@ from .core import BaseRunner, asgi_test, get_session, network_test, wsgi_test
 class SingleThreadRunner(BaseRunner):
     """Fast runner that runs tests sequentially in the main thread."""
 
-    request_tls_verify: bool | str = True
-    request_proxy: str | None = None
-    request_cert: RequestCert | None = None
-
     def _execute(
         self, results: TestResultSet, stop_event: threading.Event
     ) -> Generator[events.ExecutionEvent, None, None]:
@@ -42,10 +37,7 @@ class SingleThreadRunner(BaseRunner):
                 results=results,
                 session=session,
                 headers=self.headers,
-                request_timeout=self.request_timeout,
-                request_tls_verify=self.request_tls_verify,
-                request_proxy=self.request_proxy,
-                request_cert=self.request_cert,
+                request_config=self.request_config,
                 store_interactions=self.store_interactions,
                 dry_run=self.dry_run,
             )