Test Client

Esmerald offers an extension of the Lilya TestClient called EsmeraldTestClient as well as a create_client that can be used for context testing.

from esmerald.testclient import EsmeraldTestClient

esmerald.testclient.EsmeraldTestClient

EsmeraldTestClient(app, base_url='http://testserver', raise_server_exceptions=True, root_path='', backend='asyncio', backend_options=None, cookies=None, headers=None)

Bases: TestClient

PARAMETER	DESCRIPTION
app	TYPE: Esmerald
base_url	TYPE: str DEFAULT: 'http://testserver'
raise_server_exceptions	TYPE: bool DEFAULT: True
root_path	TYPE: str DEFAULT: ''
backend	TYPE: Literal['asyncio', 'trio'] DEFAULT: 'asyncio'
backend_options	TYPE: Optional[Dict[str, Any]] DEFAULT: None
cookies	TYPE: Optional[CookieTypes] DEFAULT: None
headers	TYPE: Dict[str, str] DEFAULT: None

Source code in esmerald/testclient.py

def __init__(
    self,
    app: Esmerald,
    base_url: str = "http://testserver",
    raise_server_exceptions: bool = True,
    root_path: str = "",
    backend: "Literal['asyncio', 'trio']" = "asyncio",
    backend_options: Optional[Dict[str, Any]] = None,
    cookies: Optional[CookieTypes] = None,
    headers: Dict[str, str] = None,
):
    super().__init__(
        app=app,
        base_url=base_url,
        raise_server_exceptions=raise_server_exceptions,
        root_path=root_path,
        backend=backend,
        backend_options=backend_options,
        cookies=cookies,
        headers=headers,
    )

headers property writable

headers

HTTP headers to include when sending requests.

follow_redirects instance-attribute

follow_redirects = follow_redirects

max_redirects instance-attribute

max_redirects = max_redirects

is_closed property

is_closed

Check if the client being closed

trust_env property

trust_env

timeout property writable

timeout

event_hooks property writable

event_hooks

auth property writable

auth

Authentication class used when none is passed at the request-level.

See also Authentication.

base_url property writable

base_url

Base URL to use when sending requests with relative URLs.

cookies property writable

cookies

Cookie values to include when sending requests.

params property writable

params

Query parameters to include in the URL when sending requests.

task instance-attribute

task

portal class-attribute instance-attribute

portal = None

async_backend instance-attribute

async_backend = AsyncBackend(backend=backend, backend_options=backend_options or {})

app_state instance-attribute

app_state = {}

app instance-attribute

app

build_request

build_request(method, url, *, content=None, data=None, files=None, json=None, params=None, headers=None, cookies=None, timeout=USE_CLIENT_DEFAULT, extensions=None)

Build and return a request instance.

• The params, headers and cookies arguments are merged with any values set on the client.
• The url argument is merged with any base_url set on the client.

See also: Request instances

PARAMETER	DESCRIPTION
method	TYPE: str
url	TYPE: URLTypes
content	TYPE: RequestContent | None DEFAULT: None
data	TYPE: RequestData | None DEFAULT: None
files	TYPE: RequestFiles | None DEFAULT: None
json	TYPE: Any | None DEFAULT: None
params	TYPE: QueryParamTypes | None DEFAULT: None
headers	TYPE: HeaderTypes | None DEFAULT: None
cookies	TYPE: CookieTypes | None DEFAULT: None
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: RequestExtensions | None DEFAULT: None

Source code in httpx/_client.py

