schemathesis 3.26.2__py3-none-any.whl → 3.27.0__py3-none-any.whl

schemathesis/cli/__init__.py

@@ -1769,6 +1769,6 @@ def after_init_cli_run_handlers(
 def process_call_kwargs(context: HookContext, case: Case, kwargs: dict[str, Any]) -> None:
     """Called before every network call in CLI tests.
 
-    Aims to modify the argument passed to `case.call` / `case.call_wsgi` / `case.call_asgi`.
+    Aims to modify the argument passed to `case.call`.
     Note that you need to modify `kwargs` in-place.
     """

schemathesis/cli/junitxml.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
+
+import base64
 import platform
+import textwrap
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
@@ -7,12 +10,14 @@ from junit_xml import TestCase, TestSuite, to_xml_report_file
 
 from ..models import Status
 from ..runner import events
-from ..runner.serialization import deduplicate_failures
+from ..runner.serialization import SerializedCheck, SerializedError
+from ..exceptions import prepare_response_payload, RuntimeErrorType
 from .handlers import EventHandler
-
+from .reporting import group_by_case, TEST_CASE_ID_TITLE, split_traceback, get_runtime_error_suggestion
 
 if TYPE_CHECKING:
     from click.utils import LazyFile
+
     from .context import ExecutionContext
 
 
@@ -29,15 +34,79 @@ class JunitXMLHandler(EventHandler):
                 allow_multiple_subelements=True,
             )
             if event.status == Status.failure:
-                checks = deduplicate_failures(event.result.checks)
-                for idx, check in enumerate(checks, 1):
-                    # `check.message` is always not empty for events with `failure` status
-                    test_case.add_failure_info(message=f"{idx}. {check.message}")
-            if event.status == Status.error:
-                test_case.add_error_info(
-                    message=event.result.errors[-1].exception, output=event.result.errors[-1].exception_with_traceback
-                )
+                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(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)
             self.test_cases.append(test_case)
         if 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 build_failure_message(idx: int, code_sample: str, checks: list[SerializedCheck]) -> str:
+    from ..transports.responses import get_reason
+
+    message = ""
+    for check_idx, check in enumerate(checks):
+        if check_idx == 0:
+            message += f"{idx}. {TEST_CASE_ID_TITLE}: {check.example.id}\n"
+        message += f"\n- {check.title}\n"
+        formatted_message = check.formatted_message
+        if formatted_message:
+            message += f"\n{formatted_message}\n"
+        if check_idx + 1 == len(checks):
+            if check.response is not None:
+                status_code = check.response.status_code
+                reason = get_reason(status_code)
+                message += f"\n[{check.response.status_code}] {reason}:\n"
+                response_body = check.response.body
+                if response_body is not None:
+                    if not response_body:
+                        message += "\n    <EMPTY>\n"
+                    else:
+                        encoding = check.response.encoding or "utf8"
+                        try:
+                            payload = base64.b64decode(response_body).decode(encoding)
+                            payload = prepare_response_payload(payload)
+                            payload = textwrap.indent(f"\n`{payload}`\n", prefix="    ")
+                            message += payload
+                        except UnicodeDecodeError:
+                            message += "\n    <BINARY>\n"
+
+    message += f"\nReproduce with: \n\n    {code_sample}"
+    return message
+
+
+def build_error_message(context: ExecutionContext, error: SerializedError) -> str:
+    message = ""
+    if error.title:
+        if error.type == RuntimeErrorType.SCHEMA_GENERIC:
+            message = "Schema Error\n"
+        else:
+            message = f"{error.title}\n"
+        if error.message:
+            message += f"\n{error.message}\n"
+    elif error.message:
+        message = error.message
+    else:
+        message = error.exception
+    if error.extras:
+        extras = error.extras
+    elif context.show_trace and error.type.has_useful_traceback:
+        extras = split_traceback(error.exception_with_traceback)
+    else:
+        extras = []
+    if extras:
+        message += "\n"
+    for extra in extras:
+        message += f"    {extra}\n"
+    suggestion = get_runtime_error_suggestion(error.type, bold=str)
+    if suggestion is not None:
+        message += f"\nTip: {suggestion}"
+    return message

schemathesis/cli/output/default.py

@@ -7,14 +7,12 @@ import shutil
 import textwrap
 import time
 from importlib import metadata
