fix: Has(T) registers type to dishka for when= usage

docs/advanced/when.rst

@@ -154,12 +154,20 @@ In case you want to activate some features when specific objects are available y
 * it is activated
 * if it actually presents in context while being registered as ``from_context``
 
+``Has(T)`` implicitly registers ``T`` for graph validation.
+
+Use ``from_context(T, ...)`` when ``Has(T)`` should become true only after a real
+context value is passed.
+
+The implicit registration only helps validation. ``Has(T)`` still stays false
+until some real provider or real context value is available.
+
 
 For example:
 
 .. code-block:: python
 
-    from dishka import Provider, provide, Scope
+    from dishka import Provider, from_context, provide, Scope
 
     class MyProvider(Provider)
         config = from_context(RedisConfig, scope=Scope.APP)
@@ -182,6 +190,6 @@ For example:
 
 In this case,
 
-* ``memcached_impl`` is not used because no factory for ``MemcachedConfig`` is provided
+* ``memcached_impl`` is not used because no real factory for ``MemcachedConfig`` is provided
 * ``redis_impl`` is not used while it is registered as ``from_context`` but no real value is provided.
-* ``base_impl`` is used as a default one, because none of later is active
+* ``base_impl`` is used as a default one, because none of later is active

src/dishka/graph_builder/builder.py

@@ -1,6 +1,6 @@
 import itertools
 from collections import defaultdict
-from collections.abc import Collection, Sequence
+from collections.abc import Collection, Iterator, Sequence
 from typing import cast
 
 from dishka.dependency_source import (
@@ -14,7 +14,7 @@
 from dishka.entities.component import Component
 from dishka.entities.factory_type import FactoryData, FactoryType
 from dishka.entities.key import DependencyKey
-from dishka.entities.marker import unpack_marker
+from dishka.entities.marker import BoolMarker, Has, Marker, unpack_marker
 from dishka.entities.scope import BaseScope, InvalidScopes
 from dishka.entities.validation_settings import ValidationSettings
 from dishka.exception_base import InvalidMarkerError
@@ -537,11 +537,52 @@ def _fix_missing_scopes(
                 requester_scope=root_scope,
             )
 
+    def _iter_factory_markers(self, factory: Factory) -> Iterator[Marker]:
+        yield from unpack_marker(factory.when_active)
+        yield from unpack_marker(factory.when_override)
+        for subfactory in factory.when_dependencies:
+            yield from self._iter_factory_markers(subfactory)
+
+    def _make_implicit_has_factory(
+        self,
+        key: DependencyKey,
+    ) -> Factory:
+        return Factory(
+            scope=next(iter(self.scopes)),
+            source=key.type_hint,
+            provides=key,
+            is_to_bind=False,
+            dependencies=[],
+            kw_dependencies={},
+            type_=FactoryType.CONTEXT,
+            cache=False,
+            when_override=None,
+            when_active=BoolMarker(False),
+            when_component=key.component,
+            when_dependencies=[],
+        )
+
+    def _add_implicit_has_factories(
+        self,
+        factories: dict[DependencyKey, Factory],
+    ) -> None:
+        missing: dict[DependencyKey, Factory] = {}
+        for factory in tuple(factories.values()):
+            for marker in self._iter_factory_markers(factory):
+                if not isinstance(marker, Has):
+                    continue
+                key = DependencyKey(marker.value, factory.when_component)
+                if key in factories or key in missing:
+                    continue
+                missing[key] = self._make_implicit_has_factory(key)
+        factories.update(missing)
+
     def build(self) -> Sequence[Registry]:
         self._check_markers()
         factories: dict[DependencyKey, Factory] = {
             f.provides: f for f in self._collect_prepared_factories()
         }
+        self._add_implicit_has_factories(factories)
         self._fix_missing_scopes(factories)
         fixed_factories = list(factories.values())
 

tests/unit/container/when/test_has.py

@@ -1,6 +1,16 @@
+from typing import Any
+
 import pytest
 
-from dishka import Has, Provider, Scope, make_async_container, make_container
+from dishka import (
+    Has,
+    Provider,
+    Scope,
+    make_async_container,
+    make_container,
+    provide,
+)
+from dishka.exceptions import NoActiveFactoryError
 
 
 @pytest.mark.parametrize(("register", "value"), [
@@ -48,3 +58,94 @@ def test_has_chained(*, register: bool, value: str):
 
     c = make_container(provider)
     assert c.get(str) == value
+
+
+@pytest.mark.parametrize(
+    ("enable_conditional_provider", "successful"), [
+        (False, False),
+        (True, True),
+    ],
+)
+def test_has_with_declared_context_dependency(
+    *, enable_conditional_provider: bool, successful: bool,
+):
+    class StringProvider(Provider):
+        @provide(when=Has(int), scope=Scope.APP)
+        def setup(self, cfg: int) -> str:
+            return "ok"
+
+    class IntProvider(Provider):
+        int_config_instance = provide(
+            source=lambda self: 42, provides=int, scope=Scope.APP,
+        )
+
+    providers: list[Any] = [StringProvider()]
+    if enable_conditional_provider:
+        providers.append(IntProvider())
+
+    container = make_container(*providers, context={})
+
+    if successful:
+        assert isinstance(container.get(str), str)
+    else:
+        with pytest.raises(NoActiveFactoryError):
+            container.get(str)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("is_async", "register_int", "value"),
+    [
+        (False, True, "b"),
+        (False, False, "a"),
+        (True, True, "b"),
+        (True, False, "a"),
+    ],
+)
+async def test_provider_declare_method_does_not_make_has_active(
+        *, is_async: bool, register_int: bool, value: str,
+):
+    provider = Provider(scope=Scope.APP)
+    provider.provide(lambda: "a", provides=str)
+    provider.provide(lambda: "b", provides=str, when=Has(int))
+
+    provider2 = Provider(scope=Scope.APP)
+    if register_int:
+        provider2.provide(lambda: 42, provides=int)
+
+    if is_async:
+        container = make_async_container(provider, provider2, context={})
+        assert await container.get(str) == value
+    else:
+        container = make_container(provider, provider2, context={})
+        assert container.get(str) == value
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("is_async", "register_ctx", "value"),
+    [
+        (False, True, "b"),
+        (False, False, "a"),
+        (True, True, "b"),
+        (True, False, "a"),
+    ],
+)
+async def test_from_context_requires_real_context_value_for_has(
+        *, is_async: bool, register_ctx: bool, value: str,
+):
+    provider = Provider(scope=Scope.APP)
+    provider.from_context(int)
+    provider.provide(lambda: "a", provides=str)
+    provider.provide(lambda: "b", provides=str, when=Has(int))
+    if register_ctx:
+        ctx = {int: 42}
+    else:
+        ctx = {}
+
+    if is_async:
+        container = make_async_container(provider, context=ctx)
+        assert await container.get(str) == value
+    else:
+        container = make_container(provider, context=ctx)
+        assert container.get(str) == value