Test Client - TestClient

You can use the TestClient class to test FastAPI applications without creating an actual HTTP and socket connection, just communicating directly with the FastAPI code.

Read more about it in the FastAPI docs for Testing.

You can import it directly from fastapi.testclient:

from fastapi.testclient import TestClient

fastapi.testclient.TestClient

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

Bases: Client

PARAMETER	DESCRIPTION
app	TYPE: ASGIApp
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: dict[str, Any] | None DEFAULT: None
cookies	TYPE: CookieTypes | None DEFAULT: None
headers	TYPE: dict[str, str] | None DEFAULT: None
follow_redirects	TYPE: bool DEFAULT: True

Source code in starlette/testclient.py

def __init__(
    self,
    app: ASGIApp,
    base_url: str = "http://testserver",
    raise_server_exceptions: bool = True,
    root_path: str = "",
    backend: typing.Literal["asyncio", "trio"] = "asyncio",
    backend_options: dict[str, typing.Any] | None = None,
    cookies: httpx._types.CookieTypes | None = None,
    headers: dict[str, str] | None = None,
    follow_redirects: bool = True,
) -> None:
    self.async_backend = _AsyncBackend(
        backend=backend, backend_options=backend_options or {}
    )
    if _is_asgi3(app):
        asgi_app = app
    else:
        app = typing.cast(ASGI2App, app)  # type: ignore[assignment]
        asgi_app = _WrapASGI2(app)  # type: ignore[arg-type]
    self.app = asgi_app
    self.app_state: dict[str, typing.Any] = {}
    transport = _TestClientTransport(
        self.app,
        portal_factory=self._portal_factory,
        raise_server_exceptions=raise_server_exceptions,
        root_path=root_path,
        app_state=self.app_state,
    )
    if headers is None:
        headers = {}
    headers.setdefault("user-agent", "testclient")
    super().__init__(
        base_url=base_url,
        headers=headers,
        transport=transport,
        follow_redirects=follow_redirects,
        cookies=cookies,
    )

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 instance-attribute

app = asgi_app

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

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

Source code in httpx/_client.py

def build_request(
    self,
    method: str,
    url: URLTypes,
    *,
    content: typing.Optional[RequestContent] = None,
    data: typing.Optional[RequestData] = None,
    files: typing.Optional[RequestFiles] = None,
    json: typing.Optional[typing.Any] = None,
    params: typing.Optional[QueryParamTypes] = None,
    headers: typing.Optional[HeaderTypes] = None,
    cookies: typing.Optional[CookieTypes] = None,
    timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
    extensions: typing.Optional[RequestExtensions] = 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,
    )

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: Optional[RequestContent] DEFAULT: None
data	TYPE: Optional[RequestData] DEFAULT: None
files	TYPE: Optional[RequestFiles] DEFAULT: None
json	TYPE: Optional[Any] DEFAULT: None
params	TYPE: Optional[QueryParamTypes] DEFAULT: None
headers	TYPE: Optional[HeaderTypes] DEFAULT: None
cookies	TYPE: Optional[CookieTypes] DEFAULT: None
auth	TYPE: Union[AuthTypes, UseClientDefault, None] DEFAULT: USE_CLIENT_DEFAULT
follow_redirects	TYPE: Union[bool, UseClientDefault] DEFAULT: USE_CLIENT_DEFAULT
timeout	TYPE: Union[TimeoutTypes, UseClientDefault] DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: Optional[RequestExtensions] DEFAULT: None

YIELDS	DESCRIPTION
Response

Source code in httpx/_client.py

