diff --git a/tests/typing/factory.py b/tests/typing/factory.py index 29b34823..21409731 100644 --- a/tests/typing/factory.py +++ b/tests/typing/factory.py @@ -1,4 +1,5 @@ from typing import Any, Callable, Dict, Optional, Tuple, Type +from typing_extensions import assert_type from dependency_injector import providers @@ -17,103 +18,136 @@ def create(cls) -> Animal: # Test 1: to check the return type (class) provider1 = providers.Factory(Cat) -animal1: Animal = provider1(1, 2, 3, b="1", c=2, e=0.0) +animal1 = provider1(1, 2, 3, b="1", c=2, e=0.0) +assert_type(animal1, Cat) # Test 2: to check the return type (class factory method) provider2 = providers.Factory(Cat.create) -animal2: Animal = provider2() +animal2 = provider2() +assert_type(animal2, Animal) # Test 3: to check the .override() method provider3 = providers.Factory(Animal) with provider3.override(providers.Factory(Cat)): - provider3() + animal3 = provider3() + assert_type(animal3, Animal) # Test 4: to check the .args, .kwargs, .attributes attributes provider4 = providers.Factory(Animal) -args4: Tuple[Any] = provider4.args -kwargs4: Dict[str, Any] = provider4.kwargs -attributes4: Dict[str, Any] = provider4.attributes +args4 = provider4.args +kwargs4 = provider4.kwargs +attributes4 = provider4.attributes +assert_type(args4, Tuple[Any]) +assert_type(kwargs4, Dict[str, Any]) +assert_type(attributes4, Dict[str, Any]) # Test 5: to check the provided instance interface provider5 = providers.Factory(Animal) -provided5: Animal = provider5.provided() -attr_getter5: providers.AttributeGetter = provider5.provided.attr -item_getter5: providers.ItemGetter = provider5.provided["item"] -method_caller5: providers.MethodCaller = provider5.provided.method.call(123, arg=324) +provided5 = provider5.provided +provided_val5 = provided5() +attr_getter5 = provider5.provided.attr +item_getter5 = provider5.provided["item"] +method_caller5 = provider5.provided.method.call(123, arg=324) +assert_type(provided5, providers.ProvidedInstance) +assert_type(provided_val5, Any) +assert_type(attr_getter5, providers.AttributeGetter) +assert_type(item_getter5, providers.ItemGetter) +assert_type(method_caller5, providers.MethodCaller) # Test 6: to check the DelegatedFactory provider6 = providers.DelegatedFactory(Cat) -animal6: Animal = provider6(1, 2, 3, b="1", c=2, e=0.0) +animal6 = provider6(1, 2, 3, b="1", c=2, e=0.0) +assert_type(animal6, Cat) # Test 7: to check the AbstractFactory provider7 = providers.AbstractFactory(Animal) provider7.override(providers.Factory(Cat)) -animal7: Animal = provider7(1, 2, 3, b="1", c=2, e=0.0) +animal7 = provider7(1, 2, 3, b="1", c=2, e=0.0) +assert_type(animal7, Animal) # Test 8: to check the FactoryDelegate __init__ provider8 = providers.FactoryDelegate(providers.Factory(object)) # Test 9: to check FactoryAggregate provider -provider9: providers.FactoryAggregate[str] = providers.FactoryAggregate( +provider9 = providers.FactoryAggregate( a=providers.Factory(str, "str1"), b=providers.Factory(str, "str2"), ) -factory_a_9: providers.Factory[str] = provider9.a -factory_b_9: providers.Factory[str] = provider9.b -val9: str = provider9("a") - -provider9_set_non_string_keys: providers.FactoryAggregate[str] = ( - providers.FactoryAggregate() +factory_a_9 = provider9.a +factory_b_9 = provider9.b +val9 = provider9("a") +assert_type(provider9, providers.FactoryAggregate[str]) +assert_type(factory_a_9, providers.Factory[str]) +assert_type(factory_b_9, providers.Factory[str]) +assert_type(val9, str) + +provider9_set_non_string_keys = ( + providers.FactoryAggregate[str]() ) provider9_set_non_string_keys.set_factories({Cat: providers.Factory(str, "str")}) -factory_set_non_string_9: providers.Factory[str] = ( +factory_set_non_string_9 = ( provider9_set_non_string_keys.factories[Cat] ) +assert_type(provider9_set_non_string_keys, providers.FactoryAggregate[str]) +assert_type(factory_set_non_string_9, providers.Factory[str]) -provider9_new_non_string_keys: providers.FactoryAggregate[str] = ( +provider9_new_non_string_keys = ( providers.FactoryAggregate( {Cat: providers.Factory(str, "str")}, ) ) -factory_new_non_string_9: providers.Factory[str] = ( +factory_new_non_string_9 = ( provider9_new_non_string_keys.factories[Cat] ) +assert_type(provider9_new_non_string_keys, providers.FactoryAggregate[str]) +assert_type(factory_new_non_string_9, providers.Factory[str]) provider9_no_explicit_typing = providers.FactoryAggregate( a=providers.Factory(str, "str") ) -provider9_no_explicit_typing_factory: providers.Factory[str] = ( +provider9_no_explicit_typing_factory = ( provider9_no_explicit_typing.factories["a"] ) -provider9_no_explicit_typing_object: str = provider9_no_explicit_typing("a") +provider9_no_explicit_typing_object = provider9_no_explicit_typing("a") +assert_type(provider9_no_explicit_typing, providers.FactoryAggregate[str]) +assert_type(provider9_no_explicit_typing_factory, providers.Factory[str]) +assert_type(provider9_no_explicit_typing_object, str) # Test 10: to check the explicit typing -factory10: providers.Provider[Animal] = providers.Factory(Cat) -animal10: Animal = factory10() +factory10 = providers.Factory[Animal](Cat) +animal10 = factory10() +assert_type(factory10, providers.Factory[Animal]) +assert_type(animal10, Animal) # Test 11: to check the return type with await provider11 = providers.Factory(Cat) async def _async11() -> None: - animal1: Animal = await provider11(1, 2, 3, b="1", c=2, e=0.0) # type: ignore - animal2: Animal = await provider11.async_(1, 2, 3, b="1", c=2, e=0.0) + animal1 = await provider11(1, 2, 3, b="1", c=2, e=0.0) # type: ignore + animal2 = await provider11.async_(1, 2, 3, b="1", c=2, e=0.0) + assert_type(animal2, Cat) # Test 12: to check class type from .provides provider12 = providers.Factory(Cat) -provided_cls12: Type[Animal] = provider12.cls +provided_cls12 = provider12.cls assert issubclass(provided_cls12, Animal) -provided_provides12: Optional[Callable[..., Animal]] = provider12.provides +provided_provides12 = provider12.provides assert provided_provides12 is not None and provided_provides12() == Cat() +assert_type(provided_cls12, Type[Cat]) +assert_type(provided_provides12, Callable[..., Cat]) + # Test 13: to check class from .provides with explicit typevar provider13 = providers.Factory[Animal](Cat) -provided_cls13: Type[Animal] = provider13.cls +provided_cls13 = provider13.cls assert issubclass(provided_cls13, Animal) -provided_provides13: Optional[Callable[..., Animal]] = provider13.provides +provided_provides13 = provider13.provides assert provided_provides13 is not None and provided_provides13() == Cat() +assert_type(provided_cls13, Type[Animal]) +assert_type(provided_provides13, Callable[..., Animal]) # Test 14: to check string imports -provider14: providers.Factory[Dict[Any, Any]] = providers.Factory("builtins.dict") +provider14 = providers.Factory[Any]("builtins.dict") provider14.set_provides("builtins.dict") diff --git a/tests/typing/list.py b/tests/typing/list.py index 65e65e78..44d66c8e 100644 --- a/tests/typing/list.py +++ b/tests/typing/list.py @@ -1,4 +1,5 @@ from typing import Any, List, Tuple +from typing_extensions import assert_type from dependency_injector import providers @@ -7,7 +8,8 @@ providers.Factory(object), providers.Factory(object), ) -var1: List[Any] = provider1() +var1 = provider1() +assert_type(var1, List[Any]) # Test 2: to check the .args attributes @@ -15,17 +17,24 @@ providers.Factory(object), providers.Factory(object), ) -args2: Tuple[Any] = provider2.args +args2 = provider2.args +assert_type(args2, Tuple[Any]) # Test 3: to check the provided instance interface provider3 = providers.List( providers.Factory(object), providers.Factory(object), ) -provided3: List[Any] = provider3.provided() -attr_getter3: providers.AttributeGetter = provider3.provided.attr -item_getter3: providers.ItemGetter = provider3.provided["item"] -method_caller3: providers.MethodCaller = provider3.provided.method.call(123, arg=324) +provided3 = provider3.provided +provided_val3 = provided3() +attr_getter3 = provider3.provided.attr +item_getter3 = provider3.provided["item"] +method_caller3 = provider3.provided.method.call(123, arg=324) +assert_type(provided3, providers.ProvidedInstance) +assert_type(provided_val3, Any) +assert_type(attr_getter3, providers.AttributeGetter) +assert_type(item_getter3, providers.ItemGetter) +assert_type(method_caller3, providers.MethodCaller) # Test 4: to check the return type with await provider4 = providers.List( @@ -35,5 +44,6 @@ async def _async4() -> None: - var1: List[Any] = await provider4() # type: ignore - var2: List[Any] = await provider4.async_() + var1 = await provider4() # type: ignore + var2 = await provider4.async_() + assert_type(var2, List[Any]) diff --git a/tests/typing/object.py b/tests/typing/object.py index 739b6238..2781a1f6 100644 --- a/tests/typing/object.py +++ b/tests/typing/object.py @@ -1,27 +1,38 @@ -from typing import Optional, Type +from typing import Optional, Any +from typing_extensions import assert_type from dependency_injector import providers # Test 1: to check the return type provider1 = providers.Object(int(3)) -var1: int = provider1() +var1 = provider1() +assert_type(var1, int) # Test 2: to check the provided instance interface provider2 = providers.Object(int) -provided2: Type[int] = provider2.provided() -attr_getter2: providers.AttributeGetter = provider2.provided.attr -item_getter2: providers.ItemGetter = provider2.provided["item"] -method_caller2: providers.MethodCaller = provider2.provided.method.call(123, arg=324) +provided2 = provider2.provided +provided_val2 = provided2() +attr_getter2 = provider2.provided.attr +item_getter2 = provider2.provided["item"] +method_caller2 = provider2.provided.method.call(123, arg=324) +assert_type(provided2, providers.ProvidedInstance) +assert_type(provided_val2, Any) +assert_type(attr_getter2, providers.AttributeGetter) +assert_type(item_getter2, providers.ItemGetter) +assert_type(method_caller2, providers.MethodCaller) + # Test 3: to check the return type with await provider3 = providers.Object(int(3)) async def _async3() -> None: - var1: int = await provider3() # type: ignore - var2: int = await provider3.async_() + var1 = await provider3() # type: ignore + var2 = await provider3.async_() + assert_type(var2, int) # Test 4: to check class type from provider provider4 = providers.Object(int("1")) -provided_provides: Optional[int] = provider4.provides +provided_provides4 = provider4.provides +assert_type(provided_provides4, Optional[int]) \ No newline at end of file diff --git a/tests/typing/provider.py b/tests/typing/provider.py index cb832b77..83085f8a 100644 --- a/tests/typing/provider.py +++ b/tests/typing/provider.py @@ -1,17 +1,26 @@ from typing import Any +from typing_extensions import assert_type from dependency_injector import providers # Test 1: to check .provided attribute provider1: providers.Provider[int] = providers.Object(1) -provided: int = provider1.provided() -provider1_delegate: providers.Provider[int] = provider1.provider +provided1 = provider1.provided +provided_val1 = provided1() +provider1_delegate = provider1.provider +assert_type(provider1, providers.Provider[int]) +assert_type(provided1, providers.ProvidedInstance) +assert_type(provided_val1, Any) +assert_type(provider1_delegate, providers.Provider[int]) # Test 2: to check async mode API -provider2: providers.Provider[Any] = providers.Provider() +provider2 = providers.Provider[Any]() provider2.enable_async_mode() provider2.disable_async_mode() provider2.reset_async_mode() -r1: bool = provider2.is_async_mode_enabled() -r2: bool = provider2.is_async_mode_disabled() -r3: bool = provider2.is_async_mode_undefined() +r1 = provider2.is_async_mode_enabled() +r2 = provider2.is_async_mode_disabled() +r3 = provider2.is_async_mode_undefined() +assert_type(r1, bool) +assert_type(r2, bool) +assert_type(r3, bool) \ No newline at end of file diff --git a/tests/typing/resource.py b/tests/typing/resource.py index 0d3bf254..7ab2f2d2 100644 --- a/tests/typing/resource.py +++ b/tests/typing/resource.py @@ -10,6 +10,7 @@ Optional, Self, ) +from typing_extensions import assert_type from dependency_injector import providers, resources @@ -20,7 +21,8 @@ def init1() -> List[int]: provider1 = providers.Resource(init1) -var1: List[int] = provider1() +var1 = provider1() +assert_type(var1, List[int]) # Test 2: to check the return type with iterator @@ -29,7 +31,8 @@ def init2() -> Iterator[List[int]]: provider2 = providers.Resource(init2) -var2: List[int] = provider2() +var2 = provider2() +assert_type(var2, List[int]) # Test 3: to check the return type with generator @@ -38,8 +41,8 @@ def init3() -> Generator[List[int], None, None]: provider3 = providers.Resource(init3) -var3: List[int] = provider3() - +var3 = provider3() +assert_type(var3, List[int]) # Test 4: to check the return type with resource subclass class MyResource4(resources.Resource[List[int]]): @@ -50,7 +53,8 @@ def shutdown(self, resource: Optional[List[int]]) -> None: ... provider4 = providers.Resource(MyResource4) -var4: List[int] = provider4() +var4 = provider4() +assert_type(var4, List[int]) # Test 5: to check the return type with async function @@ -62,8 +66,9 @@ async def init5() -> List[int]: async def _provide5() -> None: - var1: List[int] = await provider5() # type: ignore - var2: List[int] = await provider5.async_() + var1 = await provider5() # type: ignore + var2 = await provider5.async_() + assert_type(var2, List[int]) # Test 6: to check the return type with async iterator @@ -75,8 +80,9 @@ async def init6() -> AsyncIterator[List[int]]: async def _provide6() -> None: - var1: List[int] = await provider6() # type: ignore - var2: List[int] = await provider6.async_() + var1 = await provider6() # type: ignore + var2 = await provider6.async_() + assert_type(var2, List[int]) # Test 7: to check the return type with async generator @@ -88,8 +94,9 @@ async def init7() -> AsyncGenerator[List[int], None]: async def _provide7() -> None: - var1: List[int] = await provider7() # type: ignore - var2: List[int] = await provider7.async_() + var1 = await provider7() # type: ignore + var2 = await provider7.async_() + assert_type(var2, List[int]) # Test 8: to check the return type with async resource subclass @@ -104,8 +111,9 @@ async def shutdown(self, resource: Optional[List[int]]) -> None: ... async def _provide8() -> None: - var1: List[int] = await provider8() # type: ignore - var2: List[int] = await provider8.async_() + var1 = await provider8() # type: ignore + var2 = await provider8.async_() + assert_type(var2, List[int]) # Test 9: to check string imports @@ -126,7 +134,8 @@ def __exit__(self, *args: Any, **kwargs: Any) -> None: provider10 = providers.Resource(MyResource10) -var10: MyResource10 = provider10() +var10 = provider10() +assert_type(var10, MyResource10) # Test 11: to check the return type with functions decorated with contextlib.contextmanager @@ -136,7 +145,8 @@ def init11() -> Iterator[int]: provider11 = providers.Resource(init11) -var11: int = provider11() +var11 = provider11() +assert_type(var11, int) # Test 12: to check the return type with classes implementing AbstractAsyncContextManager protocol @@ -155,8 +165,9 @@ async def __aexit__(self, *args: Any, **kwargs: Any) -> None: async def _provide12() -> None: - var1: MyResource12 = await provider12() # type: ignore - var2: MyResource12 = await provider12.async_() + var1 = await provider12() # type: ignore + var2 = await provider12.async_() + assert_type(var2, MyResource12) # Test 13: to check the return type with functions decorated with contextlib.asynccontextmanager @@ -168,5 +179,6 @@ async def init13() -> AsyncIterator[int]: provider13 = providers.Resource(init13) async def _provide13() -> None: - var1: int = await provider13() # type: ignore - var2: int = await provider13.async_() + var1 = await provider13() # type: ignore + var2 = await provider13.async_() + assert_type(var2, int) diff --git a/tests/typing/selector.py b/tests/typing/selector.py index 6297baf1..a06cd385 100644 --- a/tests/typing/selector.py +++ b/tests/typing/selector.py @@ -1,4 +1,5 @@ from typing import Any, Callable, Optional, Dict +from typing_extensions import assert_type from dependency_injector import providers @@ -8,7 +9,8 @@ a=providers.Factory(object), b=providers.Factory(object), ) -var1: Any = provider1() +var1 = provider1() +assert_type(var1, Any) # Test 2: to check the provided instance interface provider2 = providers.Selector( @@ -16,10 +18,17 @@ a=providers.Factory(object), b=providers.Factory(object), ) -provided2: providers.ProvidedInstance = provider2.provided -attr_getter2: providers.AttributeGetter = provider2.provided.attr -item_getter2: providers.ItemGetter = provider2.provided["item"] -method_caller2: providers.MethodCaller = provider2.provided.method.call(123, arg=324) +provided2 = provider2.provided +provided_val2 = provided2() +attr_getter2 = provider2.provided.attr +item_getter2 = provider2.provided["item"] +method_caller2 = provider2.provided.method.call(123, arg=324) +assert_type(provider2, providers.Selector[Any]) +assert_type(provided2, providers.ProvidedInstance) +assert_type(provided_val2, Any) +assert_type(attr_getter2, providers.AttributeGetter) +assert_type(item_getter2, providers.ItemGetter) +assert_type(method_caller2, providers.MethodCaller) # Test3 to check the getattr provider3 = providers.Selector( @@ -27,7 +36,8 @@ a=providers.Factory(object), b=providers.Factory(object), ) -attr3: providers.Provider[Any] = provider3.a +attr3 = provider3.a +assert_type(attr3, providers.Provider[Any]) # Test 4: to check the return type with await provider4 = providers.Selector( @@ -38,8 +48,10 @@ async def _async4() -> None: - var1: Any = await provider4() - var2: Any = await provider4.async_() + var1 = await provider4() + var2 = await provider4.async_() + assert_type(var1, Any) + assert_type(var2, Any) # Test 5: to check selector getter and setter @@ -48,8 +60,10 @@ async def _async4() -> None: a=providers.Factory(object), b=providers.Factory(object), ) -selector5: Optional[Callable[..., Any]] = provider5.selector -provider5_after_set_selector: providers.Selector[Any] = provider5.set_selector(lambda: "a") +selector5 = provider5.selector +provider5_after_set_selector = provider5.set_selector(lambda: "a") +assert_type(selector5, Optional[Callable[..., Any]]) +assert_type(provider5_after_set_selector, providers.Selector[Any]) # Test 6: to check providers getter and setter provider6 = providers.Selector( @@ -57,19 +71,26 @@ async def _async4() -> None: a=providers.Factory(object), b=providers.Factory(object), ) -providers6: Dict[str, providers.Provider[Any]] = provider6.providers -provider6_after_set_providers: providers.Selector[Any] = provider6.set_providers(c=providers.Factory(object)) - +providers6 = provider6.providers +provider6_after_set_providers = provider6.set_providers(c=providers.Factory(object)) +assert_type(providers6, Dict[str, providers.Provider[Any]]) +assert_type(provider6_after_set_providers, providers.Selector[Any]) # Test 7: to check explicit typing: return type, getattr, getter/setter of providers and selectors provider7 = providers.Selector[bool](lambda: "a", a=providers.Factory(bool), b=providers.Factory(int)) -var7: bool = provider7() -attr7: providers.Provider[bool] = provider7.a +var7 = provider7() +attr7 = provider7.a +assert_type(var7, bool) +assert_type(attr7, providers.Provider[bool]) -selector7: Optional[Callable[..., Any]] = provider7.selector -provider7_after_set_selector: providers.Selector[bool] = provider7.set_selector(lambda: "a") +selector7 = provider7.selector +provider7_after_set_selector = provider7.set_selector(lambda: "a") +assert_type(selector7, Optional[Callable[..., Any]]) +assert_type(provider7_after_set_selector, providers.Selector[bool]) -providers7: Dict[str, providers.Provider[bool]] = provider7.providers -provider7_after_set_providers: providers.Selector[bool] = provider7.set_providers( +providers7 = provider7.providers +provider7_after_set_providers = provider7.set_providers( c=providers.Factory(str) ) # We don't require Provider of subclass of bool yet since Provider is invariant +assert_type(providers7, Dict[str, providers.Provider[bool]]) +assert_type(provider7_after_set_providers, providers.Selector[bool]) \ No newline at end of file diff --git a/tests/typing/singleton.py b/tests/typing/singleton.py index 740da8b9..08837e38 100644 --- a/tests/typing/singleton.py +++ b/tests/typing/singleton.py @@ -1,4 +1,5 @@ from typing import Any, Callable, Dict, Optional, Tuple, Type +from typing_extensions import assert_type from dependency_injector import providers @@ -17,54 +18,72 @@ def create(cls) -> Animal: # Test 1: to check the return type (class) provider1 = providers.Singleton(Cat) -animal1: Animal = provider1(1, 2, 3, b="1", c=2, e=0.0) +animal1 = provider1(1, 2, 3, b="1", c=2, e=0.0) +assert_type(animal1, Cat) # Test 2: to check the return type (class factory method) provider2 = providers.Singleton(Cat.create) -animal2: Animal = provider2() +animal2 = provider2() +assert_type(animal2, Animal) # Test 3: to check the .override() method provider3 = providers.Singleton(Animal) with provider3.override(providers.Singleton(Cat)): - provider3() + animal3 = provider3() + assert_type(animal3, Animal) # Test 4: to check the .args, .kwargs, .attributes attributes provider4 = providers.Singleton(Animal) -args4: Tuple[Any] = provider4.args -kwargs4: Dict[str, Any] = provider4.kwargs -attributes4: Dict[str, Any] = provider4.attributes +args4 = provider4.args +kwargs4 = provider4.kwargs +attributes4 = provider4.attributes +assert_type(args4, Tuple[Any]) +assert_type(kwargs4, Dict[str, Any]) +assert_type(attributes4, Dict[str, Any]) # Test 5: to check the provided instance interface provider5 = providers.Singleton(Animal) -provided5: Animal = provider5.provided() -attr_getter5: providers.AttributeGetter = provider5.provided.attr -item_getter5: providers.ItemGetter = provider5.provided["item"] -method_caller5: providers.MethodCaller = provider5.provided.method.call(123, arg=324) +provided5 = provider5.provided +provided_val5 = provided5() +attr_getter5 = provider5.provided.attr +item_getter5 = provider5.provided["item"] +method_caller5 = provider5.provided.method.call(123, arg=324) +assert_type(provided5, providers.ProvidedInstance) +assert_type(provided_val5, Any) +assert_type(attr_getter5, providers.AttributeGetter) +assert_type(item_getter5, providers.ItemGetter) +assert_type(method_caller5, providers.MethodCaller) # Test 6: to check the DelegatedSingleton provider6 = providers.DelegatedSingleton(Cat) -animal6: Animal = provider6(1, 2, 3, b="1", c=2, e=0.0) +animal6 = provider6(1, 2, 3, b="1", c=2, e=0.0) +assert_type(animal6, Cat) # Test 7: to check the ThreadSafeSingleton -provider7: providers.BaseSingleton[Animal] = providers.ThreadSafeSingleton(Cat) -animal7: Animal = provider7() +provider7 = providers.ThreadSafeSingleton(Cat) +animal7 = provider7() +assert_type(animal7, Cat) # Test 8: to check the DelegatedThreadSafeSingleton provider8 = providers.DelegatedThreadSafeSingleton(Cat) -animal8: Animal = provider8(1, 2, 3, b="1", c=2, e=0.0) +animal8 = provider8(1, 2, 3, b="1", c=2, e=0.0) +assert_type(animal8, Cat) # Test 9: to check the ThreadLocalSingleton provider9 = providers.ThreadLocalSingleton(Cat) -animal9: Animal = provider9(1, 2, 3, b="1", c=2, e=0.0) +animal9 = provider9(1, 2, 3, b="1", c=2, e=0.0) +assert_type(animal9, Cat) # Test 10: to check the DelegatedThreadLocalSingleton provider10 = providers.DelegatedThreadLocalSingleton(Cat) -animal10: Animal = provider10(1, 2, 3, b="1", c=2, e=0.0) +animal10 = provider10(1, 2, 3, b="1", c=2, e=0.0) +assert_type(animal10, Cat) # Test 11: to check the AbstractSingleton provider11 = providers.AbstractSingleton(Animal) provider11.override(providers.Singleton(Cat)) -animal11: Animal = provider11(1, 2, 3, b="1", c=2, e=0.0) +animal11 = provider11(1, 2, 3, b="1", c=2, e=0.0) +assert_type(animal11, Animal) # Test 12: to check the SingletonDelegate __init__ provider12 = providers.SingletonDelegate(providers.Singleton(object)) @@ -74,16 +93,19 @@ def create(cls) -> Animal: async def _async13() -> None: - animal1: Animal = await provider13(1, 2, 3, b="1", c=2, e=0.0) # type: ignore - animal2: Animal = await provider13.async_(1, 2, 3, b="1", c=2, e=0.0) + animal1 = await provider13(1, 2, 3, b="1", c=2, e=0.0) # type: ignore + animal2 = await provider13.async_(1, 2, 3, b="1", c=2, e=0.0) + assert_type(animal2, Cat) # Test 14: to check class from .provides provider14 = providers.Singleton(Cat) -provided_cls14: Type[Cat] = provider14.cls +provided_cls14 = provider14.cls assert issubclass(provided_cls14, Cat) -provided_provides14: Optional[Callable[..., Cat]] = provider14.provides +provided_provides14 = provider14.provides assert provided_provides14 is not None and provided_provides14() == Cat() +assert_type(provided_cls14, Type[Cat]) +assert_type(provided_provides14, Callable[..., Cat]) # Test 15: to check class from .provides with explicit typevar provider15 = providers.Singleton[Animal](Cat) @@ -91,7 +113,9 @@ async def _async13() -> None: assert issubclass(provided_cls15, Animal) provided_provides15: Optional[Callable[..., Animal]] = provider15.provides assert provided_provides15 is not None and provided_provides15() == Cat() +assert_type(provided_cls15, Type[Animal]) +assert_type(provided_provides15, Callable[..., Animal]) # Test 16: to check string imports -provider16: providers.Singleton[Dict[Any, Any]] = providers.Singleton("builtins.dict") +provider16 = providers.Singleton[Any]("builtins.dict") provider16.set_provides("builtins.dict")