mockish.Mock¶

Functions¶

AsyncMock ¶

AsyncMock(*, return_value: Optional[Any] = None, return_call: Optional[Callable[..., Optional[Any]]] = None, return_once: Optional[Any] = None, return_each: Optional[Sequence[Any]] = None, return_exception: Optional[Exception] = None, **kwargs: Any) -> mock.Mock

Same as mockish.Mock, but returns an async Mock.

PARAMETER	DESCRIPTION
`return_value`	return the given value TYPE: `Optional[Any]` DEFAULT: `None`
`return_call`	return the value returned by the given callable TYPE: `Optional[Callable[..., Optional[Any]]]` DEFAULT: `None`
`return_once`	return the given value exactly once TYPE: `Optional[Any]` DEFAULT: `None`
`return_each`	consecutively return each element of the given iterable TYPE: `Optional[Sequence[Any]]` DEFAULT: `None`
`return_exception`	raise the given exception TYPE: `Optional[Exception]` DEFAULT: `None`
`**kwargs`	passed to `Mock(...)` TYPE: `Any` DEFAULT: `{}`

RETURNS	DESCRIPTION
`Mock`	...

Mock ¶

Mock(*, return_value: Optional[Any] = None, return_call: Optional[Callable[..., Optional[Any]]] = None, return_once: Optional[Any] = None, return_each: Optional[Sequence[Any]] = None, return_exception: Optional[Exception] = None, **kwargs: Any) -> mock.Mock

A thin wrapper around unittest.mock.Mock to abstract away the use of side_effect in favor of these explicit return_X parameters:

PARAMETER	DESCRIPTION
`return_value`	return the given value TYPE: `Optional[Any]` DEFAULT: `None`
`return_call`	return the value returned by the given callable TYPE: `Optional[Callable[..., Optional[Any]]]` DEFAULT: `None`
`return_once`	return the given value exactly once TYPE: `Optional[Any]` DEFAULT: `None`
`return_each`	consecutively return each element of the given iterable TYPE: `Optional[Sequence[Any]]` DEFAULT: `None`
`return_exception`	raise the given exception TYPE: `Optional[Exception]` DEFAULT: `None`
`**kwargs`	passed to `Mock(...)` TYPE: `Any` DEFAULT: `{}`

RETURNS	DESCRIPTION
`Mock`	...

Examples:

Import

>>> from mockish import Mock

return_value

>>> obj = Mock(return_value='hello world')
>>> obj()
'hello world'

return_call

>>> func = lambda: 'hello world'
>>> obj = Mock(return_call=func)
>>> obj()
'hello world'

return_once

>>> obj = Mock(return_once='hello world')
>>> obj()
'hello world'
>>> obj()
Traceback (most recent call last):
...
StopIteration

return_each

>>> obj = Mock(return_each=[1, 2, 3])
>>> obj()
1
>>> obj()
2
>>> obj()
3
>>> obj()
Traceback (most recent call last):
...
StopIteration

return_exception:

>>> obj = Mock(return_exception=ValueError("hello world"))
>>> obj()
Traceback (most recent call last):
...
ValueError: hello world

patch_fastapi_dependencies ¶

patch_fastapi_dependencies(*args: FastAPI, overrides: Optional[Dict[Callable[..., Any], Callable[..., Any]]], remove: bool = False) -> None

Recursively patch dependencies of FastAPI instance(s).

Read about FastAPI test dependencies.

Note: fastapi must be installed.

PARAMETER	DESCRIPTION
`*args`	FastAPI instance(s) to patch TYPE: `FastAPI` DEFAULT: `()`
`overrides`	A mapping of overrides, or `None` to remove all TYPE: `Optional[Dict[Callable[..., Any], Callable[..., Any]]]`
`remove`	Remove the provided overrides TYPE: `bool` DEFAULT: `False`

RAISES	DESCRIPTION
`TypeError`	raised if any of `args` is not a FastAPI instance

Examples:

from fastapi import FastAPI
from fastapi.testclient import TestClient

app = FastAPI(...)

mockish.patch_fastapi_dependencies(
    app,
    overrides={
        get_app_settings: lambda: app_settings,
    },
)

@app.get("/")
def get() -> dict[str, str]:
    return {"hello": "world"}

return TestClient(app)