Test Client

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

from ravyn.testclient import RavynTestClient

ravyn.testclient.RavynTestClient

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

Bases: TestClient

Source code in ravyn/testclient.py

def __init__(
    self,
    app: Ravyn,
    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,
    )

app instance-attribute

app

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 = {}

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

Source code in httpx/_client.py

def build_request(
    self,
    method: str,
    url: URL | str,
    *,
    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/clients/#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=USE_CLIENT_DEFAULT,
    follow_redirects=None,
    timeout=USE_CLIENT_DEFAULT,
    extensions=None,
)

Sends an HTTP request.

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

Source code in httpx/_client.py

@contextmanager
def stream(
    self,
    method: str,
    url: URL | str,
    *,
    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

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/clients/#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
    )

    self._set_timeout(request)

    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)

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)

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)

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)

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)

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)

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)

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	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:
        with contextlib.suppress(anyio.ClosedResourceError):
            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_mode = hasattr(self, "_tg")

    if async_mode:
        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()
    else:
        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 ravyn.testclient import create_client

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

ravyn.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,
    extensions=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,
    logging_config=None,
    template_config=None,
    lifespan=None,
    cookies=None,
    redirect_slashes=None,
    tags=None,
    webhooks=None,
    encoders=None,
    before_request=None,
    after_request=None,
)

Source code in ravyn/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,
    extensions: Optional[
        dict[str, Union["Extension", "Pluggable", type["Extension"], str]]
    ] = 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: Union[
        "StaticFilesConfig",
        list["StaticFilesConfig"],
        tuple["StaticFilesConfig", ...],
        None,
    ] = None,
    logging_config: Optional["LoggingConfig"] = None,
    template_config: Optional["TemplateConfig"] = None,
    lifespan: Optional[Callable[["Ravyn"], "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,
    before_request: Union[Sequence[Callable[..., Any]], None] = None,
    after_request: Union[Sequence[Callable[..., Any]], None] = None,
) -> RavynTestClient:
    return RavynTestClient(
        app=Ravyn(
            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,
            extensions=extensions,
            encoders=encoders,
            before_request=before_request,
            after_request=after_request,
            logging_config=logging_config,
        ),
        base_url=base_url,
        backend=backend,
        backend_options=backend_options,
        root_path=root_path,
        raise_server_exceptions=raise_server_exceptions,
        cookies=cookies,
    )