def build_request(
    self,
    method: str,
    url: URLTypes,
    *,
    content: RequestContent | None = None,
    data: RequestData | None = None,
    files: RequestFiles | None = None,
    json: typing.Any | None = None,
    params: QueryParamTypes | None = None,
    headers: HeaderTypes | None = None,
    cookies: CookieTypes | None = None,
    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
    extensions: RequestExtensions | None = None,
) -> Request:
    """
    Build and return a request instance.

    * The `params`, `headers` and `cookies` arguments
    are merged with any values set on the client.
    * The `url` argument is merged with any `base_url` set on the client.

    See also: [Request instances][0]

    [0]: /advanced/#request-instances
    """
    url = self._merge_url(url)
    headers = self._merge_headers(headers)
    cookies = self._merge_cookies(cookies)
    params = self._merge_queryparams(params)
    extensions = {} if extensions is None else extensions
    if "timeout" not in extensions:
        timeout = (
            self.timeout
            if isinstance(timeout, UseClientDefault)
            else Timeout(timeout)
        )
        extensions = dict(**extensions, timeout=timeout.as_dict())
    return Request(
        method,
        url,
        content=content,
        data=data,
        files=files,
        json=json,
        params=params,
        headers=headers,
        cookies=cookies,
        extensions=extensions,
    )

request

request(method, url, *, content=None, data=None, files=None, json=None, params=None, headers=None, cookies=None, auth=httpx._client.USE_CLIENT_DEFAULT, follow_redirects=None, timeout=httpx._client.USE_CLIENT_DEFAULT, extensions=None)

Sends an HTTP request.

PARAMETER	DESCRIPTION
method	TYPE: str
url	TYPE: URLTypes
content	TYPE: RequestContent | None DEFAULT: None
data	TYPE: RequestData | None DEFAULT: None
files	TYPE: RequestFiles | None DEFAULT: None
json	TYPE: Any DEFAULT: None
params	TYPE: QueryParamTypes | None DEFAULT: None
headers	TYPE: HeaderTypes | None DEFAULT: None
cookies	TYPE: CookieTypes | None DEFAULT: None
auth	TYPE: AuthTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
follow_redirects	TYPE: bool | None DEFAULT: None
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: dict[str, Any] | None DEFAULT: None

PARAMETER	DESCRIPTION
method	The HTTP method. TYPE: str
url	The URL to send the request to. TYPE: URLTypes
content	The request content. Defaults to None. TYPE: RequestContent | None DEFAULT: None
data	The request data. Defaults to None. TYPE: RequestData | None DEFAULT: None
files	The request files. Defaults to None. TYPE: RequestFiles | None DEFAULT: None
json	The request JSON. Defaults to None. TYPE: Any DEFAULT: None
params	The request query parameters. Defaults to None. TYPE: QueryParamTypes | None DEFAULT: None
headers	The request headers. Defaults to None. TYPE: HeaderTypes | None DEFAULT: None
cookies	The request cookies. Defaults to None. TYPE: CookieTypes | None DEFAULT: None
auth	The request authentication. Defaults to httpx._client.USE_CLIENT_DEFAULT. TYPE: AuthTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
follow_redirects	Whether to follow redirects. Defaults to None. TYPE: bool | None DEFAULT: None
timeout	The request timeout. Defaults to httpx._client.USE_CLIENT_DEFAULT. TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	The request extensions. Defaults to None. TYPE: dict[str, Any] | None DEFAULT: None

RETURNS	DESCRIPTION
Response	httpx.Response: The HTTP response.

Source code in lilya/testclient/base.py

