mirror of
https://github.com/ets-labs/python-dependency-injector.git
synced 2026-02-21 14:50:42 +03:00
Retrofit assert type for:
- factory.py - list.py - object.py - provider.py - resource.py - singleton.py
This commit is contained in:
Leonardus Chen
parent
13847c0ce6
commit
334a9b186d
|
|
@ -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 @@ class Cat(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")
|
||||
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] = (
|
||||
providers.FactoryAggregate()
|
||||
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")
|
||||
|
|
|
|||
|
|
@ -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 @@ provider1 = providers.List(
|
|||
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 @@ provider2 = providers.List(
|
|||
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 @@ provider4 = providers.List(
|
|||
|
||||
|
||||
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])
|
||||
|
|
|
|||
|
|
@ -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])
|
||||
|
|
@ -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)
|
||||
|
|
@ -10,6 +10,7 @@ from typing import (
|
|||
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 @@ class MyResource4(resources.Resource[List[int]]):
|
|||
|
||||
|
||||
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 @@ provider5 = providers.Resource(init5)
|
|||
|
||||
|
||||
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 @@ provider6 = providers.Resource(init6)
|
|||
|
||||
|
||||
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 @@ provider7 = providers.Resource(init7)
|
|||
|
||||
|
||||
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 @@ provider8 = providers.Resource(MyResource8)
|
|||
|
||||
|
||||
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 @@ class MyResource10:
|
|||
|
||||
|
||||
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 @@ provider12 = providers.Resource(MyResource12)
|
|||
|
||||
|
||||
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)
|
||||
|
|
|
|||
|
|
@ -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 @@ provider1 = providers.Selector(
|
|||
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 @@ provider2 = providers.Selector(
|
|||
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 @@ provider3 = providers.Selector(
|
|||
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 @@ provider4 = providers.Selector(
|
|||
|
||||
|
||||
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 @@ provider5 = providers.Selector(
|
|||
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 @@ provider6 = providers.Selector(
|
|||
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])
|
||||
|
|
@ -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 @@ class Cat(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 @@ provider13 = providers.Singleton(Cat)
|
|||
|
||||
|
||||
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 @@ provided_cls15: Type[Animal] = provider15.cls
|
|||
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")
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user