-from itertools import groupby
 from queue import Queue
 from typing import Any, Generator, cast, TYPE_CHECKING
 
 import click
 
 from ... import service
-from ...code_samples import CodeSampleStyle
 from ...constants import (
     DISCORD_LINK,
     FALSE_VALUES,
@@ -37,10 +35,11 @@ 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 ...runner.serialization import SerializedError, SerializedTestResult
 from ...service.models import AnalysisSuccess, UnknownExtension, ErrorState
 from ..context import ExecutionContext, FileReportContext, ServiceReportContext
 from ..handlers import EventHandler
+from ..reporting import group_by_case, TEST_CASE_ID_TITLE, split_traceback, get_runtime_error_suggestion
 
 if TYPE_CHECKING:
     import requests
@@ -256,11 +255,11 @@ def _display_error(context: ExecutionContext, error: SerializedError) -> bool:
     if error.extras:
         extras = error.extras
     elif context.show_trace and error.type.has_useful_traceback:
-        extras = _split_traceback(error.exception_with_traceback)
+        extras = split_traceback(error.exception_with_traceback)
     else:
         extras = []
     _display_extras(extras)
-    suggestion = RUNTIME_ERROR_SUGGESTIONS.get(error.type)
+    suggestion = get_runtime_error_suggestion(error.type)
     _maybe_display_tip(suggestion)
     return display_full_traceback_message(error)
 
@@ -279,9 +278,6 @@ def display_failures(context: ExecutionContext, event: events.Finished) -> None:
         display_failures_for_single_test(context, result)
 
 
-TEST_CASE_ID_TITLE = "Test Case ID"
-
-
 def display_failures_for_single_test(context: ExecutionContext, result: SerializedTestResult) -> None:
     """Display a failure for a single method / path."""
     from ...transports.responses import get_reason
@@ -297,18 +293,9 @@ def display_failures_for_single_test(context: ExecutionContext, result: Serializ
         for check_idx, check in enumerate(checks):
             if check_idx == 0:
                 click.secho(f"{idx}. {TEST_CASE_ID_TITLE}: {check.example.id}", bold=True)
-            if check.context is not None:
-                title = check.context.title
-                if check.context.message:
-                    message = check.context.message
-                else:
-                    message = None
-            else:
-                title = f"Custom check failed: `{check.name}`"
-                message = check.message
-            click.secho(f"\n- {title}", fg="red", bold=True)
+            click.secho(f"\n- {check.title}", fg="red", bold=True)
+            message = check.formatted_message
             if message:
-                message = textwrap.indent(message, prefix="    ")
                 click.secho(f"\n{message}", fg="red")
             if check_idx + 1 == len(checks):
                 if check.response is not None:
@@ -316,9 +303,8 @@ def display_failures_for_single_test(context: ExecutionContext, result: Serializ
                     reason = get_reason(status_code)
                     response = bold(f"[{check.response.status_code}] {reason}")
                     click.echo(f"\n{response}:")
-
                     response_body = check.response.body
-                    if check.response is not None and response_body is not None:
+                    if response_body is not None:
                         if not response_body:
                             click.echo("\n    <EMPTY>")
                         else:
@@ -336,26 +322,6 @@ def display_failures_for_single_test(context: ExecutionContext, result: Serializ
         )
 
 
-def group_by_case(
-    checks: list[SerializedCheck], code_sample_style: CodeSampleStyle
-) -> Generator[tuple[str, Generator[SerializedCheck, None, None]], None, None]:
-    checks = deduplicate_failures(checks)
-    checks = sorted(checks, key=lambda c: _by_unique_code_sample(c, code_sample_style))
-    yield from groupby(checks, lambda c: _by_unique_code_sample(c, code_sample_style))
-
-
-def _by_unique_code_sample(check: SerializedCheck, code_sample_style: CodeSampleStyle) -> str:
-    request_body = base64.b64decode(check.example.body).decode() if check.example.body is not None else None
-    return code_sample_style.generate(
-        method=check.example.method,
-        url=check.example.url,
-        body=request_body,
-        headers=check.example.headers,
-        verify=check.example.verify,
-        extra_headers=check.example.extra_headers,
-    )
-
-
 def display_application_logs(context: ExecutionContext, event: events.Finished) -> None:
     """Print logs captured during the application run."""
     if not event.has_logs:
@@ -436,7 +402,7 @@ def display_analysis(context: ExecutionContext) -> None:
             title = "Network Error"
         else:
             traceback = format_exception(exception, True)
-            extras = _split_traceback(traceback)
+            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."
@@ -719,10 +685,6 @@ def should_skip_suggestion(context: ExecutionContext, event: events.InternalErro
     return event.subtype == SchemaErrorType.CONNECTION_OTHER and context.wait_for_schema is not None
 
 
-def _split_traceback(traceback: str) -> list[str]:
-    return [entry for entry in traceback.splitlines() if entry]
-
-
 def _display_extras(extras: list[str]) -> None:
     if extras:
         click.echo()
@@ -743,7 +705,7 @@ def display_internal_error(context: ExecutionContext, event: events.InternalErro
     if event.type == InternalErrorType.SCHEMA:
         extras = event.extras
     elif context.show_trace:
-        extras = _split_traceback(event.exception_with_traceback)
+        extras = split_traceback(event.exception_with_traceback)
     else:
         extras = [event.exception]
     _display_extras(extras)

schemathesis/cli/reporting.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import base64
+from itertools import groupby
+from typing import Callable, Generator
+
+import click
+
+from ..code_samples import CodeSampleStyle
+from ..exceptions import RuntimeErrorType
+from ..runner.serialization import SerializedCheck, deduplicate_failures
+
+TEST_CASE_ID_TITLE = "Test Case ID"
+
+
+def group_by_case(
+    checks: list[SerializedCheck], code_sample_style: CodeSampleStyle
+) -> Generator[tuple[str, Generator[SerializedCheck, None, None]], None, None]:
+    checks = deduplicate_failures(checks)
+    checks = sorted(checks, key=lambda c: _by_unique_code_sample(c, code_sample_style))
+    yield from groupby(checks, lambda c: _by_unique_code_sample(c, code_sample_style))
+
+
+def _by_unique_code_sample(check: SerializedCheck, code_sample_style: CodeSampleStyle) -> str:
+    request_body = base64.b64decode(check.example.body).decode() if check.example.body is not None else None
+    return code_sample_style.generate(
+        method=check.example.method,
+        url=check.example.url,
+        body=request_body,
+        headers=check.example.headers,
+        verify=check.example.verify,
+        extra_headers=check.example.extra_headers,
+    )
+
+
+def split_traceback(traceback: str) -> list[str]:
+    return [entry for entry in traceback.splitlines() if entry]
+
+
+def bold(option: str) -> str:
+    return click.style(option, bold=True)
+
+
+def get_runtime_error_suggestion(error_type: RuntimeErrorType, bold: Callable[[str], str] = bold) -> str | None:
+    DISABLE_SSL_SUGGESTION = f"Bypass SSL verification with {bold('`--request-tls-verify=false`')}."
+    DISABLE_SCHEMA_VALIDATION_SUGGESTION = (
+        f"Bypass validation using {bold('`--validate-schema=false`')}. Caution: May cause unexpected errors."
+    )
+
+    def _format_health_check_suggestion(label: str) -> str:
+        return f"Bypass this health check using {bold(f'`--hypothesis-suppress-health-check={label}`')}."
+
+    RUNTIME_ERROR_SUGGESTIONS = {
+        RuntimeErrorType.CONNECTION_SSL: DISABLE_SSL_SUGGESTION,
+        RuntimeErrorType.HYPOTHESIS_DEADLINE_EXCEEDED: (
+            f"Adjust the deadline using {bold('`--hypothesis-deadline=MILLIS`')} or "
+            f"disable with {bold('`--hypothesis-deadline=None`')}."
+        ),
+        RuntimeErrorType.HYPOTHESIS_UNSATISFIABLE: "Examine the schema for inconsistencies and consider simplifying it.",
+        RuntimeErrorType.SCHEMA_BODY_IN_GET_REQUEST: DISABLE_SCHEMA_VALIDATION_SUGGESTION,
+        RuntimeErrorType.SCHEMA_INVALID_REGULAR_EXPRESSION: "Ensure your regex is compatible with Python's syntax.\n"
+        "For guidance, visit: https://docs.python.org/3/library/re.html",
+        RuntimeErrorType.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR: "Define a custom strategy for it.\n"
+        "For guidance, visit: https://schemathesis.readthedocs.io/en/stable/graphql.html#custom-scalars",
+        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_DATA_TOO_LARGE: _format_health_check_suggestion("data_too_large"),
+        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_FILTER_TOO_MUCH: _format_health_check_suggestion("filter_too_much"),
+        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_TOO_SLOW: _format_health_check_suggestion("too_slow"),
+        RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_LARGE_BASE_EXAMPLE: _format_health_check_suggestion(
+            "large_base_example"
+        ),
+    }
+    return RUNTIME_ERROR_SUGGESTIONS.get(error_type)

schemathesis/models.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import datetime
 import inspect
 import textwrap
@@ -6,7 +7,7 @@ from collections import Counter
 from contextlib import contextmanager
 from dataclasses import dataclass, field
 from enum import Enum
-from functools import partial, lru_cache
+from functools import lru_cache, partial
 from itertools import chain
 from logging import LogRecord
 from typing import (
@@ -25,51 +26,48 @@ from typing import (
 )
 from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
 
-from urllib3.exceptions import ReadTimeoutError
-
-from . import failures, serializers
+from . import serializers
 from ._dependency_versions import IS_WERKZEUG_ABOVE_3
 from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
-from .generation import DataGenerationMethod, GenerationConfig
 from .constants import (
-    DEFAULT_RESPONSE_TIMEOUT,
+    NOT_SET,
     SCHEMATHESIS_TEST_CASE_HEADER,
     SERIALIZERS_SUGGESTION_MESSAGE,
     USER_AGENT,
-    NOT_SET,
 )
 from .exceptions import (
-    maybe_set_assertion_message,
     CheckFailed,
     FailureContext,
     OperationSchemaError,
     SerializationNotPossible,
+    SkipTest,
     deduplicate_failed_checks,
     get_grouped_exception,
-    get_timeout_error,
+    maybe_set_assertion_message,
     prepare_response_payload,
-    SkipTest,
 )
-from .internal.deprecation import deprecated_property
-from .internal.copy import fast_deepcopy
+from .generation import DataGenerationMethod, GenerationConfig, generate_random_case_id
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, dispatch
+from .internal.copy import fast_deepcopy
+from .internal.deprecation import deprecated_property, deprecated_function
 from .parameters import Parameter, ParameterSet, PayloadAlternatives
 from .sanitization import sanitize_request, sanitize_response
-from .serializers import Serializer, SerializerContext
-from .transports import serialize_payload
+from .serializers import Serializer
+from .transports import ASGITransport, RequestsTransport, WSGITransport, serialize_payload
 from .types import Body, Cookies, FormData, Headers, NotSet, PathParameters, Query
-from .generation import generate_random_case_id
 
 if TYPE_CHECKING:
-    import werkzeug
     import unittest
-    from requests.structures import CaseInsensitiveDict
-    from hypothesis import strategies as st
+
     import requests.auth
-    from .transports.responses import GenericResponse, WSGIResponse
+    import werkzeug
+    from hypothesis import strategies as st
+    from requests.structures import CaseInsensitiveDict
+
     from .schemas import BaseSchema
     from .stateful import Stateful, StatefulTest
+    from .transports.responses import GenericResponse, WSGIResponse
 
 
 @dataclass
@@ -86,7 +84,7 @@ class CaseSource:
 
 def cant_serialize(media_type: str) -> NoReturn:  # type: ignore
     """Reject the current example if we don't know how to send this data to the application."""
-    from hypothesis import note, event, reject
+    from hypothesis import event, note, reject
 
     event_text = f"Can't serialize data to `{media_type}`."
     note(f"{event_text} {SERIALIZERS_SUGGESTION_MESSAGE}")
@@ -210,7 +208,7 @@ class Case:
 
     def prepare_code_sample_data(self, headers: dict[str, Any] | None) -> PreparedRequestData:
         base_url = self.get_full_base_url()
-        kwargs = self.as_requests_kwargs(base_url, headers=headers)
+        kwargs = RequestsTransport().serialize_case(self, base_url=base_url, headers=headers)
         return prepare_request_data(kwargs)
 
     def get_code_to_reproduce(
@@ -286,40 +284,17 @@ class Case:
             return cls()
         return None
 
+    def _get_body(self) -> Body | NotSet:
+        return self.body
+
+    @deprecated_function(removed_in="4.0", replacement="Case.as_transport_kwargs")
     def as_requests_kwargs(self, base_url: str | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
         """Convert the case into a dictionary acceptable by requests."""
-        final_headers = self._get_headers(headers)
-        if self.media_type and self.media_type != "multipart/form-data" and not isinstance(self.body, NotSet):
-            # `requests` will handle multipart form headers with the proper `boundary` value.
-            if "content-type" not in {header.lower() for header in final_headers}:
-                final_headers["Content-Type"] = self.media_type
-        base_url = self._get_base_url(base_url)
-        formatted_path = self.formatted_path.lstrip("/")
-        if not base_url.endswith("/"):
-            base_url += "/"
-        url = unquote(urljoin(base_url, quote(formatted_path)))
-        extra: dict[str, Any]
-        serializer = self._get_serializer()
-        if serializer is not None and not isinstance(self.body, NotSet):
-            context = SerializerContext(case=self)
-            extra = serializer.as_requests(context, self.body)
-        else:
-            extra = {}
-        if self._auth is not None:
-            extra["auth"] = self._auth
-        additional_headers = extra.pop("headers", None)
-        if additional_headers:
-            # Additional headers, needed for the serializer
-            for key, value in additional_headers.items():
-                final_headers.setdefault(key, value)
-        return {
-            "method": self.method,
-            "url": url,
-            "cookies": self.cookies,
-            "headers": final_headers,
-            "params": self.query,
-            **extra,
-        }
+        return RequestsTransport().serialize_case(self, base_url=base_url, headers=headers)
+
+    def as_transport_kwargs(self, base_url: str | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
+        """Convert the test case into a dictionary acceptable by the underlying transport call."""
+        return self.operation.schema.transport.serialize_case(self, base_url=base_url, headers=headers)
 
     def call(
         self,
@@ -329,83 +304,21 @@ class Case:
         params: dict[str, Any] | None = None,
         cookies: dict[str, Any] | None = None,
         **kwargs: Any,
-    ) -> requests.Response:
-        import requests
-
-        """Make a network call with `requests`."""
+    ) -> GenericResponse:
         hook_context = HookContext(operation=self.operation)
         dispatch("before_call", hook_context, self)
-        data = self.as_requests_kwargs(base_url, headers)
-        data.update(kwargs)
-        if params is not None:
-            _merge_dict_to(data, "params", params)
-        if cookies is not None:
-            _merge_dict_to(data, "cookies", cookies)
-        data.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT / 1000)
-        if session is None:
-            validate_vanilla_requests_kwargs(data)
-            session = requests.Session()
-            close_session = True
-        else:
-            close_session = False
-        verify = data.get("verify", True)
-        try:
-            with self.operation.schema.ratelimit():
-                response = session.request(**data)  # type: ignore
-        except (requests.Timeout, requests.ConnectionError) as exc:
-            if isinstance(exc, requests.ConnectionError):
-                if not isinstance(exc.args[0], ReadTimeoutError):
-                    raise
-                req = requests.Request(
-                    method=data["method"].upper(),
-                    url=data["url"],
-                    headers=data["headers"],
-                    files=data.get("files"),
-                    data=data.get("data") or {},
-                    json=data.get("json"),
-                    params=data.get("params") or {},
-                    auth=data.get("auth"),
-                    cookies=data["cookies"],
-                    hooks=data.get("hooks"),
-                )
-                request = session.prepare_request(req)
-            else:
-                request = cast(requests.PreparedRequest, exc.request)
-            timeout = 1000 * data["timeout"]  # It is defined and not empty, since the exception happened
-            code_message = self._get_code_message(self.operation.schema.code_sample_style, request, verify=verify)
-            message = f"The server failed to respond within the specified limit of {timeout:.2f}ms"
-            raise get_timeout_error(timeout)(
-                f"\n\n1. {failures.RequestTimeout.title}\n\n{message}\n\n{code_message}",
-                context=failures.RequestTimeout(message=message, timeout=timeout),
-            ) from None
-        response.verify = verify  # type: ignore[attr-defined]
+        response = self.operation.schema.transport.send(
+            self, session=session, base_url=base_url, headers=headers, params=params, cookies=cookies, **kwargs
+        )
         dispatch("after_call", hook_context, self, response)
-        if close_session:
-            session.close()
         return response
 
+    @deprecated_function(removed_in="4.0", replacement="Case.as_transport_kwargs")
     def as_werkzeug_kwargs(self, headers: dict[str, str] | None = None) -> dict[str, Any]:
         """Convert the case into a dictionary acceptable by werkzeug.Client."""
-        final_headers = self._get_headers(headers)
-        if self.media_type and not isinstance(self.body, NotSet):
-            # If we need to send a payload, then the Content-Type header should be set
-            final_headers["Content-Type"] = self.media_type
-        extra: dict[str, Any]
-        serializer = self._get_serializer()
-        if serializer is not None and not isinstance(self.body, NotSet):
-            context = SerializerContext(case=self)
-            extra = serializer.as_werkzeug(context, self.body)
-        else:
-            extra = {}
-        return {
-            "method": self.method,
-            "path": self.operation.schema.get_full_path(self.formatted_path),
-            # Convert to a regular dictionary, as we use `CaseInsensitiveDict` which is not supported by Werkzeug
-            "headers": dict(final_headers),
-            "query_string": self.query,
-            **extra,
-        }
+        return WSGITransport(self.app).serialize_case(self, headers=headers)
 
+    @deprecated_function(removed_in="4.0", replacement="Case.call")
     def call_wsgi(
         self,
         app: Any = None,
@@ -413,10 +326,6 @@ class Case:
         query_string: dict[str, str] | None = None,
         **kwargs: Any,
     ) -> WSGIResponse:
-        from .transports.responses import WSGIResponse
-        import werkzeug
-        import requests
-
         application = app or self.app
         if application is None:
             raise RuntimeError(
@@ -425,17 +334,11 @@ class Case:
             )
         hook_context = HookContext(operation=self.operation)
         dispatch("before_call", hook_context, self)
-        data = self.as_werkzeug_kwargs(headers)
-        if query_string is not None:
-            _merge_dict_to(data, "query_string", query_string)
-        client = werkzeug.Client(application, WSGIResponse)
-        with cookie_handler(client, self.cookies), self.operation.schema.ratelimit():
-            response = client.open(**data, **kwargs)
-        requests_kwargs = self.as_requests_kwargs(base_url=self.get_full_base_url(), headers=headers)
-        response.request = requests.Request(**requests_kwargs).prepare()
+        response = WSGITransport(application).send(self, headers=headers, params=query_string, **kwargs)
         dispatch("after_call", hook_context, self, response)
         return response
 
+    @deprecated_function(removed_in="4.0", replacement="Case.call")
     def call_asgi(
         self,
         app: Any = None,
@@ -443,19 +346,17 @@ class Case:
         headers: dict[str, str] | None = None,
         **kwargs: Any,
     ) -> requests.Response:
-        from starlette_testclient import TestClient as ASGIClient
-
         application = app or self.app
         if application is None:
             raise RuntimeError(
                 "ASGI application instance is required. "
                 "Please, set `app` argument in the schema constructor or pass it to `call_asgi`"
             )
-        if base_url is None:
-            base_url = self.get_full_base_url()
-
-        with ASGIClient(application) as client:
-            return self.call(base_url=base_url, session=client, headers=headers, **kwargs)
+        hook_context = HookContext(operation=self.operation)
+        dispatch("before_call", hook_context, self)
+        response = ASGITransport(application).send(self, base_url=base_url, headers=headers, **kwargs)
+        dispatch("after_call", hook_context, self, response)
+        return response
 
     def validate_response(
         self,
@@ -560,12 +461,19 @@ class Case:
         self.validate_response(response, checks, code_sample_style=code_sample_style)
         return response
 
+    def _get_url(self, base_url: str | None) -> str:
+        base_url = self._get_base_url(base_url)
+        formatted_path = self.formatted_path.lstrip("/")
+        if not base_url.endswith("/"):
+            base_url += "/"
+        return unquote(urljoin(base_url, quote(formatted_path)))
+
     def get_full_url(self) -> str:
         """Make a full URL to the current API operation, including query parameters."""
         import requests
 
         base_url = self.base_url or "http://127.0.0.1"
-        kwargs = self.as_requests_kwargs(base_url)
+        kwargs = RequestsTransport().serialize_case(self, base_url=base_url)
         request = requests.Request(**kwargs)
         prepared = requests.Session().prepare_request(request)  # type: ignore
         return cast(str, prepared.url)
@@ -922,7 +830,7 @@ class Request:
         import requests
 
         base_url = case.get_full_base_url()
-        kwargs = case.as_requests_kwargs(base_url)
+        kwargs = RequestsTransport().serialize_case(case, base_url=base_url)
         request = requests.Request(**kwargs)
         prepared = session.prepare_request(request)  # type: ignore
         return cls.from_prepared_request(prepared)