def test_context(self): tester = self class A: pass class B: def __init__(self, a: A): self.exited = False def __enter__(self): pass def __exit__(self, exc_type, exc_value, traceback): self.exited = True service = di.Services() service.scoped(A, A) service.scoped(B, B, auto_exit=True) root_provider = service.build() with root_provider as root_provider: broot = root_provider.get(B) self.assertFalse(broot.exited) with root_provider.scope() as provider1: b1 = provider1.get(B) self.assertFalse(b1.exited) with provider1.scope() as provider2: b2 = provider2.get(B) self.assertFalse(b2.exited) self.assertTrue(b2.exited) self.assertTrue(b1.exited) self.assertTrue(broot.exited)
def test_scoped(self): tester = self class A: pass class B: def __init__(self, a: A): self.a = a service = di.Services() service.scoped(A, A) service.scoped(B, B) root_provider = service.build() def scoped_item_is(service_provider): self.assertIs(service_provider.get(A), service_provider.get(A)) self.assertIs(service_provider.get(B), service_provider.get(B)) self.assertIs(service_provider.get(B).a, service_provider.get(A)) def scoped_item_is_not(provider_1, provider_2): self.assertIsNot(provider_1.get(A), provider_2.get(A)) self.assertIsNot(provider_1.get(B), provider_2.get(B)) with root_provider.scope() as provider1: with provider1.scope() as provider2: scoped_item_is(root_provider) scoped_item_is(provider1) scoped_item_is(provider2) scoped_item_is_not(root_provider, provider1) scoped_item_is_not(root_provider, provider2) scoped_item_is_not(provider1, provider2)
def main(argv=None): if argv is None: argv = sys.argv try: class A: pass class B: def __init__(self, a: A): assert isinstance(a, A) import dependencyinjection as di service = di.Services() service.scoped(A) service.singleton(B) provider = service.build() assert isinstance(provider.get(A), A) assert isinstance(provider.get(B), B) with provider.scope() as scoped_provider: assert provider.get(A) is provider.get(A) assert scoped_provider.get(B) is scoped_provider.get(B) assert provider.get(B) is scoped_provider.get(B) assert not (provider.get(A) is scoped_provider.get(A)) except Exception: traceback.print_exc() input()
def test_service_provider(self): tester = self class A: def __init__(self, injected_provider: di.IServiceProvider): self.injected_provider = injected_provider service = di.Services() service.scoped(A) provider = service.build() tester.assertIs(provider.get(A).injected_provider, provider)
def test_map(self): class A: pass class B(A): pass class C(B): pass provider = di.Services().scoped(C).scoped(B).map(A, C).build() # define twice, so C and B is not the same thing. self.assertIsNot(provider[C], provider[B]) # with `map`, so A is C. self.assertIs(provider[C], provider[A])
def test_singleton_dep_is_root(self): class A: pass class B: def __init__(self, a: A): self.a = a service = di.Services() service.scoped(A, A) service.singleton(B, B) root_provider = service.build() with root_provider.scope() as child_provider: self.assertIs(child_provider.get(B).a, root_provider.get(A))
def test_instance(self): class A: pass service = di.Services() # type safe with self.assertRaises(TypeError): service.instance(A, 1) service.instance(A, A()) provider = service.build() a = provider.get(A) # ref equals self.assertTrue(provider.get(A) is provider.get(A)) # type safe self.assertTrue(isinstance(a, A))
def test_transient(self): tester = self class A: pass class B: def __init__(self, a: A): tester.assertIsNotNone(a) tester.assertTrue(isinstance(a, A)) service = di.Services() service.transient(A, A) service.transient(B, B) provider = service.build() # ref equals self.assertFalse(provider.get(A) is provider.get(A)) self.assertFalse(provider.get(B) is provider.get(B))
def test_auto_resolving_concrete_types_complex(self): class X1: pass class X2: pass class A: pass class B(A): def __init__(self, x1: X1, x2: X2): self.x1 = x1 self.x2 = x2 class C(B): pass provider = di.Services().scoped(X2).auto_resolve_concrete_types().build() self.assertIsNot(provider[C], provider[C]) self.assertIsNot(provider[C].x1, provider[C].x1) self.assertIs(provider[C].x2, provider[C].x2)
def test_multi_service(self): tester = self class A: pass class A1(A): pass class A2(A): pass class B: def __init__(self, a: A): self.a = a tester.assertIsNotNone(a) tester.assertTrue(isinstance(a, A2)) service = di.Services() service.singleton(A, A1) service.singleton(A, A2) service.singleton(B, B) provider = service.build() # B().a should be last singleton(A, ?) => A2 self.assertIsInstance(provider.get(B).a, A2) # list of B import typing itemsB = provider.get(typing.List[B]) self.assertEqual(1, len(itemsB)) self.assertIs(itemsB[0], provider.get(B)) # list of A items1 = provider.get(typing.List[A]) self.assertEqual(2, len(items1)) self.assertIsInstance(items1[0], A1) self.assertIsInstance(items1[1], A2) items2 = provider.get(typing.List[A]) self.assertEqual(2, len(items2)) self.assertIsInstance(items2[0], A1) self.assertIsInstance(items2[1], A2) self.assertIsNot(items1, items2)
def test_bind(self): tester = self class A: pass class B: def __init__(self, a): tester.assertIsNotNone(a) tester.assertTrue(isinstance(a, A)) service = di.Services() service.scoped(A) service.scoped(B) provider1 = service.build() with self.assertRaises(Exception): self.assertTrue(isinstance(provider1.get(B), B)) service.bind('a', A) # after bind name to type. provider2 = service.build() self.assertTrue(isinstance(provider2.get(B), B))
def test_singleton(self): tester = self class A: pass class B: def __init__(self, a: A): tester.assertIsNotNone(a) tester.assertTrue(isinstance(a, A)) service = di.Services() service.singleton(A, A) service.singleton(B, B) provider = service.build() # ref equals self.assertTrue(provider.get(A) is provider.get(A)) self.assertTrue(provider.get(B) is provider.get(B)) with provider.scope() as provider1: self.assertTrue(provider.get(A) is provider1.get(A)) self.assertTrue(provider.get(B) is provider1.get(B))
def test_auto_resolving_concrete_types(self): class A: pass provider = di.Services().auto_resolve_concrete_types().build() self.assertIsInstance(provider.get(A), A)
def test_auto_resolving_concrete_types_not_configured(self): class A: pass provider = di.Services().build() self.assertIsNone(provider.get(A))
def test_get_none(self): service = di.Services() provider = service.build() self.assertIsNone(provider.get(str))