def test_copy(provider: ServiceProvider, keep_singletons_cache: bool,
scope: Scope):
class C:
pass
world.test.singleton('factory', lambda: C())
provider.register(A, scope=scope)
cloned = provider.clone(keep_singletons_cache)
if keep_singletons_cache:
with world.test.clone(keep_singletons=True):
assert isinstance(
world.test.maybe_provide_from(cloned, A).unwrapped, A)
else:
with world.test.clone(keep_singletons=False):
assert isinstance(
world.test.maybe_provide_from(cloned, A).unwrapped, A)
class D:
pass
class E:
pass
# changing original does not change cloned
provider.register(D, scope=scope)
assert isinstance(world.get(D), D)
assert world.test.maybe_provide_from(cloned, D) is None
# changing cloned does not change original
cloned.register(E, scope=scope)
assert isinstance(world.test.maybe_provide_from(cloned, E).unwrapped, E)
with pytest.raises(DependencyNotFoundError):
world.get(E)
def test_register(singleton: bool):
with world.test.empty():
provider = ServiceProvider()
provider.register(A, scope=Scope.singleton() if singleton else None)
assert world.test.maybe_provide_from(provider,
A).is_singleton() is singleton
assert isinstance(
world.test.maybe_provide_from(provider, A).unwrapped, A)
def test_parameterized(scope: Scope):
provider = ServiceProvider()
provider.register(A, scope=scope)
s = world.test.maybe_provide_from(provider,
Parameterized(
A, dict(val=object))).unwrapped
assert isinstance(s, A)
assert dict(val=object) == s.kwargs
def test_custom_scope(provider: ServiceProvider):
dummy_scope = world.scopes.new(name='dummy')
class MyService:
pass
provider.register(MyService, scope=dummy_scope)
my_service = world.get(MyService)
assert my_service is world.get(MyService)
world.scopes.reset(dummy_scope)
assert my_service is not world.get(MyService)
def test_simple(provider: ServiceProvider, scope: Scope):
provider.register(A, scope=scope)
assert isinstance(world.get(A), A)
assert repr(A) in repr(provider)
def test_sanity_checks(provider: ServiceProvider, klass, scope):
with pytest.raises((AssertionError, TypeError)):
provider.register(klass, scope=scope)
def test_exists(provider: ServiceProvider, scope: Scope):
provider.register(A, scope=scope)
assert not provider.exists(object())
assert provider.exists(A)
assert provider.exists(Parameterized(A, dict(a=1)))
assert not provider.exists(Parameterized(B, dict(a=1)))
def test_freeze(provider: ServiceProvider, scope: Scope):
world.freeze()
with pytest.raises(FrozenWorldError):
provider.register(A, scope=scope)
def test_duplicate_error(provider: ServiceProvider, scope: Scope):
provider.register(A, scope=scope)
with pytest.raises(DuplicateDependencyError):
provider.register(A, scope=scope)