def test_traversal_provider(self):
another_provider = providers.Provider()
provider = providers.Delegate(another_provider)
all_providers = list(provider.traverse())
self.assertEqual(len(all_providers), 1)
self.assertIn(another_provider, all_providers)
def test_traversal_provider():
another_provider = providers.Provider()
provider = providers.Delegate(another_provider)
all_providers = list(provider.traverse())
assert len(all_providers) == 1
assert another_provider in all_providers
def test_traversal_provider_and_overriding(self):
provider1 = providers.Provider()
provider2 = providers.Provider()
provider3 = providers.Provider()
provider3.override(provider2)
provider = providers.Delegate(provider1)
provider.override(provider3)
all_providers = list(provider.traverse())
self.assertEqual(len(all_providers), 3)
self.assertIn(provider1, all_providers)
self.assertIn(provider2, all_providers)
self.assertIn(provider3, all_providers)
def test_traversal_provider_and_overriding():
provider1 = providers.Provider()
provider2 = providers.Provider()
provider3 = providers.Provider()
provider3.override(provider2)
provider = providers.Delegate(provider1)
provider.override(provider3)
all_providers = list(provider.traverse())
assert len(all_providers) == 3
assert provider1 in all_providers
assert provider2 in all_providers
assert provider3 in all_providers
return self._main_photo
# Defining User and Photo factories using DelegatedFactory provider:
photos_factory = providers.DelegatedFactory(Photo)
users_factory = providers.DelegatedFactory(
User,
photos_factory=photos_factory,
)
# or using Delegate(Factory(...))
photos_factory = providers.Factory(Photo)
users_factory = providers.Factory(
User,
photos_factory=providers.Delegate(photos_factory),
)
# or using Factory(...).delegate()
photos_factory = providers.Factory(Photo)
users_factory = providers.Factory(
User,
photos_factory=photos_factory.delegate(),
)
# Creating several User objects:
user1 = users_factory()
user2 = users_factory()
# Same as:
def setUp(self):
self.delegated = providers.Provider()
self.delegate = providers.Delegate(self.delegated)
def setUp(self):
"""Set test cases environment up."""
self.delegated = providers.Provider()
self.delegate = providers.Delegate(delegated=self.delegated)
from dependency_injector import providers # Test 1: to check the return type provider1 = providers.Delegate(providers.Provider()) var1: providers.Provider = provider1()
def test_init_with_not_provider():
with raises(errors.Error):
providers.Delegate(object())
def test_init_optional_provides(provider):
delegate = providers.Delegate()
delegate.set_provides(provider)
assert delegate.provides is provider
assert delegate() is provider
def delegate(provider):
return providers.Delegate(provider)
from typing import Optional
from dependency_injector import providers
# Test 1: to check the return type
provider1 = providers.Delegate(providers.Provider())
var1: providers.Provider = provider1()
# Test 2: to check the return type with await
provider2 = providers.Delegate(providers.Provider())
async def _async2() -> None:
var1: providers.Provider = await provider2() # type: ignore
var2: providers.Provider = await provider2.async_()
# Test 3: to check class type from provider
provider3 = providers.Delegate(providers.Provider())
provided_provides: Optional[providers.Provider] = provider3.provides
def test_set_provides_returns_self(self):
provider = providers.Delegate()
self.assertIs(provider.set_provides(self.delegated), provider)
def test_init_optional_provides(self):
provider = providers.Delegate()
provider.set_provides(self.delegated)
self.assertIs(provider.provides, self.delegated)
self.assertIs(provider(), self.delegated)
