fix: respect FastAPI dependency_overrides in get_injected_obj

This commit fixes a bug where `get_injected_obj` did not correctly respect FastAPI's `app.dependency_overrides` for top-level dependencies.

The issue was that `get_injected_obj` was not explicitly integrating with FastAPI's dependency injection system when called outside of a route handler. This meant that when `app.dependency_overrides` was used to
mock a dependency for testing, `get_injected_obj` would bypass the override and attempt to resolve the original dependency.

To fix this, `get_injected_obj` now wraps the provided function in a pass-through dependency using `Annotated` and `Depends`. This makes the dependency explicitly visible to FastAPI, allowing `dependency_overrides` to function as expected.

This change ensures that `get_injected_obj` can be reliably used in testing scenarios with mocked dependencies.

Author: JasperSui

noxfile.py

@@ -134,7 +134,7 @@ def mypy(session: Session) -> None:
 def tests(session: Session) -> None:
     """Run the test suite."""
     session.install(".")
-    session.install("coverage[toml]", "pytest", "pytest-asyncio")
+    session.install("coverage[toml]", "pytest", "pytest-asyncio", "httpx")
     try:
         session.run("coverage", "run", "--parallel-mode", "-m", "pytest", *session.posargs)
     finally:

poetry.lock

@@ -39,6 +39,7 @@ ipython = "^8.30.0"
 ipdb = "^0.13.13"
 furo = "^2024.8.6"
 coverage = { extras = ["toml"], version = "^7.6.9" }