def request(
    self,
    method: str,
    url: URLTypes,
    *,
    content: RequestContent | None = None,
    data: RequestData | None = None,
    files: RequestFiles | None = None,
    json: Any = None,
    params: QueryParamTypes | None = None,
    headers: HeaderTypes | None = None,
    cookies: CookieTypes | None = None,
    auth: AuthTypes | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects: bool | None = None,
    timeout: TimeoutTypes | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    extensions: dict[str, Any] | None = None,
) -> httpx.Response:
    """
    Sends an HTTP request.

    Args:
        method (str): The HTTP method.
        url (URLTypes): The URL to send the request to.
        content (RequestContent | None, optional): The request content. Defaults to None.
        data (RequestData | None, optional): The request data. Defaults to None.
        files (RequestFiles | None, optional): The request files. Defaults to None.
        json (Any, optional): The request JSON. Defaults to None.
        params (QueryParamTypes | None, optional): The request query parameters. Defaults to None.
        headers (HeaderTypes | None, optional): The request headers. Defaults to None.
        cookies (CookieTypes | None, optional): The request cookies. Defaults to None.
        auth (AuthTypes | httpx._client.UseClientDefault, optional): The request authentication. Defaults to httpx._client.USE_CLIENT_DEFAULT.
        follow_redirects (bool | None, optional): Whether to follow redirects. Defaults to None.
        timeout (TimeoutTypes | httpx._client.UseClientDefault, optional): The request timeout. Defaults to httpx._client.USE_CLIENT_DEFAULT.
        extensions (dict[str, Any] | None, optional): The request extensions. Defaults to None.

    Returns:
        httpx.Response: The HTTP response.
    """
    url = self._merge_url(url)
    redirect: bool | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT
    if follow_redirects is not None:
        redirect = follow_redirects

    return super().request(
        method,
        url,
        content=content,
        data=data,
        files=files,
        json=json,
        params=params,
        headers=headers,
        cookies=cookies,
        auth=auth,
        follow_redirects=redirect,
        timeout=timeout,
        extensions=extensions,
    )

stream

stream(method, url, *, content=None, data=None, files=None, json=None, params=None, headers=None, cookies=None, auth=USE_CLIENT_DEFAULT, follow_redirects=USE_CLIENT_DEFAULT, timeout=USE_CLIENT_DEFAULT, extensions=None)

Alternative to httpx.request() that streams the response body instead of loading it into memory at once.

Parameters: See httpx.request.

See also: Streaming Responses

PARAMETER	DESCRIPTION
method	TYPE: str
url	TYPE: URLTypes
content	TYPE: RequestContent | None DEFAULT: None
data	TYPE: RequestData | None DEFAULT: None
files	TYPE: RequestFiles | None DEFAULT: None
json	TYPE: Any | None DEFAULT: None
params	TYPE: QueryParamTypes | None DEFAULT: None
headers	TYPE: HeaderTypes | None DEFAULT: None
cookies	TYPE: CookieTypes | None DEFAULT: None
auth	TYPE: AuthTypes | UseClientDefault | None DEFAULT: USE_CLIENT_DEFAULT
follow_redirects	TYPE: bool | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: RequestExtensions | None DEFAULT: None

YIELDS	DESCRIPTION
Response

Source code in httpx/_client.py

@contextmanager
def stream(
    self,
    method: str,
    url: URLTypes,
    *,
    content: RequestContent | None = None,
    data: RequestData | None = None,
    files: RequestFiles | None = None,
    json: typing.Any | None = None,
    params: QueryParamTypes | None = None,
    headers: HeaderTypes | None = None,
    cookies: CookieTypes | None = None,
    auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
    follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
    extensions: RequestExtensions | None = None,
) -> typing.Iterator[Response]:
    """
    Alternative to `httpx.request()` that streams the response body
    instead of loading it into memory at once.

    **Parameters**: See `httpx.request`.

    See also: [Streaming Responses][0]

    [0]: /quickstart#streaming-responses
    """
    request = self.build_request(
        method=method,
        url=url,
        content=content,
        data=data,
        files=files,
        json=json,
        params=params,
        headers=headers,
        cookies=cookies,
        timeout=timeout,
        extensions=extensions,
    )
    response = self.send(
        request=request,
        auth=auth,
        follow_redirects=follow_redirects,
        stream=True,
    )
    try:
        yield response
    finally:
        response.close()

send

send(request, *, stream=False, auth=USE_CLIENT_DEFAULT, follow_redirects=USE_CLIENT_DEFAULT)

Send a request.

The request is sent as-is, unmodified.

Typically you'll want to build one with Client.build_request() so that any client-level configuration is merged into the request, but passing an explicit httpx.Request() is supported as well.

