diff --git a/tests/unit/containers/instance/test_main_py2_py3.py b/tests/unit/containers/instance/test_main_py2_py3.py new file mode 100644 index 00000000..ddd61de9 --- /dev/null +++ b/tests/unit/containers/instance/test_main_py2_py3.py @@ -0,0 +1,493 @@ +"""Main container instance tests.""" + +from dependency_injector import containers, providers, errors +from pytest import raises + + +class Container(containers.DeclarativeContainer): + p11 = providers.Provider() + p12 = providers.Provider() + + +def test_providers_attribute(): + container_1 = Container() + container_2 = Container() + + assert container_1.p11 is not container_2.p11 + assert container_1.p12 is not container_2.p12 + assert container_1.providers != container_2.providers + + +def test_dependencies_attribute(): + container = Container() + container.a1 = providers.Dependency() + container.a2 = providers.DependenciesContainer() + assert container.dependencies == {"a1": container.a1, "a2": container.a2} + + +def test_set_get_del_providers(): + p13 = providers.Provider() + + container_1 = Container() + container_2 = Container() + + container_1.p13 = p13 + container_2.p13 = p13 + + assert Container.providers == dict(p11=Container.p11, p12=Container.p12) + assert Container.cls_providers, dict(p11=Container.p11, p12=Container.p12) + + assert container_1.providers == dict(p11=container_1.p11, p12=container_1.p12, p13=p13) + assert container_2.providers == dict(p11=container_2.p11, p12=container_2.p12, p13=p13) + + del container_1.p13 + assert container_1.providers == dict(p11=container_1.p11, p12=container_1.p12) + + del container_2.p13 + assert container_2.providers == dict(p11=container_2.p11, p12=container_2.p12) + + del container_1.p11 + del container_1.p12 + assert container_1.providers == dict() + assert Container.providers == dict(p11=Container.p11, p12=Container.p12) + + del container_2.p11 + del container_2.p12 + assert container_2.providers == dict() + assert Container.providers == dict(p11=Container.p11, p12=Container.p12) + + +def test_set_invalid_provider_type(): + container = Container() + container.provider_type = providers.Object + + with raises(errors.Error): + container.px = providers.Provider() + + assert Container.provider_type is containers.DeclarativeContainer.provider_type + + +def test_set_providers(): + p13 = providers.Provider() + p14 = providers.Provider() + container = Container() + + container.set_providers(p13=p13, p14=p14) + + assert container.p13 is p13 + assert container.p14 is p14 + + +def test_override(): + class _Container(containers.DeclarativeContainer): + p11 = providers.Provider() + + class _OverridingContainer1(containers.DeclarativeContainer): + p11 = providers.Provider() + + class _OverridingContainer2(containers.DeclarativeContainer): + p11 = providers.Provider() + p12 = providers.Provider() + + container = _Container() + overriding_container1 = _OverridingContainer1() + overriding_container2 = _OverridingContainer2() + + container.override(overriding_container1) + container.override(overriding_container2) + + assert container.overridden == (overriding_container1, overriding_container2) + assert container.p11.overridden == (overriding_container1.p11, overriding_container2.p11) + + assert _Container.overridden == tuple() + assert _Container.p11.overridden == tuple() + + +def test_override_with_it(): + container = Container() + with raises(errors.Error): + container.override(container) + + +def test_override_providers(): + p1 = providers.Provider() + p2 = providers.Provider() + container = Container() + + container.override_providers(p11=p1, p12=p2) + + assert container.p11.last_overriding is p1 + assert container.p12.last_overriding is p2 + + +def test_override_providers_context_manager(): + p1 = providers.Provider() + p2 = providers.Provider() + container = Container() + + with container.override_providers(p11=p1, p12=p2) as context_container: + assert container is context_container + assert container.p11.last_overriding is p1 + assert container.p12.last_overriding is p2 + + assert container.p11.last_overriding is None + assert container.p12.last_overriding is None + + +def test_override_providers_with_unknown_provider(): + container = Container() + with raises(AttributeError): + container.override_providers(unknown=providers.Provider()) + + +def test_reset_last_overriding(): + class _Container(containers.DeclarativeContainer): + p11 = providers.Provider() + + class _OverridingContainer1(containers.DeclarativeContainer): + p11 = providers.Provider() + + class _OverridingContainer2(containers.DeclarativeContainer): + p11 = providers.Provider() + p12 = providers.Provider() + + container = _Container() + overriding_container1 = _OverridingContainer1() + overriding_container2 = _OverridingContainer2() + + container.override(overriding_container1) + container.override(overriding_container2) + container.reset_last_overriding() + + assert container.overridden == (overriding_container1,) + assert container.p11.overridden, (overriding_container1.p11,) + + +def test_reset_last_overriding_when_not_overridden(): + container = Container() + with raises(errors.Error): + container.reset_last_overriding() + + +def test_reset_override(): + class _Container(containers.DeclarativeContainer): + p11 = providers.Provider() + + class _OverridingContainer1(containers.DeclarativeContainer): + p11 = providers.Provider() + + class _OverridingContainer2(containers.DeclarativeContainer): + p11 = providers.Provider() + p12 = providers.Provider() + + container = _Container() + overriding_container1 = _OverridingContainer1() + overriding_container2 = _OverridingContainer2() + + container.override(overriding_container1) + container.override(overriding_container2) + container.reset_override() + + assert container.overridden == tuple() + assert container.p11.overridden == tuple() + + +def test_init_and_shutdown_resources_ordering(): + """Test init and shutdown resources. + + Methods .init_resources() and .shutdown_resources() should respect resources dependencies. + Initialization should first initialize resources without dependencies and then provide + these resources to other resources. Resources shutdown should follow the same rule: first + shutdown resources without initialized dependencies and then continue correspondingly + until all resources are shutdown. + """ + initialized_resources = [] + shutdown_resources = [] + + def _resource(name, **_): + initialized_resources.append(name) + yield name + shutdown_resources.append(name) + + class Container(containers.DeclarativeContainer): + resource1 = providers.Resource( + _resource, + name="r1", + ) + resource2 = providers.Resource( + _resource, + name="r2", + r1=resource1, + ) + resource3 = providers.Resource( + _resource, + name="r3", + r2=resource2, + ) + + container = Container() + + container.init_resources() + assert initialized_resources == ["r1", "r2", "r3"] + assert shutdown_resources == [] + + container.shutdown_resources() + assert initialized_resources == ["r1", "r2", "r3"] + assert shutdown_resources == ["r3", "r2", "r1"] + + container.init_resources() + assert initialized_resources == ["r1", "r2", "r3", "r1", "r2", "r3"] + assert shutdown_resources == ["r3", "r2", "r1"] + + container.shutdown_resources() + assert initialized_resources == ["r1", "r2", "r3", "r1", "r2", "r3"] + assert shutdown_resources == ["r3", "r2", "r1", "r3", "r2", "r1"] + + +def test_shutdown_resources_circular_dependencies_breaker(): + def _resource(name, **_): + yield name + + class Container(containers.DeclarativeContainer): + resource1 = providers.Resource( + _resource, + name="r1", + ) + resource2 = providers.Resource( + _resource, + name="r2", + r1=resource1, + ) + resource3 = providers.Resource( + _resource, + name="r3", + r2=resource2, + ) + + container = Container() + container.init_resources() + + # Create circular dependency after initialization (r3 -> r2 -> r1 -> r3 -> ...) + container.resource1.add_kwargs(r3=container.resource3) + + with raises(RuntimeError, match="Unable to resolve resources shutdown order"): + container.shutdown_resources() + + +def test_init_shutdown_nested_resources(): + def _init1(): + _init1.init_counter += 1 + yield + _init1.shutdown_counter += 1 + + _init1.init_counter = 0 + _init1.shutdown_counter = 0 + + def _init2(): + _init2.init_counter += 1 + yield + _init2.shutdown_counter += 1 + + _init2.init_counter = 0 + _init2.shutdown_counter = 0 + + class Container(containers.DeclarativeContainer): + + service = providers.Factory( + dict, + resource1=providers.Resource(_init1), + resource2=providers.Resource(_init2), + ) + + container = Container() + assert _init1.init_counter == 0 + assert _init1.shutdown_counter == 0 + assert _init2.init_counter == 0 + assert _init2.shutdown_counter == 0 + + container.init_resources() + assert _init1.init_counter == 1 + assert _init1.shutdown_counter == 0 + assert _init2.init_counter == 1 + assert _init2.shutdown_counter == 0 + + container.shutdown_resources() + assert _init1.init_counter == 1 + assert _init1.shutdown_counter == 1 + assert _init2.init_counter == 1 + assert _init2.shutdown_counter == 1 + + container.init_resources() + container.shutdown_resources() + assert _init1.init_counter == 2 + assert _init1.shutdown_counter == 2 + assert _init2.init_counter == 2 + assert _init2.shutdown_counter == 2 + + +def test_reset_singletons(): + class SubSubContainer(containers.DeclarativeContainer): + singleton = providers.Singleton(object) + + class SubContainer(containers.DeclarativeContainer): + singleton = providers.Singleton(object) + sub_sub_container = providers.Container(SubSubContainer) + + class Container(containers.DeclarativeContainer): + singleton = providers.Singleton(object) + sub_container = providers.Container(SubContainer) + + container = Container() + + obj11 = container.singleton() + obj12 = container.sub_container().singleton() + obj13 = container.sub_container().sub_sub_container().singleton() + + obj21 = container.singleton() + obj22 = container.sub_container().singleton() + obj23 = container.sub_container().sub_sub_container().singleton() + + assert obj11 is obj21 + assert obj12 is obj22 + assert obj13 is obj23 + + container.reset_singletons() + + obj31 = container.singleton() + obj32 = container.sub_container().singleton() + obj33 = container.sub_container().sub_sub_container().singleton() + + obj41 = container.singleton() + obj42 = container.sub_container().singleton() + obj43 = container.sub_container().sub_sub_container().singleton() + + assert obj11 is not obj31 + assert obj12 is not obj32 + assert obj13 is not obj33 + + assert obj21 is not obj31 + assert obj22 is not obj32 + assert obj23 is not obj33 + + assert obj31 is obj41 + assert obj32 is obj42 + assert obj33 is obj43 + + +def test_reset_singletons_context_manager(): + class Item: + def __init__(self, dependency): + self.dependency = dependency + + class Container(containers.DeclarativeContainer): + dependent = providers.Singleton(object) + singleton = providers.Singleton(Item, dependency=dependent) + + container = Container() + + instance1 = container.singleton() + with container.reset_singletons(): + instance2 = container.singleton() + instance3 = container.singleton() + + assert len({instance1, instance2, instance3}) == 3 + assert len({instance1.dependency, instance2.dependency, instance3.dependency}) == 3 + + +def test_reset_singletons_context_manager_as_attribute(): + container = containers.DeclarativeContainer() + with container.reset_singletons() as alias: + pass + assert container is alias + + +def test_check_dependencies(): + class SubContainer(containers.DeclarativeContainer): + dependency = providers.Dependency() + + class Container(containers.DeclarativeContainer): + dependency = providers.Dependency() + dependencies_container = providers.DependenciesContainer() + provider = providers.List(dependencies_container.dependency) + sub_container = providers.Container(SubContainer) + + container = Container() + + with raises(errors.Error) as exception_info: + container.check_dependencies() + + assert "Container \"Container\" has undefined dependencies:" in str(exception_info.value) + assert "\"Container.dependency\"" in str(exception_info.value) + assert "\"Container.dependencies_container.dependency\"" in str(exception_info.value) + assert "\"Container.sub_container.dependency\"" in str(exception_info.value) + + +def test_check_dependencies_all_defined(): + class Container(containers.DeclarativeContainer): + dependency = providers.Dependency() + + container = Container(dependency="provided") + result = container.check_dependencies() + + assert result is None + + +def test_assign_parent(): + parent = providers.DependenciesContainer() + container = Container() + + container.assign_parent(parent) + + assert container.parent is parent + + +def test_parent_name_declarative_parent(): + container = Container() + assert container.parent_name == "Container" + + +def test_parent_name(): + container = Container() + assert container.parent_name == "Container" + + +def test_parent_name_with_deep_parenting(): + class Container2(containers.DeclarativeContainer): + name = providers.Container(Container) + + class Container1(containers.DeclarativeContainer): + container = providers.Container(Container2) + + container = Container1() + assert container.container().name.parent_name == "Container1.container.name" + + +def test_parent_name_is_none(): + container = containers.DynamicContainer() + assert container.parent_name is None + + +def test_parent_deepcopy(): + class ParentContainer(containers.DeclarativeContainer): + child = providers.Container(Container) + + container = ParentContainer() + copied = providers.deepcopy(container) + + assert container.child.parent is container + assert copied.child.parent is copied + + assert container is not copied + assert container.child is not copied.child + assert container.child.parent is not copied.child.parent + + +def test_resolve_provider_name(): + container = Container() + assert container.resolve_provider_name(container.p11) == "p11" + + +def test_resolve_provider_name_no_provider(): + container = Container() + with raises(errors.Error): + container.resolve_provider_name(providers.Provider()) diff --git a/tests/unit/containers/test_dynamic_py2_py3.py b/tests/unit/containers/test_dynamic_py2_py3.py index 67dd7347..0b5e408c 100644 --- a/tests/unit/containers/test_dynamic_py2_py3.py +++ b/tests/unit/containers/test_dynamic_py2_py3.py @@ -5,501 +5,9 @@ import unittest from dependency_injector import ( containers, providers, - errors, ) -class Container(containers.DeclarativeContainer): - p11 = providers.Provider() - p12 = providers.Provider() - - -class DeclarativeContainerInstanceTests(unittest.TestCase): - - def test_providers_attribute(self): - container_a1 = Container() - container_a2 = Container() - - self.assertIsNot(container_a1.p11, container_a2.p11) - self.assertIsNot(container_a1.p12, container_a2.p12) - self.assertNotEqual(container_a1.providers, container_a2.providers) - - def test_dependencies_attribute(self): - container = Container() - container.a1 = providers.Dependency() - container.a2 = providers.DependenciesContainer() - self.assertEqual(container.dependencies, {"a1": container.a1, "a2": container.a2}) - - def test_set_get_del_providers(self): - p13 = providers.Provider() - - container_a1 = Container() - container_a2 = Container() - - container_a1.p13 = p13 - container_a2.p13 = p13 - - self.assertEqual(Container.providers, dict(p11=Container.p11, - p12=Container.p12)) - self.assertEqual(Container.cls_providers, dict(p11=Container.p11, - p12=Container.p12)) - - self.assertEqual(container_a1.providers, dict(p11=container_a1.p11, - p12=container_a1.p12, - p13=p13)) - self.assertEqual(container_a2.providers, dict(p11=container_a2.p11, - p12=container_a2.p12, - p13=p13)) - - del container_a1.p13 - self.assertEqual(container_a1.providers, dict(p11=container_a1.p11, - p12=container_a1.p12)) - - del container_a2.p13 - self.assertEqual(container_a2.providers, dict(p11=container_a2.p11, - p12=container_a2.p12)) - - del container_a1.p11 - del container_a1.p12 - self.assertEqual(container_a1.providers, dict()) - self.assertEqual(Container.providers, dict(p11=Container.p11, - p12=Container.p12)) - - del container_a2.p11 - del container_a2.p12 - self.assertEqual(container_a2.providers, dict()) - self.assertEqual(Container.providers, dict(p11=Container.p11, - p12=Container.p12)) - - def test_set_invalid_provider_type(self): - container_a = Container() - container_a.provider_type = providers.Object - - with self.assertRaises(errors.Error): - container_a.px = providers.Provider() - - self.assertIs(Container.provider_type, - containers.DeclarativeContainer.provider_type) - - def test_set_providers(self): - p13 = providers.Provider() - p14 = providers.Provider() - container_a = Container() - - container_a.set_providers(p13=p13, p14=p14) - - self.assertIs(container_a.p13, p13) - self.assertIs(container_a.p14, p14) - - def test_override(self): - class _Container(containers.DeclarativeContainer): - p11 = providers.Provider() - - class _OverridingContainer1(containers.DeclarativeContainer): - p11 = providers.Provider() - - class _OverridingContainer2(containers.DeclarativeContainer): - p11 = providers.Provider() - p12 = providers.Provider() - - container = _Container() - overriding_container1 = _OverridingContainer1() - overriding_container2 = _OverridingContainer2() - - container.override(overriding_container1) - container.override(overriding_container2) - - self.assertEqual(container.overridden, - (overriding_container1, - overriding_container2)) - self.assertEqual(container.p11.overridden, - (overriding_container1.p11, - overriding_container2.p11)) - - self.assertEqual(_Container.overridden, tuple()) - self.assertEqual(_Container.p11.overridden, tuple()) - - def test_override_with_itself(self): - container = Container() - with self.assertRaises(errors.Error): - container.override(container) - - def test_override_providers(self): - p1 = providers.Provider() - p2 = providers.Provider() - container_a = Container() - - container_a.override_providers(p11=p1, p12=p2) - - self.assertIs(container_a.p11.last_overriding, p1) - self.assertIs(container_a.p12.last_overriding, p2) - - def test_override_providers_context_manager(self): - p1 = providers.Provider() - p2 = providers.Provider() - container_a = Container() - - with container_a.override_providers(p11=p1, p12=p2) as container: - self.assertIs(container, container_a) - self.assertIs(container_a.p11.last_overriding, p1) - self.assertIs(container_a.p12.last_overriding, p2) - - self.assertIsNone(container_a.p11.last_overriding) - self.assertIsNone(container_a.p12.last_overriding) - - def test_override_providers_with_unknown_provider(self): - container_a = Container() - - with self.assertRaises(AttributeError): - container_a.override_providers(unknown=providers.Provider()) - - def test_reset_last_overriding(self): - class _Container(containers.DeclarativeContainer): - p11 = providers.Provider() - - class _OverridingContainer1(containers.DeclarativeContainer): - p11 = providers.Provider() - - class _OverridingContainer2(containers.DeclarativeContainer): - p11 = providers.Provider() - p12 = providers.Provider() - - container = _Container() - overriding_container1 = _OverridingContainer1() - overriding_container2 = _OverridingContainer2() - - container.override(overriding_container1) - container.override(overriding_container2) - container.reset_last_overriding() - - self.assertEqual(container.overridden, - (overriding_container1,)) - self.assertEqual(container.p11.overridden, - (overriding_container1.p11,)) - - def test_reset_last_overriding_when_not_overridden(self): - container = Container() - - with self.assertRaises(errors.Error): - container.reset_last_overriding() - - def test_reset_override(self): - class _Container(containers.DeclarativeContainer): - p11 = providers.Provider() - - class _OverridingContainer1(containers.DeclarativeContainer): - p11 = providers.Provider() - - class _OverridingContainer2(containers.DeclarativeContainer): - p11 = providers.Provider() - p12 = providers.Provider() - - container = _Container() - overriding_container1 = _OverridingContainer1() - overriding_container2 = _OverridingContainer2() - - container.override(overriding_container1) - container.override(overriding_container2) - container.reset_override() - - self.assertEqual(container.overridden, tuple()) - self.assertEqual(container.p11.overridden, tuple()) - - def test_init_and_shutdown_resources_ordering(self): - """Test init and shutdown resources. - - Methods .init_resources() and .shutdown_resources() should respect resources dependencies. - Initialization should first initialize resources without dependencies and then provide - these resources to other resources. Resources shutdown should follow the same rule: first - shutdown resources without initialized dependencies and then continue correspondingly - until all resources are shutdown. - """ - initialized_resources = [] - shutdown_resources = [] - - def _resource(name, **_): - initialized_resources.append(name) - yield name - shutdown_resources.append(name) - - class Container(containers.DeclarativeContainer): - resource1 = providers.Resource( - _resource, - name="r1", - ) - resource2 = providers.Resource( - _resource, - name="r2", - r1=resource1, - ) - resource3 = providers.Resource( - _resource, - name="r3", - r2=resource2, - ) - - container = Container() - - container.init_resources() - self.assertEqual(initialized_resources, ["r1", "r2", "r3"]) - self.assertEqual(shutdown_resources, []) - - container.shutdown_resources() - self.assertEqual(initialized_resources, ["r1", "r2", "r3"]) - self.assertEqual(shutdown_resources, ["r3", "r2", "r1"]) - - container.init_resources() - self.assertEqual(initialized_resources, ["r1", "r2", "r3", "r1", "r2", "r3"]) - self.assertEqual(shutdown_resources, ["r3", "r2", "r1"]) - - container.shutdown_resources() - self.assertEqual(initialized_resources, ["r1", "r2", "r3", "r1", "r2", "r3"]) - self.assertEqual(shutdown_resources, ["r3", "r2", "r1", "r3", "r2", "r1"]) - - def test_shutdown_resources_circular_dependencies_breaker(self): - def _resource(name, **_): - yield name - - class Container(containers.DeclarativeContainer): - resource1 = providers.Resource( - _resource, - name="r1", - ) - resource2 = providers.Resource( - _resource, - name="r2", - r1=resource1, - ) - resource3 = providers.Resource( - _resource, - name="r3", - r2=resource2, - ) - - container = Container() - container.init_resources() - - # Create circular dependency after initialization (r3 -> r2 -> r1 -> r3 -> ...) - container.resource1.add_kwargs(r3=container.resource3) - - with self.assertRaises(RuntimeError) as context: - container.shutdown_resources() - self.assertEqual(str(context.exception), "Unable to resolve resources shutdown order") - - def test_init_shutdown_nested_resources(self): - def _init1(): - _init1.init_counter += 1 - yield - _init1.shutdown_counter += 1 - - _init1.init_counter = 0 - _init1.shutdown_counter = 0 - - def _init2(): - _init2.init_counter += 1 - yield - _init2.shutdown_counter += 1 - - _init2.init_counter = 0 - _init2.shutdown_counter = 0 - - class Container(containers.DeclarativeContainer): - - service = providers.Factory( - dict, - resource1=providers.Resource(_init1), - resource2=providers.Resource(_init2), - ) - - container = Container() - self.assertEqual(_init1.init_counter, 0) - self.assertEqual(_init1.shutdown_counter, 0) - self.assertEqual(_init2.init_counter, 0) - self.assertEqual(_init2.shutdown_counter, 0) - - container.init_resources() - self.assertEqual(_init1.init_counter, 1) - self.assertEqual(_init1.shutdown_counter, 0) - self.assertEqual(_init2.init_counter, 1) - self.assertEqual(_init2.shutdown_counter, 0) - - container.shutdown_resources() - self.assertEqual(_init1.init_counter, 1) - self.assertEqual(_init1.shutdown_counter, 1) - self.assertEqual(_init2.init_counter, 1) - self.assertEqual(_init2.shutdown_counter, 1) - - container.init_resources() - container.shutdown_resources() - self.assertEqual(_init1.init_counter, 2) - self.assertEqual(_init1.shutdown_counter, 2) - self.assertEqual(_init2.init_counter, 2) - self.assertEqual(_init2.shutdown_counter, 2) - - def test_reset_singletons(self): - class SubSubContainer(containers.DeclarativeContainer): - singleton = providers.Singleton(object) - - class SubContainer(containers.DeclarativeContainer): - singleton = providers.Singleton(object) - sub_sub_container = providers.Container(SubSubContainer) - - class Container(containers.DeclarativeContainer): - singleton = providers.Singleton(object) - sub_container = providers.Container(SubContainer) - - container = Container() - - obj11 = container.singleton() - obj12 = container.sub_container().singleton() - obj13 = container.sub_container().sub_sub_container().singleton() - - obj21 = container.singleton() - obj22 = container.sub_container().singleton() - obj23 = container.sub_container().sub_sub_container().singleton() - - self.assertIs(obj11, obj21) - self.assertIs(obj12, obj22) - self.assertIs(obj13, obj23) - - container.reset_singletons() - - obj31 = container.singleton() - obj32 = container.sub_container().singleton() - obj33 = container.sub_container().sub_sub_container().singleton() - - obj41 = container.singleton() - obj42 = container.sub_container().singleton() - obj43 = container.sub_container().sub_sub_container().singleton() - - self.assertIsNot(obj11, obj31) - self.assertIsNot(obj12, obj32) - self.assertIsNot(obj13, obj33) - - self.assertIsNot(obj21, obj31) - self.assertIsNot(obj22, obj32) - self.assertIsNot(obj23, obj33) - - self.assertIs(obj31, obj41) - self.assertIs(obj32, obj42) - self.assertIs(obj33, obj43) - - def test_reset_singletons_context_manager(self): - class Item: - def __init__(self, dependency): - self.dependency = dependency - - class Container(containers.DeclarativeContainer): - dependent = providers.Singleton(object) - singleton = providers.Singleton(Item, dependency=dependent) - - container = Container() - - instance1 = container.singleton() - with container.reset_singletons(): - instance2 = container.singleton() - instance3 = container.singleton() - - self.assertEqual(len({instance1, instance2, instance3}), 3) - self.assertEqual( - len({instance1.dependency, instance2.dependency, instance3.dependency}), - 3, - ) - - def test_reset_singletons_context_manager_as_attribute(self): - container = containers.DeclarativeContainer() - - with container.reset_singletons() as alias: - pass - - self.assertIs(container, alias) - - def test_check_dependencies(self): - class SubContainer(containers.DeclarativeContainer): - dependency = providers.Dependency() - - class Container(containers.DeclarativeContainer): - dependency = providers.Dependency() - dependencies_container = providers.DependenciesContainer() - provider = providers.List(dependencies_container.dependency) - sub_container = providers.Container(SubContainer) - - container = Container() - - with self.assertRaises(errors.Error) as context: - container.check_dependencies() - - self.assertIn("Container \"Container\" has undefined dependencies:", str(context.exception)) - self.assertIn("\"Container.dependency\"", str(context.exception)) - self.assertIn("\"Container.dependencies_container.dependency\"", str(context.exception)) - self.assertIn("\"Container.sub_container.dependency\"", str(context.exception)) - - def test_check_dependencies_all_defined(self): - class Container(containers.DeclarativeContainer): - dependency = providers.Dependency() - - container = Container(dependency="provided") - result = container.check_dependencies() - - self.assertIsNone(result) - - def test_assign_parent(self): - parent = providers.DependenciesContainer() - container = Container() - - container.assign_parent(parent) - - self.assertIs(container.parent, parent) - - def test_parent_name_declarative_parent(self): - container = Container() - self.assertEqual(container.parent_name, "Container") - - def test_parent_name(self): - container = Container() - self.assertEqual(container.parent_name, "Container") - - def test_parent_name_with_deep_parenting(self): - class Container2(containers.DeclarativeContainer): - - name = providers.Container(Container) - - class Container1(containers.DeclarativeContainer): - - container = providers.Container(Container2) - - container = Container1() - self.assertEqual(container.container().name.parent_name, "Container1.container.name") - - def test_parent_name_is_none(self): - container = containers.DynamicContainer() - self.assertIsNone(container.parent_name) - - def test_parent_deepcopy(self): - class ParentContainer(containers.DeclarativeContainer): - child = providers.Container(Container) - - container = ParentContainer() - - copied = providers.deepcopy(container) - - self.assertIs(container.child.parent, container) - self.assertIs(copied.child.parent, copied) - - self.assertIsNot(container, copied) - self.assertIsNot(container.child, copied.child) - self.assertIsNot(container.child.parent, copied.child.parent) - - def test_resolve_provider_name(self): - container = Container() - self.assertEqual(container.resolve_provider_name(container.p11), "p11") - - def test_resolve_provider_name_no_provider(self): - container = Container() - with self.assertRaises(errors.Error): - container.resolve_provider_name(providers.Provider()) - - class DynamicContainerWithCustomStringTests(unittest.TestCase): # See: https://github.com/ets-labs/python-dependency-injector/issues/479