+httpx = "^0.28.1"
 
 [tool.ruff]
 lint.ignore = [

pyproject.toml

@@ -58,7 +58,15 @@ def _override_func_dependency_signature(func: Callable[P, T] | Callable[P, Await
                     "Injected_" + getattr(base_class, "__name__", "Injected"),
                     (base_class,),
                     {},
-                    lambda ns: ns.update({"__init__": lambda self, *args, **kwargs: None}),  # noqa: ARG005
+                    lambda ns: ns.update(
+                        {
+                            "__init__": lambda self, *args, **kwargs: None,  # noqa: ARG005
+                            **{
+                                method: lambda *args, **kwargs: None  # noqa: ARG005
+                                for method in getattr(base_class, "__abstractmethods__", [])  # noqa: B023
+                            },
+                        }
+                    ),
                 )
                 parameter = inspect.Parameter.replace(param, default=dynamic_default())
         new_parameters.append(parameter)

src/fastapi_injectable/decorator.py

@@ -1,17 +1,85 @@
 import atexit
 import inspect
 import signal
-from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine, Generator, Sequence
-from typing import Any, ParamSpec, TypeVar, cast, overload
+from collections.abc import AsyncGenerator, Awaitable, Callable, Generator, Sequence
+from typing import Annotated, Any, ParamSpec, TypeVar, cast, get_type_hints, overload
+
+from fastapi import Depends
 
 from .async_exit_stack import async_exit_stack_manager
 from .cache import dependency_cache
 from .concurrency import run_coroutine_sync
 from .decorator import injectable
 
 T = TypeVar("T")
+T2 = TypeVar("T2")
+T3 = TypeVar("T3")
 P = ParamSpec("P")
 
+PROVIDER_TO_WRAPPER_FUNC_MAP: dict[Callable[..., Any], list[Callable[[Any], Any]]] = {}
+
+
+def _create_depends_function(
+    provider: Callable[..., Any],
+) -> Callable[..., Any]:
+    """Build a pass-through dependency for FastAPI.
+
+    Related issue: https://github.com/JasperSui/fastapi-injectable/issues/153
+
+    The returned callable has a single parameter whose annotation is:
+        Annotated[<provider_return_type>, Depends(provider)]
+    and it simply returns that parameter.
+
+    Type checkers see this as Callable[[T], T] with T inferred from the provider's return type.
+
+    Raises:
+        TypeError if the provider's return type cannot be determined.
+    """
+    # Runtime: resolve the *concrete* return type for FastAPI's inspection
+    try:
+        hints = get_type_hints(provider, include_extras=True)
+    except Exception:  # pragma: no cover # noqa: BLE001
+        hints = {}
+
+    rt = hints.get("return", inspect.Signature.empty)
+
+    if rt in (inspect.Signature.empty, Any, None):  # pragma: no cover
+        msg = (
+            f"Cannot infer return type for provider {getattr(provider, '__name__', repr(provider))}. "
+            "Please add an explicit return annotation."
+        )
+        raise TypeError(msg)
+
+    def inner(dep: T2) -> T2:
+        return dep
+
+    # Provide the annotations FastAPI inspects at runtime
+    inner.__annotations__ = {
+        "dep": Annotated[rt, Depends(provider)],
+        "return": rt,
+    }
+
+    # Nice signature for docs/inspection
+    inner.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters=[
+            inspect.Parameter(
+                "dep",
+                kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                annotation=Annotated[rt, Depends(provider)],
+            )
+        ],
+        return_annotation=rt,
+    )
+
+    inner.__name__ = f"{getattr(provider, '__name__', 'provider')}_extractor"
+
+    # Store the wrapper function for cleanup the provider later
+    if provider not in PROVIDER_TO_WRAPPER_FUNC_MAP:
+        PROVIDER_TO_WRAPPER_FUNC_MAP[provider] = []
+    PROVIDER_TO_WRAPPER_FUNC_MAP[provider].append(inner)
+
+    return inner
+
 
 @overload
 def get_injected_obj(
@@ -111,30 +179,22 @@ def get_db() -> Generator[Database, None, None]:
         - Cleanup code in generators will be executed when calling cleanup functions
         - Uses FastAPI's dependency injection system under the hood
     """
-    injectable_func = injectable(func, use_cache=use_cache)
-
     if args is None:
         args = []
     if kwargs is None:
         kwargs = {}
 
-    if inspect.isasyncgenfunction(func):
-        # Handle async generator
-        async_gen = cast(AsyncGenerator[T, Any], injectable_func(*args, **kwargs))
-        return run_coroutine_sync(anext(async_gen))
-
-    if inspect.isgeneratorfunction(func):
-        # Handle sync generator
-        gen = cast(Generator[T, Any, Any], injectable_func(*args, **kwargs))
-        return next(gen)
-
-    if inspect.iscoroutinefunction(func):
-        # Handle coroutine
-        coro = cast(Coroutine[Any, Any, T], injectable_func(*args, **kwargs))
-        return run_coroutine_sync(coro)
+    wrapped_func = _create_depends_function(func)
+    injectable_func = injectable(wrapped_func, use_cache=use_cache)
+    result = injectable_func(*args, **kwargs)  # type: ignore[no-untyped-call]
 
-    # Handle regular function
-    return cast(T, injectable_func(*args, **kwargs))
+    if inspect.isasyncgen(result):
+        return cast("T", run_coroutine_sync(anext(result)))
+    if inspect.isgenerator(result):
+        return cast("T", next(result))
+    if inspect.isawaitable(result):
+        return cast("T", run_coroutine_sync(result))  # type: ignore[arg-type]
+    return cast("T", result)
 
 
 async def cleanup_exit_stack_of_func(func: Callable[..., Any], *, raise_exception: bool = False) -> None:
@@ -152,7 +212,8 @@ async def cleanup_exit_stack_of_func(func: Callable[..., Any], *, raise_exceptio
     Raises:
         DependencyCleanupError: When cleanup fails and raise_exception is True
     """
-    await async_exit_stack_manager.cleanup_stack(func, raise_exception=raise_exception)
+    for wrapper in PROVIDER_TO_WRAPPER_FUNC_MAP.get(func, [func]):
+        await async_exit_stack_manager.cleanup_stack(wrapper, raise_exception=raise_exception)
 
 
 async def cleanup_all_exit_stacks(*, raise_exception: bool = False) -> None:

src/fastapi_injectable/util.py

@@ -1,12 +1,19 @@
 from collections.abc import AsyncGenerator, Generator
 from typing import Annotated, Any
+from unittest.mock import Mock
 
 import pytest
-from fastapi import Depends
+from fastapi import Depends, FastAPI
+from fastapi.testclient import TestClient
 
-from src.fastapi_injectable.concurrency import run_coroutine_sync
+from src.fastapi_injectable import register_app
+from src.fastapi_injectable.concurrency import loop_manager, run_coroutine_sync
 from src.fastapi_injectable.decorator import injectable
-from src.fastapi_injectable.util import cleanup_all_exit_stacks, cleanup_exit_stack_of_func, get_injected_obj
+from src.fastapi_injectable.util import (
+    cleanup_all_exit_stacks,
+    cleanup_exit_stack_of_func,
+    get_injected_obj,
+)
 
 
 @pytest.fixture
@@ -604,3 +611,154 @@ def get_country(
 
     country: Country = get_country(basic_str="basic_str", basic_int=1, basic_bool=True, basic_dict={"key": "value"})  # type: ignore  # noqa: PGH003
     assert country is not None
+
+
+def test_get_injected_obj_with_dependency_override_sync(clean_exit_stack_manager: None) -> None:
+    """Tests that get_injected_obj respects dependency_overrides for sync dependencies."""
+
+    def sync_dependency_override() -> int:
+        return 1
+
+    def use_sync_dependency_override() -> int:
+        return get_injected_obj(sync_dependency_override)
+
+    loop_manager.set_loop_strategy(
+        "background_thread"
+    )  # To avoid affecting the FastAPI app and httpx client event loop
+    app = FastAPI()
+
+    @app.get("/")
+    def read_root() -> int:
+        return use_sync_dependency_override()
+
+    mock_dependency = Mock(return_value=2)
+    app.dependency_overrides[sync_dependency_override] = lambda: mock_dependency()
+    run_coroutine_sync(register_app(app))
+
+    client = TestClient(app)
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.json() == 2
+    mock_dependency.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_get_injected_obj_with_dependency_override_async(clean_exit_stack_manager: None) -> None:
+    """Tests that get_injected_obj respects dependency_overrides for async dependencies."""
+
+    async def async_dependency_override() -> int:
+        return 1
+
+    def use_async_dependency_override() -> int:
+        return get_injected_obj(async_dependency_override)
+
+    loop_manager.set_loop_strategy(
+        "background_thread"
+    )  # To avoid affecting the FastAPI app and httpx client event loop
+    app = FastAPI()
+
+    @app.get("/")
+    async def read_root() -> int:
+        return use_async_dependency_override()
+
+    mock_dependency = Mock(return_value=2)
+    app.dependency_overrides[async_dependency_override] = lambda: mock_dependency()
+    await register_app(app)
+
+    client = TestClient(app)
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.json() == 2
+    mock_dependency.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_get_injected_obj_with_dependency_override_sync_generator(
+    clean_exit_stack_manager: None,
+) -> None:
+    """Tests that get_injected_obj respects dependency_overrides for sync generators."""
+    sync_cleanup_mock_override = Mock()
+
+    def sync_gen_dependency_override() -> Generator[int, None, None]:
+        try:
+            yield 1
+        finally:
+            sync_cleanup_mock_override()
+
+    def use_sync_gen_dependency_override() -> int:
+        return get_injected_obj(sync_gen_dependency_override)
+
+    override_sync_cleanup_mock = Mock()
+
+    def override_sync_gen() -> Generator[int, None, None]:
+        try:
+            yield 2
+        finally:
+            override_sync_cleanup_mock()
+
+    loop_manager.set_loop_strategy(
+        "background_thread"
+    )  # To avoid affecting the FastAPI app and httpx client event loop
+    app = FastAPI()
+
+    @app.get("/")
+    def read_root() -> int:
+        return use_sync_gen_dependency_override()
+
+    app.dependency_overrides[sync_gen_dependency_override] = override_sync_gen
+    await register_app(app)
+
+    with TestClient(app) as client:
+        response = client.get("/")
+        assert response.status_code == 200
+        assert response.json() == 2
+
+    await cleanup_all_exit_stacks()
+    sync_cleanup_mock_override.assert_not_called()
+    override_sync_cleanup_mock.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_get_injected_obj_with_dependency_override_async_generator(
+    clean_exit_stack_manager: None,
+) -> None:
+    """Tests that get_injected_obj respects dependency_overrides for async generators."""
+    async_cleanup_mock_override = Mock()
+
+    async def async_gen_dependency_override() -> AsyncGenerator[int, None]:
+        try:
+            yield 1
+        finally:
+            async_cleanup_mock_override()
+
+    def use_async_gen_dependency_override() -> int:
+        return get_injected_obj(async_gen_dependency_override)
+
+    override_async_cleanup_mock = Mock()
+
+    async def override_async_gen() -> AsyncGenerator[int, None]:
+        try:
+            yield 2
+        finally:
+            override_async_cleanup_mock()
+
+    loop_manager.set_loop_strategy(
+        "background_thread"
+    )  # To avoid affecting the FastAPI app and httpx client event loop
+    app = FastAPI()
+
+    @app.get("/")
+    async def read_root() -> int:
+        return use_async_gen_dependency_override()
+
+    app.dependency_overrides[async_gen_dependency_override] = override_async_gen
+    await register_app(app)
+
+    with TestClient(app) as client:
+        response = client.get("/")
+        assert response.status_code == 200
+        assert response.json() == 2
+
+    await cleanup_all_exit_stacks()
+    async_cleanup_mock_override.assert_not_called()
+    override_async_cleanup_mock.assert_called_once()