See also: Request instances

PARAMETER	DESCRIPTION
request	TYPE: Request
stream	TYPE: bool DEFAULT: False
auth	TYPE: AuthTypes | UseClientDefault | None DEFAULT: USE_CLIENT_DEFAULT
follow_redirects	TYPE: bool | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT

Source code in httpx/_client.py

def send(
    self,
    request: Request,
    *,
    stream: bool = False,
    auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
    follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
) -> Response:
    """
    Send a request.

    The request is sent as-is, unmodified.

    Typically you'll want to build one with `Client.build_request()`
    so that any client-level configuration is merged into the request,
    but passing an explicit `httpx.Request()` is supported as well.

    See also: [Request instances][0]

    [0]: /advanced/#request-instances
    """
    if self._state == ClientState.CLOSED:
        raise RuntimeError("Cannot send a request, as the client has been closed.")

    self._state = ClientState.OPENED
    follow_redirects = (
        self.follow_redirects
        if isinstance(follow_redirects, UseClientDefault)
        else follow_redirects
    )

    auth = self._build_request_auth(request, auth)

    response = self._send_handling_auth(
        request,
        auth=auth,
        follow_redirects=follow_redirects,
        history=[],
    )
    try:
        if not stream:
            response.read()

        return response

    except BaseException as exc:
        response.close()
        raise exc

get

get(url, **kwargs)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
**kwargs	TYPE: Any DEFAULT: {}

Source code in lilya/testclient/base.py

def get(
    self,
    url: URLTypes,
    **kwargs: Any,
) -> httpx.Response:
    return self._process_request(method="GET", url=url, **kwargs)  # type: ignore

options

options(url, **kwargs)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
**kwargs	TYPE: Any DEFAULT: {}

Source code in lilya/testclient/base.py

def options(
    self,
    url: URLTypes,
    **kwargs: Any,
) -> httpx.Response:
    return self._process_request(method="OPTIONS", url=url, **kwargs)  # type: ignore

head

head(url, **kwargs)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
**kwargs	TYPE: Any DEFAULT: {}

Source code in lilya/testclient/base.py

def head(
    self,
    url: URLTypes,
    **kwargs: Any,
) -> httpx.Response:
    return self._process_request(method="HEAD", url=url, **kwargs)  # type: ignore

post

post(url, **kwargs)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
**kwargs	TYPE: Any DEFAULT: {}

Source code in lilya/testclient/base.py

def post(
    self,
    url: URLTypes,
    **kwargs: Any,
) -> httpx.Response:
    return self._process_request(method="POST", url=url, **kwargs)  # type: ignore

put

put(url, **kwargs)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
**kwargs	TYPE: Any DEFAULT: {}

Source code in lilya/testclient/base.py

def put(
    self,
    url: URLTypes,
    **kwargs: Any,
) -> httpx.Response:
    return self._process_request(method="PUT", url=url, **kwargs)  # type: ignore

patch

patch(url, **kwargs)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
**kwargs	TYPE: Any DEFAULT: {}

Source code in lilya/testclient/base.py

def patch(
    self,
    url: URLTypes,
    **kwargs: Any,
) -> httpx.Response:
    return self._process_request(method="PATCH", url=url, **kwargs)  # type: ignore

delete

delete(url, **kwargs)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
**kwargs	TYPE: Any DEFAULT: {}

Source code in lilya/testclient/base.py

def delete(
    self,
    url: URLTypes,
    **kwargs: Any,
) -> httpx.Response:
    return self._process_request(method="DELETE", url=url, **kwargs)  # type: ignore

close

close()

Close transport and proxies.

Source code in httpx/_client.py

def close(self) -> None:
    """
    Close transport and proxies.
    """
    if self._state != ClientState.CLOSED:
        self._state = ClientState.CLOSED

        self._transport.close()
        for transport in self._mounts.values():
            if transport is not None:
                transport.close()

websocket_connect

