Add implementation, typing stubs, and tests

src/dependency_injector/containers.pyi

@@ -45,6 +45,7 @@ class Container:
     def shutdown_resources(self) -> Optional[Awaitable]: ...
     def apply_container_providers_overridings(self) -> None: ...
     def reset_singletons(self) -> None: ...
+    def check_dependencies(self) -> None: ...
     @overload
     def resolve_provider_name(self, provider: Provider) -> str: ...
     @classmethod

src/dependency_injector/containers.pyx

@@ -305,6 +305,30 @@ class DynamicContainer(Container):
         for provider in self.traverse(types=[providers.BaseSingleton]):
             provider.reset()
 
+    def check_dependencies(self):
+        """Check if container dependencies are defined.
+
+        If any dependency is undefined, raises an error.
+        """
+        undefined = [
+            dependency
+            for dependency in self.traverse(types=[providers.Dependency])
+            if not dependency.is_defined
+        ]
+
+        if not undefined:
+            return
+
+        container_name = self.parent_name if self.parent_name else self.__class__.__name__
+        undefined_names = [
+            f'"{dependency.parent_name if dependency.parent_name else dependency}"'
+            for dependency in undefined
+        ]
+        raise errors.Error(
+            f'Container "{container_name}" has undefined dependencies: '
+            f'{", ".join(undefined_names)}',
+        )
+
     def resolve_provider_name(self, provider):
         """Try to resolve provider name."""
         for provider_name, container_provider in self.providers.items():

src/dependency_injector/providers.pyi

@@ -106,6 +106,8 @@ class Dependency(Provider[T]):
     def instance_of(self) -> Type[T]: ...
     @property
     def default(self) -> Provider[T]: ...
+    @property
+    def is_defined(self) -> bool: ...
     def provided_by(self, provider: Provider) -> OverridingContext: ...
     @property
     def parent(self) -> Optional[ProviderParent]: ...

src/dependency_injector/providers.pyx

@@ -708,6 +708,11 @@ cdef class Dependency(Provider):
         """Return default provider."""
         return self.__default
 
+    @property
+    def is_defined(self):
+        """Return True if dependency is defined."""
+        return self.__last_overriding or self.__default is not UNDEFINED
+
     def provided_by(self, provider):
         """Set external dependency provider.
 

tests/unit/containers/test_dynamic_py2_py3.py

@@ -336,6 +336,35 @@ class DeclarativeContainerInstanceTests(unittest.TestCase):
         self.assertIs(obj32, obj42)
         self.assertIs(obj33, obj43)
 
+    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 = ContainerA()

tests/unit/providers/test_base_py2_py3.py

@@ -352,6 +352,19 @@ class DependencyTests(unittest.TestCase):
         self.assertEqual(provider.default(), {'foo': 'bar'})
         self.assertIs(provider.default, default)
 
+    def test_is_defined(self):
+        provider = providers.Dependency()
+        self.assertFalse(provider.is_defined)
+
+    def test_is_defined_when_overridden(self):
+        provider = providers.Dependency()
+        provider.override('value')
+        self.assertTrue(provider.is_defined)
+
+    def test_is_defined_with_default(self):
+        provider = providers.Dependency(default='value')
+        self.assertTrue(provider.is_defined)
+
     def test_call_overridden(self):
         self.provider.provided_by(providers.Factory(list))
         self.assertIsInstance(self.provider(), list)