def test_scoped_services_context_used_more_than_once_manual_dispose():
container = Container()
container.add_instance('value')
provider = container.build_provider()
context = GetServiceContext(provider)
context.dispose()
assert context.provider is None
def test_add_singleton_by_factory_given_type(method_name):
container = Container()
def factory(a):
return Cat('Celine')
method = getattr(container, method_name)
method(factory, Cat)
provider = container.build_provider()
cat = provider.get(Cat)
assert cat is not None
assert cat.name == 'Celine'
if method_name == 'add_singleton_by_factory':
cat_2 = provider.get(Cat)
assert cat_2 is cat
if method_name == 'add_transient_by_factory':
assert provider.get(Cat) is not cat
assert provider.get(Cat) is not cat
assert provider.get(Cat) is not cat
if method_name == 'add_scoped_by_factory':
with GetServiceContext() as context:
cat_2 = provider.get(Cat, context)
assert cat_2 is not cat
assert provider.get(Cat, context) is cat_2
assert provider.get(Cat, context) is cat_2
assert provider.get(Cat, context) is cat_2
def test_factories_activating_singleton_type_consistency(method_name):
container = Container()
class ABase(ABC):
pass
class BBase(ABC):
pass
class A(ABase):
def __init__(self, b: BBase):
self.b = b
class B(BBase):
def __init__(self):
pass
def bbase_factory(context: Services, activating_type: Type) -> BBase:
assert isinstance(context, Services)
assert activating_type is A
return B()
container.add_singleton(ABase, A)
method = getattr(container, method_name)
method(bbase_factory)
provider = container.build_provider()
context = GetServiceContext(provider)
a = provider.get(ABase, context)
assert isinstance(a, A)
assert isinstance(a.b, B)
def test_scoped_services_exact():
container = Container()
class A:
def __init__(self, b):
self.b = b
class B:
def __init__(self, c):
self.c = c
class C:
def __init__(self):
pass
container.add_exact_scoped(A)
container.add_exact_scoped(B)
container.add_exact_scoped(C)
provider = container.build_provider()
context = GetServiceContext(provider)
a = provider.get(A, context)
assert isinstance(a, A)
assert isinstance(a.b, B)
assert isinstance(a.b.c, C)
a2 = provider.get(A, context)
assert a is a2
assert a.b is a2.b
assert a.b.c is a2.b.c
def test_scoped_services_with_shortcut():
container = Container()
container.add_scoped(IdGetter)
provider = container.build_provider()
with GetServiceContext() as context:
a = provider.get(IdGetter, context)
b = provider.get(IdGetter, context)
c = provider.get(IdGetter, context)
d = provider.get(IdGetter)
assert a is b
assert b is c
assert a is not d
assert b is not d
def test_singleton_services():
container = Container()
container.add_exact_singleton(IdGetter)
provider = container.build_provider()
with GetServiceContext() as context:
a = provider.get(IdGetter, context)
b = provider.get(IdGetter, context)
c = provider.get(IdGetter, context)
d = provider.get(IdGetter)
assert a is b
assert a is c
assert b is c
assert d is a
def test_transient_services():
container = Container()
container.add_exact_transient(IdGetter)
provider = container.build_provider()
with GetServiceContext() as context:
a = provider.get(IdGetter, context)
b = provider.get(IdGetter, context)
c = provider.get(IdGetter, context)
d = provider.get(IdGetter)
assert a is not b
assert a is not c
assert b is not c
assert d is not a
assert d is not b
assert d is not c
def test_scoped_services_context_used_more_than_once():
container = Container()
class C:
def __init__(self):
pass
class B2:
def __init__(self, c: C):
self.c = c
class B1:
def __init__(self, c: C):
self.c = c
class A:
def __init__(self, b1: B1, b2: B2):
self.b1 = b1
self.b2 = b2
container.add_exact_scoped(C)
container.add_exact_transient(B1)
container.add_exact_transient(B2)
container.add_exact_transient(A)
provider = container.build_provider()
context = GetServiceContext(provider)
with context:
a = provider.get(A, context)
first_c = provider.get(C)
a.b1.c is first_c
a.b2.c is first_c
with context:
a = provider.get(A, context)
second_c = provider.get(C)
a.b1.c is second_c
a.b2.c is second_c
assert first_c is not None
assert second_c is not None
assert first_c is not second_c
def test_factories_type_singleton_consistency_nested(method_name):
container = Container()
class ABase(ABC):
pass
class BBase(ABC):
pass
class CBase(ABC):
pass
class A(ABase):
def __init__(self, b: BBase):
self.b = b
class B(BBase):
def __init__(self, c: CBase):
self.c = c
class C(CBase):
def __init__(self):
pass
def cbase_factory(context: Services, activating_type: Type) -> CBase:
assert isinstance(context, Services)
assert activating_type is B
return C()
container.add_singleton(ABase, A)
container.add_singleton(BBase, B)
method = getattr(container, method_name)
method(cbase_factory)
provider = container.build_provider()
context = GetServiceContext(provider)
a = provider.get(ABase, context)
assert isinstance(a, A)
assert isinstance(a.b, B)
assert isinstance(a.b.c, C)
def test_scoped_services_abstract():
container = Container()
class ABase(ABC):
pass
class BBase(ABC):
pass
class CBase(ABC):
pass
class A(ABase):
def __init__(self, b: BBase):
self.b = b
class B(BBase):
def __init__(self, c: CBase):
self.c = c
class C(CBase):
def __init__(self):
pass
container.add_scoped(ABase, A)
container.add_scoped(BBase, B)
container.add_scoped(CBase, C)
provider = container.build_provider()
context = GetServiceContext(provider)
a = provider.get(ABase, context)
assert isinstance(a, A)
assert isinstance(a.b, B)
assert isinstance(a.b.c, C)
a2 = provider.get(ABase, context)
assert a is a2
assert a.b is a2.b
assert a.b.c is a2.b.c
async def dependency_injection_middleware(
request: Request, handler: Callable[[Request], Awaitable[Response]]
) -> Response:
with GetServiceContext() as context:
request.services_context = context # type: ignore
return await handler(request)
async def dependency_injection_middleware(request, handler):
with GetServiceContext() as context:
request.services_context = context
return await handler(request)