Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
core/tests/test_config_entries.py

7617 lines
255 KiB
Python
Raw Permalink Blame History

"""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.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.dhcp import DhcpServiceInfo
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 <component>.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 <component>.setup_entry and the <component> 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 <component>.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, await async_forward_entry_setups instead. "
"This will stop working in Home Assistant 2025.6, 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: 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=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, value in expected_result.items():
assert result[key] == value
@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, value in expected_result.items():
assert result[key] == value
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),
patch.object(frame, "_REPORTED_INTEGRATIONS", set()),
):
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 that integration 'test' creates a new entry in a '{source}' flow, "
"when it is expected to update an existing entry and abort. This will stop "
"working in Home Assistant 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.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_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="my_integration", data={})
original_entry.add_to_hass(hass)
mock_setup_entry = AsyncMock(return_value=True)
mock_integration(
hass, MockModule("my_integration", async_setup_entry=mock_setup_entry)
)
mock_platform(hass, "my_integration.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("my_integration", 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 custom integration 'my_integration' sets option flow "
"config_entry explicitly, which is deprecated at "
"custom_components/my_integration/light.py, line 23: "
"self.light.is_on. This will stop working in Home Assistant 2025.12, please "
"create a bug report at " 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"}
Reference in New Issue View Git Blame Copy Permalink