websocket_connect(url, subprotocols=None, **kwargs)

Establishes a WebSocket connection.

PARAMETER	DESCRIPTION
url	TYPE: str
subprotocols	TYPE: Sequence[str] | None DEFAULT: None
**kwargs	TYPE: Any DEFAULT: {}

PARAMETER	DESCRIPTION
url	The WebSocket URL. TYPE: str
subprotocols	The WebSocket subprotocols. Defaults to None. TYPE: Sequence[str] | None DEFAULT: None
**kwargs	Additional keyword arguments. TYPE: Any DEFAULT: {}

RETURNS	DESCRIPTION
WebSocketTestSession	The WebSocket session. TYPE: WebSocketTestSession

Source code in lilya/testclient/base.py

def websocket_connect(
    self,
    url: str,
    subprotocols: Sequence[str] | None = None,
    **kwargs: Any,
) -> WebSocketTestSession:
    """
    Establishes a WebSocket connection.

    Args:
        url (str): The WebSocket URL.
        subprotocols (Sequence[str] | None, optional): The WebSocket subprotocols. Defaults to None.
        **kwargs (Any): Additional keyword arguments.

    Returns:
        WebSocketTestSession: The WebSocket session.
    """
    url = urljoin("ws://testserver", url)
    headers = self._prepare_websocket_headers(subprotocols, **kwargs)
    kwargs["headers"] = headers
    try:
        super().request("GET", url, **kwargs)
    except UpgradeException as exc:
        session = exc.session
    else:
        raise RuntimeError("Expected WebSocket upgrade")

    return session

lifespan async

lifespan()

Handles the lifespan of the ASGI application.

Source code in lilya/testclient/base.py

async def lifespan(self) -> None:
    """
    Handles the lifespan of the ASGI application.
    """
    scope = {"type": "lifespan", "state": self.app_state}
    try:
        await self.app(scope, self.stream_receive.receive, self.stream_send.send)
    finally:
        await self.stream_send.send(None)

wait_startup async

wait_startup()

Waits for the ASGI application to start up.

Source code in lilya/testclient/base.py

async def wait_startup(self) -> None:
    """
    Waits for the ASGI application to start up.
    """
    await self.stream_receive.send({"type": "lifespan.startup"})

    async def receive() -> Any:
        message = await self.stream_send.receive()
        if message is None:
            self.task.result()
        return message

    message = await receive()
    assert message["type"] in (
        "lifespan.startup.complete",
        "lifespan.startup.failed",
    )
    if message["type"] == "lifespan.startup.failed":
        await receive()

wait_shutdown async

wait_shutdown()

Waits for the ASGI application to shut down.

Source code in lilya/testclient/base.py

async def wait_shutdown(self) -> None:
    """
    Waits for the ASGI application to shut down.
    """

    async def receive() -> Any:
        message = await self.stream_send.receive()
        if message is None:
            self.task.result()
        return message

    async with self.stream_send:
        await self.stream_receive.send({"type": "lifespan.shutdown"})
        message = await receive()
        assert message["type"] in (
            "lifespan.shutdown.complete",
            "lifespan.shutdown.failed",
        )
        if message["type"] == "lifespan.shutdown.failed":
            await receive()

from esmerald.testclient import create_client

You can learn more how to use it in the documentation.

esmerald.testclient.create_client

create_client(routes, *, settings_module=None, debug=None, app_name=None, title=None, version=None, summary=None, description=None, contact=None, terms_of_service=None, license=None, security=None, servers=None, secret_key=get_random_secret_key(), allowed_hosts=None, allow_origins=None, base_url='http://testserver', backend='asyncio', backend_options=None, interceptors=None, pluggables=None, permissions=None, dependencies=None, middleware=None, csrf_config=None, exception_handlers=None, openapi_config=None, on_shutdown=None, on_startup=None, cors_config=None, session_config=None, scheduler_config=None, enable_scheduler=None, enable_openapi=True, include_in_schema=True, openapi_version='3.1.0', raise_server_exceptions=True, root_path='', static_files_config=None, template_config=None, lifespan=None, cookies=None, redirect_slashes=None, tags=None, webhooks=None, encoders=None)

