From 8a07bf0e392e944ed24efd8f9517e9f9a7921a79 Mon Sep 17 00:00:00 2001 From: Roman Mogylatov Date: Sun, 17 Oct 2021 21:25:31 -0400 Subject: [PATCH] Migrate container provider tests --- .../unit/providers/test_container_py2_py3.py | 318 +++++++++--------- 1 file changed, 166 insertions(+), 152 deletions(-) diff --git a/tests/unit/providers/test_container_py2_py3.py b/tests/unit/providers/test_container_py2_py3.py index e4cf9a1e..62d946ce 100644 --- a/tests/unit/providers/test_container_py2_py3.py +++ b/tests/unit/providers/test_container_py2_py3.py @@ -1,4 +1,4 @@ -"""Dependency injector container provider unit tests.""" +"""Container provider tests.""" import copy @@ -42,213 +42,227 @@ class Application(containers.DeclarativeContainer): dict_factory = providers.Factory(dict, value=core.value_getter) -class ContainerTests(unittest.TestCase): +def test(): + application = Application(config=_copied(TEST_CONFIG_1)) + assert application.dict_factory() == {"value": TEST_VALUE_1} - def test(self): - application = Application(config=_copied(TEST_CONFIG_1)) - assert application.dict_factory() == {"value": TEST_VALUE_1} - def test_double_override(self): - application = Application() - application.config.override(_copied(TEST_CONFIG_1)) - application.config.override(_copied(TEST_CONFIG_2)) - assert application.dict_factory() == {"value": TEST_VALUE_2} +def test_double_override(): + application = Application() + application.config.override(_copied(TEST_CONFIG_1)) + application.config.override(_copied(TEST_CONFIG_2)) + assert application.dict_factory() == {"value": TEST_VALUE_2} - def test_override(self): - # See: https://github.com/ets-labs/python-dependency-injector/issues/354 - class D(containers.DeclarativeContainer): - foo = providers.Object("foo") - class A(containers.DeclarativeContainer): - d = providers.DependenciesContainer() - bar = providers.Callable(lambda f: f + "++", d.foo.provided) +def test_override(): + # See: https://github.com/ets-labs/python-dependency-injector/issues/354 + class D(containers.DeclarativeContainer): + foo = providers.Object("foo") - class B(containers.DeclarativeContainer): - d = providers.Container(D) + class A(containers.DeclarativeContainer): + d = providers.DependenciesContainer() + bar = providers.Callable(lambda f: f + "++", d.foo.provided) - a = providers.Container(A, d=d) + class B(containers.DeclarativeContainer): + d = providers.Container(D) - b = B(d=D()) - result = b.a().bar() - assert result == "foo++" + a = providers.Container(A, d=d) - def test_override_not_root_provider(self): - # See: https://github.com/ets-labs/python-dependency-injector/issues/379 - class NestedContainer(containers.DeclarativeContainer): - settings = providers.Configuration() + b = B(d=D()) + result = b.a().bar() + assert result == "foo++" - print_settings = providers.Callable( - lambda s: s, - settings, - ) - class TestContainer(containers.DeclarativeContainer): - settings = providers.Configuration() +def test_override_not_root_provider(): + # See: https://github.com/ets-labs/python-dependency-injector/issues/379 + class NestedContainer(containers.DeclarativeContainer): + settings = providers.Configuration() - root_container = providers.Container( + print_settings = providers.Callable( + lambda s: s, + settings, + ) + + class TestContainer(containers.DeclarativeContainer): + settings = providers.Configuration() + + root_container = providers.Container( + NestedContainer, + settings=settings, + ) + + not_root_container = providers.Selector( + settings.container, + using_factory=providers.Factory( + NestedContainer, + settings=settings, + ), + using_container=providers.Container( NestedContainer, settings=settings, ) + ) - not_root_container = providers.Selector( - settings.container, - using_factory=providers.Factory( - NestedContainer, - settings=settings, - ), - using_container=providers.Container( - NestedContainer, - settings=settings, - ) - ) + container_using_factory = TestContainer(settings=dict( + container="using_factory", + foo="bar" + )) + assert container_using_factory.root_container().print_settings() == {"container": "using_factory", "foo": "bar"} + assert container_using_factory.not_root_container().print_settings() == {"container": "using_factory", "foo": "bar"} - container_using_factory = TestContainer(settings=dict( - container="using_factory", - foo="bar" - )) - assert container_using_factory.root_container().print_settings() == {"container": "using_factory", "foo": "bar"} - assert container_using_factory.not_root_container().print_settings() == {"container": "using_factory", "foo": "bar"} + container_using_container = TestContainer(settings=dict( + container="using_container", + foo="bar" + )) + assert container_using_container.root_container().print_settings() == {"container": "using_container", "foo": "bar"} + assert container_using_container.not_root_container().print_settings() == {"container": "using_container", "foo": "bar"} - container_using_container = TestContainer(settings=dict( - container="using_container", - foo="bar" - )) - assert container_using_container.root_container().print_settings() == {"container": "using_container", "foo": "bar"} - assert container_using_container.not_root_container().print_settings() == {"container": "using_container", "foo": "bar"} - def test_override_by_not_a_container(self): - provider = providers.Container(Core) +def test_override_by_not_a_container(): + provider = providers.Container(Core) - with raises(errors.Error): - provider.override(providers.Object("foo")) + with raises(errors.Error): + provider.override(providers.Object("foo")) - def test_lazy_overriding(self): - # See: https://github.com/ets-labs/python-dependency-injector/issues/354 - class D(containers.DeclarativeContainer): - foo = providers.Object("foo") +def test_lazy_overriding(): + # See: https://github.com/ets-labs/python-dependency-injector/issues/354 + class D(containers.DeclarativeContainer): + foo = providers.Object("foo") - class A(containers.DeclarativeContainer): - d = providers.DependenciesContainer() - bar = providers.Callable(lambda f: f + "++", d.foo.provided) + class A(containers.DeclarativeContainer): + d = providers.DependenciesContainer() + bar = providers.Callable(lambda f: f + "++", d.foo.provided) - class B(containers.DeclarativeContainer): - d = providers.DependenciesContainer() + class B(containers.DeclarativeContainer): + d = providers.DependenciesContainer() - a = providers.Container(A, d=d) + a = providers.Container(A, d=d) - b = B(d=D()) - result = b.a().bar() - assert result == "foo++" + b = B(d=D()) + result = b.a().bar() + assert result == "foo++" - def test_lazy_overriding_deep(self): - # Extended version of test_lazy_overriding() - class D(containers.DeclarativeContainer): - foo = providers.Object("foo") +def test_lazy_overriding_deep(): + # Extended version of test_lazy_overriding() + class D(containers.DeclarativeContainer): + foo = providers.Object("foo") - class C(containers.DeclarativeContainer): - d = providers.DependenciesContainer() - bar = providers.Callable(lambda f: f + "++", d.foo.provided) + class C(containers.DeclarativeContainer): + d = providers.DependenciesContainer() + bar = providers.Callable(lambda f: f + "++", d.foo.provided) - class A(containers.DeclarativeContainer): - d = providers.DependenciesContainer() - c = providers.Container(C, d=d) + class A(containers.DeclarativeContainer): + d = providers.DependenciesContainer() + c = providers.Container(C, d=d) - class B(containers.DeclarativeContainer): - d = providers.DependenciesContainer() + class B(containers.DeclarativeContainer): + d = providers.DependenciesContainer() - a = providers.Container(A, d=d) + a = providers.Container(A, d=d) - b = B(d=D()) - result = b.a().c().bar() - assert result == "foo++" + b = B(d=D()) + result = b.a().c().bar() + assert result == "foo++" - def test_reset_last_overriding(self): - application = Application(config=_copied(TEST_CONFIG_1)) - application.core.override(Core(config=_copied(TEST_CONFIG_2["core"]))) - application.core.reset_last_overriding() +def test_reset_last_overriding(): + application = Application(config=_copied(TEST_CONFIG_1)) + application.core.override(Core(config=_copied(TEST_CONFIG_2["core"]))) - assert application.dict_factory() == {"value": TEST_VALUE_1} + application.core.reset_last_overriding() - def test_reset_last_overriding_only_overridden(self): - application = Application(config=_copied(TEST_CONFIG_1)) - application.core.override(providers.DependenciesContainer(config=_copied(TEST_CONFIG_2["core"]))) + assert application.dict_factory() == {"value": TEST_VALUE_1} - application.core.reset_last_overriding() - assert application.dict_factory() == {"value": TEST_VALUE_1} +def test_reset_last_overriding_only_overridden(): + application = Application(config=_copied(TEST_CONFIG_1)) + application.core.override(providers.DependenciesContainer(config=_copied(TEST_CONFIG_2["core"]))) - def test_override_context_manager(self): - application = Application(config=_copied(TEST_CONFIG_1)) - overriding_core = Core(config=_copied(TEST_CONFIG_2["core"])) + application.core.reset_last_overriding() - with application.core.override(overriding_core) as context_core: - assert application.dict_factory() == {"value": TEST_VALUE_2} - assert context_core() is overriding_core + assert application.dict_factory() == {"value": TEST_VALUE_1} - assert application.dict_factory() == {"value": TEST_VALUE_1} - def test_reset_override(self): - application = Application(config=_copied(TEST_CONFIG_1)) - application.core.override(Core(config=_copied(TEST_CONFIG_2["core"]))) +def test_override_context_manager(): + application = Application(config=_copied(TEST_CONFIG_1)) + overriding_core = Core(config=_copied(TEST_CONFIG_2["core"])) - application.core.reset_override() + with application.core.override(overriding_core) as context_core: + assert application.dict_factory() == {"value": TEST_VALUE_2} + assert context_core() is overriding_core - assert application.dict_factory() == {"value": None} + assert application.dict_factory() == {"value": TEST_VALUE_1} - def test_reset_override_only_overridden(self): - application = Application(config=_copied(TEST_CONFIG_1)) - application.core.override(providers.DependenciesContainer(config=_copied(TEST_CONFIG_2["core"]))) - application.core.reset_override() +def test_reset_override(): + application = Application(config=_copied(TEST_CONFIG_1)) + application.core.override(Core(config=_copied(TEST_CONFIG_2["core"]))) - assert application.dict_factory() == {"value": None} + application.core.reset_override() - def test_assign_parent(self): - parent = providers.DependenciesContainer() - provider = providers.Container(Core) + assert application.dict_factory() == {"value": None} - provider.assign_parent(parent) - assert provider.parent is parent +def test_reset_override_only_overridden(): + application = Application(config=_copied(TEST_CONFIG_1)) + application.core.override(providers.DependenciesContainer(config=_copied(TEST_CONFIG_2["core"]))) - def test_parent_name(self): - container = containers.DynamicContainer() - provider = providers.Container(Core) - container.name = provider - assert provider.parent_name == "name" + application.core.reset_override() - def test_parent_name_with_deep_parenting(self): - provider = providers.Container(Core) - container = providers.DependenciesContainer(name=provider) - _ = providers.DependenciesContainer(container=container) - assert provider.parent_name == "container.name" + assert application.dict_factory() == {"value": None} - def test_parent_name_is_none(self): - provider = providers.Container(Core) - assert provider.parent_name is None - def test_parent_deepcopy(self): - container = containers.DynamicContainer() - provider = providers.Container(Core) - container.name = provider +def test_assign_parent(): + parent = providers.DependenciesContainer() + provider = providers.Container(Core) - copied = providers.deepcopy(container) + provider.assign_parent(parent) - assert container.name.parent is container - assert copied.name.parent is copied + assert provider.parent is parent - assert container is not copied - assert container.name is not copied.name - assert container.name.parent is not copied.name.parent - def test_resolve_provider_name(self): - container = providers.Container(Core) - assert container.resolve_provider_name(container.value_getter) == "value_getter" +def test_parent_name(): + container = containers.DynamicContainer() + provider = providers.Container(Core) + container.name = provider + assert provider.parent_name == "name" - def test_resolve_provider_name_no_provider(self): - container = providers.Container(Core) - with raises(errors.Error): - container.resolve_provider_name(providers.Provider()) + +def test_parent_name_with_deep_parenting(): + provider = providers.Container(Core) + container = providers.DependenciesContainer(name=provider) + _ = providers.DependenciesContainer(container=container) + assert provider.parent_name == "container.name" + + +def test_parent_name_is_none(): + provider = providers.Container(Core) + assert provider.parent_name is None + + +def test_parent_deepcopy(): + container = containers.DynamicContainer() + provider = providers.Container(Core) + container.name = provider + + copied = providers.deepcopy(container) + + assert container.name.parent is container + assert copied.name.parent is copied + + assert container is not copied + assert container.name is not copied.name + assert container.name.parent is not copied.name.parent + + +def test_resolve_provider_name(): + container = providers.Container(Core) + assert container.resolve_provider_name(container.value_getter) == "value_getter" + + +def test_resolve_provider_name_no_provider(): + container = providers.Container(Core) + with raises(errors.Error): + container.resolve_provider_name(providers.Provider())