fix: nested generics (#23)

aioinject/_features/generics.py

@@ -72,9 +72,9 @@ def get_generic_parameter_map(
         ):
             # This is a generic type, we need to resolve the type arguments
             # and pass them to the provider.
-            resolved_args = [
+            resolved_args = tuple(
                 args_map[arg.__name__] for arg in generic_arguments
-            ]
+            )
             #  We can use `[]` when we drop support for 3.10
-            result[dependency.name] = inner_type.__getitem__(*resolved_args)
+            result[dependency.name] = inner_type[resolved_args]
     return result

pyproject.toml

@@ -32,6 +32,7 @@ dev = [
     "mkdocs-material>=9.5.44",
     "mypy>=1.13.0",
     "pydantic-settings>=2.6.1",
+    "pytest-cov>=6.0.0",
     "pytest>=8.3.3",
     "ruff>=0.7.4",
     "strawberry-graphql>=0.248.1",

tests/features/test_generics.py

@@ -1,5 +1,6 @@
 import abc
 from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
 from typing import Generic, TypeVar
 
 import pytest
@@ -9,39 +10,61 @@
 
 
 T = TypeVar("T")
+U = TypeVar("U")
 ReqT = TypeVar("ReqT")
 ResT = TypeVar("ResT")
 
 
-class GenericService(Generic[T]):
+class UnusedGeneric(Generic[T]):
     def __init__(self, dependency: str) -> None:
         self.dependency = dependency
 
 
-class WithGenericDependency(Generic[T]):
+class SimpleGeneric(Generic[T]):
     def __init__(self, dependency: T) -> None:
         self.dependency = dependency
 
 
-class ConstrainedGenericDependency(WithGenericDependency[int]):
+class SimpleGenericExtended(SimpleGeneric[int]):
     pass
 
 
+class MultipleSimpleGeneric(Generic[T, U]):
+    def __init__(self, service: T, b: U) -> None:
+        self.service = service
+        self.b = b
+
+
+class NestedGeneric(Generic[T, U]):
+    def __init__(self, simple_gen: MultipleSimpleGeneric[T, U], u: U) -> None:
+        self.simple_gen = simple_gen
+        self.u = u
+
+
+class Something:
+    def __init__(self) -> None:
+        self.a = MEANING_OF_LIFE_INT
+
+
+MEANING_OF_LIFE_INT = 42
+MEANING_OF_LIFE_STR = "42"
+
+
 async def test_generic_dependency() -> None:
-    assert Scoped(GenericService[int]).collect_dependencies() == (
+    assert Scoped(UnusedGeneric[int]).collect_dependencies() == (
         Dependency(
             name="dependency",
             type_=str,
         ),
     )
 
-    assert Scoped(WithGenericDependency[int]).collect_dependencies() == (
+    assert Scoped(SimpleGeneric[int]).collect_dependencies() == (
         Dependency(
             name="dependency",
             type_=int,
         ),
     )
-    assert Scoped(ConstrainedGenericDependency).collect_dependencies() == (
+    assert Scoped(SimpleGenericExtended).collect_dependencies() == (
         Dependency(
             name="dependency",
             type_=int,
@@ -52,9 +75,9 @@ async def test_generic_dependency() -> None:
 @pytest.mark.parametrize(
     ("type_", "instanceof"),
     [
-        (GenericService, GenericService),
-        (WithGenericDependency[int], WithGenericDependency),
-        (ConstrainedGenericDependency, ConstrainedGenericDependency),
+        (UnusedGeneric, UnusedGeneric),
+        (SimpleGeneric[int], SimpleGeneric),
+        (SimpleGenericExtended, SimpleGenericExtended),
     ],
 )
 async def test_resolve_generics(
@@ -71,87 +94,48 @@ async def test_resolve_generics(
         assert isinstance(instance, instanceof)
 
 
-class NestedGenericService(Generic[T]):
-    def __init__(self, service: T) -> None:
-        self.service = service
-
-
-MEANING_OF_LIFE_INT = 42
-MEANING_OF_LIFE_STR = "42"
-
-
-class Something:
-    def __init__(self) -> None:
-        self.a = MEANING_OF_LIFE_INT
-
-
 async def test_nested_generics() -> None:
     container = Container()
     container.register(
-        Scoped(NestedGenericService[WithGenericDependency[Something]]),
-        Scoped(WithGenericDependency[Something]),
-        Scoped(Something),
+        Scoped(NestedGeneric[int, str]),
+        Scoped(MultipleSimpleGeneric[int, str]),
         Object(MEANING_OF_LIFE_INT),
-        Object("42"),
+        Object(MEANING_OF_LIFE_STR),
     )
 
     async with container.context() as ctx:
-        instance = await ctx.resolve(
-            NestedGenericService[WithGenericDependency[Something]]
-        )
-        assert isinstance(instance, NestedGenericService)
-        assert isinstance(instance.service, WithGenericDependency)
-        assert isinstance(instance.service.dependency, Something)
-        assert instance.service.dependency.a == MEANING_OF_LIFE_INT
-
-
-class NestedUnresolvedGeneric(Generic[T]):
-    def __init__(self, service: WithGenericDependency[T]) -> None:
-        self.service = service
+        instance = await ctx.resolve(NestedGeneric[int, str])
+        assert isinstance(instance, NestedGeneric)
+        assert isinstance(instance.simple_gen, MultipleSimpleGeneric)
+        assert instance.simple_gen.service == MEANING_OF_LIFE_INT
+        assert instance.simple_gen.b == MEANING_OF_LIFE_STR
+        assert instance.u == MEANING_OF_LIFE_STR
 
 
 async def test_nested_unresolved_generic() -> None:
+    @dataclass
+    class NestedUnresolvedGeneric:
+        service: SimpleGeneric  # type: ignore[type-arg]
+
     container = Container()
+    obj = SimpleGeneric(MEANING_OF_LIFE_INT)
     container.register(
-        Scoped(NestedUnresolvedGeneric[int]),
-        Scoped(WithGenericDependency[int]),
-        Object(42),
-        Object("42"),
+        Scoped(NestedUnresolvedGeneric),
+        Object(obj, type_=SimpleGeneric),
     )
 
     async with container.context() as ctx:
-        instance = await ctx.resolve(NestedUnresolvedGeneric[int])
+        instance = await ctx.resolve(NestedUnresolvedGeneric)
         assert isinstance(instance, NestedUnresolvedGeneric)
-        assert isinstance(instance.service, WithGenericDependency)
+        assert isinstance(instance.service, SimpleGeneric)
         assert instance.service.dependency == MEANING_OF_LIFE_INT
 
 
-async def test_nested_unresolved_concrete_generic() -> None:
-    class GenericImpl(NestedUnresolvedGeneric[str]):
-        pass
-
-    container = Container()
-    container.register(
-        Scoped(GenericImpl),
-        Scoped(WithGenericDependency[str]),
-        Object(42),
-        Object("42"),
-    )
-
-    async with container.context() as ctx:
-        instance = await ctx.resolve(GenericImpl)
-        assert isinstance(instance, GenericImpl)
-        assert isinstance(instance.service, WithGenericDependency)
-        assert instance.service.dependency == "42"
-
-
 async def test_partially_resolved_generic() -> None:
     K = TypeVar("K")
 
     class TwoGeneric(Generic[T, K]):
-        def __init__(
-            self, a: WithGenericDependency[T], b: WithGenericDependency[K]
-        ) -> None:
+        def __init__(self, a: SimpleGeneric[T], b: SimpleGeneric[K]) -> None:
             self.a = a
             self.b = b
 
@@ -163,8 +147,8 @@ def __init__(self, service: TwoGeneric[T, str]) -> None:
     container.register(
         Scoped(UsesTwoGeneric[int]),
         Scoped(TwoGeneric[int, str]),
-        Scoped(WithGenericDependency[int]),
-        Scoped(WithGenericDependency[str]),
+        Scoped(SimpleGeneric[int]),
+        Scoped(SimpleGeneric[str]),
         Object(MEANING_OF_LIFE_INT),
         Object("42"),
     )
@@ -173,8 +157,8 @@ def __init__(self, service: TwoGeneric[T, str]) -> None:
         instance = await ctx.resolve(UsesTwoGeneric[int])
         assert isinstance(instance, UsesTwoGeneric)
         assert isinstance(instance.service, TwoGeneric)
-        assert isinstance(instance.service.a, WithGenericDependency)
-        assert isinstance(instance.service.b, WithGenericDependency)
+        assert isinstance(instance.service.a, SimpleGeneric)
+        assert isinstance(instance.service.b, SimpleGeneric)
         assert instance.service.a.dependency == MEANING_OF_LIFE_INT
         assert instance.service.b.dependency == MEANING_OF_LIFE_STR