PARAMETER	DESCRIPTION
routes	TYPE: Union[APIGateHandler, List[APIGateHandler]]
settings_module	TYPE: Union[Optional[SettingsType], Optional[str]] DEFAULT: None
debug	TYPE: Optional[bool] DEFAULT: None
app_name	TYPE: Optional[str] DEFAULT: None
title	TYPE: Optional[str] DEFAULT: None
version	TYPE: Optional[str] DEFAULT: None
summary	TYPE: Optional[str] DEFAULT: None
description	TYPE: Optional[str] DEFAULT: None
contact	TYPE: Optional[Contact] DEFAULT: None
terms_of_service	TYPE: Optional[AnyUrl] DEFAULT: None
license	TYPE: Optional[License] DEFAULT: None
security	TYPE: Optional[List[SecurityScheme]] DEFAULT: None
servers	TYPE: Optional[List[Dict[str, Union[str, Any]]]] DEFAULT: None
secret_key	TYPE: Optional[str] DEFAULT: get_random_secret_key()
allowed_hosts	TYPE: Optional[List[str]] DEFAULT: None
allow_origins	TYPE: Optional[List[str]] DEFAULT: None
base_url	TYPE: str DEFAULT: 'http://testserver'
backend	TYPE: Literal['asyncio', 'trio'] DEFAULT: 'asyncio'
backend_options	TYPE: Optional[Dict[str, Any]] DEFAULT: None
interceptors	TYPE: Optional[List[Interceptor]] DEFAULT: None
pluggables	TYPE: Optional[Dict[str, Pluggable]] DEFAULT: None
permissions	TYPE: Optional[List[Permission]] DEFAULT: None
dependencies	TYPE: Optional[Dependencies] DEFAULT: None
middleware	TYPE: Optional[List[Middleware]] DEFAULT: None
csrf_config	TYPE: Optional[CSRFConfig] DEFAULT: None
exception_handlers	TYPE: Optional[ExceptionHandlerMap] DEFAULT: None
openapi_config	TYPE: Optional[OpenAPIConfig] DEFAULT: None
on_shutdown	TYPE: Optional[List[LifeSpanHandler]] DEFAULT: None
on_startup	TYPE: Optional[List[LifeSpanHandler]] DEFAULT: None
cors_config	TYPE: Optional[CORSConfig] DEFAULT: None
session_config	TYPE: Optional[SessionConfig] DEFAULT: None
scheduler_config	TYPE: Optional[SchedulerConfig] DEFAULT: None
enable_scheduler	TYPE: bool DEFAULT: None
enable_openapi	TYPE: bool DEFAULT: True
include_in_schema	TYPE: bool DEFAULT: True
openapi_version	TYPE: Optional[str] DEFAULT: '3.1.0'
raise_server_exceptions	TYPE: bool DEFAULT: True
root_path	TYPE: str DEFAULT: ''
static_files_config	TYPE: Optional[StaticFilesConfig] DEFAULT: None
template_config	TYPE: Optional[TemplateConfig] DEFAULT: None
lifespan	TYPE: Optional[Callable[[Esmerald], AsyncContextManager]] DEFAULT: None
cookies	TYPE: Optional[CookieTypes] DEFAULT: None
redirect_slashes	TYPE: Optional[bool] DEFAULT: None
tags	TYPE: Optional[List[str]] DEFAULT: None
webhooks	TYPE: Optional[Sequence[WebhookGateway]] DEFAULT: None
encoders	TYPE: Optional[Sequence[Encoder]] DEFAULT: None

Source code in esmerald/testclient.py