@contextmanager
def stream(
    self,
    method: str,
    url: URLTypes,
    *,
    content: typing.Optional[RequestContent] = None,
    data: typing.Optional[RequestData] = None,
    files: typing.Optional[RequestFiles] = None,
    json: typing.Optional[typing.Any] = None,
    params: typing.Optional[QueryParamTypes] = None,
    headers: typing.Optional[HeaderTypes] = None,
    cookies: typing.Optional[CookieTypes] = None,
    auth: typing.Union[AuthTypes, UseClientDefault, None] = USE_CLIENT_DEFAULT,
    follow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
    timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
    extensions: typing.Optional[RequestExtensions] = 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: Union[AuthTypes, UseClientDefault, None] DEFAULT: USE_CLIENT_DEFAULT
follow_redirects	TYPE: Union[bool, UseClientDefault] DEFAULT: USE_CLIENT_DEFAULT

Source code in httpx/_client.py

def send(
    self,
    request: Request,
    *,
    stream: bool = False,
    auth: typing.Union[AuthTypes, UseClientDefault, None] = USE_CLIENT_DEFAULT,
    follow_redirects: typing.Union[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

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()

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,
    allow_redirects=None,
    timeout=httpx._client.USE_CLIENT_DEFAULT,
    extensions=None
)

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
allow_redirects	TYPE: bool | None DEFAULT: None
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: dict[str, Any] | None DEFAULT: None

Source code in starlette/testclient.py

def request(  # type: ignore[override]
    self,
    method: str,
    url: httpx._types.URLTypes,
    *,
    content: httpx._types.RequestContent | None = None,
    data: _RequestData | None = None,
    files: httpx._types.RequestFiles | None = None,
    json: typing.Any = None,
    params: httpx._types.QueryParamTypes | None = None,
    headers: httpx._types.HeaderTypes | None = None,
    cookies: httpx._types.CookieTypes | None = None,
    auth: httpx._types.AuthTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects: bool | None = None,
    allow_redirects: bool | None = None,
    timeout: httpx._types.TimeoutTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    extensions: dict[str, typing.Any] | None = None,
) -> httpx.Response:
    url = self._merge_url(url)
    redirect = self._choose_redirect_arg(follow_redirects, allow_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,
    )

get

get(
    url,
    *,
    params=None,
    headers=None,
    cookies=None,
    auth=httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects=None,
    allow_redirects=None,
    timeout=httpx._client.USE_CLIENT_DEFAULT,
    extensions=None
)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
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
allow_redirects	TYPE: bool | None DEFAULT: None
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: dict[str, Any] | None DEFAULT: None

Source code in starlette/testclient.py

def get(  # type: ignore[override]
    self,
    url: httpx._types.URLTypes,
    *,
    params: httpx._types.QueryParamTypes | None = None,
    headers: httpx._types.HeaderTypes | None = None,
    cookies: httpx._types.CookieTypes | None = None,
    auth: httpx._types.AuthTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects: bool | None = None,
    allow_redirects: bool | None = None,
    timeout: httpx._types.TimeoutTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    extensions: dict[str, typing.Any] | None = None,
) -> httpx.Response:
    redirect = self._choose_redirect_arg(follow_redirects, allow_redirects)
    return super().get(
        url,
        params=params,
        headers=headers,
        cookies=cookies,
        auth=auth,
        follow_redirects=redirect,
        timeout=timeout,
        extensions=extensions,
    )

options

options(
    url,
    *,
    params=None,
    headers=None,
    cookies=None,
    auth=httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects=None,
    allow_redirects=None,
    timeout=httpx._client.USE_CLIENT_DEFAULT,
    extensions=None
)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
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
allow_redirects	TYPE: bool | None DEFAULT: None
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: dict[str, Any] | None DEFAULT: None

Source code in starlette/testclient.py

def options(  # type: ignore[override]
    self,
    url: httpx._types.URLTypes,
    *,
    params: httpx._types.QueryParamTypes | None = None,
    headers: httpx._types.HeaderTypes | None = None,
    cookies: httpx._types.CookieTypes | None = None,
    auth: httpx._types.AuthTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects: bool | None = None,
    allow_redirects: bool | None = None,
    timeout: httpx._types.TimeoutTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    extensions: dict[str, typing.Any] | None = None,
) -> httpx.Response:
    redirect = self._choose_redirect_arg(follow_redirects, allow_redirects)
    return super().options(
        url,
        params=params,
        headers=headers,
        cookies=cookies,
        auth=auth,
        follow_redirects=redirect,
        timeout=timeout,
        extensions=extensions,
    )

head

head(
    url,
    *,
    params=None,
    headers=None,
    cookies=None,
    auth=httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects=None,
    allow_redirects=None,
    timeout=httpx._client.USE_CLIENT_DEFAULT,
    extensions=None
)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
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
allow_redirects	TYPE: bool | None DEFAULT: None
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: dict[str, Any] | None DEFAULT: None

Source code in starlette/testclient.py

def head(  # type: ignore[override]
    self,
    url: httpx._types.URLTypes,
    *,
    params: httpx._types.QueryParamTypes | None = None,
    headers: httpx._types.HeaderTypes | None = None,
    cookies: httpx._types.CookieTypes | None = None,
    auth: httpx._types.AuthTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects: bool | None = None,
    allow_redirects: bool | None = None,
    timeout: httpx._types.TimeoutTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    extensions: dict[str, typing.Any] | None = None,
) -> httpx.Response:
    redirect = self._choose_redirect_arg(follow_redirects, allow_redirects)
    return super().head(
        url,
        params=params,
        headers=headers,
        cookies=cookies,
        auth=auth,
        follow_redirects=redirect,
        timeout=timeout,
        extensions=extensions,
    )

post

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

PARAMETER	DESCRIPTION
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
allow_redirects	TYPE: bool | None DEFAULT: None
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: dict[str, Any] | None DEFAULT: None

Source code in starlette/testclient.py

def post(  # type: ignore[override]
    self,
    url: httpx._types.URLTypes,
    *,
    content: httpx._types.RequestContent | None = None,
    data: _RequestData | None = None,
    files: httpx._types.RequestFiles | None = None,
    json: typing.Any = None,
    params: httpx._types.QueryParamTypes | None = None,
    headers: httpx._types.HeaderTypes | None = None,
    cookies: httpx._types.CookieTypes | None = None,
    auth: httpx._types.AuthTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects: bool | None = None,
    allow_redirects: bool | None = None,
    timeout: httpx._types.TimeoutTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    extensions: dict[str, typing.Any] | None = None,
) -> httpx.Response:
    redirect = self._choose_redirect_arg(follow_redirects, allow_redirects)
    return super().post(
        url,
        content=content,
        data=data,
        files=files,
        json=json,
        params=params,
        headers=headers,
        cookies=cookies,
        auth=auth,
        follow_redirects=redirect,
        timeout=timeout,
        extensions=extensions,
    )

put

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

PARAMETER	DESCRIPTION
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
allow_redirects	TYPE: bool | None DEFAULT: None
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: dict[str, Any] | None DEFAULT: None

Source code in starlette/testclient.py

def put(  # type: ignore[override]
    self,
    url: httpx._types.URLTypes,
    *,
    content: httpx._types.RequestContent | None = None,
    data: _RequestData | None = None,
    files: httpx._types.RequestFiles | None = None,
    json: typing.Any = None,
    params: httpx._types.QueryParamTypes | None = None,
    headers: httpx._types.HeaderTypes | None = None,
    cookies: httpx._types.CookieTypes | None = None,
    auth: httpx._types.AuthTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects: bool | None = None,
    allow_redirects: bool | None = None,
    timeout: httpx._types.TimeoutTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    extensions: dict[str, typing.Any] | None = None,
) -> httpx.Response:
    redirect = self._choose_redirect_arg(follow_redirects, allow_redirects)
    return super().put(
        url,
        content=content,
        data=data,
        files=files,
        json=json,
        params=params,
        headers=headers,
        cookies=cookies,
        auth=auth,
        follow_redirects=redirect,
        timeout=timeout,
        extensions=extensions,
    )

patch

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

PARAMETER	DESCRIPTION
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
allow_redirects	TYPE: bool | None DEFAULT: None
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: dict[str, Any] | None DEFAULT: None

Source code in starlette/testclient.py

def patch(  # type: ignore[override]
    self,
    url: httpx._types.URLTypes,
    *,
    content: httpx._types.RequestContent | None = None,
    data: _RequestData | None = None,
    files: httpx._types.RequestFiles | None = None,
    json: typing.Any = None,
    params: httpx._types.QueryParamTypes | None = None,
    headers: httpx._types.HeaderTypes | None = None,
    cookies: httpx._types.CookieTypes | None = None,
    auth: httpx._types.AuthTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects: bool | None = None,
    allow_redirects: bool | None = None,
    timeout: httpx._types.TimeoutTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    extensions: dict[str, typing.Any] | None = None,
) -> httpx.Response:
    redirect = self._choose_redirect_arg(follow_redirects, allow_redirects)
    return super().patch(
        url,
        content=content,
        data=data,
        files=files,
        json=json,
        params=params,
        headers=headers,
        cookies=cookies,
        auth=auth,
        follow_redirects=redirect,
        timeout=timeout,
        extensions=extensions,
    )

delete

delete(
    url,
    *,
    params=None,
    headers=None,
    cookies=None,
    auth=httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects=None,
    allow_redirects=None,
    timeout=httpx._client.USE_CLIENT_DEFAULT,
    extensions=None
)

PARAMETER	DESCRIPTION
url	TYPE: URLTypes
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
allow_redirects	TYPE: bool | None DEFAULT: None
timeout	TYPE: TimeoutTypes | UseClientDefault DEFAULT: USE_CLIENT_DEFAULT
extensions	TYPE: dict[str, Any] | None DEFAULT: None

Source code in starlette/testclient.py

def delete(  # type: ignore[override]
    self,
    url: httpx._types.URLTypes,
    *,
    params: httpx._types.QueryParamTypes | None = None,
    headers: httpx._types.HeaderTypes | None = None,
    cookies: httpx._types.CookieTypes | None = None,
    auth: httpx._types.AuthTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    follow_redirects: bool | None = None,
    allow_redirects: bool | None = None,
    timeout: httpx._types.TimeoutTypes
    | httpx._client.UseClientDefault = httpx._client.USE_CLIENT_DEFAULT,
    extensions: dict[str, typing.Any] | None = None,
) -> httpx.Response:
    redirect = self._choose_redirect_arg(follow_redirects, allow_redirects)
    return super().delete(
        url,
        params=params,
        headers=headers,
        cookies=cookies,
        auth=auth,
        follow_redirects=redirect,
        timeout=timeout,
        extensions=extensions,
    )

websocket_connect

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

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

Source code in starlette/testclient.py

def websocket_connect(
    self,
    url: str,
    subprotocols: typing.Sequence[str] | None = None,
    **kwargs: typing.Any,
) -> WebSocketTestSession:
    url = urljoin("ws://testserver", url)
    headers = kwargs.get("headers", {})
    headers.setdefault("connection", "upgrade")
    headers.setdefault("sec-websocket-key", "testserver==")
    headers.setdefault("sec-websocket-version", "13")
    if subprotocols is not None:
        headers.setdefault("sec-websocket-protocol", ", ".join(subprotocols))
    kwargs["headers"] = headers
    try:
        super().request("GET", url, **kwargs)
    except _Upgrade as exc:
        session = exc.session
    else:
        raise RuntimeError("Expected WebSocket upgrade")  # pragma: no cover

    return session

lifespan async

lifespan()

Source code in starlette/testclient.py

async def lifespan(self) -> None:
    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()

Source code in starlette/testclient.py

async def wait_startup(self) -> None:
    await self.stream_receive.send({"type": "lifespan.startup"})

    async def receive() -> typing.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()

Source code in starlette/testclient.py

async def wait_shutdown(self) -> None:
    async def receive() -> typing.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()