Only raise integrationnotfound for dependencies

homeassistant/requirements.py

@@ -8,7 +8,12 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.typing import UNDEFINED, UndefinedType
-from homeassistant.loader import Integration, IntegrationNotFound, async_get_integration
+from homeassistant.loader import (
+    PACKAGE_CUSTOM_COMPONENTS,
+    Integration,
+    IntegrationNotFound,
+    async_get_integration,
+)
 import homeassistant.util.package as pkg_util
 
 # mypy: disallow-any-generics
@@ -97,12 +102,21 @@ async def async_get_integration_with_requirements(
             deps_to_check.append(check_domain)
 
     if deps_to_check:
-        await asyncio.gather(
+        results = await asyncio.gather(
             *[
                 async_get_integration_with_requirements(hass, dep, done)
                 for dep in deps_to_check
-            ]
+            ],
+            return_exceptions=True,
         )
+        for result in results:
+            if not isinstance(result, BaseException):
+                continue
+            if not isinstance(result, IntegrationNotFound) or not (
+                not integration.is_built_in
+                and result.domain in integration.after_dependencies
+            ):
+                raise result
 
     cache[domain] = integration
     event.set()

tests/common.py

@@ -1046,10 +1046,15 @@ async def get_system_health_info(hass, domain):
     return await hass.data["system_health"][domain].info_callback(hass)
 
 
-def mock_integration(hass, module):
+def mock_integration(hass, module, built_in=True):
     """Mock an integration."""
     integration = loader.Integration(
-        hass, f"homeassistant.components.{module.DOMAIN}", None, module.mock_manifest()
+        hass,
+        f"{loader.PACKAGE_BUILTIN}.{module.DOMAIN}"
+        if built_in
+        else f"{loader.PACKAGE_CUSTOM_COMPONENTS}.{module.DOMAIN}",
+        None,
+        module.mock_manifest(),
     )
 
     def mock_import_platform(platform_name):

tests/test_requirements.py

@@ -139,6 +139,69 @@ async def test_get_integration_with_requirements(hass):
     ]
 
 
+async def test_get_integration_with_missing_dependencies(hass):
+    """Check getting an integration with missing dependencies."""
+    hass.config.skip_pip = False
+    mock_integration(
+        hass,
+        MockModule("test_component_after_dep"),
+    )
+    mock_integration(
+        hass,
+        MockModule(
+            "test_component",
+            dependencies=["test_component_dep"],
+            partial_manifest={"after_dependencies": ["test_component_after_dep"]},
+        ),
+    )
+    mock_integration(
+        hass,
+        MockModule(
+            "test_custom_component",
+            dependencies=["test_component_dep"],
+            partial_manifest={"after_dependencies": ["test_component_after_dep"]},
+        ),
+        built_in=False,
+    )
+    with pytest.raises(loader.IntegrationNotFound):
+        await async_get_integration_with_requirements(hass, "test_component")
+    with pytest.raises(loader.IntegrationNotFound):
+        await async_get_integration_with_requirements(hass, "test_custom_component")
+
+
+async def test_get_built_in_integration_with_missing_after_dependencies(hass):
+    """Check getting a built_in integration with missing after_dependencies results in exception."""
+    hass.config.skip_pip = False
+    mock_integration(
+        hass,
+        MockModule(
+            "test_component",
+            partial_manifest={"after_dependencies": ["test_component_after_dep"]},
+        ),
+        built_in=True,
+    )
+    with pytest.raises(loader.IntegrationNotFound):
+        await async_get_integration_with_requirements(hass, "test_component")
+
+
+async def test_get_custom_integration_with_missing_after_dependencies(hass):
+    """Check getting a custom integration with missing after_dependencies."""
+    hass.config.skip_pip = False
+    mock_integration(
+        hass,
+        MockModule(
+            "test_custom_component",
+            partial_manifest={"after_dependencies": ["test_component_after_dep"]},
+        ),
+        built_in=False,
+    )
+    integration = await async_get_integration_with_requirements(
+        hass, "test_custom_component"
+    )
+    assert integration
+    assert integration.domain == "test_custom_component"
+
+
 async def test_install_with_wheels_index(hass):
     """Test an install attempt with wheels index URL."""
     hass.config.skip_pip = False