def create_client(
    routes: Union["APIGateHandler", List["APIGateHandler"]],
    *,
    settings_module: Union[Optional["SettingsType"], Optional[str]] = None,
    debug: Optional[bool] = None,
    app_name: Optional[str] = None,
    title: Optional[str] = None,
    version: Optional[str] = None,
    summary: Optional[str] = None,
    description: Optional[str] = None,
    contact: Optional[Contact] = None,
    terms_of_service: Optional[AnyUrl] = None,
    license: Optional[License] = None,
    security: Optional[List[SecurityScheme]] = None,
    servers: Optional[List[Dict[str, Union[str, Any]]]] = None,
    secret_key: Optional[str] = get_random_secret_key(),
    allowed_hosts: Optional[List[str]] = None,
    allow_origins: Optional[List[str]] = None,
    base_url: str = "http://testserver",
    backend: "Literal['asyncio', 'trio']" = "asyncio",
    backend_options: Optional[Dict[str, Any]] = None,
    interceptors: Optional[List["Interceptor"]] = None,
    pluggables: Optional[Dict[str, "Pluggable"]] = None,
    permissions: Optional[List["Permission"]] = None,
    dependencies: Optional["Dependencies"] = None,
    middleware: Optional[List["Middleware"]] = None,
    csrf_config: Optional["CSRFConfig"] = None,
    exception_handlers: Optional["ExceptionHandlerMap"] = None,
    openapi_config: Optional["OpenAPIConfig"] = None,
    on_shutdown: Optional[List["LifeSpanHandler"]] = None,
    on_startup: Optional[List["LifeSpanHandler"]] = None,
    cors_config: Optional["CORSConfig"] = None,
    session_config: Optional["SessionConfig"] = None,
    scheduler_config: Optional[SchedulerConfig] = None,
    enable_scheduler: bool = None,
    enable_openapi: bool = True,
    include_in_schema: bool = True,
    openapi_version: Optional[str] = "3.1.0",
    raise_server_exceptions: bool = True,
    root_path: str = "",
    static_files_config: Optional["StaticFilesConfig"] = None,
    template_config: Optional["TemplateConfig"] = None,
    lifespan: Optional[Callable[["Esmerald"], "AsyncContextManager"]] = None,
    cookies: Optional[CookieTypes] = None,
    redirect_slashes: Optional[bool] = None,
    tags: Optional[List[str]] = None,
    webhooks: Optional[Sequence["WebhookGateway"]] = None,
    encoders: Optional[Sequence[Encoder]] = None,
) -> EsmeraldTestClient:
    return EsmeraldTestClient(
        app=Esmerald(
            settings_module=settings_module,
            debug=debug,
            title=title,
            version=version,
            summary=summary,
            description=description,
            contact=contact,
            terms_of_service=terms_of_service,
            license=license,
            security=security,
            servers=servers,
            routes=cast("Any", routes if isinstance(routes, list) else [routes]),
            app_name=app_name,
            secret_key=secret_key,
            allowed_hosts=allowed_hosts,
            allow_origins=allow_origins,
            interceptors=interceptors,
            permissions=permissions,
            dependencies=dependencies,
            middleware=middleware,
            csrf_config=csrf_config,
            exception_handlers=exception_handlers,
            openapi_config=openapi_config,
            on_shutdown=on_shutdown,
            on_startup=on_startup,
            cors_config=cors_config,
            scheduler_config=scheduler_config,
            enable_scheduler=enable_scheduler,
            static_files_config=static_files_config,
            template_config=template_config,
            session_config=session_config,
            lifespan=lifespan,
            redirect_slashes=redirect_slashes,
            enable_openapi=enable_openapi,
            openapi_version=openapi_version,
            include_in_schema=include_in_schema,
            tags=tags,
            webhooks=webhooks,
            pluggables=pluggables,
            encoders=encoders,
        ),
        base_url=base_url,
        backend=backend,
        backend_options=backend_options,
        root_path=root_path,
        raise_server_exceptions=raise_server_exceptions,
        cookies=cookies,
    )