Migrate container instance tests

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())

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