def test_get_factory():
world.provider(FactoryProvider)
@factory
def build_a() -> A:
return A()
assert world.get[A] @ build_a is world.get(A @ build_a)
def test_lazy_factory():
world.provider(FactoryProvider)
@factory
def build_a() -> A:
return A()
assert (world.lazy[A] @ build_a).get() is world.get(A @ build_a)
def test_provide_from():
provider = DummyIntProvider()
assert world.test.maybe_provide_from(provider, 10) == DependencyValue(20)
assert world.test.maybe_provide_from(provider, "1") is None
world.provider(DummyIntProvider)
with pytest.raises(RuntimeError):
world.test.maybe_provide_from(world.get(DummyIntProvider), 10)
def test_assert_not_duplicate():
x = object()
class A(Provider[Hashable]):
def __init__(self):
super().__init__()
self.registered = dict()
def exists(self, dependency: Hashable) -> bool:
return dependency in self.registered
def provide(self, dependency: Hashable,
container: Container) -> DependencyValue:
return DependencyValue(self.registered[dependency])
def add(self, dependency: Hashable, value: object):
self._assert_not_duplicate(dependency)
self.registered[dependency] = value
with world.test.empty():
a = A()
a.add(x, 1)
with pytest.raises(DuplicateDependencyError):
with pytest.warns(UserWarning, match="(?i).*debug.*"):
a.add(x, 1)
with world.test.empty():
world.provider(A)
@world.provider
class B(Provider[Hashable]):
def __init__(self):
super().__init__()
self.registered = dict()
def debug(self, dependency: Hashable) -> DependencyDebug:
return DependencyDebug("DebugInfo")
def exists(self, dependency: Hashable) -> bool:
return dependency in self.registered
def provide(self, dependency: Hashable,
container: Container) -> DependencyValue:
return DependencyValue(self.registered[dependency])
def add(self, dependency: Hashable, value: object):
self._assert_not_duplicate(dependency)
self.registered[dependency] = value
world.get[B]().add(x, 1)
with pytest.raises(DuplicateDependencyError, match=".*DebugInfo.*"):
world.get[A]().add(x, 1)
def test_clone_restrictions(keep_singletons, keep_scopes):
with world.test.clone(keep_singletons=keep_singletons,
keep_scopes=keep_scopes):
with pytest.raises(FrozenWorldError):
world.scopes.new(name="new scope")
with pytest.raises(FrozenWorldError):
world.provider(DummyIntProvider)
with pytest.raises(FrozenWorldError):
world.test.singleton('test', 1)
def test_provider():
# overrides normal provider
with world.test.empty():
world.provider(DummyProvider)
p = world.get[DummyProvider]()
p.data = {'test': sentinel, 'test2': sentinel}
assert world.get('test') is sentinel
assert world.get('test2') is sentinel
with world.test.clone():
@world.test.override.provider()
def f(dependency: Hashable) -> Optional[DependencyValue]:
if dependency == 'test':
return DependencyValue('a')
assert world.get('test') == 'a'
assert world.get('test2') is sentinel
# overrides singletons
with world.test.empty():
world.test.singleton({'test': sentinel, 'test2': sentinel})
assert world.get('test') is sentinel
assert world.get('test2') is sentinel
with world.test.clone(keep_singletons=True):
@world.test.override.provider()
def f2(dependency: Hashable) -> Optional[DependencyValue]:
if dependency == 'test':
return DependencyValue('a')
assert world.get('test') == 'a'
assert world.get('test2') is sentinel
# non singleton dependency
with world.test.clone():
@world.test.override.provider()
def f3(dependency: Hashable) -> Optional[DependencyValue]:
if dependency == 'test':
return DependencyValue(object())
assert world.get('test') is not world.get('test')
# singleton dependency
with world.test.clone():
@world.test.override.provider()
def f4(dependency: Hashable) -> Optional[DependencyValue]:
if dependency == 'test':
return DependencyValue(object(), scope=Scope.singleton())
assert world.get('test') is world.get('test')
def test_clone_keep_singletons():
world.test.singleton("singleton", 2)
world.provider(DummyIntProvider)
with world.test.clone(keep_singletons=True):
assert world.get("singleton") == 2
assert world.get(10) == 20
with world.test.clone(keep_singletons=False):
with pytest.raises(DependencyNotFoundError):
world.get("singleton")
assert world.get(10) == 20
def test_world(context: Callable, keeps_singletons: bool, strategy: str):
class DummyFloatProvider(StatelessProvider[float]):
def exists(self, dependency: Hashable) -> bool:
return isinstance(dependency, float)
def provide(self, dependency: float, container: Container
) -> Optional[DependencyValue]:
return DependencyValue(dependency ** 2)
x = object()
y = object()
world.test.singleton("x", x)
world.provider(DummyIntProvider)
provider = world.get(DummyIntProvider)
with context():
if keeps_singletons:
assert world.get('x') == x
else:
with pytest.raises(DependencyNotFoundError):
world.get('x')
if strategy == 'new':
assert isinstance(world.get[DummyIntProvider](), DummyIntProvider)
assert world.get(DummyIntProvider).original is None
elif strategy == 'clone':
assert isinstance(world.get(DummyIntProvider), DummyIntProvider)
assert world.get(DummyIntProvider) is not provider
assert world.get(DummyIntProvider).original is provider
elif strategy == 'empty':
with pytest.raises(DependencyNotFoundError):
world.get(DummyIntProvider)
with pytest.raises(DependencyNotFoundError):
world.get(ServiceProvider)
if strategy != 'clone':
world.test.singleton("y", y)
assert world.get('y') is y
world.provider(DummyFloatProvider)
assert world.get(1.2) == 1.2 ** 2
s = world.scopes.new(name='dummy')
world.scopes.reset(s)
with pytest.raises(DependencyNotFoundError):
world.get('y')
with pytest.raises(DependencyNotFoundError):
world.get(1.2)
with pytest.raises(DependencyNotFoundError):
world.get(DummyFloatProvider)
def test_freeze():
world.provider(ServiceProvider)
provider = world.get[ServiceProvider]()
class Service:
pass
world.freeze()
with pytest.raises(FrozenWorldError):
world.test.singleton("test", "x")
with pytest.raises(FrozenWorldError):
provider.register(Service, scope=None)
def test_new():
world.test.singleton("singleton", 2)
world.provider(DummyIntProvider)
assert world.get(10) == 20
with world.test.new():
world.test.singleton("a", 3)
assert world.get("a") == 3
with pytest.raises(DependencyNotFoundError):
world.get("singleton")
assert world.get(10) == 20
with pytest.raises(DependencyNotFoundError):
world.get("a")
def test_freeze_world():
class DummyProvider(Provider):
def provide(self, dependency: Hashable,
container: Container) -> Optional[DependencyValue]:
return None
def clone(self, keep_singletons_cache: bool) -> 'DummyProvider':
return self
def register(self):
return "register"
@does_not_freeze
def method(self):
return "method"
@staticmethod
def static():
return "static"
@classmethod
def klass(cls):
return "klass"
provider = DummyProvider()
assert provider.register() == "register"
assert provider.method() == "method"
assert provider.static() == "static"
assert provider.klass() == "klass"
with world.test.empty():
world.provider(DummyProvider)
provider = world.get[DummyProvider]()
assert provider.register() == "register"
assert provider.method() == "method"
assert provider.static() == "static"
assert provider.klass() == "klass"
world.freeze()
assert provider.method() == "method"
assert provider.static() == "static"
assert provider.klass() == "klass"
provider.clone(False)
provider.provide(None, None)
with pytest.raises(FrozenWorldError):
provider.register()
def test_get():
world.provider(ServiceProvider)
a = A()
world.test.singleton(A, a)
assert world.get(A) is a
class B(Service):
pass
assert world.get[A](A) is a
assert world.get[B]() is world.get(B)
b = B()
assert world.get(B, default=b) is world.get(B)
assert world.get[B](default=b) is world.get(B)
with pytest.raises(DependencyNotFoundError):
world.get(Service)
with pytest.raises(DependencyNotFoundError):
world.get[Service]()
assert world.get[Service](default=b) is b
def test_factory():
# overrides normal provider
with world.test.empty():
world.provider(DummyProvider)
p = world.get[DummyProvider]()
p.data = {'test': sentinel}
assert world.get('test') is sentinel
with world.test.clone():
@world.test.override.factory('test')
def f():
return 'a'
assert world.get('test') == 'a'
@world.test.override.factory('test')
def g():
return 'b'
assert world.get('test') == 'b'
# overrides singletons
with world.test.empty():
world.test.singleton({'test': sentinel, 'test2': sentinel})
assert world.get('test') is sentinel
assert world.get('test2') is sentinel
with world.test.clone(keep_singletons=True):
@world.test.override.factory('test')
def f1():
return 'a'
assert world.get('test') == 'a'
assert world.get('test2') is sentinel
# default => singleton
with world.test.clone():
@world.test.override.factory('test')
def f2():
return object()
assert world.get('test') is world.get('test')
# non singleton
with world.test.clone():
@world.test.override.factory('test', singleton=False)
def f3():
return object()
assert world.get('test') is not world.get('test')
# singleton
with world.test.clone():
@world.test.override.factory('test', singleton=True)
def f4():
return object()
assert world.get('test') is world.get('test')
def provider():
with world.test.empty():
world.test.singleton('lazy_build', build)
world.provider(FactoryProvider)
yield world.get(FactoryProvider)
def test_add_provider():
world.provider(DummyIntProvider)
assert world.get(10) == 20
def test_no_duplicate_provider():
world.provider(DummyIntProvider)
assert world.get(10) == 20
with pytest.raises(ValueError, match=".*already exists.*"):
world.provider(DummyIntProvider)
def provider():
with world.test.empty():
world.provider(ServiceProvider)
yield world.get(ServiceProvider)
def lazy_provider():
with world.test.empty():
world.provider(LazyProvider)
yield world.get(LazyProvider)
def test_world():
with world.test.empty():
world.provider(ServiceProvider)
world.provider(FactoryProvider)
world.provider(LazyProvider)
yield
def test_world():
with world.test.empty():
world.provider(ServiceProvider)
yield
def indirect(empty_world):
world.provider(IndirectProvider)
return world.get(IndirectProvider)
def test_invalid_add_provider(p, expectation):
with expectation:
world.provider(p)
def empty_world():
with world.test.empty():
world.provider(LazyProvider)
world.provider(ServiceProvider)
yield
def service(empty_world):
world.provider(ServiceProvider)
return world.get(ServiceProvider)
