Add matter during onboarding (#116163)

* Add matter during onboarding

* test_zeroconf_not_onboarded_running

* test_zeroconf_not_onboarded_installed

* test_zeroconf_not_onboarded_not_installed

* test_zeroconf_discovery_not_onboarded_not_supervisor

* Clean up

* Add udp address

* Test zeroconf udp info too

* test_addon_installed_failures_zeroconf

* test_addon_running_failures_zeroconf

* test_addon_not_installed_failures_zeroconf

* Clean up stale changes

* Set unique id for discovery step

* Fix tests for background flow

* Fix flow running in background

* Test already discovered zeroconf

* Mock unload entry
This commit is contained in:
Martin Hjelmare
2024-04-29 10:59:36 +02:00
committed by GitHub
parent 8153ff78bf
commit 0e0ea0017e
4 changed files with 436 additions and 12 deletions
+405 -9
View File
@@ -24,6 +24,37 @@ ADDON_DISCOVERY_INFO = {
"host": "host1",
"port": 5581,
}
ZEROCONF_INFO_TCP = ZeroconfServiceInfo(
ip_address=ip_address("fd11:be53:8d46:0:729e:5a4f:539d:1ee6"),
ip_addresses=[ip_address("fd11:be53:8d46:0:729e:5a4f:539d:1ee6")],
port=5540,
hostname="CDEFGHIJ12345678.local.",
type="_matter._tcp.local.",
name="ABCDEFGH123456789-0000000012345678._matter._tcp.local.",
properties={"SII": "3300", "SAI": "1100", "T": "0"},
)
ZEROCONF_INFO_UDP = ZeroconfServiceInfo(
ip_address=ip_address("fd11:be53:8d46:0:729e:5a4f:539d:1ee6"),
ip_addresses=[ip_address("fd11:be53:8d46:0:729e:5a4f:539d:1ee6")],
port=5540,
hostname="CDEFGHIJ12345678.local.",
type="_matterc._udp.local.",
name="ABCDEFGH123456789._matterc._udp.local.",
properties={
"VP": "4874+77",
"DT": "21",
"DN": "Eve Door",
"SII": "3300",
"SAI": "1100",
"T": "0",
"D": "183",
"CM": "2",
"RI": "0400530980B950D59BF473CFE42BD7DDBF2D",
"PH": "36",
"PI": None,
},
)
@pytest.fixture(name="setup_entry", autouse=True)
@@ -35,6 +66,15 @@ def setup_entry_fixture() -> Generator[AsyncMock, None, None]:
yield mock_setup_entry
@pytest.fixture(name="unload_entry", autouse=True)
def unload_entry_fixture() -> Generator[AsyncMock, None, None]:
"""Mock entry unload."""
with patch(
"homeassistant.components.matter.async_unload_entry", return_value=True
) as mock_unload_entry:
yield mock_unload_entry
@pytest.fixture(name="client_connect", autouse=True)
def client_connect_fixture() -> Generator[AsyncMock, None, None]:
"""Mock server version."""
@@ -80,6 +120,16 @@ def addon_setup_time_fixture() -> Generator[int, None, None]:
yield addon_setup_time
@pytest.fixture(name="not_onboarded")
def mock_onboarded_fixture() -> Generator[MagicMock, None, None]:
"""Mock that Home Assistant is not yet onboarded."""
with patch(
"homeassistant.components.matter.config_flow.async_is_onboarded",
return_value=False,
) as mock_onboarded:
yield mock_onboarded
async def test_manual_create_entry(
hass: HomeAssistant,
client_connect: AsyncMock,
@@ -179,24 +229,18 @@ async def test_manual_already_configured(
assert setup_entry.call_count == 1
@pytest.mark.parametrize("zeroconf_info", [ZEROCONF_INFO_TCP, ZEROCONF_INFO_UDP])
async def test_zeroconf_discovery(
hass: HomeAssistant,
client_connect: AsyncMock,
setup_entry: AsyncMock,
zeroconf_info: ZeroconfServiceInfo,
) -> None:
"""Test flow started from Zeroconf discovery."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_ZEROCONF},
data=ZeroconfServiceInfo(
ip_address=ip_address("fd11:be53:8d46:0:729e:5a4f:539d:1ee6"),
ip_addresses=[ip_address("fd11:be53:8d46:0:729e:5a4f:539d:1ee6")],
port=5540,
hostname="CDEFGHIJ12345678.local.",
type="_matter._tcp.local.",
name="ABCDEFGH123456789-0000000012345678._matter._tcp.local.",
properties={"SII": "3300", "SAI": "1100", "T": "0"},
),
data=zeroconf_info,
)
assert result["type"] is FlowResultType.FORM
assert result["step_id"] == "manual"
@@ -221,6 +265,185 @@ async def test_zeroconf_discovery(
assert setup_entry.call_count == 1
@pytest.mark.parametrize("zeroconf_info", [ZEROCONF_INFO_TCP, ZEROCONF_INFO_UDP])
async def test_zeroconf_discovery_not_onboarded_not_supervisor(
hass: HomeAssistant,
client_connect: AsyncMock,
setup_entry: AsyncMock,
not_onboarded: MagicMock,
zeroconf_info: ZeroconfServiceInfo,
) -> None:
"""Test flow started from Zeroconf discovery when not onboarded."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_ZEROCONF},
data=zeroconf_info,
)
assert result["type"] is FlowResultType.FORM
assert result["step_id"] == "manual"
assert result["errors"] is None
result = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"url": "ws://localhost:5580/ws",
},
)
await hass.async_block_till_done()
assert client_connect.call_count == 1
assert result["type"] is FlowResultType.CREATE_ENTRY
assert result["title"] == "Matter"
assert result["data"] == {
"url": "ws://localhost:5580/ws",
"integration_created_addon": False,
"use_addon": False,
}
assert setup_entry.call_count == 1
@pytest.mark.parametrize("zeroconf_info", [ZEROCONF_INFO_TCP, ZEROCONF_INFO_UDP])
@pytest.mark.parametrize("discovery_info", [{"config": ADDON_DISCOVERY_INFO}])
async def test_zeroconf_not_onboarded_already_discovered(
hass: HomeAssistant,
supervisor: MagicMock,
addon_info: AsyncMock,
addon_running: AsyncMock,
client_connect: AsyncMock,
setup_entry: AsyncMock,
not_onboarded: MagicMock,
zeroconf_info: ZeroconfServiceInfo,
) -> None:
"""Test flow Zeroconf discovery when not onboarded and already discovered."""
result_flow_1 = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_ZEROCONF},
data=zeroconf_info,
)
result_flow_2 = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_ZEROCONF},
data=zeroconf_info,
)
await hass.async_block_till_done()
assert result_flow_2["type"] is FlowResultType.ABORT
assert result_flow_2["reason"] == "already_configured"
assert addon_info.call_count == 1
assert client_connect.call_count == 1
assert result_flow_1["type"] is FlowResultType.CREATE_ENTRY
assert result_flow_1["title"] == "Matter"
assert result_flow_1["data"] == {
"url": "ws://host1:5581/ws",
"use_addon": True,
"integration_created_addon": False,
}
assert setup_entry.call_count == 1
@pytest.mark.parametrize("zeroconf_info", [ZEROCONF_INFO_TCP, ZEROCONF_INFO_UDP])
@pytest.mark.parametrize("discovery_info", [{"config": ADDON_DISCOVERY_INFO}])
async def test_zeroconf_not_onboarded_running(
hass: HomeAssistant,
supervisor: MagicMock,
addon_info: AsyncMock,
addon_running: AsyncMock,
client_connect: AsyncMock,
setup_entry: AsyncMock,
not_onboarded: MagicMock,
zeroconf_info: ZeroconfServiceInfo,
) -> None:
"""Test flow Zeroconf discovery when not onboarded and add-on running."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_ZEROCONF},
data=zeroconf_info,
)
await hass.async_block_till_done()
assert addon_info.call_count == 1
assert client_connect.call_count == 1
assert result["type"] is FlowResultType.CREATE_ENTRY
assert result["title"] == "Matter"
assert result["data"] == {
"url": "ws://host1:5581/ws",
"use_addon": True,
"integration_created_addon": False,
}
assert setup_entry.call_count == 1
@pytest.mark.parametrize("zeroconf_info", [ZEROCONF_INFO_TCP, ZEROCONF_INFO_UDP])
@pytest.mark.parametrize("discovery_info", [{"config": ADDON_DISCOVERY_INFO}])
async def test_zeroconf_not_onboarded_installed(
hass: HomeAssistant,
supervisor: MagicMock,
addon_info: AsyncMock,
addon_installed: AsyncMock,
start_addon: AsyncMock,
client_connect: AsyncMock,
setup_entry: AsyncMock,
not_onboarded: MagicMock,
zeroconf_info: ZeroconfServiceInfo,
) -> None:
"""Test flow Zeroconf discovery when not onboarded and add-on installed."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_ZEROCONF},
data=zeroconf_info,
)
await hass.async_block_till_done()
assert addon_info.call_count == 1
assert start_addon.call_args == call(hass, "core_matter_server")
assert client_connect.call_count == 1
assert result["type"] is FlowResultType.CREATE_ENTRY
assert result["title"] == "Matter"
assert result["data"] == {
"url": "ws://host1:5581/ws",
"use_addon": True,
"integration_created_addon": False,
}
assert setup_entry.call_count == 1
@pytest.mark.parametrize("zeroconf_info", [ZEROCONF_INFO_TCP, ZEROCONF_INFO_UDP])
@pytest.mark.parametrize("discovery_info", [{"config": ADDON_DISCOVERY_INFO}])
async def test_zeroconf_not_onboarded_not_installed(
hass: HomeAssistant,
supervisor: MagicMock,
addon_info: AsyncMock,
addon_store_info: AsyncMock,
addon_not_installed: AsyncMock,
install_addon: AsyncMock,
start_addon: AsyncMock,
client_connect: AsyncMock,
setup_entry: AsyncMock,
not_onboarded: MagicMock,
zeroconf_info: ZeroconfServiceInfo,
) -> None:
"""Test flow Zeroconf discovery when not onboarded and add-on not installed."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_ZEROCONF},
data=zeroconf_info,
)
await hass.async_block_till_done()
assert addon_info.call_count == 0
assert addon_store_info.call_count == 2
assert install_addon.call_args == call(hass, "core_matter_server")
assert start_addon.call_args == call(hass, "core_matter_server")
assert client_connect.call_count == 1
assert result["type"] is FlowResultType.CREATE_ENTRY
assert result["title"] == "Matter"
assert result["data"] == {
"url": "ws://host1:5581/ws",
"use_addon": True,
"integration_created_addon": True,
}
assert setup_entry.call_count == 1
@pytest.mark.parametrize("discovery_info", [{"config": ADDON_DISCOVERY_INFO}])
async def test_supervisor_discovery(
hass: HomeAssistant,
@@ -702,6 +925,90 @@ async def test_addon_running_failures(
assert result["reason"] == abort_reason
@pytest.mark.parametrize("zeroconf_info", [ZEROCONF_INFO_TCP, ZEROCONF_INFO_UDP])
@pytest.mark.parametrize(
(
"discovery_info",
"discovery_info_error",
"client_connect_error",
"addon_info_error",
"abort_reason",
"discovery_info_called",
"client_connect_called",
),
[
(
{"config": ADDON_DISCOVERY_INFO},
HassioAPIError(),
None,
None,
"addon_get_discovery_info_failed",
True,
False,
),
(
{"config": ADDON_DISCOVERY_INFO},
None,
CannotConnect(Exception("Boom")),
None,
"cannot_connect",
True,
True,
),
(
None,
None,
None,
None,
"addon_get_discovery_info_failed",
True,
False,
),
(
{"config": ADDON_DISCOVERY_INFO},
None,
None,
HassioAPIError(),
"addon_info_failed",
False,
False,
),
],
)
async def test_addon_running_failures_zeroconf(
hass: HomeAssistant,
supervisor: MagicMock,
addon_running: AsyncMock,
addon_info: AsyncMock,
get_addon_discovery_info: AsyncMock,
client_connect: AsyncMock,
discovery_info_error: Exception | None,
client_connect_error: Exception | None,
addon_info_error: Exception | None,
abort_reason: str,
discovery_info_called: bool,
client_connect_called: bool,
not_onboarded: MagicMock,
zeroconf_info: ZeroconfServiceInfo,
) -> None:
"""Test all failures when add-on is running and not onboarded."""
get_addon_discovery_info.side_effect = discovery_info_error
client_connect.side_effect = client_connect_error
addon_info.side_effect = addon_info_error
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_ZEROCONF},
data=zeroconf_info,
)
await hass.async_block_till_done()
assert addon_info.call_count == 1
assert get_addon_discovery_info.called is discovery_info_called
assert client_connect.called is client_connect_called
assert result["type"] is FlowResultType.ABORT
assert result["reason"] == abort_reason
@pytest.mark.parametrize("discovery_info", [{"config": ADDON_DISCOVERY_INFO}])
async def test_addon_running_already_configured(
hass: HomeAssistant,
@@ -854,6 +1161,71 @@ async def test_addon_installed_failures(
assert result["reason"] == "addon_start_failed"
@pytest.mark.parametrize("zeroconf_info", [ZEROCONF_INFO_TCP, ZEROCONF_INFO_UDP])
@pytest.mark.parametrize(
(
"discovery_info",
"start_addon_error",
"client_connect_error",
"discovery_info_called",
"client_connect_called",
),
[
(
{"config": ADDON_DISCOVERY_INFO},
HassioAPIError(),
None,
False,
False,
),
(
{"config": ADDON_DISCOVERY_INFO},
None,
CannotConnect(Exception("Boom")),
True,
True,
),
(
None,
None,
None,
True,
False,
),
],
)
async def test_addon_installed_failures_zeroconf(
hass: HomeAssistant,
supervisor: MagicMock,
addon_installed: AsyncMock,
addon_info: AsyncMock,
start_addon: AsyncMock,
get_addon_discovery_info: AsyncMock,
client_connect: AsyncMock,
start_addon_error: Exception | None,
client_connect_error: Exception | None,
discovery_info_called: bool,
client_connect_called: bool,
not_onboarded: MagicMock,
zeroconf_info: ZeroconfServiceInfo,
) -> None:
"""Test add-on start failure when add-on is installed and not onboarded."""
start_addon.side_effect = start_addon_error
client_connect.side_effect = client_connect_error
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_ZEROCONF}, data=zeroconf_info
)
await hass.async_block_till_done()
assert addon_info.call_count == 1
assert start_addon.call_args == call(hass, "core_matter_server")
assert get_addon_discovery_info.called is discovery_info_called
assert client_connect.called is client_connect_called
assert result["type"] is FlowResultType.ABORT
assert result["reason"] == "addon_start_failed"
@pytest.mark.parametrize("discovery_info", [{"config": ADDON_DISCOVERY_INFO}])
async def test_addon_installed_already_configured(
hass: HomeAssistant,
@@ -985,6 +1357,30 @@ async def test_addon_not_installed_failures(
assert result["reason"] == "addon_install_failed"
@pytest.mark.parametrize("zeroconf_info", [ZEROCONF_INFO_TCP, ZEROCONF_INFO_UDP])
async def test_addon_not_installed_failures_zeroconf(
hass: HomeAssistant,
supervisor: MagicMock,
addon_not_installed: AsyncMock,
addon_info: AsyncMock,
install_addon: AsyncMock,
not_onboarded: MagicMock,
zeroconf_info: ZeroconfServiceInfo,
) -> None:
"""Test add-on install failure."""
install_addon.side_effect = HassioAPIError()
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_ZEROCONF}, data=zeroconf_info
)
await hass.async_block_till_done()
assert install_addon.call_args == call(hass, "core_matter_server")
assert addon_info.call_count == 0
assert result["type"] is FlowResultType.ABORT
assert result["reason"] == "addon_install_failed"
@pytest.mark.parametrize("discovery_info", [{"config": ADDON_DISCOVERY_INFO}])
async def test_addon_not_installed_already_configured(
hass: HomeAssistant,