"""Test the config manager.""" from __future__ import annotations import asyncio from collections.abc import Generator from datetime import timedelta import logging import re from typing import Any, Self from unittest.mock import ANY, AsyncMock, Mock, patch from freezegun import freeze_time from freezegun.api import FrozenDateTimeFactory import pytest from syrupy.assertion import SnapshotAssertion from homeassistant import config_entries, data_entry_flow, loader from homeassistant.components import dhcp from homeassistant.config_entries import ConfigEntry from homeassistant.const import ( CONF_NAME, EVENT_COMPONENT_LOADED, EVENT_HOMEASSISTANT_STARTED, EVENT_HOMEASSISTANT_STOP, ) from homeassistant.core import ( DOMAIN as HOMEASSISTANT_DOMAIN, CoreState, HomeAssistant, callback, ) from homeassistant.data_entry_flow import BaseServiceInfo, FlowResult, FlowResultType from homeassistant.exceptions import ( ConfigEntryAuthFailed, ConfigEntryError, ConfigEntryNotReady, HomeAssistantError, ) from homeassistant.helpers import entity_registry as er, frame, issue_registry as ir from homeassistant.helpers.discovery_flow import DiscoveryKey from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.json import json_dumps from homeassistant.helpers.service_info.hassio import HassioServiceInfo from homeassistant.helpers.typing import ConfigType from homeassistant.helpers.update_coordinator import DataUpdateCoordinator from homeassistant.setup import async_set_domains_to_be_loaded, async_setup_component from homeassistant.util.async_ import create_eager_task import homeassistant.util.dt as dt_util from homeassistant.util.json import json_loads from .common import ( MockConfigEntry, MockEntity, MockModule, MockPlatform, async_capture_events, async_fire_time_changed, async_get_persistent_notifications, flush_store, mock_config_flow, mock_integration, mock_platform, ) @pytest.fixture(autouse=True) def mock_handlers() -> Generator[None]: """Mock config flows.""" class MockFlowHandler(config_entries.ConfigFlow): """Define a mock flow handler.""" VERSION = 1 async def async_step_reauth(self, data): """Mock Reauth.""" return await self.async_step_reauth_confirm() async def async_step_reauth_confirm(self, user_input=None): """Test reauth confirm step.""" if user_input is None: return self.async_show_form(step_id="reauth_confirm") return self.async_abort(reason="test") async def async_step_reconfigure(self, data): """Mock Reauth.""" return await self.async_step_reauth_confirm() class MockFlowHandler2(config_entries.ConfigFlow): """Define a second mock flow handler.""" VERSION = 1 async def async_step_reauth(self, data): """Mock Reauth.""" return await self.async_step_reauth_confirm() async def async_step_reauth_confirm(self, user_input=None): """Test reauth confirm step.""" if user_input is None: return self.async_show_form( step_id="reauth_confirm", description_placeholders={CONF_NAME: "Custom title"}, ) return self.async_abort(reason="test") with patch.dict( config_entries.HANDLERS, {"comp": MockFlowHandler, "test": MockFlowHandler, "test2": MockFlowHandler2}, ): yield @pytest.fixture async def manager(hass: HomeAssistant) -> config_entries.ConfigEntries: """Fixture of a loaded config manager.""" manager = config_entries.ConfigEntries(hass, {}) await manager.async_initialize() hass.config_entries = manager return manager async def test_setup_race_only_setup_once(hass: HomeAssistant) -> None: """Test ensure that config entries are only setup once.""" attempts = 0 slow_config_entry_setup_future = hass.loop.create_future() fast_config_entry_setup_future = hass.loop.create_future() slow_setup_future = hass.loop.create_future() async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: """Mock setup.""" await slow_setup_future return True async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock setup entry.""" slow = entry.data["slow"] if slow: await slow_config_entry_setup_future return True nonlocal attempts attempts += 1 if attempts == 1: raise ConfigEntryNotReady await fast_config_entry_setup_future return True async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock unload entry.""" return True mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) entry = MockConfigEntry(domain="comp", data={"slow": False}) entry.add_to_hass(hass) entry2 = MockConfigEntry(domain="comp", data={"slow": True}) entry2.add_to_hass(hass) await entry2.setup_lock.acquire() async def _async_reload_entry(entry: MockConfigEntry): async with entry.setup_lock: await entry.async_unload(hass) await entry.async_setup(hass) hass.async_create_task(_async_reload_entry(entry2)) setup_task = hass.async_create_task(async_setup_component(hass, "comp", {})) entry2.setup_lock.release() assert entry.state is config_entries.ConfigEntryState.NOT_LOADED assert entry2.state is config_entries.ConfigEntryState.NOT_LOADED assert "comp" not in hass.config.components slow_setup_future.set_result(None) await asyncio.sleep(0) assert "comp" in hass.config.components assert entry.state is config_entries.ConfigEntryState.SETUP_RETRY assert entry2.state is config_entries.ConfigEntryState.SETUP_IN_PROGRESS fast_config_entry_setup_future.set_result(None) # Make sure setup retry is started async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=5)) slow_config_entry_setup_future.set_result(None) await hass.async_block_till_done() assert entry.state is config_entries.ConfigEntryState.LOADED await hass.async_block_till_done() assert attempts == 2 await hass.async_block_till_done() assert setup_task.done() assert entry2.state is config_entries.ConfigEntryState.LOADED async def test_call_setup_entry(hass: HomeAssistant) -> None: """Test we call .setup_entry.""" entry = MockConfigEntry(domain="comp") entry.add_to_hass(hass) assert not entry.supports_unload mock_setup_entry = AsyncMock(return_value=True) mock_migrate_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup_entry=mock_setup_entry, async_migrate_entry=mock_migrate_entry, ), ) mock_platform(hass, "comp.config_flow", None) with patch("homeassistant.config_entries.support_entry_unload", return_value=True): result = await async_setup_component(hass, "comp", {}) await hass.async_block_till_done() assert result assert len(mock_migrate_entry.mock_calls) == 0 assert len(mock_setup_entry.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED assert entry.supports_unload async def test_call_setup_entry_without_reload_support(hass: HomeAssistant) -> None: """Test we call .setup_entry and the does not support unloading.""" entry = MockConfigEntry(domain="comp") entry.add_to_hass(hass) assert not entry.supports_unload mock_setup_entry = AsyncMock(return_value=True) mock_migrate_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup_entry=mock_setup_entry, async_migrate_entry=mock_migrate_entry, ), ) mock_platform(hass, "comp.config_flow", None) with patch("homeassistant.config_entries.support_entry_unload", return_value=False): result = await async_setup_component(hass, "comp", {}) await hass.async_block_till_done() assert result assert len(mock_migrate_entry.mock_calls) == 0 assert len(mock_setup_entry.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED assert not entry.supports_unload @pytest.mark.parametrize(("major_version", "minor_version"), [(2, 1), (1, 2), (2, 2)]) async def test_call_async_migrate_entry( hass: HomeAssistant, major_version: int, minor_version: int ) -> None: """Test we call .async_migrate_entry when version mismatch.""" entry = MockConfigEntry( domain="comp", version=major_version, minor_version=minor_version ) assert not entry.supports_unload entry.add_to_hass(hass) mock_migrate_entry = AsyncMock(return_value=True) mock_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup_entry=mock_setup_entry, async_migrate_entry=mock_migrate_entry, ), ) mock_platform(hass, "comp.config_flow", None) with patch("homeassistant.config_entries.support_entry_unload", return_value=True): result = await async_setup_component(hass, "comp", {}) await hass.async_block_till_done() assert result assert len(mock_migrate_entry.mock_calls) == 1 assert len(mock_setup_entry.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED assert entry.supports_unload @pytest.mark.parametrize(("major_version", "minor_version"), [(2, 1), (1, 2), (2, 2)]) async def test_call_async_migrate_entry_failure_false( hass: HomeAssistant, major_version: int, minor_version: int ) -> None: """Test migration fails if returns false.""" entry = MockConfigEntry( domain="comp", version=major_version, minor_version=minor_version ) entry.add_to_hass(hass) assert not entry.supports_unload mock_migrate_entry = AsyncMock(return_value=False) mock_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup_entry=mock_setup_entry, async_migrate_entry=mock_migrate_entry, ), ) mock_platform(hass, "comp.config_flow", None) result = await async_setup_component(hass, "comp", {}) assert result assert len(mock_migrate_entry.mock_calls) == 1 assert len(mock_setup_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.MIGRATION_ERROR assert not entry.supports_unload @pytest.mark.parametrize(("major_version", "minor_version"), [(2, 1), (1, 2), (2, 2)]) async def test_call_async_migrate_entry_failure_exception( hass: HomeAssistant, major_version: int, minor_version: int ) -> None: """Test migration fails if exception raised.""" entry = MockConfigEntry( domain="comp", version=major_version, minor_version=minor_version ) entry.add_to_hass(hass) assert not entry.supports_unload mock_migrate_entry = AsyncMock(side_effect=Exception) mock_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup_entry=mock_setup_entry, async_migrate_entry=mock_migrate_entry, ), ) mock_platform(hass, "comp.config_flow", None) result = await async_setup_component(hass, "comp", {}) assert result assert len(mock_migrate_entry.mock_calls) == 1 assert len(mock_setup_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.MIGRATION_ERROR assert not entry.supports_unload @pytest.mark.parametrize(("major_version", "minor_version"), [(2, 1), (1, 2), (2, 2)]) async def test_call_async_migrate_entry_failure_not_bool( hass: HomeAssistant, major_version: int, minor_version: int ) -> None: """Test migration fails if boolean not returned.""" entry = MockConfigEntry( domain="comp", version=major_version, minor_version=minor_version ) entry.add_to_hass(hass) assert not entry.supports_unload mock_migrate_entry = AsyncMock(return_value=None) mock_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup_entry=mock_setup_entry, async_migrate_entry=mock_migrate_entry, ), ) mock_platform(hass, "comp.config_flow", None) result = await async_setup_component(hass, "comp", {}) assert result assert len(mock_migrate_entry.mock_calls) == 1 assert len(mock_setup_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.MIGRATION_ERROR assert not entry.supports_unload @pytest.mark.parametrize(("major_version", "minor_version"), [(2, 1), (2, 2)]) async def test_call_async_migrate_entry_failure_not_supported( hass: HomeAssistant, major_version: int, minor_version: int ) -> None: """Test migration fails if async_migrate_entry not implemented.""" entry = MockConfigEntry( domain="comp", version=major_version, minor_version=minor_version ) entry.add_to_hass(hass) assert not entry.supports_unload mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_setup_entry=mock_setup_entry)) mock_platform(hass, "comp.config_flow", None) result = await async_setup_component(hass, "comp", {}) assert result assert len(mock_setup_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.MIGRATION_ERROR assert not entry.supports_unload @pytest.mark.parametrize(("major_version", "minor_version"), [(1, 2)]) async def test_call_async_migrate_entry_not_supported_minor_version( hass: HomeAssistant, major_version: int, minor_version: int ) -> None: """Test migration without async_migrate_entry and minor version changed.""" entry = MockConfigEntry( domain="comp", version=major_version, minor_version=minor_version ) entry.add_to_hass(hass) assert not entry.supports_unload mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_setup_entry=mock_setup_entry)) mock_platform(hass, "comp.config_flow", None) result = await async_setup_component(hass, "comp", {}) assert result assert len(mock_setup_entry.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED assert not entry.supports_unload async def test_remove_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries, entity_registry: er.EntityRegistry, ) -> None: """Test that we can remove an entry.""" async def mock_setup_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock setting up entry.""" await hass.config_entries.async_forward_entry_setups(entry, ["light"]) return True async def mock_unload_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock unloading an entry.""" result = await hass.config_entries.async_unload_platforms(entry, ["light"]) assert result return result mock_remove_entry = AsyncMock(return_value=None) entity = MockEntity(unique_id="1234", name="Test Entity") async def mock_setup_entry_platform( hass: HomeAssistant, entry: config_entries.ConfigEntry, async_add_entities: AddEntitiesCallback, ) -> None: """Mock setting up platform.""" async_add_entities([entity]) mock_integration( hass, MockModule( "test", async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, async_remove_entry=mock_remove_entry, ), ) mock_platform( hass, "test.light", MockPlatform(async_setup_entry=mock_setup_entry_platform) ) mock_platform(hass, "test.config_flow", None) MockConfigEntry(domain="test_other", entry_id="test1").add_to_manager(manager) entry = MockConfigEntry(domain="test", entry_id="test2") entry.add_to_manager(manager) MockConfigEntry(domain="test_other", entry_id="test3").add_to_manager(manager) # Check all config entries exist assert manager.async_entry_ids() == [ "test1", "test2", "test3", ] # Setup entry await manager.async_setup(entry.entry_id) await hass.async_block_till_done() # Check entity state got added assert hass.states.get("light.test_entity") is not None assert len(hass.states.async_all()) == 1 # Check entity got added to entity registry assert len(entity_registry.entities) == 1 entity_entry = list(entity_registry.entities.values())[0] assert entity_entry.config_entry_id == entry.entry_id # Remove entry result = await manager.async_remove("test2") await hass.async_block_till_done() # Check that unload went well and so no need to restart assert result == {"require_restart": False} # Check the remove callback was invoked. assert mock_remove_entry.call_count == 1 # Check that config entry was removed. assert manager.async_entry_ids() == ["test1", "test3"] # Check that entity state has been removed assert hass.states.get("light.test_entity") is None assert len(hass.states.async_all()) == 0 # Check that entity registry entry has been removed entity_entry_list = list(entity_registry.entities.values()) assert not entity_entry_list async def test_remove_entry_non_unique_unique_id( hass: HomeAssistant, manager: config_entries.ConfigEntries, entity_registry: er.EntityRegistry, ) -> None: """Test that we can remove entry with colliding unique_id.""" entry_1 = MockConfigEntry( domain="test_other", entry_id="test1", unique_id="not_unique" ) entry_1.add_to_manager(manager) entry_2 = MockConfigEntry( domain="test_other", entry_id="test2", unique_id="not_unique" ) entry_2.add_to_manager(manager) entry_3 = MockConfigEntry( domain="test_other", entry_id="test3", unique_id="not_unique" ) entry_3.add_to_manager(manager) # Check all config entries exist assert manager.async_entry_ids() == [ "test1", "test2", "test3", ] # Remove entries assert await manager.async_remove("test1") == {"require_restart": False} await hass.async_block_till_done() assert await manager.async_remove("test2") == {"require_restart": False} await hass.async_block_till_done() assert await manager.async_remove("test3") == {"require_restart": False} await hass.async_block_till_done() async def test_remove_entry_cancels_reauth( hass: HomeAssistant, manager: config_entries.ConfigEntries, issue_registry: ir.IssueRegistry, ) -> None: """Tests that removing a config entry, also aborts existing reauth flows.""" entry = MockConfigEntry(title="test_title", domain="test") mock_setup_entry = AsyncMock(side_effect=ConfigEntryAuthFailed()) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) entry.add_to_hass(hass) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() flows = hass.config_entries.flow.async_progress_by_handler("test") assert len(flows) == 1 assert flows[0]["context"]["entry_id"] == entry.entry_id assert flows[0]["context"]["source"] == config_entries.SOURCE_REAUTH assert entry.state is config_entries.ConfigEntryState.SETUP_ERROR issue_id = f"config_entry_reauth_test_{entry.entry_id}" assert issue_registry.async_get_issue(HOMEASSISTANT_DOMAIN, issue_id) await manager.async_remove(entry.entry_id) flows = hass.config_entries.flow.async_progress_by_handler("test") assert len(flows) == 0 assert not issue_registry.async_get_issue(HOMEASSISTANT_DOMAIN, issue_id) async def test_remove_entry_handles_callback_error( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that exceptions in the remove callback are handled.""" mock_setup_entry = AsyncMock(return_value=True) mock_unload_entry = AsyncMock(return_value=True) mock_remove_entry = AsyncMock(return_value=None) mock_integration( hass, MockModule( "test", async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, async_remove_entry=mock_remove_entry, ), ) entry = MockConfigEntry(domain="test", entry_id="test1") entry.add_to_manager(manager) # Check all config entries exist assert manager.async_entry_ids() == ["test1"] # Setup entry await manager.async_setup(entry.entry_id) await hass.async_block_till_done() # Remove entry result = await manager.async_remove("test1") await hass.async_block_till_done() # Check that unload went well and so no need to restart assert result == {"require_restart": False} # Check the remove callback was invoked. assert mock_remove_entry.call_count == 1 # Check that config entry was removed. assert manager.async_entry_ids() == [] async def test_remove_entry_raises( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test if a component raises while removing entry.""" async def mock_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock unload entry function.""" raise Exception("BROKEN") # noqa: TRY002 mock_integration(hass, MockModule("comp", async_unload_entry=mock_unload_entry)) MockConfigEntry(domain="test", entry_id="test1").add_to_manager(manager) MockConfigEntry( domain="comp", entry_id="test2", state=config_entries.ConfigEntryState.LOADED ).add_to_manager(manager) MockConfigEntry(domain="test", entry_id="test3").add_to_manager(manager) assert manager.async_entry_ids() == [ "test1", "test2", "test3", ] result = await manager.async_remove("test2") assert result == {"require_restart": True} assert manager.async_entry_ids() == ["test1", "test3"] async def test_remove_entry_if_not_loaded( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can remove an entry that is not loaded.""" mock_unload_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_unload_entry=mock_unload_entry)) MockConfigEntry(domain="test", entry_id="test1").add_to_manager(manager) MockConfigEntry(domain="comp", entry_id="test2").add_to_manager(manager) MockConfigEntry(domain="test", entry_id="test3").add_to_manager(manager) assert manager.async_entry_ids() == [ "test1", "test2", "test3", ] result = await manager.async_remove("test2") assert result == {"require_restart": False} assert manager.async_entry_ids() == ["test1", "test3"] assert len(mock_unload_entry.mock_calls) == 0 async def test_remove_entry_if_integration_deleted( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can remove an entry when the integration is deleted.""" mock_unload_entry = AsyncMock(return_value=True) MockConfigEntry(domain="test", entry_id="test1").add_to_manager(manager) MockConfigEntry(domain="comp", entry_id="test2").add_to_manager(manager) MockConfigEntry(domain="test", entry_id="test3").add_to_manager(manager) assert manager.async_entry_ids() == [ "test1", "test2", "test3", ] result = await manager.async_remove("test2") assert result == {"require_restart": False} assert manager.async_entry_ids() == ["test1", "test3"] assert len(mock_unload_entry.mock_calls) == 0 async def test_add_entry_calls_setup_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test we call setup_config_entry.""" mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_setup_entry=mock_setup_entry)) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" return self.async_create_entry(title="title", data={"token": "supersecret"}) with mock_config_flow("comp", TestFlow), mock_config_flow("invalid_flow", 5): await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() assert len(mock_setup_entry.mock_calls) == 1 p_hass, p_entry = mock_setup_entry.mock_calls[0][1] assert p_hass is hass assert p_entry.data == {"token": "supersecret"} async def test_entries_gets_entries(manager: config_entries.ConfigEntries) -> None: """Test entries are filtered by domain.""" MockConfigEntry(domain="test").add_to_manager(manager) entry1 = MockConfigEntry(domain="test2") entry1.add_to_manager(manager) entry2 = MockConfigEntry(domain="test2") entry2.add_to_manager(manager) assert manager.async_entries("test2") == [entry1, entry2] async def test_domains_gets_domains_uniques( manager: config_entries.ConfigEntries, ) -> None: """Test we only return each domain once.""" MockConfigEntry(domain="test").add_to_manager(manager) MockConfigEntry(domain="test2").add_to_manager(manager) MockConfigEntry(domain="test2").add_to_manager(manager) MockConfigEntry(domain="test").add_to_manager(manager) MockConfigEntry(domain="test3").add_to_manager(manager) assert manager.async_domains() == ["test", "test2", "test3"] async def test_domains_gets_domains_excludes_ignore_and_disabled( manager: config_entries.ConfigEntries, ) -> None: """Test we only return each domain once.""" MockConfigEntry(domain="test").add_to_manager(manager) MockConfigEntry(domain="test2").add_to_manager(manager) MockConfigEntry(domain="test2").add_to_manager(manager) MockConfigEntry( domain="ignored", source=config_entries.SOURCE_IGNORE ).add_to_manager(manager) MockConfigEntry(domain="test3").add_to_manager(manager) MockConfigEntry( domain="disabled", disabled_by=config_entries.ConfigEntryDisabler.USER ).add_to_manager(manager) assert manager.async_domains() == ["test", "test2", "test3"] assert manager.async_domains(include_ignore=False) == ["test", "test2", "test3"] assert manager.async_domains(include_disabled=False) == ["test", "test2", "test3"] assert manager.async_domains(include_ignore=False, include_disabled=False) == [ "test", "test2", "test3", ] assert manager.async_domains(include_ignore=True) == [ "test", "test2", "ignored", "test3", ] assert manager.async_domains(include_disabled=True) == [ "test", "test2", "test3", "disabled", ] assert manager.async_domains(include_ignore=True, include_disabled=True) == [ "test", "test2", "ignored", "test3", "disabled", ] async def test_entries_excludes_ignore_and_disabled( manager: config_entries.ConfigEntries, ) -> None: """Test ignored and disabled entries are returned by default.""" entry = MockConfigEntry(domain="test") entry.add_to_manager(manager) entry2a = MockConfigEntry(domain="test2") entry2a.add_to_manager(manager) entry2b = MockConfigEntry(domain="test2") entry2b.add_to_manager(manager) entry_ignored = MockConfigEntry( domain="ignored", source=config_entries.SOURCE_IGNORE ) entry_ignored.add_to_manager(manager) entry3 = MockConfigEntry(domain="test3") entry3.add_to_manager(manager) disabled_entry = MockConfigEntry( domain="disabled", disabled_by=config_entries.ConfigEntryDisabler.USER ) disabled_entry.add_to_manager(manager) assert manager.async_entries() == [ entry, entry2a, entry2b, entry_ignored, entry3, disabled_entry, ] assert manager.async_has_entries("test") is True assert manager.async_has_entries("test2") is True assert manager.async_has_entries("test3") is True assert manager.async_has_entries("ignored") is True assert manager.async_has_entries("disabled") is True assert manager.async_has_entries("not") is False assert manager.async_entries(include_ignore=False) == [ entry, entry2a, entry2b, entry3, disabled_entry, ] assert manager.async_entries(include_disabled=False) == [ entry, entry2a, entry2b, entry_ignored, entry3, ] assert manager.async_entries(include_ignore=False, include_disabled=False) == [ entry, entry2a, entry2b, entry3, ] assert manager.async_has_entries("test", include_ignore=False) is True assert manager.async_has_entries("test2", include_ignore=False) is True assert manager.async_has_entries("test3", include_ignore=False) is True assert manager.async_has_entries("ignored", include_ignore=False) is False assert manager.async_entries(include_ignore=True) == [ entry, entry2a, entry2b, entry_ignored, entry3, disabled_entry, ] assert manager.async_entries(include_disabled=True) == [ entry, entry2a, entry2b, entry_ignored, entry3, disabled_entry, ] assert manager.async_entries(include_ignore=True, include_disabled=True) == [ entry, entry2a, entry2b, entry_ignored, entry3, disabled_entry, ] assert manager.async_has_entries("test", include_disabled=False) is True assert manager.async_has_entries("test2", include_disabled=False) is True assert manager.async_has_entries("test3", include_disabled=False) is True assert manager.async_has_entries("disabled", include_disabled=False) is False async def test_saving_and_loading( hass: HomeAssistant, freezer: FrozenDateTimeFactory ) -> None: """Test that we're saving and loading correctly.""" mock_integration( hass, MockModule("test", async_setup_entry=AsyncMock(return_value=True)), ) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 5 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("unique") return self.async_create_entry(title="Test Title", data={"token": "abcd"}) with mock_config_flow("test", TestFlow): await hass.config_entries.flow.async_init( "test", context={"source": config_entries.SOURCE_USER} ) class Test2Flow(config_entries.ConfigFlow): """Test flow.""" VERSION = 3 async def async_step_user(self, user_input=None): """Test user step.""" return self.async_create_entry( title="Test 2 Title", data={"username": "bla"} ) with patch("homeassistant.config_entries.HANDLERS.get", return_value=Test2Flow): await hass.config_entries.flow.async_init( "test", context={ "source": config_entries.SOURCE_USER, "discovery_key": DiscoveryKey(domain="test", key=("blah"), version=1), }, ) await hass.config_entries.flow.async_init( "test", context={ "source": config_entries.SOURCE_USER, "discovery_key": DiscoveryKey(domain="test", key=("a", "b"), version=1), }, ) assert len(hass.config_entries.async_entries()) == 3 entry_1 = hass.config_entries.async_entries()[0] hass.config_entries.async_update_entry( entry_1, pref_disable_polling=True, pref_disable_new_entities=True, ) # To trigger the call_later freezer.tick(1.0) async_fire_time_changed(hass) # To execute the save await hass.async_block_till_done() # Now load written data in new config manager manager = config_entries.ConfigEntries(hass, {}) await manager.async_initialize() assert len(manager.async_entries()) == 3 # Ensure same order for orig, loaded in zip( hass.config_entries.async_entries(), manager.async_entries(), strict=False ): assert orig.as_dict() == loaded.as_dict() @freeze_time("2024-02-14 12:00:00") async def test_as_dict(snapshot: SnapshotAssertion) -> None: """Test ConfigEntry.as_dict.""" # Ensure as_dict is not overridden assert MockConfigEntry.as_dict is config_entries.ConfigEntry.as_dict excluded_from_dict = { "supports_unload", "supports_remove_device", "state", "_setup_lock", "update_listeners", "reason", "error_reason_translation_key", "error_reason_translation_placeholders", "_async_cancel_retry_setup", "_on_unload", "setup_lock", "_reauth_lock", "_tasks", "_background_tasks", "_integration_for_domain", "_tries", "_setup_again_job", "_supports_options", "supports_reconfigure", } entry = MockConfigEntry(entry_id="mock-entry") # Make sure the expected keys are present dict_repr = entry.as_dict() for key in config_entries.ConfigEntry.__dict__: func = getattr(config_entries.ConfigEntry, key) if ( key.startswith("__") or callable(func) or type(func).__name__ in ("cached_property", "property") ): continue assert key in dict_repr or key in excluded_from_dict assert not (key in dict_repr and key in excluded_from_dict) # Make sure the dict representation is as expected assert dict_repr == snapshot async def test_forward_entry_sets_up_component(hass: HomeAssistant) -> None: """Test we setup the component entry is forwarded to.""" entry = MockConfigEntry( domain="original", state=config_entries.ConfigEntryState.LOADED ) mock_original_setup_entry = AsyncMock(return_value=True) integration = mock_integration( hass, MockModule("original", async_setup_entry=mock_original_setup_entry) ) mock_forwarded_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule("forwarded", async_setup_entry=mock_forwarded_setup_entry) ) with patch.object(integration, "async_get_platforms") as mock_async_get_platforms: await hass.config_entries.async_forward_entry_setups(entry, ["forwarded"]) mock_async_get_platforms.assert_called_once_with(["forwarded"]) assert len(mock_original_setup_entry.mock_calls) == 0 assert len(mock_forwarded_setup_entry.mock_calls) == 1 async def test_forward_entry_does_not_setup_entry_if_setup_fails( hass: HomeAssistant, ) -> None: """Test we do not set up entry if component setup fails.""" entry = MockConfigEntry( domain="original", state=config_entries.ConfigEntryState.LOADED ) mock_original_setup_entry = AsyncMock(return_value=True) integration = mock_integration( hass, MockModule("original", async_setup_entry=mock_original_setup_entry) ) mock_setup = AsyncMock(return_value=False) mock_setup_entry = AsyncMock() mock_integration( hass, MockModule( "forwarded", async_setup=mock_setup, async_setup_entry=mock_setup_entry ), ) with patch.object(integration, "async_get_platforms"): await hass.config_entries.async_forward_entry_setups(entry, ["forwarded"]) assert len(mock_setup.mock_calls) == 1 assert len(mock_setup_entry.mock_calls) == 0 async def test_async_forward_entry_setup_deprecated( hass: HomeAssistant, caplog: pytest.LogCaptureFixture ) -> None: """Test async_forward_entry_setup is deprecated.""" entry = MockConfigEntry( domain="original", state=config_entries.ConfigEntryState.LOADED ) mock_original_setup_entry = AsyncMock(return_value=True) integration = mock_integration( hass, MockModule("original", async_setup_entry=mock_original_setup_entry) ) mock_setup = AsyncMock(return_value=False) mock_setup_entry = AsyncMock() mock_integration( hass, MockModule( "forwarded", async_setup=mock_setup, async_setup_entry=mock_setup_entry ), ) entry_id = entry.entry_id caplog.clear() with patch.object(integration, "async_get_platforms"): async with entry.setup_lock: await hass.config_entries.async_forward_entry_setup(entry, "forwarded") assert ( "Detected code that calls async_forward_entry_setup for integration, " f"original with title: Mock Title and entry_id: {entry_id}, " "which is deprecated and will stop working in Home Assistant 2025.6, " "await async_forward_entry_setups instead. Please report this issue." ) in caplog.text async def test_discovery_notification( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we create/dismiss a notification when source is discovery.""" mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 5 async def async_step_discovery(self, discovery_info): """Test discovery step.""" return self.async_show_form(step_id="discovery_confirm") async def async_step_discovery_confirm(self, discovery_info): """Test discovery confirm step.""" return self.async_create_entry(title="Test Title", data={"token": "abcd"}) with mock_config_flow("test", TestFlow): notifications = async_get_persistent_notifications(hass) assert "config_entry_discovery" not in notifications # Start first discovery flow to assert that reconfigure notification fires flow1 = await hass.config_entries.flow.async_init( "test", context={"source": config_entries.SOURCE_DISCOVERY} ) await hass.async_block_till_done() notifications = async_get_persistent_notifications(hass) assert "config_entry_discovery" in notifications # Start a second discovery flow so we can finish the first and assert that # the discovery notification persists until the second one is complete flow2 = await hass.config_entries.flow.async_init( "test", context={"source": config_entries.SOURCE_DISCOVERY} ) flow1 = await hass.config_entries.flow.async_configure(flow1["flow_id"], {}) assert flow1["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY await hass.async_block_till_done() notifications = async_get_persistent_notifications(hass) assert "config_entry_discovery" in notifications flow2 = await hass.config_entries.flow.async_configure(flow2["flow_id"], {}) assert flow2["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY await hass.async_block_till_done() notifications = async_get_persistent_notifications(hass) assert "config_entry_discovery" not in notifications async def test_reauth_notification(hass: HomeAssistant) -> None: """Test that we create/dismiss a notification when source is reauth.""" mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 5 async def async_step_user(self, user_input): """Test user step.""" return self.async_show_form(step_id="user_confirm") async def async_step_user_confirm(self, user_input): """Test user confirm step.""" return self.async_show_form(step_id="user_confirm") async def async_step_reauth(self, user_input): """Test reauth step.""" return self.async_show_form(step_id="reauth_confirm") async def async_step_reauth_confirm(self, user_input): """Test reauth confirm step.""" return self.async_abort(reason="test") with mock_config_flow("test", TestFlow): # Start user flow to assert that reconfigure notification doesn't fire await hass.config_entries.flow.async_init( "test", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() notifications = async_get_persistent_notifications(hass) assert "config_entry_reconfigure" not in notifications # Start first reauth flow to assert that reconfigure notification fires flow1 = await hass.config_entries.flow.async_init( "test", context={ "source": config_entries.SOURCE_REAUTH, "entry_id": entry.entry_id, }, ) await hass.async_block_till_done() notifications = async_get_persistent_notifications(hass) assert "config_entry_reconfigure" in notifications # Start a second reauth flow so we can finish the first and assert that # the reconfigure notification persists until the second one is complete flow2 = await hass.config_entries.flow.async_init( "test", context={ "source": config_entries.SOURCE_REAUTH, "entry_id": entry.entry_id, }, ) flow1 = await hass.config_entries.flow.async_configure(flow1["flow_id"], {}) assert flow1["type"] == data_entry_flow.FlowResultType.ABORT await hass.async_block_till_done() notifications = async_get_persistent_notifications(hass) assert "config_entry_reconfigure" in notifications flow2 = await hass.config_entries.flow.async_configure(flow2["flow_id"], {}) assert flow2["type"] == data_entry_flow.FlowResultType.ABORT await hass.async_block_till_done() notifications = async_get_persistent_notifications(hass) assert "config_entry_reconfigure" not in notifications async def test_reauth_issue( hass: HomeAssistant, manager: config_entries.ConfigEntries, issue_registry: ir.IssueRegistry, ) -> None: """Test that we create/delete an issue when source is reauth.""" assert len(issue_registry.issues) == 0 entry = MockConfigEntry(title="test_title", domain="test") mock_setup_entry = AsyncMock(side_effect=ConfigEntryAuthFailed()) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) entry.add_to_hass(hass) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() flows = hass.config_entries.flow.async_progress_by_handler("test") assert len(flows) == 1 assert len(issue_registry.issues) == 1 issue_id = f"config_entry_reauth_test_{entry.entry_id}" issue = issue_registry.async_get_issue(HOMEASSISTANT_DOMAIN, issue_id) assert issue == ir.IssueEntry( active=True, breaks_in_ha_version=None, created=ANY, data={"flow_id": flows[0]["flow_id"]}, dismissed_version=None, domain=HOMEASSISTANT_DOMAIN, is_fixable=False, is_persistent=False, issue_domain="test", issue_id=issue_id, learn_more_url=None, severity=ir.IssueSeverity.ERROR, translation_key="config_entry_reauth", translation_placeholders={"name": "test_title"}, ) result = await hass.config_entries.flow.async_configure(issue.data["flow_id"], {}) assert result["type"] == FlowResultType.ABORT assert len(issue_registry.issues) == 0 async def test_discovery_notification_not_created(hass: HomeAssistant) -> None: """Test that we not create a notification when discovery is aborted.""" mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 5 async def async_step_discovery(self, discovery_info): """Test discovery step.""" return self.async_abort(reason="test") with mock_config_flow("test", TestFlow): await hass.config_entries.flow.async_init( "test", context={"source": config_entries.SOURCE_DISCOVERY} ) await hass.async_block_till_done() state = hass.states.get("persistent_notification.config_entry_discovery") assert state is None async def test_loading_default_config(hass: HomeAssistant) -> None: """Test loading the default config.""" manager = config_entries.ConfigEntries(hass, {}) with patch("homeassistant.util.json.open", side_effect=FileNotFoundError): await manager.async_initialize() assert len(manager.async_entries()) == 0 async def test_updating_entry_data( manager: config_entries.ConfigEntries, freezer: FrozenDateTimeFactory ) -> None: """Test that we can update an entry data.""" created = dt_util.utcnow() entry = MockConfigEntry( domain="test", data={"first": True}, state=config_entries.ConfigEntryState.SETUP_ERROR, ) entry.add_to_manager(manager) assert len(manager.async_entries()) == 1 assert manager.async_entries()[0] == entry assert entry.created_at == created assert entry.modified_at == created freezer.tick() assert manager.async_update_entry(entry) is False assert entry.data == {"first": True} assert entry.modified_at == created assert manager.async_entries()[0].modified_at == created freezer.tick() modified = dt_util.utcnow() assert manager.async_update_entry(entry, data={"second": True}) is True assert entry.data == {"second": True} assert entry.modified_at == modified assert manager.async_entries()[0].modified_at == modified async def test_updating_entry_system_options( manager: config_entries.ConfigEntries, freezer: FrozenDateTimeFactory ) -> None: """Test that we can update an entry data.""" created = dt_util.utcnow() entry = MockConfigEntry( domain="test", data={"first": True}, state=config_entries.ConfigEntryState.SETUP_ERROR, pref_disable_new_entities=True, ) entry.add_to_manager(manager) assert entry.pref_disable_new_entities is True assert entry.pref_disable_polling is False assert entry.created_at == created assert entry.modified_at == created freezer.tick() modified = dt_util.utcnow() manager.async_update_entry( entry, pref_disable_new_entities=False, pref_disable_polling=True ) assert entry.pref_disable_new_entities is False assert entry.pref_disable_polling is True assert entry.created_at == created assert entry.modified_at == modified async def test_update_entry_options_and_trigger_listener( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can update entry options and trigger listener.""" entry = MockConfigEntry(domain="test", options={"first": True}) entry.add_to_manager(manager) update_listener_calls = [] async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None: """Test function.""" assert entry.options == {"second": True} update_listener_calls.append(None) entry.add_update_listener(update_listener) assert manager.async_update_entry(entry, options={"second": True}) is True await hass.async_block_till_done(wait_background_tasks=True) assert entry.options == {"second": True} assert len(update_listener_calls) == 1 async def test_setup_raise_not_ready( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test a setup raising not ready.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) mock_setup_entry = AsyncMock( side_effect=ConfigEntryNotReady("The internet connection is offline") ) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) with patch("homeassistant.config_entries.async_call_later") as mock_call: await manager.async_setup(entry.entry_id) assert len(mock_call.mock_calls) == 1 assert ( "Config entry 'test_title' for test integration not ready yet:" " The internet connection is offline" ) in caplog.text p_hass, p_wait_time, p_setup = mock_call.mock_calls[0][1] assert p_hass is hass assert 5 <= p_wait_time <= 5.5 assert entry.state is config_entries.ConfigEntryState.SETUP_RETRY assert entry.reason == "The internet connection is offline" mock_setup_entry.side_effect = None mock_setup_entry.return_value = True hass.async_run_hass_job(p_setup, None) await hass.async_block_till_done() assert entry.state is config_entries.ConfigEntryState.LOADED assert entry.reason is None async def test_setup_raise_not_ready_from_exception( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test a setup raising not ready from another exception.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) original_exception = HomeAssistantError("The device dropped the connection") config_entry_exception = ConfigEntryNotReady() config_entry_exception.__cause__ = original_exception mock_setup_entry = AsyncMock(side_effect=config_entry_exception) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) with patch("homeassistant.config_entries.async_call_later") as mock_call: await manager.async_setup(entry.entry_id) assert len(mock_call.mock_calls) == 1 assert ( "Config entry 'test_title' for test integration not ready yet: The device" " dropped the connection" in caplog.text ) async def test_setup_retrying_during_unload( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test if we unload an entry that is in retry mode.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) mock_setup_entry = AsyncMock(side_effect=ConfigEntryNotReady) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) with patch("homeassistant.config_entries.async_call_later") as mock_call: await manager.async_setup(entry.entry_id) assert entry.state is config_entries.ConfigEntryState.SETUP_RETRY assert len(mock_call.return_value.mock_calls) == 0 await manager.async_unload(entry.entry_id) assert entry.state is config_entries.ConfigEntryState.NOT_LOADED assert len(mock_call.return_value.mock_calls) == 1 async def test_setup_retrying_during_unload_before_started( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test if we unload an entry that is in retry mode before started.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) hass.set_state(CoreState.starting) initial_listeners = hass.bus.async_listeners()[EVENT_HOMEASSISTANT_STARTED] mock_setup_entry = AsyncMock(side_effect=ConfigEntryNotReady) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert entry.state is config_entries.ConfigEntryState.SETUP_RETRY assert ( hass.bus.async_listeners()[EVENT_HOMEASSISTANT_STARTED] == initial_listeners + 1 ) await manager.async_unload(entry.entry_id) await hass.async_block_till_done() assert entry.state is config_entries.ConfigEntryState.NOT_LOADED assert ( hass.bus.async_listeners()[EVENT_HOMEASSISTANT_STARTED] == initial_listeners + 0 ) async def test_setup_does_not_retry_during_shutdown( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test we do not retry when HASS is shutting down.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) mock_setup_entry = AsyncMock(side_effect=ConfigEntryNotReady) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) assert entry.state is config_entries.ConfigEntryState.SETUP_RETRY assert len(mock_setup_entry.mock_calls) == 1 hass.set_state(CoreState.stopping) async_fire_time_changed(hass, dt_util.utcnow() + timedelta(minutes=5)) await hass.async_block_till_done() assert entry.state is config_entries.ConfigEntryState.SETUP_RETRY assert len(mock_setup_entry.mock_calls) == 1 async def test_reload_during_setup_retrying_waits(hass: HomeAssistant) -> None: """Test reloading during setup retry waits.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) load_attempts = [] sleep_duration = 0 async def _mock_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock setup entry.""" nonlocal sleep_duration await asyncio.sleep(sleep_duration) load_attempts.append(entry.entry_id) raise ConfigEntryNotReady mock_integration(hass, MockModule("test", async_setup_entry=_mock_setup_entry)) mock_platform(hass, "test.config_flow", None) await hass.async_create_task( hass.config_entries.async_setup(entry.entry_id), eager_start=True ) assert entry.state is config_entries.ConfigEntryState.SETUP_RETRY # Now make the setup take a while so that the setup retry # will still be in progress when the reload request comes in sleep_duration = 0.1 async_fire_time_changed(hass, dt_util.utcnow() + timedelta(minutes=5)) await asyncio.sleep(0) # Should not raise homeassistant.config_entries.OperationNotAllowed await hass.config_entries.async_reload(entry.entry_id) async_fire_time_changed(hass, dt_util.utcnow() + timedelta(minutes=10)) await asyncio.sleep(0) # Should not raise homeassistant.config_entries.OperationNotAllowed hass.config_entries.async_schedule_reload(entry.entry_id) await hass.async_block_till_done() assert load_attempts == [ entry.entry_id, entry.entry_id, entry.entry_id, entry.entry_id, entry.entry_id, ] async def test_create_entry_options( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test a config entry being created with options.""" async def mock_async_setup(hass: HomeAssistant, config: ConfigType) -> bool: """Mock setup.""" hass.async_create_task( hass.config_entries.flow.async_init( "comp", context={"source": config_entries.SOURCE_IMPORT}, data={"data": "data", "option": "option"}, ) ) return True async_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=mock_async_setup, async_setup_entry=async_setup_entry ), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_import(self, user_input): """Test import step creating entry, with options.""" return self.async_create_entry( title="title", data={"example": user_input["data"]}, options={"example": user_input["option"]}, ) with mock_config_flow("comp", TestFlow): assert await async_setup_component(hass, "comp", {}) await hass.async_block_till_done() assert len(async_setup_entry.mock_calls) == 1 entries = hass.config_entries.async_entries("comp") assert len(entries) == 1 assert entries[0].supports_options is False assert entries[0].data == {"example": "data"} assert entries[0].options == {"example": "option"} async def test_entry_options( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can set options on an entry.""" mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) entry = MockConfigEntry(domain="test", data={"first": True}, options=None) entry.add_to_manager(manager) class TestFlow(config_entries.ConfigFlow): """Test flow.""" @staticmethod @callback def async_get_options_flow(config_entry): """Test options flow.""" class OptionsFlowHandler(data_entry_flow.FlowHandler): """Test options flow handler.""" return OptionsFlowHandler() with mock_config_flow("test", TestFlow): flow = await manager.options.async_create_flow( entry.entry_id, context={"source": "test"}, data=None ) flow.handler = entry.entry_id # Used to keep reference to config entry await manager.options.async_finish_flow( flow, { "data": {"second": True}, "type": data_entry_flow.FlowResultType.CREATE_ENTRY, }, ) assert entry.data == {"first": True} assert entry.options == {"second": True} assert entry.supports_options is True async def test_entry_options_abort( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can abort options flow.""" mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) entry = MockConfigEntry(domain="test", data={"first": True}, options=None) entry.add_to_manager(manager) class TestFlow(config_entries.ConfigFlow): """Test flow.""" @staticmethod @callback def async_get_options_flow(config_entry): """Test options flow.""" class OptionsFlowHandler(data_entry_flow.FlowHandler): """Test options flow handler.""" return OptionsFlowHandler() with mock_config_flow("test", TestFlow): flow = await manager.options.async_create_flow( entry.entry_id, context={"source": "test"}, data=None ) flow.handler = entry.entry_id # Used to keep reference to config entry assert await manager.options.async_finish_flow( flow, {"type": data_entry_flow.FlowResultType.ABORT, "reason": "test"} ) async def test_entry_options_unknown_config_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can abort options flow.""" mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) class TestFlow: """Test flow.""" @staticmethod @callback def async_get_options_flow(config_entry): """Test options flow.""" with pytest.raises(config_entries.UnknownEntry): await manager.options.async_create_flow( "blah", context={"source": "test"}, data=None ) async def test_entry_setup_succeed( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can setup an entry.""" entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.NOT_LOADED ) entry.add_to_hass(hass) mock_setup = AsyncMock(return_value=True) mock_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule("comp", async_setup=mock_setup, async_setup_entry=mock_setup_entry), ) mock_platform(hass, "comp.config_flow", None) assert await manager.async_setup(entry.entry_id) assert len(mock_setup.mock_calls) == 1 assert len(mock_setup_entry.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED @pytest.mark.parametrize( "state", [ config_entries.ConfigEntryState.LOADED, config_entries.ConfigEntryState.SETUP_ERROR, config_entries.ConfigEntryState.MIGRATION_ERROR, config_entries.ConfigEntryState.SETUP_RETRY, config_entries.ConfigEntryState.FAILED_UNLOAD, ], ) async def test_entry_setup_invalid_state( hass: HomeAssistant, manager: config_entries.ConfigEntries, state: config_entries.ConfigEntryState, ) -> None: """Test that we cannot setup an entry with invalid state.""" entry = MockConfigEntry(domain="comp", state=state) entry.add_to_hass(hass) mock_setup = AsyncMock(return_value=True) mock_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule("comp", async_setup=mock_setup, async_setup_entry=mock_setup_entry), ) with pytest.raises(config_entries.OperationNotAllowed, match=str(state)): assert await manager.async_setup(entry.entry_id) assert len(mock_setup.mock_calls) == 0 assert len(mock_setup_entry.mock_calls) == 0 assert entry.state is state async def test_entry_unload_succeed( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can unload an entry.""" unloads_called = [] async def verify_runtime_data(*args): """Verify runtime data.""" assert entry.runtime_data == 2 unloads_called.append(args) return True entry = MockConfigEntry(domain="comp", state=config_entries.ConfigEntryState.LOADED) entry.add_to_hass(hass) entry.async_on_unload(verify_runtime_data) entry.runtime_data = 2 mock_integration(hass, MockModule("comp", async_unload_entry=verify_runtime_data)) assert await manager.async_unload(entry.entry_id) assert len(unloads_called) == 2 assert entry.state is config_entries.ConfigEntryState.NOT_LOADED assert not hasattr(entry, "runtime_data") @pytest.mark.parametrize( "state", [ config_entries.ConfigEntryState.NOT_LOADED, config_entries.ConfigEntryState.SETUP_ERROR, config_entries.ConfigEntryState.SETUP_RETRY, ], ) async def test_entry_unload_failed_to_load( hass: HomeAssistant, manager: config_entries.ConfigEntries, state: config_entries.ConfigEntryState, ) -> None: """Test that we can unload an entry.""" entry = MockConfigEntry(domain="comp", state=state) entry.add_to_hass(hass) async_unload_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_unload_entry=async_unload_entry)) assert await manager.async_unload(entry.entry_id) assert len(async_unload_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.NOT_LOADED @pytest.mark.parametrize( "state", [ config_entries.ConfigEntryState.MIGRATION_ERROR, config_entries.ConfigEntryState.FAILED_UNLOAD, ], ) async def test_entry_unload_invalid_state( hass: HomeAssistant, manager: config_entries.ConfigEntries, state: config_entries.ConfigEntryState, ) -> None: """Test that we cannot unload an entry with invalid state.""" entry = MockConfigEntry(domain="comp", state=state) entry.add_to_hass(hass) async_unload_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_unload_entry=async_unload_entry)) with pytest.raises(config_entries.OperationNotAllowed, match=str(state)): assert await manager.async_unload(entry.entry_id) assert len(async_unload_entry.mock_calls) == 0 assert entry.state is state async def test_entry_reload_succeed( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can reload an entry.""" entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.NOT_LOADED ) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) async_setup_entry = AsyncMock(return_value=True) async_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) assert await manager.async_reload(entry.entry_id) assert len(async_setup.mock_calls) == 1 assert len(async_setup_entry.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED @pytest.mark.parametrize( "state", [ config_entries.ConfigEntryState.LOADED, config_entries.ConfigEntryState.SETUP_IN_PROGRESS, ], ) async def test_entry_cannot_be_loaded_twice( hass: HomeAssistant, state: config_entries.ConfigEntryState ) -> None: """Test that a config entry cannot be loaded twice.""" entry = MockConfigEntry(domain="comp", state=state) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) async_setup_entry = AsyncMock(return_value=True) async_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) with pytest.raises(config_entries.OperationNotAllowed, match=str(state)): await entry.async_setup(hass) assert len(async_setup.mock_calls) == 0 assert len(async_setup_entry.mock_calls) == 0 assert entry.state is state async def test_entry_setup_without_lock_raises(hass: HomeAssistant) -> None: """Test trying to setup a config entry without the lock.""" entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.NOT_LOADED ) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) async_setup_entry = AsyncMock(return_value=True) async_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) with pytest.raises( config_entries.OperationNotAllowed, match="cannot be set up because it does not hold the setup lock", ): await entry.async_setup(hass) assert len(async_setup.mock_calls) == 0 assert len(async_setup_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.NOT_LOADED async def test_entry_unload_without_lock_raises(hass: HomeAssistant) -> None: """Test trying to unload a config entry without the lock.""" entry = MockConfigEntry(domain="comp", state=config_entries.ConfigEntryState.LOADED) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) async_setup_entry = AsyncMock(return_value=True) async_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) with pytest.raises( config_entries.OperationNotAllowed, match="cannot be unloaded because it does not hold the setup lock", ): await entry.async_unload(hass) assert len(async_setup.mock_calls) == 0 assert len(async_setup_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.LOADED async def test_entry_remove_without_lock_raises(hass: HomeAssistant) -> None: """Test trying to remove a config entry without the lock.""" entry = MockConfigEntry(domain="comp", state=config_entries.ConfigEntryState.LOADED) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) async_setup_entry = AsyncMock(return_value=True) async_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) with pytest.raises( config_entries.OperationNotAllowed, match="cannot be removed because it does not hold the setup lock", ): await entry.async_remove(hass) assert len(async_setup.mock_calls) == 0 assert len(async_setup_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.LOADED @pytest.mark.parametrize( "state", [ config_entries.ConfigEntryState.NOT_LOADED, config_entries.ConfigEntryState.SETUP_ERROR, config_entries.ConfigEntryState.SETUP_RETRY, ], ) async def test_entry_reload_not_loaded( hass: HomeAssistant, manager: config_entries.ConfigEntries, state: config_entries.ConfigEntryState, ) -> None: """Test that we can reload an entry.""" entry = MockConfigEntry(domain="comp", state=state) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) async_setup_entry = AsyncMock(return_value=True) async_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) assert await manager.async_reload(entry.entry_id) assert len(async_unload_entry.mock_calls) == 0 assert len(async_setup.mock_calls) == 1 assert len(async_setup_entry.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED @pytest.mark.parametrize( "state", [ config_entries.ConfigEntryState.MIGRATION_ERROR, config_entries.ConfigEntryState.FAILED_UNLOAD, ], ) async def test_entry_reload_error( hass: HomeAssistant, manager: config_entries.ConfigEntries, state: config_entries.ConfigEntryState, ) -> None: """Test that we can reload an entry.""" entry = MockConfigEntry(domain="comp", state=state) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) async_setup_entry = AsyncMock(return_value=True) async_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, ), ) hass.config.components.add("comp") with pytest.raises(config_entries.OperationNotAllowed, match=str(state)): assert await manager.async_reload(entry.entry_id) assert len(async_unload_entry.mock_calls) == 0 assert len(async_setup.mock_calls) == 0 assert len(async_setup_entry.mock_calls) == 0 assert entry.state == state async def test_entry_disable_succeed( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can disable an entry.""" entry = MockConfigEntry(domain="comp", state=config_entries.ConfigEntryState.LOADED) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) async_setup_entry = AsyncMock(return_value=True) async_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) hass.config.components.add("comp") # Disable assert len(async_setup.mock_calls) == 0 assert len(async_setup_entry.mock_calls) == 0 assert await manager.async_set_disabled_by( entry.entry_id, config_entries.ConfigEntryDisabler.USER ) assert len(async_unload_entry.mock_calls) == 1 assert len(async_setup.mock_calls) == 0 assert len(async_setup_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.NOT_LOADED # Enable assert await manager.async_set_disabled_by(entry.entry_id, None) assert len(async_unload_entry.mock_calls) == 1 assert len(async_setup.mock_calls) == 0 assert len(async_setup_entry.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED async def test_entry_disable_without_reload_support( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can disable an entry without reload support.""" entry = MockConfigEntry(domain="comp", state=config_entries.ConfigEntryState.LOADED) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) async_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, ), ) mock_platform(hass, "comp.config_flow", None) hass.config.components.add("comp") # Disable assert not await manager.async_set_disabled_by( entry.entry_id, config_entries.ConfigEntryDisabler.USER ) assert len(async_setup.mock_calls) == 0 assert len(async_setup_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.FAILED_UNLOAD # Enable with pytest.raises( config_entries.OperationNotAllowed, match=str(config_entries.ConfigEntryState.FAILED_UNLOAD), ): await manager.async_set_disabled_by(entry.entry_id, None) assert len(async_setup.mock_calls) == 0 assert len(async_setup_entry.mock_calls) == 0 assert entry.state is config_entries.ConfigEntryState.FAILED_UNLOAD async def test_entry_enable_without_reload_support( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can disable an entry without reload support.""" entry = MockConfigEntry( domain="comp", disabled_by=config_entries.ConfigEntryDisabler.USER ) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) async_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=async_setup_entry, ), ) mock_platform(hass, "comp.config_flow", None) # Enable assert await manager.async_set_disabled_by(entry.entry_id, None) assert len(async_setup.mock_calls) == 1 assert len(async_setup_entry.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED # Disable assert not await manager.async_set_disabled_by( entry.entry_id, config_entries.ConfigEntryDisabler.USER ) assert len(async_setup.mock_calls) == 1 assert len(async_setup_entry.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.FAILED_UNLOAD async def test_init_custom_integration(hass: HomeAssistant) -> None: """Test initializing flow for custom integration.""" integration = loader.Integration( hass, "custom_components.hue", None, {"name": "Hue", "dependencies": [], "requirements": [], "domain": "hue"}, ) with ( pytest.raises(data_entry_flow.UnknownHandler), patch( "homeassistant.loader.async_get_integration", return_value=integration, ), ): await hass.config_entries.flow.async_init("bla", context={"source": "user"}) async def test_init_custom_integration_with_missing_handler( hass: HomeAssistant, ) -> None: """Test initializing flow for custom integration with a missing handler.""" integration = loader.Integration( hass, "custom_components.hue", None, {"name": "Hue", "dependencies": [], "requirements": [], "domain": "hue"}, ) mock_integration( hass, MockModule("hue"), ) mock_platform(hass, "hue.config_flow", None) with ( pytest.raises(data_entry_flow.UnknownHandler), patch( "homeassistant.loader.async_get_integration", return_value=integration, ), ): await hass.config_entries.flow.async_init("bla", context={"source": "user"}) async def test_support_entry_unload(hass: HomeAssistant) -> None: """Test unloading entry.""" assert await config_entries.support_entry_unload(hass, "light") assert not await config_entries.support_entry_unload(hass, "auth") async def test_reload_entry_entity_registry_ignores_no_entry( hass: HomeAssistant, entity_registry: er.EntityRegistry ) -> None: """Test reloading entry in entity registry skips if no config entry linked.""" handler = config_entries.EntityRegistryDisabledHandler(hass) # Test we ignore entities without config entry entry = entity_registry.async_get_or_create("light", "hue", "123") entity_registry.async_update_entity( entry.entity_id, disabled_by=er.RegistryEntryDisabler.USER ) await hass.async_block_till_done() assert not handler.changed assert handler._remove_call_later is None async def test_reload_entry_entity_registry_works( hass: HomeAssistant, entity_registry: er.EntityRegistry ) -> None: """Test we schedule an entry to be reloaded if disabled_by is updated.""" handler = config_entries.EntityRegistryDisabledHandler(hass) handler.async_setup() config_entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.LOADED ) config_entry.supports_unload = True config_entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) # Only changing disabled_by should update trigger entity_entry = entity_registry.async_get_or_create( "light", "hue", "123", config_entry=config_entry ) entity_registry.async_update_entity(entity_entry.entity_id, name="yo") await hass.async_block_till_done() assert not handler.changed assert handler._remove_call_later is None # Disable entity, we should not do anything, only act when enabled. entity_registry.async_update_entity( entity_entry.entity_id, disabled_by=er.RegistryEntryDisabler.USER ) await hass.async_block_till_done() assert not handler.changed assert handler._remove_call_later is None # Enable entity, check we are reloading config entry. entity_registry.async_update_entity(entity_entry.entity_id, disabled_by=None) await hass.async_block_till_done() assert handler.changed == {config_entry.entry_id} assert handler._remove_call_later is not None async_fire_time_changed( hass, dt_util.utcnow() + timedelta(seconds=config_entries.RELOAD_AFTER_UPDATE_DELAY + 1), ) await hass.async_block_till_done() assert len(mock_unload_entry.mock_calls) == 1 async def test_unique_id_persisted( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that a unique ID is stored in the config entry.""" mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_setup_entry=mock_setup_entry)) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("mock-unique-id") return self.async_create_entry(title="mock-title", data={}) with mock_config_flow("comp", TestFlow): await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) assert len(mock_setup_entry.mock_calls) == 1 p_hass, p_entry = mock_setup_entry.mock_calls[0][1] assert p_hass is hass assert p_entry.unique_id == "mock-unique-id" async def test_unique_id_existing_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we remove an entry if there already is an entry with unique ID.""" hass.config.components.add("comp") MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.LOADED, unique_id="mock-unique-id", ).add_to_hass(hass) async_setup_entry = AsyncMock(return_value=True) async_unload_entry = AsyncMock(return_value=True) async_remove_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, async_remove_entry=async_remove_entry, ), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" existing_entry = await self.async_set_unique_id("mock-unique-id") assert existing_entry is not None return self.async_create_entry(title="mock-title", data={"via": "flow"}) with mock_config_flow("comp", TestFlow): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY entries = hass.config_entries.async_entries("comp") assert len(entries) == 1 assert entries[0].data == {"via": "flow"} assert len(async_setup_entry.mock_calls) == 1 assert len(async_unload_entry.mock_calls) == 1 assert len(async_remove_entry.mock_calls) == 1 async def test_entry_id_existing_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we throw when the entry id collides.""" collide_entry_id = "collide" hass.config.components.add("comp") MockConfigEntry( entry_id=collide_entry_id, domain="comp", state=config_entries.ConfigEntryState.LOADED, unique_id="mock-unique-id", ).add_to_hass(hass) mock_integration( hass, MockModule("comp"), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" return self.async_create_entry(title="mock-title", data={"via": "flow"}) with ( pytest.raises(HomeAssistantError), mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ulid_util.ulid_now", return_value=collide_entry_id, ), ): await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) async def test_unique_id_update_existing_entry_without_reload( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we update an entry if there already is an entry with unique ID.""" hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", data={"additional": "data", "host": "0.0.0.0"}, unique_id="mock-unique-id", state=config_entries.ConfigEntryState.LOADED, ) entry.add_to_hass(hass) mock_integration( hass, MockModule("comp"), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("mock-unique-id") self._abort_if_unique_id_configured( updates={"host": "1.1.1.1"}, reload_on_update=False ) with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ConfigEntries.async_reload" ) as async_reload, ): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() assert result["type"] == FlowResultType.ABORT assert result["reason"] == "already_configured" assert entry.data["host"] == "1.1.1.1" assert entry.data["additional"] == "data" assert len(async_reload.mock_calls) == 0 async def test_unique_id_update_existing_entry_with_reload( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we update an entry if there already is an entry with unique ID and we reload on changes.""" hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", data={"additional": "data", "host": "0.0.0.0"}, unique_id="mock-unique-id", state=config_entries.ConfigEntryState.LOADED, ) entry.add_to_hass(hass) mock_integration( hass, MockModule("comp"), ) mock_platform(hass, "comp.config_flow", None) updates = {"host": "1.1.1.1"} class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("mock-unique-id") await self._abort_if_unique_id_configured( updates=updates, reload_on_update=True ) with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ConfigEntries.async_reload" ) as async_reload, ): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() assert result["type"] == FlowResultType.ABORT assert result["reason"] == "already_configured" assert entry.data["host"] == "1.1.1.1" assert entry.data["additional"] == "data" assert len(async_reload.mock_calls) == 1 # Test we don't reload if entry not started updates["host"] = "2.2.2.2" entry._async_set_state(hass, config_entries.ConfigEntryState.NOT_LOADED, None) with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ConfigEntries.async_reload" ) as async_reload, ): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() assert result["type"] == FlowResultType.ABORT assert result["reason"] == "already_configured" assert entry.data["host"] == "2.2.2.2" assert entry.data["additional"] == "data" assert len(async_reload.mock_calls) == 0 async def test_unique_id_from_discovery_in_setup_retry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we reload when in a setup retry state from discovery.""" hass.config.components.add("comp") unique_id = "34ea34b43b5a" host = "0.0.0.0" entry = MockConfigEntry( domain="comp", data={"additional": "data", "host": host}, unique_id=unique_id, state=config_entries.ConfigEntryState.SETUP_RETRY, ) entry.add_to_hass(hass) mock_integration( hass, MockModule("comp"), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_dhcp( self, discovery_info: dhcp.DhcpServiceInfo ) -> FlowResult: """Test dhcp step.""" await self.async_set_unique_id(unique_id) self._abort_if_unique_id_configured() async def async_step_user(self, user_input: dict | None = None) -> FlowResult: """Test user step.""" await self.async_set_unique_id(unique_id) self._abort_if_unique_id_configured() # Verify we do not reload from a user source with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ConfigEntries.async_reload" ) as async_reload, ): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() assert result["type"] == FlowResultType.ABORT assert result["reason"] == "already_configured" assert len(async_reload.mock_calls) == 0 # Verify do reload from a discovery source with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ConfigEntries.async_reload" ) as async_reload, ): discovery_result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_DHCP}, data=dhcp.DhcpServiceInfo( hostname="any", ip=host, macaddress=unique_id, ), ) await hass.async_block_till_done() assert discovery_result["type"] == FlowResultType.ABORT assert discovery_result["reason"] == "already_configured" assert len(async_reload.mock_calls) == 1 async def test_unique_id_not_update_existing_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we do not update an entry if existing entry has the data.""" hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", data={"additional": "data", "host": "0.0.0.0"}, unique_id="mock-unique-id", ) entry.add_to_hass(hass) mock_integration( hass, MockModule("comp"), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("mock-unique-id") await self._abort_if_unique_id_configured( updates={"host": "0.0.0.0"}, reload_on_update=True ) with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ConfigEntries.async_reload" ) as async_reload, ): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() assert result["type"] == FlowResultType.ABORT assert result["reason"] == "already_configured" assert entry.data["host"] == "0.0.0.0" assert entry.data["additional"] == "data" assert len(async_reload.mock_calls) == 0 async def test_unique_id_in_progress( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we abort if there is already a flow in progress with same unique id.""" mock_integration(hass, MockModule("comp")) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("mock-unique-id") return self.async_show_form(step_id="discovery") with mock_config_flow("comp", TestFlow): # Create one to be in progress result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) assert result["type"] == data_entry_flow.FlowResultType.FORM # Will be canceled result2 = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) assert result2["type"] == data_entry_flow.FlowResultType.ABORT assert result2["reason"] == "already_in_progress" async def test_finish_flow_aborts_progress( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that when finishing a flow, we abort other flows in progress with unique ID.""" mock_integration( hass, MockModule("comp", async_setup_entry=AsyncMock(return_value=True)), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("mock-unique-id", raise_on_progress=False) if user_input is None: return self.async_show_form(step_id="discovery") return self.async_create_entry(title="yo", data={}) with mock_config_flow("comp", TestFlow): # Create one to be in progress result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) assert result["type"] == data_entry_flow.FlowResultType.FORM # Will finish and cancel other one. result2 = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER}, data={} ) assert result2["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY assert len(hass.config_entries.flow.async_progress()) == 0 @pytest.mark.parametrize( ("extra_context", "expected_entry_discovery_keys"), [ ( {}, {}, ), ( {"discovery_key": DiscoveryKey(domain="test", key="blah", version=1)}, {"test": (DiscoveryKey(domain="test", key="blah", version=1),)}, ), ], ) async def test_unique_id_ignore( hass: HomeAssistant, manager: config_entries.ConfigEntries, extra_context: dict, expected_entry_discovery_keys: dict, ) -> None: """Test that we can ignore flows that are in progress and have a unique ID.""" async_setup_entry = AsyncMock(return_value=False) mock_integration(hass, MockModule("comp", async_setup_entry=async_setup_entry)) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user flow.""" await self.async_set_unique_id("mock-unique-id") return self.async_show_form(step_id="discovery") with mock_config_flow("comp", TestFlow): # Create one to be in progress result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) assert result["type"] == data_entry_flow.FlowResultType.FORM result2 = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_IGNORE} | extra_context, data={"unique_id": "mock-unique-id", "title": "Ignored Title"}, ) assert result2["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY # assert len(hass.config_entries.flow.async_progress()) == 0 # We should never set up an ignored entry. assert len(async_setup_entry.mock_calls) == 0 entry = hass.config_entries.async_entries("comp")[0] assert entry.source == "ignore" assert entry.unique_id == "mock-unique-id" assert entry.title == "Ignored Title" assert entry.data == {} assert entry.discovery_keys == expected_entry_discovery_keys async def test_manual_add_overrides_ignored_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can ignore manually add entry, overriding ignored entry.""" hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", data={"additional": "data", "host": "0.0.0.0"}, unique_id="mock-unique-id", state=config_entries.ConfigEntryState.LOADED, source=config_entries.SOURCE_IGNORE, ) entry.add_to_hass(hass) mock_integration( hass, MockModule("comp"), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("mock-unique-id") self._abort_if_unique_id_configured( updates={"host": "1.1.1.1"}, reload_on_update=False ) return self.async_show_form(step_id="step2") async def async_step_step2(self, user_input=None): raise NotImplementedError with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ConfigEntries.async_reload" ) as async_reload, ): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() assert result["type"] == data_entry_flow.FlowResultType.FORM assert entry.data["host"] == "1.1.1.1" assert entry.data["additional"] == "data" assert len(async_reload.mock_calls) == 0 async def test_manual_add_overrides_ignored_entry_singleton( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can ignore manually add entry, overriding ignored entry.""" hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.LOADED, source=config_entries.SOURCE_IGNORE, ) entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_setup_entry=mock_setup_entry)) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" if self._async_current_entries(): return self.async_abort(reason="single_instance_allowed") return self.async_create_entry(title="title", data={"token": "supersecret"}) with mock_config_flow("comp", TestFlow), mock_config_flow("invalid_flow", 5): await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() assert len(mock_setup_entry.mock_calls) == 1 p_hass, p_entry = mock_setup_entry.mock_calls[0][1] assert p_hass is hass assert p_entry.data == {"token": "supersecret"} @pytest.mark.parametrize( ( "discovery_keys", "entry_unique_id", "flow_context", "flow_source", "flow_result", "updated_discovery_keys", ), [ # No discovery key ( {}, "mock-unique-id", {}, config_entries.SOURCE_ZEROCONF, data_entry_flow.FlowResultType.ABORT, {}, ), # Discovery key added to ignored entry data ( {}, "mock-unique-id", {"discovery_key": DiscoveryKey(domain="test", key="blah", version=1)}, config_entries.SOURCE_ZEROCONF, data_entry_flow.FlowResultType.ABORT, {"test": (DiscoveryKey(domain="test", key="blah", version=1),)}, ), # Discovery key added to ignored entry data ( {"test": (DiscoveryKey(domain="test", key="bleh", version=1),)}, "mock-unique-id", {"discovery_key": DiscoveryKey(domain="test", key="blah", version=1)}, config_entries.SOURCE_ZEROCONF, data_entry_flow.FlowResultType.ABORT, { "test": ( DiscoveryKey(domain="test", key="bleh", version=1), DiscoveryKey(domain="test", key="blah", version=1), ) }, ), # Discovery key added to ignored entry data ( { "test": ( DiscoveryKey(domain="test", key="1", version=1), DiscoveryKey(domain="test", key="2", version=1), DiscoveryKey(domain="test", key="3", version=1), DiscoveryKey(domain="test", key="4", version=1), DiscoveryKey(domain="test", key="5", version=1), DiscoveryKey(domain="test", key="6", version=1), DiscoveryKey(domain="test", key="7", version=1), DiscoveryKey(domain="test", key="8", version=1), DiscoveryKey(domain="test", key="9", version=1), DiscoveryKey(domain="test", key="10", version=1), ) }, "mock-unique-id", {"discovery_key": DiscoveryKey(domain="test", key="11", version=1)}, config_entries.SOURCE_ZEROCONF, data_entry_flow.FlowResultType.ABORT, { "test": ( DiscoveryKey(domain="test", key="2", version=1), DiscoveryKey(domain="test", key="3", version=1), DiscoveryKey(domain="test", key="4", version=1), DiscoveryKey(domain="test", key="5", version=1), DiscoveryKey(domain="test", key="6", version=1), DiscoveryKey(domain="test", key="7", version=1), DiscoveryKey(domain="test", key="8", version=1), DiscoveryKey(domain="test", key="9", version=1), DiscoveryKey(domain="test", key="10", version=1), DiscoveryKey(domain="test", key="11", version=1), ) }, ), # Discovery key already in ignored entry data ( {"test": (DiscoveryKey(domain="test", key="blah", version=1),)}, "mock-unique-id", {"discovery_key": DiscoveryKey(domain="test", key="blah", version=1)}, config_entries.SOURCE_ZEROCONF, data_entry_flow.FlowResultType.ABORT, {"test": (DiscoveryKey(domain="test", key="blah", version=1),)}, ), # Flow not aborted when unique id is not matching ( {}, "mock-unique-id-2", {"discovery_key": DiscoveryKey(domain="test", key="blah", version=1)}, config_entries.SOURCE_ZEROCONF, data_entry_flow.FlowResultType.FORM, {}, ), ], ) @pytest.mark.parametrize( "entry_source", [ config_entries.SOURCE_IGNORE, config_entries.SOURCE_USER, config_entries.SOURCE_ZEROCONF, ], ) async def test_update_discovery_keys( hass: HomeAssistant, manager: config_entries.ConfigEntries, discovery_keys: tuple, entry_source: str, entry_unique_id: str, flow_context: dict, flow_source: str, flow_result: data_entry_flow.FlowResultType, updated_discovery_keys: tuple, ) -> None: """Test that discovery keys of an entry can be updated.""" hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", discovery_keys=discovery_keys, unique_id=entry_unique_id, state=config_entries.ConfigEntryState.LOADED, source=entry_source, ) entry.add_to_hass(hass) mock_integration(hass, MockModule("comp")) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("mock-unique-id") self._abort_if_unique_id_configured(reload_on_update=False) return self.async_show_form(step_id="step2") async def async_step_step2(self, user_input=None): raise NotImplementedError async def async_step_zeroconf(self, discovery_info=None): """Test zeroconf step.""" return await self.async_step_user(discovery_info) with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ConfigEntries.async_reload" ) as async_reload, ): result = await manager.flow.async_init( "comp", context={"source": flow_source} | flow_context ) await hass.async_block_till_done() assert result["type"] == flow_result assert entry.data == {} assert entry.discovery_keys == updated_discovery_keys assert len(async_reload.mock_calls) == 0 @pytest.mark.parametrize( ( "discovery_keys", "entry_source", "entry_unique_id", "flow_context", "flow_source", "flow_result", "updated_discovery_keys", ), [ # Flow not aborted when user initiated flow ( {}, config_entries.SOURCE_IGNORE, "mock-unique-id-2", {"discovery_key": DiscoveryKey(domain="test", key="blah", version=1)}, config_entries.SOURCE_USER, data_entry_flow.FlowResultType.FORM, {}, ), ], ) async def test_update_discovery_keys_2( hass: HomeAssistant, manager: config_entries.ConfigEntries, discovery_keys: tuple, entry_source: str, entry_unique_id: str, flow_context: dict, flow_source: str, flow_result: data_entry_flow.FlowResultType, updated_discovery_keys: tuple, ) -> None: """Test that discovery keys of an entry can be updated.""" hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", discovery_keys=discovery_keys, unique_id=entry_unique_id, state=config_entries.ConfigEntryState.LOADED, source=entry_source, ) entry.add_to_hass(hass) mock_integration(hass, MockModule("comp")) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("mock-unique-id") self._abort_if_unique_id_configured(reload_on_update=False) return self.async_show_form(step_id="step2") async def async_step_step2(self, user_input=None): raise NotImplementedError async def async_step_zeroconf(self, discovery_info=None): """Test zeroconf step.""" return await self.async_step_user(discovery_info) with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ConfigEntries.async_reload" ) as async_reload, ): result = await manager.flow.async_init( "comp", context={"source": flow_source} | flow_context ) await hass.async_block_till_done() assert result["type"] == flow_result assert entry.data == {} assert entry.discovery_keys == updated_discovery_keys assert len(async_reload.mock_calls) == 0 async def test_async_current_entries_does_not_skip_ignore_non_user( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that _async_current_entries does not skip ignore by default for non user step.""" hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.LOADED, source=config_entries.SOURCE_IGNORE, ) entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_setup_entry=mock_setup_entry)) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_import(self, user_input=None): """Test not the user step.""" if self._async_current_entries(): return self.async_abort(reason="single_instance_allowed") return self.async_create_entry(title="title", data={"token": "supersecret"}) with mock_config_flow("comp", TestFlow), mock_config_flow("invalid_flow", 5): await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_IMPORT} ) await hass.async_block_till_done() assert len(mock_setup_entry.mock_calls) == 0 async def test_async_current_entries_explicit_skip_ignore( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that _async_current_entries can explicitly include ignore.""" hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.LOADED, source=config_entries.SOURCE_IGNORE, ) entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_setup_entry=mock_setup_entry)) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_import(self, user_input=None): """Test not the user step.""" if self._async_current_entries(include_ignore=False): return self.async_abort(reason="single_instance_allowed") return self.async_create_entry(title="title", data={"token": "supersecret"}) with mock_config_flow("comp", TestFlow), mock_config_flow("invalid_flow", 5): await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_IMPORT} ) await hass.async_block_till_done() assert len(mock_setup_entry.mock_calls) == 1 p_hass, p_entry = mock_setup_entry.mock_calls[0][1] assert p_hass is hass assert p_entry.data == {"token": "supersecret"} async def test_async_current_entries_explicit_include_ignore( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that _async_current_entries can explicitly include ignore.""" hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.LOADED, source=config_entries.SOURCE_IGNORE, ) entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_setup_entry=mock_setup_entry)) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_import(self, user_input=None): """Test not the user step.""" if self._async_current_entries(include_ignore=True): return self.async_abort(reason="single_instance_allowed") return self.async_create_entry(title="title", data={"token": "supersecret"}) with mock_config_flow("comp", TestFlow), mock_config_flow("invalid_flow", 5): await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_IMPORT} ) await hass.async_block_till_done() assert len(mock_setup_entry.mock_calls) == 0 async def test_partial_flows_hidden( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that flows that don't have a cur_step and haven't finished initing are hidden.""" async_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_setup_entry=async_setup_entry)) mock_platform(hass, "comp.config_flow", None) # A flag to test our assertion that `async_step_discovery` was called and is in its blocked state # This simulates if the step was e.g. doing network i/o discovery_started = asyncio.Event() # A flag to allow `async_step_discovery` to resume after we have verified the uninited flow is not # visible and has not triggered a discovery alert. This lets us control when the mocked network # i/o is complete. pause_discovery = asyncio.Event() class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_discovery(self, discovery_info): """Test discovery step.""" discovery_started.set() await pause_discovery.wait() return self.async_show_form(step_id="someform") async def async_step_someform(self, user_input=None): raise NotImplementedError with mock_config_flow("comp", TestFlow): # Start a config entry flow and wait for it to be blocked init_task = asyncio.ensure_future( manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_DISCOVERY}, data={"unique_id": "mock-unique-id"}, ) ) await discovery_started.wait() # While it's blocked it shouldn't be visible or trigger discovery notifications assert len(hass.config_entries.flow.async_progress()) == 0 await hass.async_block_till_done() notifications = async_get_persistent_notifications(hass) assert "config_entry_discovery" not in notifications # Let the flow init complete pause_discovery.set() # When it's complete it should now be visible in async_progress and have triggered # discovery notifications result = await init_task assert result["type"] == data_entry_flow.FlowResultType.FORM assert len(hass.config_entries.flow.async_progress()) == 1 await hass.async_block_till_done() notifications = async_get_persistent_notifications(hass) assert "config_entry_discovery" in notifications async def test_async_setup_init_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test a config entry being initialized during integration setup.""" async def mock_async_setup(hass: HomeAssistant, config: ConfigType) -> bool: """Mock setup.""" hass.async_create_task( hass.config_entries.flow.async_init( "comp", context={"source": config_entries.SOURCE_IMPORT}, data={}, ) ) return True async_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=mock_async_setup, async_setup_entry=async_setup_entry ), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_import(self, user_input): """Test import step creating entry.""" return self.async_create_entry(title="title", data={}) with mock_config_flow("comp", TestFlow): assert await async_setup_component(hass, "comp", {}) await hass.async_block_till_done() assert len(async_setup_entry.mock_calls) == 1 entries = hass.config_entries.async_entries("comp") assert len(entries) == 1 assert entries[0].state is config_entries.ConfigEntryState.LOADED async def test_async_setup_init_entry_completes_before_loaded_event_fires( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test a config entry being initialized during integration setup before the loaded event fires.""" load_events = async_capture_events(hass, EVENT_COMPONENT_LOADED) async def mock_async_setup(hass: HomeAssistant, config: ConfigType) -> bool: """Mock setup.""" hass.async_create_task( hass.config_entries.flow.async_init( "comp", context={"source": config_entries.SOURCE_IMPORT}, data={}, ) ) return True async_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=mock_async_setup, async_setup_entry=async_setup_entry ), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_three(self, user_input=None): """Test import step creating entry.""" return self.async_create_entry(title="title", data={}) async def async_step_two(self, user_input=None): """Test import step creating entry.""" return await self.async_step_three() async def async_step_one(self, user_input=None): """Test import step creating entry.""" return await self.async_step_two() async def async_step_import(self, user_input=None): """Test import step creating entry.""" return await self.async_step_one() # This test must not use hass.async_block_till_done() # as its explicitly testing what happens without it with mock_config_flow("comp", TestFlow): assert await async_setup_component(hass, "comp", {}) assert len(async_setup_entry.mock_calls) == 1 assert load_events[0].event_type == EVENT_COMPONENT_LOADED assert load_events[0].data == {"component": "comp"} entries = hass.config_entries.async_entries("comp") assert len(entries) == 1 assert entries[0].state is config_entries.ConfigEntryState.LOADED async def test_async_setup_update_entry(hass: HomeAssistant) -> None: """Test a config entry being updated during integration setup.""" entry = MockConfigEntry(domain="comp", data={"value": "initial"}) entry.add_to_hass(hass) async def mock_async_setup(hass: HomeAssistant, config: ConfigType) -> bool: """Mock setup.""" hass.async_create_task( hass.config_entries.flow.async_init( "comp", context={"source": config_entries.SOURCE_IMPORT}, data={}, ) ) return True async def mock_async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock setting up an entry.""" assert entry.data["value"] == "updated" return True mock_integration( hass, MockModule( "comp", async_setup=mock_async_setup, async_setup_entry=mock_async_setup_entry, ), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_import(self, user_input): """Test import step updating existing entry.""" assert ( self.hass.config_entries.async_update_entry( entry, data={"value": "updated"} ) is True ) return self.async_abort(reason="yo") with mock_config_flow("comp", TestFlow): assert await async_setup_component(hass, "comp", {}) entries = hass.config_entries.async_entries("comp") assert len(entries) == 1 assert entries[0].state is config_entries.ConfigEntryState.LOADED assert entries[0].data == {"value": "updated"} @pytest.mark.parametrize( "discovery_source", [ (config_entries.SOURCE_BLUETOOTH, BaseServiceInfo()), (config_entries.SOURCE_DISCOVERY, {}), (config_entries.SOURCE_SSDP, BaseServiceInfo()), (config_entries.SOURCE_USB, BaseServiceInfo()), (config_entries.SOURCE_HOMEKIT, BaseServiceInfo()), (config_entries.SOURCE_DHCP, BaseServiceInfo()), (config_entries.SOURCE_ZEROCONF, BaseServiceInfo()), ( config_entries.SOURCE_HASSIO, HassioServiceInfo(config={}, name="Test", slug="test", uuid="1234"), ), ], ) async def test_flow_with_default_discovery( hass: HomeAssistant, manager: config_entries.ConfigEntries, discovery_source: tuple[str, dict | BaseServiceInfo], ) -> None: """Test that finishing a default discovery flow removes the unique ID in the entry.""" mock_integration( hass, MockModule("comp", async_setup_entry=AsyncMock(return_value=True)), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" if user_input is None: return self.async_show_form(step_id="user") return self.async_create_entry(title="yo", data={}) with mock_config_flow("comp", TestFlow): # Create one to be in progress result = await manager.flow.async_init( "comp", context={"source": discovery_source[0]}, data=discovery_source[1] ) assert result["type"] == data_entry_flow.FlowResultType.FORM flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert ( flows[0]["context"]["unique_id"] == config_entries.DEFAULT_DISCOVERY_UNIQUE_ID ) # Finish flow result2 = await manager.flow.async_configure( result["flow_id"], user_input={"fake": "data"} ) assert result2["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY assert len(hass.config_entries.flow.async_progress()) == 0 entry = hass.config_entries.async_entries("comp")[0] assert entry.title == "yo" assert entry.source == discovery_source[0] assert entry.unique_id is None async def test_flow_with_default_discovery_with_unique_id( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test discovery flow using the default discovery is ignored when unique ID is set.""" mock_integration(hass, MockModule("comp")) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_discovery(self, discovery_info): """Test discovery step.""" await self.async_set_unique_id("mock-unique-id") # This call should make no difference, as a unique ID is set await self._async_handle_discovery_without_unique_id() return self.async_show_form(step_id="mock") async def async_step_mock(self, user_input=None): raise NotImplementedError with mock_config_flow("comp", TestFlow): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_DISCOVERY} ) assert result["type"] == data_entry_flow.FlowResultType.FORM flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"]["unique_id"] == "mock-unique-id" async def test_default_discovery_abort_existing_entries( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that a flow without discovery implementation aborts when a config entry exists.""" hass.config.components.add("comp") entry = MockConfigEntry(domain="comp", data={}, unique_id="mock-unique-id") entry.add_to_hass(hass) mock_integration(hass, MockModule("comp")) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 with mock_config_flow("comp", TestFlow): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_DISCOVERY} ) assert result["type"] == data_entry_flow.FlowResultType.ABORT assert result["reason"] == "already_configured" async def test_default_discovery_in_progress( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that a flow using default discovery can only be triggered once.""" mock_integration(hass, MockModule("comp")) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_discovery(self, discovery_info): """Test discovery step.""" await self.async_set_unique_id(discovery_info.get("unique_id")) await self._async_handle_discovery_without_unique_id() return self.async_show_form(step_id="mock") async def async_step_mock(self, user_input=None): raise NotImplementedError with mock_config_flow("comp", TestFlow): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_DISCOVERY}, data={"unique_id": "mock-unique-id"}, ) assert result["type"] == data_entry_flow.FlowResultType.FORM # Second discovery without a unique ID result2 = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_DISCOVERY}, data={} ) assert result2["type"] == data_entry_flow.FlowResultType.ABORT flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"]["unique_id"] == "mock-unique-id" async def test_default_discovery_abort_on_new_unique_flow( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that a flow using default discovery is aborted when a second flow with unique ID is created.""" mock_integration(hass, MockModule("comp")) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_discovery(self, discovery_info): """Test discovery step.""" await self.async_set_unique_id(discovery_info.get("unique_id")) await self._async_handle_discovery_without_unique_id() return self.async_show_form(step_id="mock") async def async_step_mock(self, user_input=None): raise NotImplementedError with mock_config_flow("comp", TestFlow): # First discovery with default, no unique ID result2 = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_DISCOVERY}, data={} ) assert result2["type"] == data_entry_flow.FlowResultType.FORM # Second discovery brings in a unique ID result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_DISCOVERY}, data={"unique_id": "mock-unique-id"}, ) assert result["type"] == data_entry_flow.FlowResultType.FORM # Ensure the first one is cancelled and we end up with just the last one flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"]["unique_id"] == "mock-unique-id" async def test_default_discovery_abort_on_user_flow_complete( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that a flow using default discovery is aborted when a second flow completes.""" mock_integration(hass, MockModule("comp")) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" if user_input is None: return self.async_show_form(step_id="user") return self.async_create_entry(title="title", data={"token": "supersecret"}) async def async_step_discovery(self, discovery_info=None): """Test discovery step.""" await self._async_handle_discovery_without_unique_id() return self.async_show_form(step_id="mock") async def async_step_mock(self, user_input=None): raise NotImplementedError with mock_config_flow("comp", TestFlow): # First discovery with default, no unique ID flow1 = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_DISCOVERY}, data={} ) assert flow1["type"] == data_entry_flow.FlowResultType.FORM flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 # User sets up a manual flow flow2 = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) assert flow2["type"] == data_entry_flow.FlowResultType.FORM flows = hass.config_entries.flow.async_progress() assert len(flows) == 2 # Complete the manual flow result = await hass.config_entries.flow.async_configure(flow2["flow_id"], {}) assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY # Ensure the first flow is gone now flows = hass.config_entries.flow.async_progress() assert len(flows) == 0 async def test_flow_same_device_multiple_sources( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test discovery of the same devices from multiple discovery sources.""" mock_integration( hass, MockModule("comp", async_setup_entry=AsyncMock(return_value=True)), ) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_zeroconf(self, discovery_info=None): """Test zeroconf step.""" return await self._async_discovery_handler(discovery_info) async def async_step_homekit(self, discovery_info=None): """Test homekit step.""" return await self._async_discovery_handler(discovery_info) async def _async_discovery_handler(self, discovery_info=None): """Test any discovery handler.""" await self.async_set_unique_id("thisid") self._abort_if_unique_id_configured() await asyncio.sleep(0.1) return await self.async_step_link() async def async_step_link(self, user_input=None): """Test a link step.""" if user_input is None: return self.async_show_form(step_id="link") return self.async_create_entry(title="title", data={"token": "supersecret"}) with mock_config_flow("comp", TestFlow): # Create one to be in progress flow1 = manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_ZEROCONF} ) flow2 = manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_ZEROCONF} ) flow3 = manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_HOMEKIT} ) result1, result2, result3 = await asyncio.gather(flow1, flow2, flow3) flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"]["unique_id"] == "thisid" # Finish flow result2 = await manager.flow.async_configure( flows[0]["flow_id"], user_input={"fake": "data"} ) assert result2["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY assert len(hass.config_entries.flow.async_progress()) == 0 entry = hass.config_entries.async_entries("comp")[0] assert entry.title == "title" assert entry.source in { config_entries.SOURCE_ZEROCONF, config_entries.SOURCE_HOMEKIT, } assert entry.unique_id == "thisid" async def test_updating_entry_with_and_without_changes( manager: config_entries.ConfigEntries, ) -> None: """Test that we can update an entry data.""" entry = MockConfigEntry( domain="test", data={"first": True}, title="thetitle", options={"option": True}, unique_id="abc123", state=config_entries.ConfigEntryState.SETUP_ERROR, ) entry.add_to_manager(manager) assert "abc123" in str(entry) assert manager.async_entry_for_domain_unique_id("test", "abc123") is entry assert manager.async_update_entry(entry) is False for change in ( {"data": {"second": True, "third": 456}}, {"data": {"second": True}}, {"minor_version": 2}, {"options": {"hello": True}}, {"pref_disable_new_entities": True}, {"pref_disable_polling": True}, {"title": "sometitle"}, {"unique_id": "abcd1234"}, {"version": 2}, ): assert manager.async_update_entry(entry, **change) is True key = next(iter(change)) value = next(iter(change.values())) assert getattr(entry, key) == value assert manager.async_update_entry(entry, **change) is False assert manager.async_entry_for_domain_unique_id("test", "abc123") is None assert manager.async_entry_for_domain_unique_id("test", "abcd1234") is entry assert "abcd1234" in str(entry) async def test_entry_reload_calls_on_unload_listeners( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test reload calls the on unload listeners.""" entry = MockConfigEntry(domain="comp", state=config_entries.ConfigEntryState.LOADED) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) mock_setup_entry = AsyncMock(return_value=True) async_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=mock_setup_entry, async_unload_entry=async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) hass.config.components.add("comp") mock_unload_callback = Mock() entry.async_on_unload(mock_unload_callback) assert await manager.async_reload(entry.entry_id) assert len(async_unload_entry.mock_calls) == 1 assert len(mock_setup_entry.mock_calls) == 1 assert len(mock_unload_callback.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED assert await manager.async_reload(entry.entry_id) assert len(async_unload_entry.mock_calls) == 2 assert len(mock_setup_entry.mock_calls) == 2 # Since we did not register another async_on_unload it should # have only been called once assert len(mock_unload_callback.mock_calls) == 1 assert entry.state is config_entries.ConfigEntryState.LOADED async def test_setup_raise_entry_error( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test a setup raising ConfigEntryError.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) mock_setup_entry = AsyncMock( side_effect=ConfigEntryError("Incompatible firmware version") ) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert ( "Error setting up entry test_title for test: Incompatible firmware version" in caplog.text ) assert entry.state is config_entries.ConfigEntryState.SETUP_ERROR assert entry.reason == "Incompatible firmware version" async def test_setup_raise_entry_error_from_first_coordinator_update( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test async_config_entry_first_refresh raises ConfigEntryError.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock setup entry with a simple coordinator.""" async def _async_update_data(): raise ConfigEntryError("Incompatible firmware version") coordinator = DataUpdateCoordinator( hass, logging.getLogger(__name__), name="any", update_method=_async_update_data, update_interval=timedelta(seconds=1000), ) await coordinator.async_config_entry_first_refresh() return True mock_integration(hass, MockModule("test", async_setup_entry=async_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert ( "Error setting up entry test_title for test: Incompatible firmware version" in caplog.text ) assert entry.state is config_entries.ConfigEntryState.SETUP_ERROR assert entry.reason == "Incompatible firmware version" async def test_setup_not_raise_entry_error_from_future_coordinator_update( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test a coordinator not raises ConfigEntryError in the future.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock setup entry with a simple coordinator.""" async def _async_update_data(): raise ConfigEntryError("Incompatible firmware version") coordinator = DataUpdateCoordinator( hass, logging.getLogger(__name__), name="any", update_method=_async_update_data, update_interval=timedelta(seconds=1000), ) await coordinator.async_refresh() return True mock_integration(hass, MockModule("test", async_setup_entry=async_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert ( "Config entry setup failed while fetching any data: Incompatible firmware" " version" in caplog.text ) assert entry.state is config_entries.ConfigEntryState.LOADED async def test_setup_raise_auth_failed( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test a setup raising ConfigEntryAuthFailed.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) mock_setup_entry = AsyncMock( side_effect=ConfigEntryAuthFailed("The password is no longer valid") ) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert "could not authenticate: The password is no longer valid" in caplog.text assert entry.state is config_entries.ConfigEntryState.SETUP_ERROR assert entry.reason == "The password is no longer valid" flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"]["entry_id"] == entry.entry_id assert flows[0]["context"]["source"] == config_entries.SOURCE_REAUTH assert flows[0]["context"]["title_placeholders"] == {"name": "test_title"} caplog.clear() entry._async_set_state(hass, config_entries.ConfigEntryState.NOT_LOADED, None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert "could not authenticate: The password is no longer valid" in caplog.text # Verify multiple ConfigEntryAuthFailed does not generate a second flow assert entry.state is config_entries.ConfigEntryState.SETUP_ERROR flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 async def test_setup_raise_auth_failed_from_first_coordinator_update( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test async_config_entry_first_refresh raises ConfigEntryAuthFailed.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock setup entry with a simple coordinator.""" async def _async_update_data(): raise ConfigEntryAuthFailed("The password is no longer valid") coordinator = DataUpdateCoordinator( hass, logging.getLogger(__name__), name="any", update_method=_async_update_data, update_interval=timedelta(seconds=1000), ) await coordinator.async_config_entry_first_refresh() return True mock_integration(hass, MockModule("test", async_setup_entry=async_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert "could not authenticate: The password is no longer valid" in caplog.text assert entry.state is config_entries.ConfigEntryState.SETUP_ERROR flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"]["entry_id"] == entry.entry_id assert flows[0]["context"]["source"] == config_entries.SOURCE_REAUTH caplog.clear() entry._async_set_state(hass, config_entries.ConfigEntryState.NOT_LOADED, None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert "could not authenticate: The password is no longer valid" in caplog.text # Verify multiple ConfigEntryAuthFailed does not generate a second flow assert entry.state is config_entries.ConfigEntryState.SETUP_ERROR flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 async def test_setup_raise_auth_failed_from_future_coordinator_update( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test a coordinator raises ConfigEntryAuthFailed in the future.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock setup entry with a simple coordinator.""" async def _async_update_data(): raise ConfigEntryAuthFailed("The password is no longer valid") coordinator = DataUpdateCoordinator( hass, logging.getLogger(__name__), name="any", update_method=_async_update_data, update_interval=timedelta(seconds=1000), ) await coordinator.async_refresh() return True mock_integration(hass, MockModule("test", async_setup_entry=async_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert "Authentication failed while fetching" in caplog.text assert "The password is no longer valid" in caplog.text assert entry.state is config_entries.ConfigEntryState.LOADED flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"]["entry_id"] == entry.entry_id assert flows[0]["context"]["source"] == config_entries.SOURCE_REAUTH caplog.clear() entry._async_set_state(hass, config_entries.ConfigEntryState.NOT_LOADED, None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert "Authentication failed while fetching" in caplog.text assert "The password is no longer valid" in caplog.text # Verify multiple ConfigEntryAuthFailed does not generate a second flow assert entry.state is config_entries.ConfigEntryState.LOADED flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 async def test_initialize_and_shutdown(hass: HomeAssistant) -> None: """Test we call the shutdown function at stop.""" manager = config_entries.ConfigEntries(hass, {}) with patch.object(manager, "_async_shutdown") as mock_async_shutdown: await manager.async_initialize() hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP) await hass.async_block_till_done() assert mock_async_shutdown.called async def test_setup_retrying_during_shutdown( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test if we shutdown an entry that is in retry mode.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) mock_setup_entry = AsyncMock(side_effect=ConfigEntryNotReady) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) with patch("homeassistant.helpers.event.async_call_later") as mock_call: await manager.async_setup(entry.entry_id) assert entry.state is config_entries.ConfigEntryState.SETUP_RETRY assert len(mock_call.return_value.mock_calls) == 0 hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP) await hass.async_block_till_done() assert len(mock_call.return_value.mock_calls) == 0 async_fire_time_changed(hass, dt_util.utcnow() + timedelta(hours=4)) await hass.async_block_till_done() assert len(mock_call.return_value.mock_calls) == 0 # Cleanup to avoid lingering timer entry.async_cancel_retry_setup() async def test_scheduling_reload_cancels_setup_retry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test scheduling a reload cancels setup retry.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) mock_setup_entry = AsyncMock(side_effect=ConfigEntryNotReady) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) cancel_mock = Mock() with patch( "homeassistant.config_entries.async_call_later", return_value=cancel_mock ): await manager.async_setup(entry.entry_id) assert entry.state is config_entries.ConfigEntryState.SETUP_RETRY assert len(cancel_mock.mock_calls) == 0 mock_setup_entry.side_effect = None mock_setup_entry.return_value = True hass.config_entries.async_schedule_reload(entry.entry_id) assert len(cancel_mock.mock_calls) == 1 await hass.async_block_till_done() assert entry.state is config_entries.ConfigEntryState.LOADED async def test_scheduling_reload_unknown_entry(hass: HomeAssistant) -> None: """Test scheduling a reload raises with an unknown entry.""" with pytest.raises(config_entries.UnknownEntry): hass.config_entries.async_schedule_reload("non-existing") @pytest.mark.parametrize( ("matchers", "reason"), [ ({}, "already_configured"), ({"host": "3.3.3.3"}, "no_match"), ({"vendor": "no_match"}, "no_match"), ({"host": "3.4.5.6"}, "already_configured"), ({"host": "3.4.5.6", "ip": "3.4.5.6"}, "no_match"), ({"host": "3.4.5.6", "ip": "1.2.3.4"}, "already_configured"), ({"host": "3.4.5.6", "ip": "1.2.3.4", "port": 23}, "already_configured"), ( {"host": "9.9.9.9", "ip": "6.6.6.6", "port": 12, "vendor": "zoo"}, "already_configured", ), ({"vendor": "zoo"}, "already_configured"), ({"ip": "9.9.9.9"}, "already_configured"), ({"ip": "7.7.7.7"}, "no_match"), # ignored # The next two data sets ensure options or data match # as options previously shadowed data when matching. ({"vendor": "data"}, "already_configured"), ( {"vendor": "options"}, "already_configured", ), ], ) async def test_async_abort_entries_match( hass: HomeAssistant, manager: config_entries.ConfigEntries, matchers: dict[str, str], reason: str, ) -> None: """Test aborting if matching config entries exist.""" MockConfigEntry( domain="comp", data={"ip": "1.2.3.4", "host": "4.5.6.7", "port": 23} ).add_to_hass(hass) MockConfigEntry( domain="comp", data={"ip": "9.9.9.9", "host": "4.5.6.7", "port": 23} ).add_to_hass(hass) MockConfigEntry( domain="comp", data={"ip": "1.2.3.4", "host": "3.4.5.6", "port": 23} ).add_to_hass(hass) MockConfigEntry( domain="comp", source=config_entries.SOURCE_IGNORE, data={"ip": "7.7.7.7", "host": "4.5.6.7", "port": 23}, ).add_to_hass(hass) MockConfigEntry( domain="comp", data={"ip": "6.6.6.6", "host": "9.9.9.9", "port": 12}, options={"vendor": "zoo"}, ).add_to_hass(hass) MockConfigEntry( domain="comp", data={"vendor": "data"}, options={"vendor": "options"}, ).add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("comp", async_setup_entry=mock_setup_entry)) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" self._async_abort_entries_match(matchers) return self.async_abort(reason="no_match") with mock_config_flow("comp", TestFlow), mock_config_flow("invalid_flow", 5): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() assert result["type"] == FlowResultType.ABORT assert result["reason"] == reason @pytest.mark.parametrize( ("matchers", "reason"), [ ({}, "already_configured"), ({"host": "3.3.3.3"}, "no_match"), ({"vendor": "no_match"}, "no_match"), ({"host": "3.4.5.6"}, "already_configured"), ({"host": "3.4.5.6", "ip": "3.4.5.6"}, "no_match"), ({"host": "3.4.5.6", "ip": "1.2.3.4"}, "already_configured"), ({"host": "3.4.5.6", "ip": "1.2.3.4", "port": 23}, "already_configured"), ( {"host": "9.9.9.9", "ip": "6.6.6.6", "port": 12, "vendor": "zoo"}, "already_configured", ), ({"vendor": "zoo"}, "already_configured"), ({"ip": "9.9.9.9"}, "already_configured"), ({"ip": "7.7.7.7"}, "no_match"), # ignored # The next two data sets ensure options or data match # as options previously shadowed data when matching. ({"vendor": "data"}, "already_configured"), ( {"vendor": "options"}, "already_configured", ), ], ) async def test_async_abort_entries_match_options_flow( hass: HomeAssistant, manager: config_entries.ConfigEntries, matchers: dict[str, str], reason: str, ) -> None: """Test aborting if matching config entries exist.""" MockConfigEntry( domain="test_abort", data={"ip": "1.2.3.4", "host": "4.5.6.7", "port": 23} ).add_to_hass(hass) MockConfigEntry( domain="test_abort", data={"ip": "9.9.9.9", "host": "4.5.6.7", "port": 23} ).add_to_hass(hass) MockConfigEntry( domain="test_abort", data={"ip": "1.2.3.4", "host": "3.4.5.6", "port": 23} ).add_to_hass(hass) MockConfigEntry( domain="test_abort", source=config_entries.SOURCE_IGNORE, data={"ip": "7.7.7.7", "host": "4.5.6.7", "port": 23}, ).add_to_hass(hass) MockConfigEntry( domain="test_abort", data={"ip": "6.6.6.6", "host": "9.9.9.9", "port": 12}, options={"vendor": "zoo"}, ).add_to_hass(hass) MockConfigEntry( domain="test_abort", data={"vendor": "data"}, options={"vendor": "options"}, ).add_to_hass(hass) original_entry = MockConfigEntry(domain="test_abort", data={}) original_entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("test_abort", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test_abort.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" @staticmethod @callback def async_get_options_flow(config_entry): """Test options flow.""" class _OptionsFlow(config_entries.OptionsFlow): """Test flow.""" async def async_step_init(self, user_input=None): """Test user step.""" if errors := self._async_abort_entries_match(user_input): return self.async_abort(reason=errors["base"]) return self.async_abort(reason="no_match") return _OptionsFlow() with mock_config_flow("test_abort", TestFlow): result = await hass.config_entries.options.async_init( original_entry.entry_id, data=matchers ) assert result["type"] == FlowResultType.ABORT assert result["reason"] == reason async def test_loading_old_data( hass: HomeAssistant, hass_storage: dict[str, Any] ) -> None: """Test automatically migrating old data.""" hass_storage[config_entries.STORAGE_KEY] = { "version": 1, "data": { "entries": [ { "version": 5, "domain": "my_domain", "entry_id": "mock-id", "data": {"my": "data"}, "source": "user", "title": "Mock title", "system_options": {"disable_new_entities": True}, } ] }, } manager = config_entries.ConfigEntries(hass, {}) await manager.async_initialize() entries = manager.async_entries() assert len(entries) == 1 entry = entries[0] assert entry.version == 5 assert entry.domain == "my_domain" assert entry.entry_id == "mock-id" assert entry.title == "Mock title" assert entry.data == {"my": "data"} assert entry.pref_disable_new_entities is True async def test_deprecated_disabled_by_str_ctor() -> None: """Test deprecated str disabled_by constructor enumizes and logs a warning.""" with pytest.raises( TypeError, match="disabled_by must be a ConfigEntryDisabler value, got user" ): MockConfigEntry(disabled_by=config_entries.ConfigEntryDisabler.USER.value) async def test_deprecated_disabled_by_str_set( hass: HomeAssistant, manager: config_entries.ConfigEntries, ) -> None: """Test deprecated str set disabled_by enumizes and logs a warning.""" entry = MockConfigEntry(domain="comp") entry.add_to_manager(manager) hass.config.components.add("comp") with pytest.raises( TypeError, match="disabled_by must be a ConfigEntryDisabler value, got user" ): await manager.async_set_disabled_by( entry.entry_id, config_entries.ConfigEntryDisabler.USER.value ) async def test_entry_reload_concurrency( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test multiple reload calls do not cause a reload race.""" entry = MockConfigEntry(domain="comp", state=config_entries.ConfigEntryState.LOADED) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) loaded = 1 async def _async_setup_entry(*args, **kwargs): await asyncio.sleep(0) nonlocal loaded loaded += 1 return loaded == 1 async def _async_unload_entry(*args, **kwargs): await asyncio.sleep(0) nonlocal loaded loaded -= 1 return loaded == 0 mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=_async_setup_entry, async_unload_entry=_async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) hass.config.components.add("comp") tasks = [ asyncio.create_task(manager.async_reload(entry.entry_id)) for _ in range(15) ] await asyncio.gather(*tasks) assert entry.state is config_entries.ConfigEntryState.LOADED assert loaded == 1 async def test_entry_reload_concurrency_not_setup_setup( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test multiple reload calls do not cause a reload race.""" entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.NOT_LOADED ) entry.add_to_hass(hass) async_setup = AsyncMock(return_value=True) loaded = 0 async def _async_setup_entry(*args, **kwargs): await asyncio.sleep(0) nonlocal loaded loaded += 1 return loaded == 1 async def _async_unload_entry(*args, **kwargs): await asyncio.sleep(0) nonlocal loaded loaded -= 1 return loaded == 0 mock_integration( hass, MockModule( "comp", async_setup=async_setup, async_setup_entry=_async_setup_entry, async_unload_entry=_async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) tasks = [ asyncio.create_task(manager.async_reload(entry.entry_id)) for _ in range(15) ] await asyncio.gather(*tasks) assert entry.state is config_entries.ConfigEntryState.LOADED assert loaded == 1 async def test_unique_id_update_while_setup_in_progress( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test we handle the case where the config entry is updated while setup is in progress.""" async def mock_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock setting up entry.""" await asyncio.sleep(0.1) return True async def mock_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock unloading an entry.""" return True hass.config.components.add("comp") entry = MockConfigEntry( domain="comp", data={"additional": "data", "host": "0.0.0.0"}, unique_id="mock-unique-id", state=config_entries.ConfigEntryState.SETUP_RETRY, ) entry.add_to_hass(hass) mock_integration( hass, MockModule( "comp", async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) updates = {"host": "1.1.1.1"} hass.async_create_task(hass.config_entries.async_reload(entry.entry_id)) await asyncio.sleep(0) assert entry.state is config_entries.ConfigEntryState.SETUP_IN_PROGRESS class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" await self.async_set_unique_id("mock-unique-id") await self._abort_if_unique_id_configured( updates=updates, reload_on_update=True ) with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.config_entries.ConfigEntries.async_reload" ) as async_reload, ): result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) await hass.async_block_till_done() assert result["type"] == FlowResultType.ABORT assert result["reason"] == "already_configured" assert entry.data["host"] == "1.1.1.1" assert entry.data["additional"] == "data" # Setup is already in progress, we should not reload # if it fails it will go into a retry state and try again assert len(async_reload.mock_calls) == 0 await hass.async_block_till_done() assert entry.state is config_entries.ConfigEntryState.LOADED async def test_disallow_entry_reload_with_setup_in_progress( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test we do not allow reload while the config entry is still setting up.""" entry = MockConfigEntry( domain="comp", state=config_entries.ConfigEntryState.SETUP_IN_PROGRESS ) entry.add_to_hass(hass) hass.config.components.add("comp") with pytest.raises( config_entries.OperationNotAllowed, match=str(config_entries.ConfigEntryState.SETUP_IN_PROGRESS), ): assert await manager.async_reload(entry.entry_id) assert entry.state is config_entries.ConfigEntryState.SETUP_IN_PROGRESS async def test_reauth( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test the async_reauth_helper.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) entry2 = MockConfigEntry(title="test_title", domain="test") entry2.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() flow = hass.config_entries.flow with patch.object(flow, "async_init", wraps=flow.async_init) as mock_init: entry.async_start_reauth( hass, context={"extra_context": "some_extra_context"}, data={"extra_data": 1234}, ) await hass.async_block_till_done() flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"]["entry_id"] == entry.entry_id assert flows[0]["context"]["source"] == config_entries.SOURCE_REAUTH assert flows[0]["context"]["title_placeholders"] == {"name": "test_title"} assert flows[0]["context"]["extra_context"] == "some_extra_context" assert mock_init.call_args.kwargs["data"]["extra_data"] == 1234 assert entry.entry_id != entry2.entry_id # Check that we can't start duplicate reauth flows entry.async_start_reauth(hass, {"extra_context": "some_extra_context"}) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 1 # Check that we can't start duplicate reauth flows when the context is different entry.async_start_reauth(hass, {"diff": "diff"}) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 1 # Check that we can start a reauth flow for a different entry entry2.async_start_reauth(hass, {"extra_context": "some_extra_context"}) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 2 # Abort all existing flows for flow in hass.config_entries.flow.async_progress(): hass.config_entries.flow.async_abort(flow["flow_id"]) await hass.async_block_till_done() # Check that we can't start duplicate reauth flows # without blocking between flows entry.async_start_reauth(hass, {"extra_context": "some_extra_context"}) entry.async_start_reauth(hass, {"extra_context": "some_extra_context"}) entry.async_start_reauth(hass, {"extra_context": "some_extra_context"}) entry.async_start_reauth(hass, {"extra_context": "some_extra_context"}) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 1 @pytest.mark.parametrize( "source", [config_entries.SOURCE_REAUTH, config_entries.SOURCE_RECONFIGURE] ) async def test_reauth_reconfigure_missing_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries, source: str, caplog: pytest.LogCaptureFixture, ) -> None: """Test the async_reauth_helper.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() with pytest.raises( RuntimeError, match=f"Detected code that initialises a {source} flow without a link " "to the config entry. Please report this issue.", ): await manager.flow.async_init("test", context={"source": source}) await hass.async_block_till_done() flows = hass.config_entries.flow.async_progress() assert len(flows) == 0 @pytest.mark.usefixtures("mock_integration_frame") @patch.object(frame, "_REPORTED_INTEGRATIONS", set()) @pytest.mark.parametrize( "source", [config_entries.SOURCE_REAUTH, config_entries.SOURCE_RECONFIGURE] ) async def test_reauth_reconfigure_missing_entry_component( hass: HomeAssistant, manager: config_entries.ConfigEntries, source: str, caplog: pytest.LogCaptureFixture, ) -> None: """Test the async_reauth_helper.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() with patch.object(frame, "_REPORTED_INTEGRATIONS", set()): await manager.flow.async_init("test", context={"source": source}) await hass.async_block_till_done() # Flow still created, but deprecation logged flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"]["source"] == source assert ( f"Detected that integration 'hue' initialises a {source} flow" " without a link to the config entry at homeassistant/components" in caplog.text ) async def test_reconfigure( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test the async_reconfigure_helper.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) entry2 = MockConfigEntry(title="test_title", domain="test") entry2.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() def _async_start_reconfigure(config_entry: MockConfigEntry) -> None: hass.async_create_task( manager.flow.async_init( config_entry.domain, context={ "source": config_entries.SOURCE_RECONFIGURE, "entry_id": config_entry.entry_id, }, ), f"config entry reconfigure {config_entry.title} " f"{config_entry.domain} {config_entry.entry_id}", ) _async_start_reconfigure(entry) await hass.async_block_till_done() flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 assert flows[0]["context"]["entry_id"] == entry.entry_id assert flows[0]["context"]["source"] == config_entries.SOURCE_RECONFIGURE assert entry.entry_id != entry2.entry_id # Check that we can start duplicate reconfigure flows # (may need revisiting) _async_start_reconfigure(entry) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 2 # Check that we can start a reconfigure flow for a different entry _async_start_reconfigure(entry2) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 3 # Abort all existing flows for flow in hass.config_entries.flow.async_progress(): hass.config_entries.flow.async_abort(flow["flow_id"]) await hass.async_block_till_done() # Check that we can start duplicate reconfigure flows # without blocking between flows # (may need revisiting) _async_start_reconfigure(entry) _async_start_reconfigure(entry) _async_start_reconfigure(entry) _async_start_reconfigure(entry) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 4 # Abort all existing flows for flow in hass.config_entries.flow.async_progress(): hass.config_entries.flow.async_abort(flow["flow_id"]) await hass.async_block_till_done() # Check that we can start reconfigure flows with active reauth flow # (may need revisiting) entry.async_start_reauth(hass, {"extra_context": "some_extra_context"}) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 1 _async_start_reconfigure(entry) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 2 # Abort all existing flows for flow in hass.config_entries.flow.async_progress(): hass.config_entries.flow.async_abort(flow["flow_id"]) await hass.async_block_till_done() # Check that we can't start reauth flows with active reconfigure flow _async_start_reconfigure(entry) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 1 entry.async_start_reauth(hass, {"extra_context": "some_extra_context"}) await hass.async_block_till_done() assert len(hass.config_entries.flow.async_progress()) == 1 async def test_get_active_flows( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test the async_get_active_flows helper.""" entry = MockConfigEntry(title="test_title", domain="test") entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() flow = hass.config_entries.flow with patch.object(flow, "async_init", wraps=flow.async_init): entry.async_start_reauth( hass, context={"extra_context": "some_extra_context"}, data={"extra_data": 1234}, ) await hass.async_block_till_done() # Check that there's an active reauth flow: active_reauth_flow = next( iter(entry.async_get_active_flows(hass, {config_entries.SOURCE_REAUTH})), None ) assert active_reauth_flow is not None # Check that there isn't any other flow (in this case, a user flow): active_user_flow = next( iter(entry.async_get_active_flows(hass, {config_entries.SOURCE_USER})), None ) assert active_user_flow is None async def test_async_wait_component_dynamic(hass: HomeAssistant) -> None: """Test async_wait_component for a config entry which is dynamically loaded.""" entry = MockConfigEntry(title="test_title", domain="test") mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) entry.add_to_hass(hass) # The config entry is not loaded, and is also not scheduled to load assert await hass.config_entries.async_wait_component(entry) is False await hass.config_entries.async_setup(entry.entry_id) await hass.async_block_till_done() # The config entry is loaded assert await hass.config_entries.async_wait_component(entry) is True async def test_async_wait_component_startup(hass: HomeAssistant) -> None: """Test async_wait_component for a config entry which is loaded at startup.""" entry = MockConfigEntry(title="test_title", domain="test") setup_stall = asyncio.Event() setup_started = asyncio.Event() async def mock_setup(hass: HomeAssistant, _) -> bool: setup_started.set() await setup_stall.wait() return True mock_setup_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule("test", async_setup=mock_setup, async_setup_entry=mock_setup_entry), ) mock_platform(hass, "test.config_flow", None) entry.add_to_hass(hass) # The config entry is not loaded, and is also not scheduled to load assert await hass.config_entries.async_wait_component(entry) is False # Mark the component as scheduled to be loaded async_set_domains_to_be_loaded(hass, {"test"}) # Start loading the component, including its config entries hass.async_create_task(async_setup_component(hass, "test", {})) await setup_started.wait() # The component is not yet loaded assert "test" not in hass.config.components # Allow setup to proceed setup_stall.set() # The component is scheduled to load, this will block until the config entry is loaded assert await hass.config_entries.async_wait_component(entry) is True # The component has been loaded assert "test" in hass.config.components @pytest.mark.parametrize( "integration_frame_path", ["homeassistant/components/my_integration", "homeassistant.core"], ) @pytest.mark.usefixtures("mock_integration_frame") async def test_options_flow_with_config_entry_core() -> None: """Test that OptionsFlowWithConfigEntry cannot be used in core.""" entry = MockConfigEntry( domain="hue", data={"first": True}, options={"sub_dict": {"1": "one"}, "sub_list": ["one"]}, ) with pytest.raises(RuntimeError, match="inherits from OptionsFlowWithConfigEntry"): _ = config_entries.OptionsFlowWithConfigEntry(entry) @pytest.mark.parametrize("integration_frame_path", ["custom_components/my_integration"]) @pytest.mark.usefixtures("mock_integration_frame") @patch.object(frame, "_REPORTED_INTEGRATIONS", set()) async def test_options_flow_with_config_entry(caplog: pytest.LogCaptureFixture) -> None: """Test that OptionsFlowWithConfigEntry doesn't mutate entry options.""" entry = MockConfigEntry( domain="hue", data={"first": True}, options={"sub_dict": {"1": "one"}, "sub_list": ["one"]}, ) options_flow = config_entries.OptionsFlowWithConfigEntry(entry) assert caplog.text == "" # No deprecation warning for custom components # Ensure available at startup assert options_flow.config_entry is entry assert options_flow.options == entry.options options_flow.options["sub_dict"]["2"] = "two" options_flow.options["sub_list"].append("two") # Ensure it does not mutate the entry options assert options_flow.options == { "sub_dict": {"1": "one", "2": "two"}, "sub_list": ["one", "two"], } assert entry.options == {"sub_dict": {"1": "one"}, "sub_list": ["one"]} async def test_initializing_flows_canceled_on_shutdown( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that initializing flows are canceled on shutdown.""" class MockFlowHandler(config_entries.ConfigFlow): """Define a mock flow handler.""" VERSION = 1 async def async_step_reauth(self, data): """Mock Reauth.""" await asyncio.sleep(1) mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) with patch.dict( config_entries.HANDLERS, {"comp": MockFlowHandler, "test": MockFlowHandler} ): task = asyncio.create_task( manager.flow.async_init( "test", context={"source": "reauth", "entry_id": "abc"} ) ) await hass.async_block_till_done() manager.flow.async_shutdown() with pytest.raises(asyncio.exceptions.CancelledError): await task async def test_task_tracking(hass: HomeAssistant) -> None: """Test task tracking for a config entry.""" entry = MockConfigEntry(title="test_title", domain="test") event = asyncio.Event() results = [] async def test_task() -> None: try: await event.wait() results.append("normal") except asyncio.CancelledError: results.append("background") raise async def test_unload() -> None: await event.wait() results.append("on_unload") entry.async_on_unload(test_unload) entry.async_create_task(hass, test_task()) entry.async_create_background_task( hass, test_task(), "background-task-name", eager_start=True ) entry.async_create_background_task( hass, test_task(), "background-task-name", eager_start=False ) await asyncio.sleep(0) hass.loop.call_soon(event.set) await entry._async_process_on_unload(hass) assert results == [ "background", "background", "normal", "on_unload", ] async def test_preview_supported( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test preview support.""" preview_calls = [] class MockFlowHandler(config_entries.ConfigFlow): """Define a mock flow handler.""" VERSION = 1 async def async_step_test1(self, data): """Mock Reauth.""" return self.async_show_form(step_id="next") async def async_step_test2(self, data): """Mock Reauth.""" return self.async_show_form(step_id="next", preview="test") async def async_step_next(self, user_input=None): raise NotImplementedError @staticmethod async def async_setup_preview(hass: HomeAssistant) -> None: """Set up preview.""" preview_calls.append(None) mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) assert len(preview_calls) == 0 with patch.dict( config_entries.HANDLERS, {"comp": MockFlowHandler, "test": MockFlowHandler} ): result = await manager.flow.async_init("test", context={"source": "test1"}) assert len(preview_calls) == 0 assert result["preview"] is None result = await manager.flow.async_init("test", context={"source": "test2"}) assert len(preview_calls) == 1 assert result["preview"] == "test" async def test_preview_not_supported( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test preview support.""" class MockFlowHandler(config_entries.ConfigFlow): """Define a mock flow handler.""" VERSION = 1 async def async_step_user(self, user_input): """Mock Reauth.""" return self.async_show_form(step_id="user_confirm") async def async_step_user_confirm(self, user_input=None): raise NotImplementedError mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) with patch.dict( config_entries.HANDLERS, {"comp": MockFlowHandler, "test": MockFlowHandler} ): result = await manager.flow.async_init( "test", context={"source": config_entries.SOURCE_USER} ) assert result["preview"] is None def test_raise_trying_to_add_same_config_entry_twice( hass: HomeAssistant, caplog: pytest.LogCaptureFixture ) -> None: """Test we log an error if trying to add same config entry twice.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) entry.add_to_hass(hass) assert f"An entry with the id {entry.entry_id} already exists" in caplog.text @pytest.mark.parametrize( ( "kwargs", "expected_title", "expected_unique_id", "expected_data", "expected_options", "calls_entry_load_unload", "raises", ), [ ( { "unique_id": "5678", "title": "Updated title", "data": {"vendor": "data2"}, "options": {"vendor": "options2"}, }, "Updated title", "5678", {"vendor": "data2"}, {"vendor": "options2"}, (2, 1), None, ), ( { "unique_id": "1234", "title": "Test", "data": {"vendor": "data"}, "options": {"vendor": "options"}, }, "Test", "1234", {"vendor": "data"}, {"vendor": "options"}, (2, 1), None, ), ( { "unique_id": "5678", "title": "Updated title", "data": {"vendor": "data2"}, "options": {"vendor": "options2"}, "reload_even_if_entry_is_unchanged": True, }, "Updated title", "5678", {"vendor": "data2"}, {"vendor": "options2"}, (2, 1), None, ), ( { "unique_id": "1234", "title": "Test", "data": {"vendor": "data"}, "options": {"vendor": "options"}, "reload_even_if_entry_is_unchanged": False, }, "Test", "1234", {"vendor": "data"}, {"vendor": "options"}, (1, 0), None, ), ( {}, "Test", "1234", {"vendor": "data"}, {"vendor": "options"}, (2, 1), None, ), ( {"data": {"buyer": "me"}, "options": {}}, "Test", "1234", {"buyer": "me"}, {}, (2, 1), None, ), ( {"data_updates": {"buyer": "me"}}, "Test", "1234", {"vendor": "data", "buyer": "me"}, {"vendor": "options"}, (2, 1), None, ), ( { "unique_id": "5678", "title": "Updated title", "data": {"vendor": "data2"}, "options": {"vendor": "options2"}, "data_updates": {"buyer": "me"}, }, "Test", "1234", {"vendor": "data"}, {"vendor": "options"}, (1, 0), ValueError, ), ], ids=[ "changed_entry_default", "unchanged_entry_default", "changed_entry_explicit_reload", "unchanged_entry_no_reload", "no_kwargs", "replace_data", "update_data", "update_and_data_raises", ], ) @pytest.mark.parametrize( ("source", "reason"), [ (config_entries.SOURCE_REAUTH, "reauth_successful"), (config_entries.SOURCE_RECONFIGURE, "reconfigure_successful"), ], ) async def test_update_entry_and_reload( hass: HomeAssistant, source: str, reason: str, expected_title: str, expected_unique_id: str, expected_data: dict[str, Any], expected_options: dict[str, Any], kwargs: dict[str, Any], calls_entry_load_unload: tuple[int, int], raises: type[Exception] | None, ) -> None: """Test updating an entry and reloading.""" entry = MockConfigEntry( domain="comp", unique_id="1234", title="Test", data={"vendor": "data"}, options={"vendor": "options"}, ) entry.add_to_hass(hass) comp = MockModule( "comp", async_setup_entry=AsyncMock(return_value=True), async_unload_entry=AsyncMock(return_value=True), ) mock_integration(hass, comp) mock_platform(hass, "comp.config_flow", None) await hass.config_entries.async_setup(entry.entry_id) class MockFlowHandler(config_entries.ConfigFlow): """Define a mock flow handler.""" VERSION = 1 async def async_step_reauth(self, data): """Mock Reauth.""" return self.async_update_reload_and_abort(entry, **kwargs) async def async_step_reconfigure(self, data): """Mock Reconfigure.""" return self.async_update_reload_and_abort(entry, **kwargs) err: Exception with mock_config_flow("comp", MockFlowHandler): try: if source == config_entries.SOURCE_REAUTH: result = await entry.start_reauth_flow(hass) elif source == config_entries.SOURCE_RECONFIGURE: result = await entry.start_reconfigure_flow(hass) except Exception as ex: # noqa: BLE001 err = ex await hass.async_block_till_done() assert entry.title == expected_title assert entry.unique_id == expected_unique_id assert entry.data == expected_data assert entry.options == expected_options assert entry.state == config_entries.ConfigEntryState.LOADED if raises: assert isinstance(err, raises) else: assert result["type"] == FlowResultType.ABORT assert result["reason"] == reason # Assert entry was reloaded assert len(comp.async_setup_entry.mock_calls) == calls_entry_load_unload[0] assert len(comp.async_unload_entry.mock_calls) == calls_entry_load_unload[1] @pytest.mark.parametrize("unique_id", [["blah", "bleh"], {"key": "value"}]) async def test_unhashable_unique_id_fails( hass: HomeAssistant, caplog: pytest.LogCaptureFixture, unique_id: Any ) -> None: """Test the ConfigEntryItems user dict fails unhashable unique_id.""" entries = config_entries.ConfigEntryItems(hass) entry = config_entries.ConfigEntry( data={}, discovery_keys={}, domain="test", entry_id="mock_id", minor_version=1, options={}, source="test", title="title", unique_id=unique_id, version=1, ) unique_id_string = re.escape(str(unique_id)) with pytest.raises( HomeAssistantError, match=f"The entry unique id {unique_id_string} is not a string.", ): entries[entry.entry_id] = entry assert entry.entry_id not in entries with pytest.raises( HomeAssistantError, match=f"The entry unique id {unique_id_string} is not a string.", ): entries.get_entry_by_domain_and_unique_id("test", unique_id) @pytest.mark.parametrize("unique_id", [["blah", "bleh"], {"key": "value"}]) async def test_unhashable_unique_id_fails_on_update( hass: HomeAssistant, caplog: pytest.LogCaptureFixture, unique_id: Any ) -> None: """Test the ConfigEntryItems user dict fails non-hashable unique_id on update.""" entries = config_entries.ConfigEntryItems(hass) entry = config_entries.ConfigEntry( data={}, discovery_keys={}, domain="test", entry_id="mock_id", minor_version=1, options={}, source="test", title="title", unique_id="123", version=1, ) entries[entry.entry_id] = entry assert entry.entry_id in entries unique_id_string = re.escape(str(unique_id)) with pytest.raises( HomeAssistantError, match=f"The entry unique id {unique_id_string} is not a string.", ): entries.update_unique_id(entry, unique_id) async def test_string_unique_id_no_warning( hass: HomeAssistant, caplog: pytest.LogCaptureFixture, ) -> None: """Test the ConfigEntryItems user dict string unique id doesn't log warning.""" entries = config_entries.ConfigEntryItems(hass) entry = config_entries.ConfigEntry( data={}, discovery_keys={}, domain="test", entry_id="mock_id", minor_version=1, options={}, source="test", title="title", unique_id="123", version=1, ) entries[entry.entry_id] = entry assert ( "Config entry 'title' from integration test has an invalid unique_id" ) not in caplog.text assert entry.entry_id in entries assert entries[entry.entry_id] is entry assert entries.get_entry_by_domain_and_unique_id("test", "123") == entry del entries[entry.entry_id] assert not entries assert entries.get_entry_by_domain_and_unique_id("test", "123") is None @pytest.mark.parametrize( ("unique_id", "type_name"), [ (123, "int"), (2.3, "float"), ], ) async def test_hashable_unique_id( hass: HomeAssistant, caplog: pytest.LogCaptureFixture, unique_id: Any, type_name: str, ) -> None: """Test the ConfigEntryItems user dict handles hashable non string unique_id.""" entries = config_entries.ConfigEntryItems(hass) entry = config_entries.ConfigEntry( data={}, discovery_keys={}, domain="test", entry_id="mock_id", minor_version=1, options={}, source="test", title="title", unique_id=unique_id, version=1, ) entries[entry.entry_id] = entry assert ( "Config entry 'title' from integration test has an invalid unique_id" f" '{unique_id}' of type {type_name} when a string is expected" ) in caplog.text assert entry.entry_id in entries assert entries[entry.entry_id] is entry assert entries.get_entry_by_domain_and_unique_id("test", unique_id) == entry del entries[entry.entry_id] assert not entries assert entries.get_entry_by_domain_and_unique_id("test", unique_id) is None async def test_no_unique_id_no_warning( hass: HomeAssistant, caplog: pytest.LogCaptureFixture, ) -> None: """Test the ConfigEntryItems user dict don't log warning with no unique id.""" entries = config_entries.ConfigEntryItems(hass) entry = config_entries.ConfigEntry( data={}, discovery_keys={}, domain="test", entry_id="mock_id", minor_version=1, options={}, source="test", title="title", unique_id=None, version=1, ) entries[entry.entry_id] = entry assert ( "Config entry 'title' from integration test has an invalid unique_id" ) not in caplog.text assert entry.entry_id in entries assert entries[entry.entry_id] is entry @pytest.mark.parametrize( ("context", "user_input", "expected_result"), [ ( {"source": config_entries.SOURCE_IGNORE}, {"unique_id": "blah", "title": "blah"}, {"type": data_entry_flow.FlowResultType.CREATE_ENTRY}, ), ( {"source": config_entries.SOURCE_REAUTH, "entry_id": "1234"}, None, {"type": data_entry_flow.FlowResultType.FORM, "step_id": "reauth_confirm"}, ), ( {"source": config_entries.SOURCE_RECONFIGURE, "entry_id": "1234"}, None, {"type": data_entry_flow.FlowResultType.FORM, "step_id": "reauth_confirm"}, ), ( {"source": config_entries.SOURCE_USER}, None, { "type": data_entry_flow.FlowResultType.ABORT, "reason": "single_instance_allowed", "translation_domain": HOMEASSISTANT_DOMAIN, }, ), ], ) async def test_starting_config_flow_on_single_config_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries, context: dict[str, Any], user_input: dict, expected_result: dict, ) -> None: """Test starting a config flow for a single config entry integration. In this test, the integration has one ignored flow and one entry added by user. """ integration = loader.Integration( hass, "components.comp", None, { "name": "Comp", "dependencies": [], "requirements": [], "domain": "comp", "single_config_entry": True, }, ) entry = MockConfigEntry( domain="comp", unique_id="1234", entry_id="1234", title="Test", data={"vendor": "data"}, options={"vendor": "options"}, ) entry.add_to_hass(hass) ignored_entry = MockConfigEntry( domain="comp", unique_id="2345", entry_id="2345", title="Test", data={"vendor": "data"}, options={"vendor": "options"}, source=config_entries.SOURCE_IGNORE, ) ignored_entry.add_to_hass(hass) mock_platform(hass, "comp.config_flow", None) with patch( "homeassistant.loader.async_get_integration", return_value=integration, ): result = await hass.config_entries.flow.async_init( "comp", context=context, data=user_input ) for key in expected_result: assert result[key] == expected_result[key] @pytest.mark.parametrize( ("context", "user_input", "expected_result"), [ ( {"source": config_entries.SOURCE_IGNORE}, {"unique_id": "blah", "title": "blah"}, {"type": data_entry_flow.FlowResultType.CREATE_ENTRY}, ), ( {"source": config_entries.SOURCE_REAUTH, "entry_id": "2345"}, None, {"type": data_entry_flow.FlowResultType.FORM, "step_id": "reauth_confirm"}, ), ( {"source": config_entries.SOURCE_RECONFIGURE, "entry_id": "2345"}, None, {"type": data_entry_flow.FlowResultType.FORM, "step_id": "reauth_confirm"}, ), ( {"source": config_entries.SOURCE_USER}, None, {"type": data_entry_flow.FlowResultType.ABORT, "reason": "not_implemented"}, ), ( {"source": config_entries.SOURCE_ZEROCONF}, None, { "type": data_entry_flow.FlowResultType.ABORT, "reason": "single_instance_allowed", }, ), ], ) async def test_starting_config_flow_on_single_config_entry_2( hass: HomeAssistant, manager: config_entries.ConfigEntries, context: dict[str, Any], user_input: dict, expected_result: dict, ) -> None: """Test starting a config flow for a single config entry integration. In this test, the integration has one ignored flow but no entry added by user. """ integration = loader.Integration( hass, "components.comp", None, { "name": "Comp", "dependencies": [], "requirements": [], "domain": "comp", "single_config_entry": True, }, ) ignored_entry = MockConfigEntry( domain="comp", unique_id="2345", entry_id="2345", title="Test", data={"vendor": "data"}, options={"vendor": "options"}, source=config_entries.SOURCE_IGNORE, ) ignored_entry.add_to_hass(hass) mock_platform(hass, "comp.config_flow", None) with patch( "homeassistant.loader.async_get_integration", return_value=integration, ): result = await hass.config_entries.flow.async_init( "comp", context=context, data=user_input ) for key in expected_result: assert result[key] == expected_result[key] async def test_avoid_adding_second_config_entry_on_single_config_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we cannot add a second entry for a single config entry integration.""" class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" if user_input is None: return self.async_show_form(step_id="user") return self.async_create_entry(title="yo", data={}) integration = loader.Integration( hass, "components.comp", None, { "name": "Comp", "dependencies": [], "requirements": [], "domain": "comp", "single_config_entry": True, }, ) mock_integration(hass, MockModule("comp")) mock_platform(hass, "comp.config_flow", None) with ( patch( "homeassistant.loader.async_get_integration", return_value=integration, ), mock_config_flow("comp", TestFlow), ): # Start a flow result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) assert result["type"] == data_entry_flow.FlowResultType.FORM # Add a config entry entry = MockConfigEntry( domain="comp", unique_id="1234", title="Test", data={"vendor": "data"}, options={"vendor": "options"}, ) entry.add_to_hass(hass) # Finish the in progress flow result = await manager.flow.async_configure( result["flow_id"], user_input={"host": "127.0.0.1"} ) assert result["type"] == data_entry_flow.FlowResultType.ABORT assert result["reason"] == "single_instance_allowed" assert result["translation_domain"] == HOMEASSISTANT_DOMAIN @pytest.mark.parametrize( ("flow_1_unique_id", "flow_2_unique_id"), [ (None, None), ("very_unique", "very_unique"), (None, config_entries.DEFAULT_DISCOVERY_UNIQUE_ID), ("very_unique", config_entries.DEFAULT_DISCOVERY_UNIQUE_ID), ], ) async def test_in_progress_get_canceled_when_entry_is_created( hass: HomeAssistant, manager: config_entries.ConfigEntries, flow_1_unique_id: str | None, flow_2_unique_id: str | None, ) -> None: """Test that we abort all in progress flows when a new entry is created on a single instance only integration.""" integration = loader.Integration( hass, "components.comp", None, { "name": "Comp", "dependencies": [], "requirements": [], "domain": "comp", "single_config_entry": True, }, ) mock_integration(hass, MockModule("comp")) mock_platform(hass, "comp.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" if user_input is not None: return self.async_create_entry(title="Test Title", data=user_input) await self.async_set_unique_id(flow_1_unique_id, raise_on_progress=False) return self.async_show_form(step_id="user") async def async_step_zeroconfg(self, user_input=None): """Test user step.""" if user_input is not None: return self.async_create_entry(title="Test Title", data=user_input) await self.async_set_unique_id(flow_2_unique_id, raise_on_progress=False) return self.async_show_form(step_id="user") with ( mock_config_flow("comp", TestFlow), patch( "homeassistant.loader.async_get_integration", return_value=integration, ), ): # Create one to be in progress result = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) assert result["type"] == data_entry_flow.FlowResultType.FORM # Will be canceled result2 = await manager.flow.async_init( "comp", context={"source": config_entries.SOURCE_USER} ) assert result2["type"] == data_entry_flow.FlowResultType.FORM result = await manager.flow.async_configure( result["flow_id"], user_input={"host": "127.0.0.1"} ) assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY assert len(manager.flow.async_progress()) == 0 assert len(manager.async_entries()) == 1 async def test_directly_mutating_blocked( hass: HomeAssistant, caplog: pytest.LogCaptureFixture ) -> None: """Test directly mutating a ConfigEntry is blocked.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) with pytest.raises(AttributeError, match="entry_id cannot be changed"): entry.entry_id = "new_entry_id" with pytest.raises(AttributeError, match="domain cannot be changed"): entry.domain = "new_domain" with pytest.raises(AttributeError, match="state cannot be changed"): entry.state = config_entries.ConfigEntryState.FAILED_UNLOAD with pytest.raises(AttributeError, match="reason cannot be changed"): entry.reason = "new_reason" with pytest.raises( AttributeError, match="unique_id cannot be changed directly, use async_update_entry instead", ): entry.unique_id = "new_id" @pytest.mark.parametrize( "field", [ "data", "options", "title", "pref_disable_new_entities", "pref_disable_polling", "minor_version", "version", ], ) async def test_report_direct_mutation_of_config_entry( hass: HomeAssistant, caplog: pytest.LogCaptureFixture, field: str ) -> None: """Test directly mutating a ConfigEntry is reported.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) with pytest.raises(AttributeError): setattr(entry, field, "new_value") async def test_updating_non_added_entry_raises(hass: HomeAssistant) -> None: """Test updating a non added entry raises UnknownEntry.""" entry = MockConfigEntry(domain="test") with pytest.raises(config_entries.UnknownEntry, match=entry.entry_id): hass.config_entries.async_update_entry(entry, unique_id="new_id") async def test_reload_during_setup(hass: HomeAssistant) -> None: """Test reload during setup waits.""" entry = MockConfigEntry(domain="comp", data={"value": "initial"}) entry.add_to_hass(hass) setup_start_future = hass.loop.create_future() setup_finish_future = hass.loop.create_future() in_setup = False setup_calls = 0 async def mock_async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock setting up an entry.""" nonlocal in_setup nonlocal setup_calls setup_calls += 1 assert not in_setup in_setup = True setup_start_future.set_result(None) await setup_finish_future in_setup = False return True mock_integration( hass, MockModule( "comp", async_setup_entry=mock_async_setup_entry, async_unload_entry=AsyncMock(return_value=True), ), ) mock_platform(hass, "comp.config_flow", None) setup_task = hass.async_create_task(async_setup_component(hass, "comp", {})) await setup_start_future # ensure we are in the setup reload_task = hass.async_create_task( hass.config_entries.async_reload(entry.entry_id) ) await asyncio.sleep(0) setup_finish_future.set_result(None) await setup_task await reload_task assert setup_calls == 2 @pytest.mark.parametrize( "exc", [ ConfigEntryError, ConfigEntryAuthFailed, ConfigEntryNotReady, ], ) async def test_raise_wrong_exception_in_forwarded_platform( hass: HomeAssistant, manager: config_entries.ConfigEntries, exc: Exception, caplog: pytest.LogCaptureFixture, ) -> None: """Test that we can remove an entry.""" async def mock_setup_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock setting up entry.""" await hass.config_entries.async_forward_entry_setups(entry, ["light"]) return True async def mock_unload_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock unloading an entry.""" result = await hass.config_entries.async_unload_platforms(entry, ["light"]) assert result return result mock_remove_entry = AsyncMock(return_value=None) async def mock_setup_entry_platform( hass: HomeAssistant, entry: config_entries.ConfigEntry, async_add_entities: AddEntitiesCallback, ) -> None: """Mock setting up platform.""" raise exc mock_integration( hass, MockModule( "test", async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, async_remove_entry=mock_remove_entry, ), ) mock_platform( hass, "test.light", MockPlatform(async_setup_entry=mock_setup_entry_platform) ) mock_platform(hass, "test.config_flow", None) entry = MockConfigEntry(domain="test", entry_id="test2") entry.add_to_manager(manager) # Setup entry await manager.async_setup(entry.entry_id) await hass.async_block_till_done() exc_type_name = type(exc()).__name__ assert ( f"test raises exception {exc_type_name} in forwarded platform light;" in caplog.text ) assert ( f"Instead raise {exc_type_name} before calling async_forward_entry_setups" in caplog.text ) async def test_config_entry_unloaded_during_platform_setups( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test async_forward_entry_setups not being awaited.""" task = None async def mock_setup_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock setting up entry.""" # Call async_forward_entry_setups in a non-tracked task # so we can unload the config entry during the setup def _late_setup(): nonlocal task task = asyncio.create_task( hass.config_entries.async_forward_entry_setups(entry, ["light"]) ) hass.loop.call_soon(_late_setup) return True async def mock_unload_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock unloading an entry.""" result = await hass.config_entries.async_unload_platforms(entry, ["light"]) assert result return result mock_remove_entry = AsyncMock(return_value=None) async def mock_setup_entry_platform( hass: HomeAssistant, entry: config_entries.ConfigEntry, async_add_entities: AddEntitiesCallback, ) -> None: """Mock setting up platform.""" await asyncio.sleep(0) await asyncio.sleep(0) mock_integration( hass, MockModule( "test", async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, async_remove_entry=mock_remove_entry, ), ) mock_platform( hass, "test.light", MockPlatform(async_setup_entry=mock_setup_entry_platform) ) mock_platform(hass, "test.config_flow", None) entry = MockConfigEntry(domain="test", entry_id="test2") entry.add_to_manager(manager) # Setup entry await manager.async_setup(entry.entry_id) await hass.async_block_till_done() await manager.async_unload(entry.entry_id) await hass.async_block_till_done() del task assert ( "OperationNotAllowed: The config entry 'Mock Title' (test) with " "entry_id 'test2' cannot forward setup for ['light'] because it is " "in state ConfigEntryState.NOT_LOADED, but needs to be in the " "ConfigEntryState.LOADED state" ) in caplog.text async def test_non_awaited_async_forward_entry_setups( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test async_forward_entry_setups not being awaited.""" forward_event = asyncio.Event() task: asyncio.Task | None = None async def mock_setup_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock setting up entry.""" # Call async_forward_entry_setups without awaiting it # This is not allowed and will raise a warning nonlocal task task = create_eager_task( hass.config_entries.async_forward_entry_setups(entry, ["light"]) ) return True async def mock_unload_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock unloading an entry.""" result = await hass.config_entries.async_unload_platforms(entry, ["light"]) assert result return result mock_remove_entry = AsyncMock(return_value=None) async def mock_setup_entry_platform( hass: HomeAssistant, entry: config_entries.ConfigEntry, async_add_entities: AddEntitiesCallback, ) -> None: """Mock setting up platform.""" await forward_event.wait() mock_integration( hass, MockModule( "test", async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, async_remove_entry=mock_remove_entry, ), ) mock_platform( hass, "test.light", MockPlatform(async_setup_entry=mock_setup_entry_platform) ) mock_platform(hass, "test.config_flow", None) entry = MockConfigEntry(domain="test", entry_id="test2") entry.add_to_manager(manager) # Setup entry await manager.async_setup(entry.entry_id) await hass.async_block_till_done() forward_event.set() await hass.async_block_till_done() await task assert ( "Detected code that calls async_forward_entry_setups for integration " "test with title: Mock Title and entry_id: test2, during setup without " "awaiting async_forward_entry_setups, which can cause the setup lock " "to be released before the setup is done. This will stop working in " "Home Assistant 2025.1. Please report this issue." ) in caplog.text async def test_non_awaited_async_forward_entry_setup( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test async_forward_entry_setup not being awaited.""" forward_event = asyncio.Event() task: asyncio.Task | None = None async def mock_setup_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock setting up entry.""" # Call async_forward_entry_setup without awaiting it # This is not allowed and will raise a warning nonlocal task task = create_eager_task( hass.config_entries.async_forward_entry_setup(entry, "light") ) return True async def mock_unload_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock unloading an entry.""" result = await hass.config_entries.async_unload_platforms(entry, ["light"]) assert result return result mock_remove_entry = AsyncMock(return_value=None) async def mock_setup_entry_platform( hass: HomeAssistant, entry: config_entries.ConfigEntry, async_add_entities: AddEntitiesCallback, ) -> None: """Mock setting up platform.""" await forward_event.wait() mock_integration( hass, MockModule( "test", async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, async_remove_entry=mock_remove_entry, ), ) mock_platform( hass, "test.light", MockPlatform(async_setup_entry=mock_setup_entry_platform) ) mock_platform(hass, "test.config_flow", None) entry = MockConfigEntry(domain="test", entry_id="test2") entry.add_to_manager(manager) # Setup entry await manager.async_setup(entry.entry_id) await hass.async_block_till_done() forward_event.set() await hass.async_block_till_done() await task assert ( "Detected code that calls async_forward_entry_setup for integration " "test with title: Mock Title and entry_id: test2, during setup without " "awaiting async_forward_entry_setup, which can cause the setup lock " "to be released before the setup is done. This will stop working in " "Home Assistant 2025.1. Please report this issue." ) in caplog.text async def test_config_entry_unloaded_during_platform_setup( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test async_forward_entry_setup not being awaited.""" task = None async def mock_setup_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock setting up entry.""" # Call async_forward_entry_setup in a non-tracked task # so we can unload the config entry during the setup def _late_setup(): nonlocal task task = asyncio.create_task( hass.config_entries.async_forward_entry_setup(entry, "light") ) hass.loop.call_soon(_late_setup) return True async def mock_unload_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock unloading an entry.""" result = await hass.config_entries.async_unload_platforms(entry, ["light"]) assert result return result mock_remove_entry = AsyncMock(return_value=None) async def mock_setup_entry_platform( hass: HomeAssistant, entry: config_entries.ConfigEntry, async_add_entities: AddEntitiesCallback, ) -> None: """Mock setting up platform.""" await asyncio.sleep(0) await asyncio.sleep(0) mock_integration( hass, MockModule( "test", async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, async_remove_entry=mock_remove_entry, ), ) mock_platform( hass, "test.light", MockPlatform(async_setup_entry=mock_setup_entry_platform) ) mock_platform(hass, "test.config_flow", None) entry = MockConfigEntry(domain="test", entry_id="test2") entry.add_to_manager(manager) # Setup entry await manager.async_setup(entry.entry_id) await hass.async_block_till_done() await manager.async_unload(entry.entry_id) await hass.async_block_till_done() del task assert ( "OperationNotAllowed: The config entry 'Mock Title' (test) with " "entry_id 'test2' cannot forward setup for light because it is " "in state ConfigEntryState.NOT_LOADED, but needs to be in the " "ConfigEntryState.LOADED state" ) in caplog.text async def test_config_entry_late_platform_setup( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test async_forward_entry_setup not being awaited.""" task = None async def mock_setup_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock setting up entry.""" # Call async_forward_entry_setup in a non-tracked task # so we can unload the config entry during the setup def _late_setup(): nonlocal task task = asyncio.create_task( hass.config_entries.async_forward_entry_setup(entry, "light") ) hass.loop.call_soon(_late_setup) return True async def mock_unload_entry( hass: HomeAssistant, entry: config_entries.ConfigEntry ) -> bool: """Mock unloading an entry.""" result = await hass.config_entries.async_unload_platforms(entry, ["light"]) assert result return result mock_remove_entry = AsyncMock(return_value=None) async def mock_setup_entry_platform( hass: HomeAssistant, entry: config_entries.ConfigEntry, async_add_entities: AddEntitiesCallback, ) -> None: """Mock setting up platform.""" await asyncio.sleep(0) await asyncio.sleep(0) mock_integration( hass, MockModule( "test", async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, async_remove_entry=mock_remove_entry, ), ) mock_platform( hass, "test.light", MockPlatform(async_setup_entry=mock_setup_entry_platform) ) mock_platform(hass, "test.config_flow", None) entry = MockConfigEntry(domain="test", entry_id="test2") entry.add_to_manager(manager) # Setup entry await manager.async_setup(entry.entry_id) await hass.async_block_till_done() await task await hass.async_block_till_done() assert ( "OperationNotAllowed: The config entry Mock Title (test) with " "entry_id test2 cannot forward setup for light because it is " "not loaded in the ConfigEntryState.NOT_LOADED state" ) not in caplog.text @pytest.mark.parametrize("load_registries", [False]) async def test_migration_from_1_2( hass: HomeAssistant, hass_storage: dict[str, Any] ) -> None: """Test migration from version 1.2.""" hass_storage[config_entries.STORAGE_KEY] = { "version": 1, "minor_version": 2, "data": { "entries": [ { "data": {}, "disabled_by": None, "domain": "sun", "entry_id": "0a8bd02d0d58c7debf5daf7941c9afe2", "minor_version": 1, "options": {}, "pref_disable_new_entities": False, "pref_disable_polling": False, "source": "import", "title": "Sun", "unique_id": None, "version": 1, }, ] }, } manager = config_entries.ConfigEntries(hass, {}) await manager.async_initialize() # Test data was loaded entries = manager.async_entries() assert len(entries) == 1 # Check we store migrated data await flush_store(manager._store) assert hass_storage[config_entries.STORAGE_KEY] == { "version": config_entries.STORAGE_VERSION, "minor_version": config_entries.STORAGE_VERSION_MINOR, "key": config_entries.STORAGE_KEY, "data": { "entries": [ { "created_at": "1970-01-01T00:00:00+00:00", "data": {}, "disabled_by": None, "discovery_keys": {}, "domain": "sun", "entry_id": "0a8bd02d0d58c7debf5daf7941c9afe2", "minor_version": 1, "modified_at": "1970-01-01T00:00:00+00:00", "options": {}, "pref_disable_new_entities": False, "pref_disable_polling": False, "source": "import", "title": "Sun", "unique_id": None, "version": 1, }, ] }, } async def test_async_loaded_entries( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test that we can get loaded config entries.""" entry1 = MockConfigEntry(domain="comp") entry1.add_to_hass(hass) entry2 = MockConfigEntry(domain="comp", source=config_entries.SOURCE_IGNORE) entry2.add_to_hass(hass) entry3 = MockConfigEntry( domain="comp", disabled_by=config_entries.ConfigEntryDisabler.USER ) entry3.add_to_hass(hass) mock_setup = AsyncMock(return_value=True) mock_setup_entry = AsyncMock(return_value=True) mock_unload_entry = AsyncMock(return_value=True) mock_integration( hass, MockModule( "comp", async_setup=mock_setup, async_setup_entry=mock_setup_entry, async_unload_entry=mock_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) assert hass.config_entries.async_loaded_entries("comp") == [] assert await manager.async_setup(entry1.entry_id) assert not await manager.async_setup(entry2.entry_id) assert not await manager.async_setup(entry3.entry_id) assert hass.config_entries.async_loaded_entries("comp") == [entry1] assert await hass.config_entries.async_unload(entry1.entry_id) assert hass.config_entries.async_loaded_entries("comp") == [] async def test_async_has_matching_discovery_flow( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test we can check for matching discovery flows.""" assert ( manager.flow.async_has_matching_discovery_flow( "test", {"source": config_entries.SOURCE_HOMEKIT}, {"properties": {"id": "aa:bb:cc:dd:ee:ff"}}, ) is False ) mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): VERSION = 5 async def async_step_init(self, user_input=None): return self.async_show_progress( step_id="init", progress_action="task_one", ) async def async_step_homekit(self, discovery_info=None): return await self.async_step_init(discovery_info) with mock_config_flow("test", TestFlow): result = await manager.flow.async_init( "test", context={"source": config_entries.SOURCE_HOMEKIT}, data={"properties": {"id": "aa:bb:cc:dd:ee:ff"}}, ) assert result["type"] == data_entry_flow.FlowResultType.SHOW_PROGRESS assert result["progress_action"] == "task_one" assert len(manager.flow.async_progress()) == 1 assert len(manager.flow.async_progress_by_handler("test")) == 1 assert ( len( manager.flow.async_progress_by_handler( "test", match_context={"source": config_entries.SOURCE_HOMEKIT} ) ) == 1 ) assert ( len( manager.flow.async_progress_by_handler( "test", match_context={"source": config_entries.SOURCE_BLUETOOTH} ) ) == 0 ) assert manager.flow.async_get(result["flow_id"])["handler"] == "test" assert ( manager.flow.async_has_matching_discovery_flow( "test", {"source": config_entries.SOURCE_HOMEKIT}, {"properties": {"id": "aa:bb:cc:dd:ee:ff"}}, ) is True ) assert ( manager.flow.async_has_matching_discovery_flow( "test", {"source": config_entries.SOURCE_SSDP}, {"properties": {"id": "aa:bb:cc:dd:ee:ff"}}, ) is False ) assert ( manager.flow.async_has_matching_discovery_flow( "other", {"source": config_entries.SOURCE_HOMEKIT}, {"properties": {"id": "aa:bb:cc:dd:ee:ff"}}, ) is False ) async def test_async_has_matching_flow( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test check for matching flows when there is no active flow.""" mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): VERSION = 5 async def async_step_init(self, user_input=None): return self.async_show_progress( step_id="init", progress_action="task_one", ) async def async_step_homekit(self, discovery_info=None): return await self.async_step_init(discovery_info) def is_matching(self, other_flow: Self) -> bool: """Return True if other_flow is matching this flow.""" return True # Initiate a flow with mock_config_flow("test", TestFlow): await manager.flow.async_init( "test", context={"source": config_entries.SOURCE_HOMEKIT}, data={"properties": {"id": "aa:bb:cc:dd:ee:ff"}}, ) flow = list(manager.flow._handler_progress_index.get("test"))[0] assert manager.flow.async_has_matching_flow(flow) is False # Initiate another flow with mock_config_flow("test", TestFlow): await manager.flow.async_init( "test", context={"source": config_entries.SOURCE_HOMEKIT}, data={"properties": {"id": "aa:bb:cc:dd:ee:ff"}}, ) assert manager.flow.async_has_matching_flow(flow) is True async def test_async_has_matching_flow_no_flows( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test check for matching flows when there is no active flow.""" mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): VERSION = 5 async def async_step_init(self, user_input=None): return self.async_show_progress( step_id="init", progress_action="task_one", ) async def async_step_homekit(self, discovery_info=None): return await self.async_step_init(discovery_info) with mock_config_flow("test", TestFlow): result = await manager.flow.async_init( "test", context={"source": config_entries.SOURCE_HOMEKIT}, data={"properties": {"id": "aa:bb:cc:dd:ee:ff"}}, ) flow = list(manager.flow._handler_progress_index.get("test"))[0] # Abort the flow before checking for matching flows manager.flow.async_abort(result["flow_id"]) assert manager.flow.async_has_matching_flow(flow) is False async def test_async_has_matching_flow_not_implemented( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test check for matching flows when there is no active flow.""" mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): VERSION = 5 async def async_step_init(self, user_input=None): return self.async_show_progress( step_id="init", progress_action="task_one", ) async def async_step_homekit(self, discovery_info=None): return await self.async_step_init(discovery_info) # Initiate a flow with mock_config_flow("test", TestFlow): await manager.flow.async_init( "test", context={"source": config_entries.SOURCE_HOMEKIT}, data={"properties": {"id": "aa:bb:cc:dd:ee:ff"}}, ) flow = list(manager.flow._handler_progress_index.get("test"))[0] # Initiate another flow with mock_config_flow("test", TestFlow): await manager.flow.async_init( "test", context={"source": config_entries.SOURCE_HOMEKIT}, data={"properties": {"id": "aa:bb:cc:dd:ee:ff"}}, ) # The flow does not implement is_matching with pytest.raises(NotImplementedError): manager.flow.async_has_matching_flow(flow) async def test_get_reauth_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test _get_context_entry behavior.""" entry = MockConfigEntry( title="test_title", domain="test", entry_id="01J915Q6T9F6G5V0QJX6HBC94T", data={"host": "any", "port": 123}, unique_id=None, ) entry.add_to_hass(hass) mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" return await self._async_step_confirm() async def async_step_reauth(self, entry_data): """Test reauth step.""" return await self._async_step_confirm() async def async_step_reconfigure(self, user_input=None): """Test reauth step.""" return await self._async_step_confirm() async def _async_step_confirm(self): """Confirm input.""" try: entry = self._get_reauth_entry() except ValueError as err: reason = str(err) except config_entries.UnknownEntry: reason = "Entry not found" else: reason = f"Found entry {entry.title}" try: entry_id = self._reauth_entry_id except ValueError: reason = f"{reason}: -" else: reason = f"{reason}: {entry_id}" return self.async_abort(reason=reason) # A reauth flow finds the config entry from context with mock_config_flow("test", TestFlow): result = await entry.start_reauth_flow(hass) assert result["reason"] == "Found entry test_title: 01J915Q6T9F6G5V0QJX6HBC94T" # The config entry is removed before the reauth flow is aborted with mock_config_flow("test", TestFlow): result = await entry.start_reauth_flow(hass, context={"entry_id": "01JRemoved"}) assert result["reason"] == "Entry not found: 01JRemoved" # A reconfigure flow does not have access to the config entry with mock_config_flow("test", TestFlow): result = await entry.start_reconfigure_flow(hass) assert result["reason"] == "Source is reconfigure, expected reauth: -" # A user flow does not have access to the config entry with mock_config_flow("test", TestFlow): result = await manager.flow.async_init( "test", context={"source": config_entries.SOURCE_USER} ) assert result["reason"] == "Source is user, expected reauth: -" async def test_get_reconfigure_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test _get_context_entry behavior.""" entry = MockConfigEntry( title="test_title", domain="test", entry_id="01J915Q6T9F6G5V0QJX6HBC94T", data={"host": "any", "port": 123}, unique_id=None, ) entry.add_to_hass(hass) mock_integration(hass, MockModule("test")) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" return await self._async_step_confirm() async def async_step_reauth(self, entry_data): """Test reauth step.""" return await self._async_step_confirm() async def async_step_reconfigure(self, user_input=None): """Test reauth step.""" return await self._async_step_confirm() async def _async_step_confirm(self): """Confirm input.""" try: entry = self._get_reconfigure_entry() except ValueError as err: reason = str(err) except config_entries.UnknownEntry: reason = "Entry not found" else: reason = f"Found entry {entry.title}" try: entry_id = self._reconfigure_entry_id except ValueError: reason = f"{reason}: -" else: reason = f"{reason}: {entry_id}" return self.async_abort(reason=reason) # A reauth flow does not have access to the config entry from context with mock_config_flow("test", TestFlow): result = await entry.start_reauth_flow(hass) assert result["reason"] == "Source is reauth, expected reconfigure: -" # A reconfigure flow finds the config entry with mock_config_flow("test", TestFlow): result = await entry.start_reconfigure_flow(hass) assert result["reason"] == "Found entry test_title: 01J915Q6T9F6G5V0QJX6HBC94T" # The entry_id no longer exists with mock_config_flow("test", TestFlow): result = await manager.flow.async_init( "test", context={ "source": config_entries.SOURCE_RECONFIGURE, "entry_id": "01JRemoved", }, ) assert result["reason"] == "Entry not found: 01JRemoved" # A user flow does not have access to the config entry with mock_config_flow("test", TestFlow): result = await manager.flow.async_init( "test", context={"source": config_entries.SOURCE_USER} ) assert result["reason"] == "Source is user, expected reconfigure: -" async def test_reauth_helper_alignment( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test `start_reauth_flow` helper alignment. It should be aligned with `ConfigEntry._async_init_reauth`. """ entry = MockConfigEntry( title="test_title", domain="test", entry_id="01J915Q6T9F6G5V0QJX6HBC94T", data={"host": "any", "port": 123}, unique_id=None, ) entry.add_to_hass(hass) mock_setup_entry = AsyncMock( side_effect=ConfigEntryAuthFailed("The password is no longer valid") ) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) # Check context via auto-generated reauth await manager.async_setup(entry.entry_id) await hass.async_block_till_done() assert "could not authenticate: The password is no longer valid" in caplog.text assert entry.state is config_entries.ConfigEntryState.SETUP_ERROR assert entry.reason == "The password is no longer valid" flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 reauth_flow_context = flows[0]["context"] reauth_flow_init_data = hass.config_entries.flow._progress[ flows[0]["flow_id"] ].init_data # Clear to make way for `start_reauth_flow` helper manager.flow.async_abort(flows[0]["flow_id"]) flows = hass.config_entries.flow.async_progress() assert len(flows) == 0 # Check context via `start_reauth_flow` helper await entry.start_reauth_flow(hass) flows = hass.config_entries.flow.async_progress() assert len(flows) == 1 helper_flow_context = flows[0]["context"] helper_flow_init_data = hass.config_entries.flow._progress[ flows[0]["flow_id"] ].init_data # Ensure context and init data are aligned assert helper_flow_context == reauth_flow_context assert helper_flow_init_data == reauth_flow_init_data @pytest.mark.parametrize( ("original_unique_id", "new_unique_id", "reason"), [ ("unique", "unique", "success"), (None, None, "success"), ("unique", "new", "unique_id_mismatch"), ("unique", None, "unique_id_mismatch"), (None, "new", "unique_id_mismatch"), ], ) @pytest.mark.parametrize( "source", [config_entries.SOURCE_REAUTH, config_entries.SOURCE_RECONFIGURE], ) async def test_abort_if_unique_id_mismatch( hass: HomeAssistant, source: str, original_unique_id: str | None, new_unique_id: str | None, reason: str, ) -> None: """Test to check if_unique_id_mismatch behavior.""" entry = MockConfigEntry( title="From config flow", domain="test", entry_id="01J915Q6T9F6G5V0QJX6HBC94T", data={"host": "any", "port": 123}, unique_id=original_unique_id, ) entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" return await self._async_step_confirm() async def async_step_reauth(self, entry_data): """Test reauth step.""" return await self._async_step_confirm() async def async_step_reconfigure(self, user_input=None): """Test reauth step.""" return await self._async_step_confirm() async def _async_step_confirm(self): """Confirm input.""" await self.async_set_unique_id(new_unique_id) self._abort_if_unique_id_mismatch() return self.async_abort(reason="success") with mock_config_flow("test", TestFlow): if source == config_entries.SOURCE_REAUTH: result = await entry.start_reauth_flow(hass) elif source == config_entries.SOURCE_RECONFIGURE: result = await entry.start_reconfigure_flow(hass) await hass.async_block_till_done() assert result["type"] is FlowResultType.ABORT assert result["reason"] == reason def test_state_not_stored_in_storage() -> None: """Test that state is not stored in storage. Verify we don't start accidentally storing state in storage. """ entry = MockConfigEntry(domain="test") loaded = json_loads(json_dumps(entry.as_storage_fragment)) for key in config_entries.STATE_KEYS: assert key not in loaded def test_storage_cache_is_cleared_on_entry_update(hass: HomeAssistant) -> None: """Test that the storage cache is cleared when an entry is updated.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) _ = entry.as_storage_fragment hass.config_entries.async_update_entry(entry, data={"new": "data"}) loaded = json_loads(json_dumps(entry.as_storage_fragment)) assert "new" in loaded["data"] async def test_storage_cache_is_cleared_on_entry_disable(hass: HomeAssistant) -> None: """Test that the storage cache is cleared when an entry is disabled.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) _ = entry.as_storage_fragment await hass.config_entries.async_set_disabled_by( entry.entry_id, config_entries.ConfigEntryDisabler.USER ) loaded = json_loads(json_dumps(entry.as_storage_fragment)) assert loaded["disabled_by"] == "user" async def test_state_cache_is_cleared_on_entry_disable(hass: HomeAssistant) -> None: """Test that the state cache is cleared when an entry is disabled.""" entry = MockConfigEntry(domain="test") entry.add_to_hass(hass) _ = entry.as_storage_fragment await hass.config_entries.async_set_disabled_by( entry.entry_id, config_entries.ConfigEntryDisabler.USER ) loaded = json_loads(json_dumps(entry.as_json_fragment)) assert loaded["disabled_by"] == "user" @pytest.mark.parametrize( ("original_unique_id", "new_unique_id", "count"), [ ("unique", "unique", 1), ("unique", "new", 2), ("unique", None, 2), (None, "unique", 2), ], ) @pytest.mark.parametrize( "source", [config_entries.SOURCE_REAUTH, config_entries.SOURCE_RECONFIGURE], ) async def test_create_entry_reauth_reconfigure( hass: HomeAssistant, source: str, original_unique_id: str | None, new_unique_id: str | None, count: int, caplog: pytest.LogCaptureFixture, ) -> None: """Test to highlight unexpected behavior on create_entry.""" entry = MockConfigEntry( title="From config flow", domain="test", entry_id="01J915Q6T9F6G5V0QJX6HBC94T", data={"host": "any", "port": 123}, unique_id=original_unique_id, ) entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): VERSION = 1 async def async_step_user(self, user_input=None): """Test user step.""" return await self._async_step_confirm() async def async_step_reauth(self, entry_data): """Test reauth step.""" return await self._async_step_confirm() async def async_step_reconfigure(self, user_input=None): """Test reauth step.""" return await self._async_step_confirm() async def _async_step_confirm(self): """Confirm input.""" await self.async_set_unique_id(new_unique_id) return self.async_create_entry( title="From config flow", data={"token": "supersecret"}, ) assert len(hass.config_entries.async_entries("test")) == 1 with mock_config_flow("test", TestFlow): result = await getattr(entry, f"start_{source}_flow")(hass) await hass.async_block_till_done() assert result["type"] is FlowResultType.CREATE_ENTRY entries = hass.config_entries.async_entries("test") assert len(entries) == count if count == 1: # Show that the previous entry got binned and recreated assert entries[0].entry_id != entry.entry_id assert ( f"Detected {source} config flow creating a new entry, when it is expected " "to update an existing entry and abort. This will stop working in " "2025.11, please create a bug report at https://github.com/home" "-assistant/core/issues?q=is%3Aopen+is%3Aissue+" "label%3A%22integration%3A+test%22" ) in caplog.text async def test_async_update_entry_unique_id_collision( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, issue_registry: ir.IssueRegistry, ) -> None: """Test we warn when async_update_entry creates a unique_id collision. Also test an issue registry issue is created. """ assert len(issue_registry.issues) == 0 entry1 = MockConfigEntry(domain="test", unique_id=None) entry2 = MockConfigEntry(domain="test", unique_id="not none") entry3 = MockConfigEntry(domain="test", unique_id="very unique") entry4 = MockConfigEntry(domain="test", unique_id="also very unique") entry1.add_to_manager(manager) entry2.add_to_manager(manager) entry3.add_to_manager(manager) entry4.add_to_manager(manager) manager.async_update_entry(entry2, unique_id=None) assert len(issue_registry.issues) == 0 assert len(caplog.record_tuples) == 0 manager.async_update_entry(entry4, unique_id="very unique") assert len(issue_registry.issues) == 1 assert len(caplog.record_tuples) == 1 assert ( "Unique id of config entry 'Mock Title' from integration test changed to " "'very unique' which is already in use" ) in caplog.text issue_id = "config_entry_unique_id_collision_test_very unique" assert issue_registry.async_get_issue(HOMEASSISTANT_DOMAIN, issue_id) @pytest.mark.parametrize("domain", ["flipr"]) async def test_async_update_entry_unique_id_collision_allowed_domain( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, issue_registry: ir.IssueRegistry, domain: str, ) -> None: """Test we warn when async_update_entry creates a unique_id collision. This tests we don't warn and don't create issues for domains which have their own migration path. """ assert len(issue_registry.issues) == 0 entry1 = MockConfigEntry(domain=domain, unique_id=None) entry2 = MockConfigEntry(domain=domain, unique_id="not none") entry3 = MockConfigEntry(domain=domain, unique_id="very unique") entry4 = MockConfigEntry(domain=domain, unique_id="also very unique") entry1.add_to_manager(manager) entry2.add_to_manager(manager) entry3.add_to_manager(manager) entry4.add_to_manager(manager) manager.async_update_entry(entry2, unique_id=None) assert len(issue_registry.issues) == 0 assert len(caplog.record_tuples) == 0 manager.async_update_entry(entry4, unique_id="very unique") assert len(issue_registry.issues) == 0 assert len(caplog.record_tuples) == 0 assert ("already in use") not in caplog.text async def test_unique_id_collision_issues( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, issue_registry: ir.IssueRegistry, snapshot: SnapshotAssertion, ) -> None: """Test issue registry issues are created and remove on unique id collision.""" assert len(issue_registry.issues) == 0 mock_setup_entry = AsyncMock(return_value=True) for i in range(3): mock_integration( hass, MockModule(f"test{i+1}", async_setup_entry=mock_setup_entry) ) mock_platform(hass, f"test{i+1}.config_flow", None) test2_group_1: list[MockConfigEntry] = [] test2_group_2: list[MockConfigEntry] = [] test3: list[MockConfigEntry] = [] for _ in range(3): await manager.async_add(MockConfigEntry(domain="test1", unique_id=None)) test2_group_1.append(MockConfigEntry(domain="test2", unique_id="group_1")) test2_group_2.append(MockConfigEntry(domain="test2", unique_id="group_2")) await manager.async_add(test2_group_1[-1]) await manager.async_add(test2_group_2[-1]) for _ in range(6): test3.append(MockConfigEntry(domain="test3", unique_id="not_unique")) await manager.async_add(test3[-1]) # Add an ignored config entry await manager.async_add( MockConfigEntry( domain="test2", unique_id="group_1", source=config_entries.SOURCE_IGNORE ) ) # Check we get one issue for domain test2 and one issue for domain test3 assert len(issue_registry.issues) == 2 issue_id = "config_entry_unique_id_collision_test2_group_1" assert issue_registry.async_get_issue(HOMEASSISTANT_DOMAIN, issue_id) == snapshot issue_id = "config_entry_unique_id_collision_test3_not_unique" assert issue_registry.async_get_issue(HOMEASSISTANT_DOMAIN, issue_id) == snapshot # Remove one config entry for domain test3, the translations should be updated await manager.async_remove(test3[0].entry_id) assert set(issue_registry.issues) == { (HOMEASSISTANT_DOMAIN, "config_entry_unique_id_collision_test2_group_1"), (HOMEASSISTANT_DOMAIN, "config_entry_unique_id_collision_test3_not_unique"), } assert issue_registry.async_get_issue(HOMEASSISTANT_DOMAIN, issue_id) == snapshot # Remove all but two config entries for domain test 3 for i in range(3): await manager.async_remove(test3[1 + i].entry_id) assert set(issue_registry.issues) == { (HOMEASSISTANT_DOMAIN, "config_entry_unique_id_collision_test2_group_1"), (HOMEASSISTANT_DOMAIN, "config_entry_unique_id_collision_test3_not_unique"), } # Remove the last test3 duplicate, the issue is cleared await manager.async_remove(test3[-1].entry_id) assert set(issue_registry.issues) == { (HOMEASSISTANT_DOMAIN, "config_entry_unique_id_collision_test2_group_1"), } await manager.async_remove(test2_group_1[0].entry_id) assert set(issue_registry.issues) == { (HOMEASSISTANT_DOMAIN, "config_entry_unique_id_collision_test2_group_1"), } # Remove the last test2 group1 duplicate, a new issue is created await manager.async_remove(test2_group_1[1].entry_id) assert set(issue_registry.issues) == { (HOMEASSISTANT_DOMAIN, "config_entry_unique_id_collision_test2_group_2"), } await manager.async_remove(test2_group_2[0].entry_id) assert set(issue_registry.issues) == { (HOMEASSISTANT_DOMAIN, "config_entry_unique_id_collision_test2_group_2"), } # Remove the last test2 group2 duplicate, the issue is cleared await manager.async_remove(test2_group_2[1].entry_id) assert not issue_registry.issues async def test_context_no_leak(hass: HomeAssistant) -> None: """Test ensure that config entry context does not leak. Unlikely to happen in real world, but occurs often in tests. """ connected_future = asyncio.Future() bg_tasks = [] async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock setup entry.""" async def _async_set_runtime_data(): # Show that config_entries.current_entry is preserved for child tasks await connected_future entry.runtime_data = config_entries.current_entry.get() bg_tasks.append(hass.loop.create_task(_async_set_runtime_data())) return True async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Mock unload entry.""" return True mock_integration( hass, MockModule( "comp", async_setup_entry=async_setup_entry, async_unload_entry=async_unload_entry, ), ) mock_platform(hass, "comp.config_flow", None) entry1 = MockConfigEntry(domain="comp") entry1.add_to_hass(hass) await hass.config_entries.async_setup(entry1.entry_id) assert entry1.state is config_entries.ConfigEntryState.LOADED assert config_entries.current_entry.get() is None # Load an existing config entry entry2 = MockConfigEntry(domain="comp") entry2.add_to_hass(hass) await hass.config_entries.async_setup(entry2.entry_id) assert entry2.state is config_entries.ConfigEntryState.LOADED assert config_entries.current_entry.get() is None # Add a new config entry (eg. from config flow) entry3 = MockConfigEntry(domain="comp") await hass.config_entries.async_add(entry3) assert entry3.state is config_entries.ConfigEntryState.LOADED assert config_entries.current_entry.get() is None for entry in (entry1, entry2, entry3): assert entry.state is config_entries.ConfigEntryState.LOADED assert not hasattr(entry, "runtime_data") assert config_entries.current_entry.get() is None connected_future.set_result(None) await asyncio.gather(*bg_tasks) for entry in (entry1, entry2, entry3): assert entry.state is config_entries.ConfigEntryState.LOADED assert entry.runtime_data is entry assert config_entries.current_entry.get() is None async def test_options_flow_config_entry( hass: HomeAssistant, manager: config_entries.ConfigEntries ) -> None: """Test _config_entry_id and config_entry properties in options flow.""" original_entry = MockConfigEntry(domain="test", data={}) original_entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" @staticmethod @callback def async_get_options_flow(config_entry): """Test options flow.""" class _OptionsFlow(config_entries.OptionsFlow): """Test flow.""" def __init__(self) -> None: """Test initialisation.""" try: self.init_entry_id = self._config_entry_id except ValueError as err: self.init_entry_id = err try: self.init_entry = self.config_entry except ValueError as err: self.init_entry = err async def async_step_init(self, user_input=None): """Test user step.""" errors = {} if user_input is not None: if user_input.get("abort"): return self.async_abort(reason="abort") errors["entry_id"] = self._config_entry_id try: errors["entry"] = self.config_entry except config_entries.UnknownEntry as err: errors["entry"] = err return self.async_show_form(step_id="init", errors=errors) return _OptionsFlow() with mock_config_flow("test", TestFlow): result = await hass.config_entries.options.async_init(original_entry.entry_id) options_flow = hass.config_entries.options._progress.get(result["flow_id"]) assert isinstance(options_flow, config_entries.OptionsFlow) assert options_flow.handler == original_entry.entry_id assert isinstance(options_flow.init_entry_id, ValueError) assert ( str(options_flow.init_entry_id) == "The config entry id is not available during initialisation" ) assert isinstance(options_flow.init_entry, ValueError) assert ( str(options_flow.init_entry) == "The config entry is not available during initialisation" ) assert result["type"] == FlowResultType.FORM assert result["step_id"] == "init" assert result["errors"] == {} result = await hass.config_entries.options.async_configure(result["flow_id"], {}) assert result["type"] == FlowResultType.FORM assert result["step_id"] == "init" assert result["errors"]["entry_id"] == original_entry.entry_id assert result["errors"]["entry"] is original_entry # Bad handler - not linked to a config entry options_flow.handler = "123" result = await hass.config_entries.options.async_configure(result["flow_id"], {}) result = await hass.config_entries.options.async_configure(result["flow_id"], {}) assert result["type"] == FlowResultType.FORM assert result["step_id"] == "init" assert result["errors"]["entry_id"] == "123" assert isinstance(result["errors"]["entry"], config_entries.UnknownEntry) # Reset handler options_flow.handler = original_entry.entry_id result = await hass.config_entries.options.async_configure( result["flow_id"], {"abort": True} ) assert result["type"] == FlowResultType.ABORT assert result["reason"] == "abort" @pytest.mark.usefixtures("mock_integration_frame") @patch.object(frame, "_REPORTED_INTEGRATIONS", set()) async def test_options_flow_deprecated_config_entry_setter( hass: HomeAssistant, manager: config_entries.ConfigEntries, caplog: pytest.LogCaptureFixture, ) -> None: """Test that setting config_entry explicitly still works.""" original_entry = MockConfigEntry(domain="hue", data={}) original_entry.add_to_hass(hass) mock_setup_entry = AsyncMock(return_value=True) mock_integration(hass, MockModule("hue", async_setup_entry=mock_setup_entry)) mock_platform(hass, "hue.config_flow", None) class TestFlow(config_entries.ConfigFlow): """Test flow.""" @staticmethod @callback def async_get_options_flow(config_entry): """Test options flow.""" class _OptionsFlow(config_entries.OptionsFlow): """Test flow.""" def __init__(self, entry) -> None: """Test initialisation.""" self.config_entry = entry async def async_step_init(self, user_input=None): """Test user step.""" errors = {} if user_input is not None: if user_input.get("abort"): return self.async_abort(reason="abort") errors["entry_id"] = self._config_entry_id try: errors["entry"] = self.config_entry except config_entries.UnknownEntry as err: errors["entry"] = err return self.async_show_form(step_id="init", errors=errors) return _OptionsFlow(config_entry) with mock_config_flow("hue", TestFlow): result = await hass.config_entries.options.async_init(original_entry.entry_id) options_flow = hass.config_entries.options._progress.get(result["flow_id"]) assert options_flow.config_entry is original_entry assert ( "Detected that integration 'hue' sets option flow config_entry explicitly, " "which is deprecated and will stop working in 2025.12" in caplog.text ) async def test_add_description_placeholder_automatically( hass: HomeAssistant, manager: config_entries.ConfigEntries, ) -> None: """Test entry title is added automatically to reauth flows description placeholder.""" entry = MockConfigEntry(title="test_title", domain="test") mock_setup_entry = AsyncMock(side_effect=ConfigEntryAuthFailed()) mock_integration(hass, MockModule("test", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test.config_flow", None) entry.add_to_hass(hass) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() flows = hass.config_entries.flow.async_progress_by_handler("test") assert len(flows) == 1 result = await hass.config_entries.flow.async_configure(flows[0]["flow_id"], None) assert result["type"] == FlowResultType.FORM assert result["description_placeholders"] == {"name": "test_title"} async def test_add_description_placeholder_automatically_not_overwrites( hass: HomeAssistant, manager: config_entries.ConfigEntries, ) -> None: """Test entry title is not added automatically to reauth flows when custom name exist.""" entry = MockConfigEntry(title="test_title", domain="test2") mock_setup_entry = AsyncMock(side_effect=ConfigEntryAuthFailed()) mock_integration(hass, MockModule("test2", async_setup_entry=mock_setup_entry)) mock_platform(hass, "test2.config_flow", None) entry.add_to_hass(hass) await manager.async_setup(entry.entry_id) await hass.async_block_till_done() flows = hass.config_entries.flow.async_progress_by_handler("test2") assert len(flows) == 1 result = await hass.config_entries.flow.async_configure(flows[0]["flow_id"], None) assert result["type"] == FlowResultType.FORM assert result["description_placeholders"] == {"name": "Custom title"}