Rebuild device discovery on the ClientHello probe and resolve identity up front
Two problems, one setup path. Port detection (issue #211): the config flow found the DTLS port by elimination -- a 1-byte UDP probe can't tell a silent port from a real DTLS server, so every port it couldn't rule out got a full certificate handshake, and every false positive cost the whole 12s HANDSHAKE_TIMEOUT_S before the next was tried. Adding an appliance took 30-40s. smartthings-local 0.1.2 ships a stateless ClientHello probe that settles this positively: a real DTLS server answers with a HelloVerifyRequest in ~1 RTT, and per RFC 6347 4.2.1 it does so without allocating association state, so the probe leaves nothing behind on the appliance. The whole 49152-49160 range is probed at once and exactly one confirmed port is given a certificate handshake. Fanning out is safe here in a way racing real handshakes is not -- each probe is bounded by a 3s budget, so the pool costs one probe's wall clock rather than the sum of the range, with no losing threads left running behind us. The UDP sweep stays as the fallback for when the probe confirms nothing: it errs in the opposite direction (it reports everything it can't rule out), so it still surfaces a device on a path that eats our ClientHello, and it keeps its issue #192 preferred-port rescue. Port detection now runs first and needs no credentials, so an unreachable host fails before any round trip to Samsung's cloud. And a second appliance reuses the existing entry's leaf cert rather than re-minting -- every device accepts the same one -- which makes adding one independent of Samsung-cloud reachability. A confirmed-live device rejecting the reused leaf (the UUID does rotate) re-mints and retries once, so reuse stays self-correcting; a timeout doesn't, since a fresh cert can't fix nothing answering. Identity (issue #236): the coordinator seeded device_serial with the configured host and only replaced it after the first successful poll. But device_serial mints *permanent* registry keys -- entity unique_ids and device identifiers -- so anything registering before that poll returned was written into the registry keyed on the IP address forever. The connection-mode sensor is added unconditionally rather than from `bound`, so it was the reliable victim: when the serial-keyed identity appeared moments later HA created a second device and entity, and the IP-keyed pair was orphaned. Deleting them didn't help; the next restart that lost the race recreated them. The probe already learns the identity, so store it on the config entry -- serial, model, manufacturer, device type. The coordinator seeds device_serial and its DeviceInfo from those at construction, so keys are correct from the first entity that registers even if the first poll is slow or fails outright. There is no placeholder left to correct. Discovery now treats the registered identity as authoritative rather than re-keying a device that already has registry entries; it adopts and persists the polled identity only for an entry that has none, and warns if a different appliance answers on the same IP. Entry version 1 -> 2 recovers the serial from the entry's unique_id (the flow has always keyed it on the probe's serial) and repairs what the old registration orphaned: IP-keyed devices and entities are rewritten in place where the serial-keyed key is free -- keeping entity_id, name, area and every automation referencing them -- and removed where both exist, since the IP-keyed one has been dead since the restart that made it. Placeholder-serial boards (issues #83/#189) were keyed two ways at once, `host:port` on the entry and `host` in the registry; migration collapses the entry onto the registry's form. One resolve_serial() now serves both sides, so they can't drift apart again. The remaining step in the desired pipeline -- probe for subdevices, then register devices, then populate entities -- already holds: _enumerate_subdevices_blocking runs before _run_discovery, which runs before platforms are forwarded. Duplicating it in the config flow would mean re-running Pattern B's per-href fallback probe, which is the opposite of what issue #211 is about.
This commit is contained in:
18 files changed
+1186
-210
No files matched your search
@@ -14,10 +14,14 @@ from pytest_homeassistant_custom_component.common import MockConfigEntry
|
||||
from custom_components.localthings.const import (
|
||||
CONF_CA_CERT_PEM,
|
||||
CONF_CA_KEY_PEM,
|
||||
CONF_DEVICE_TYPE,
|
||||
CONF_HOST,
|
||||
CONF_LEAF_CERT_PEM,
|
||||
CONF_LEAF_KEY_PEM,
|
||||
CONF_MANUFACTURER,
|
||||
CONF_MODEL,
|
||||
CONF_PORT,
|
||||
CONF_SERIAL,
|
||||
DOMAIN,
|
||||
)
|
||||
from custom_components.localthings.coordinator import LocalThingsCoordinator
|
||||
@@ -74,7 +78,12 @@ FIXTURES = Path(__file__).resolve().parent.parent / "fixtures"
|
||||
|
||||
MOCK_HOST = "10.0.0.254"
|
||||
MOCK_PORT = 49154
|
||||
MOCK_SERIAL = "TEST-SERIAL-001"
|
||||
# Matches the identity in tests/fixtures/refrigerator_device.json, which is
|
||||
# what mock_coordinator_session polls -- so an entry built from ENTRY_DATA and
|
||||
# the device it "reaches" agree on who they are, the same as in production.
|
||||
MOCK_SERIAL = "TEST-SERIAL-0000"
|
||||
MOCK_MODEL = "TEST-MODEL"
|
||||
MOCK_DEVICE_TYPE = "refrigerator"
|
||||
MOCK_CA_CERT_PEM = "-----BEGIN CERTIFICATE-----\nTEST-CA\n-----END CERTIFICATE-----"
|
||||
MOCK_CA_KEY_PEM = "-----BEGIN PRIVATE KEY-----\nTEST-CA-KEY\n-----END PRIVATE KEY-----"
|
||||
MOCK_LEAF_CERT_PEM = "-----BEGIN CERTIFICATE-----\nTEST-LEAF\n-----END CERTIFICATE-----"
|
||||
@@ -87,6 +96,23 @@ ENTRY_DATA = {
|
||||
CONF_CA_KEY_PEM: MOCK_CA_KEY_PEM,
|
||||
CONF_LEAF_CERT_PEM: MOCK_LEAF_CERT_PEM,
|
||||
CONF_LEAF_KEY_PEM: MOCK_LEAF_KEY_PEM,
|
||||
# Identity the config flow's probe resolved (issue #236) -- what the
|
||||
# coordinator keys its devices and entities on from construction.
|
||||
CONF_SERIAL: MOCK_SERIAL,
|
||||
CONF_MODEL: MOCK_MODEL,
|
||||
CONF_MANUFACTURER: "Samsung",
|
||||
CONF_DEVICE_TYPE: MOCK_DEVICE_TYPE,
|
||||
}
|
||||
|
||||
# A pre-identity entry, as a real install upgrading through the v1 -> v2
|
||||
# migration still has it on disk.
|
||||
LEGACY_ENTRY_DATA = {
|
||||
CONF_HOST: MOCK_HOST,
|
||||
CONF_PORT: MOCK_PORT,
|
||||
CONF_CA_CERT_PEM: MOCK_CA_CERT_PEM,
|
||||
CONF_CA_KEY_PEM: MOCK_CA_KEY_PEM,
|
||||
CONF_LEAF_CERT_PEM: MOCK_LEAF_CERT_PEM,
|
||||
CONF_LEAF_KEY_PEM: MOCK_LEAF_KEY_PEM,
|
||||
}
|
||||
|
||||
|
||||
@@ -102,18 +128,25 @@ def fridge_resources():
|
||||
return _load_fridge_resources()
|
||||
|
||||
|
||||
def _probe_result(*, recognized: bool) -> dict:
|
||||
return {
|
||||
"port": MOCK_PORT,
|
||||
"serial": MOCK_SERIAL,
|
||||
"model": MOCK_MODEL,
|
||||
"manufacturer": "Samsung",
|
||||
"device_type_name": MOCK_DEVICE_TYPE if recognized else None,
|
||||
"device_type_recognized": recognized,
|
||||
"leaf_cert_pem": MOCK_LEAF_CERT_PEM,
|
||||
"leaf_key_pem": MOCK_LEAF_KEY_PEM,
|
||||
}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_probe():
|
||||
"""Patch _probe_and_validate to succeed (recognized type) without a real DTLS connection."""
|
||||
with patch(
|
||||
"custom_components.localthings.config_flow._probe_and_validate",
|
||||
return_value={
|
||||
"port": MOCK_PORT,
|
||||
"serial": MOCK_SERIAL,
|
||||
"leaf_cert_pem": MOCK_LEAF_CERT_PEM,
|
||||
"leaf_key_pem": MOCK_LEAF_KEY_PEM,
|
||||
"device_type_recognized": True,
|
||||
},
|
||||
return_value=_probe_result(recognized=True),
|
||||
) as m:
|
||||
yield m
|
||||
|
||||
@@ -123,13 +156,7 @@ def mock_probe_unknown_type():
|
||||
"""Patch _probe_and_validate to succeed, but with an unrecognized device type."""
|
||||
with patch(
|
||||
"custom_components.localthings.config_flow._probe_and_validate",
|
||||
return_value={
|
||||
"port": MOCK_PORT,
|
||||
"serial": MOCK_SERIAL,
|
||||
"leaf_cert_pem": MOCK_LEAF_CERT_PEM,
|
||||
"leaf_key_pem": MOCK_LEAF_KEY_PEM,
|
||||
"device_type_recognized": False,
|
||||
},
|
||||
return_value=_probe_result(recognized=False),
|
||||
) as m:
|
||||
yield m
|
||||
|
||||
@@ -218,6 +245,24 @@ def mock_entry(hass):
|
||||
domain=DOMAIN,
|
||||
data=ENTRY_DATA,
|
||||
unique_id=f"localthings_{MOCK_SERIAL}",
|
||||
version=2,
|
||||
)
|
||||
entry.add_to_hass(hass)
|
||||
return entry
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def legacy_entry(hass):
|
||||
"""A v1 entry with no stored identity, as an upgrading install has it.
|
||||
|
||||
Its device identity is only knowable from the first poll, which is the
|
||||
one case where _run_discovery still adopts what the device reports.
|
||||
"""
|
||||
entry = MockConfigEntry(
|
||||
domain=DOMAIN,
|
||||
data=LEGACY_ENTRY_DATA,
|
||||
unique_id=f"localthings_{MOCK_SERIAL}",
|
||||
version=1,
|
||||
)
|
||||
entry.add_to_hass(hass)
|
||||
return entry
|
||||
@@ -3,9 +3,10 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from collections.abc import Iterable
|
||||
from typing import cast
|
||||
from typing import ClassVar, cast
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
from homeassistant.core import HomeAssistant
|
||||
from homeassistant.data_entry_flow import FlowResultType
|
||||
from pytest_homeassistant_custom_component.common import MockConfigEntry
|
||||
@@ -15,6 +16,7 @@ from custom_components.localthings.const import (
|
||||
CONF_CA_CERT_PEM,
|
||||
CONF_CA_KEY_PEM,
|
||||
CONF_HOST,
|
||||
CONF_LEAF_CERT_PEM,
|
||||
CONF_PORT,
|
||||
DOMAIN,
|
||||
)
|
||||
@@ -24,6 +26,8 @@ from .conftest import (
|
||||
MOCK_CA_CERT_PEM,
|
||||
MOCK_CA_KEY_PEM,
|
||||
MOCK_HOST,
|
||||
MOCK_LEAF_CERT_PEM,
|
||||
MOCK_MODEL,
|
||||
MOCK_PORT,
|
||||
MOCK_SERIAL,
|
||||
)
|
||||
@@ -165,58 +169,144 @@ def test_find_live_ports_rescues_preferred_ports_the_sweep_missed(
|
||||
assert set(result) == {preferred_port, live_port}
|
||||
|
||||
|
||||
async def test_probe_uses_discovered_low_port(hass: HomeAssistant, monkeypatch) -> None:
|
||||
"""A device that only answers on 49153 — outside the historical
|
||||
49154/49155 pair — is found by the liveness sweep and its port is stored
|
||||
on the config entry (issue #13)."""
|
||||
import cbor2
|
||||
WASHER_DEVICE0 = [
|
||||
{"rt": ["x.com.samsung.devcol"]},
|
||||
{
|
||||
"href": "/information/vs/0",
|
||||
"rep": {
|
||||
"x.com.samsung.da.modelNum": "DA_WM_TP1_21_COMMON|20375141|20010002001811424AA30217008A0000", # noqa: E501
|
||||
"x.com.samsung.da.description": "DA_WM_TP1_21_COMMON_WW5000C/DC92-03495A_B048",
|
||||
"x.com.samsung.da.serialNum": "DISHWASHER-49153",
|
||||
},
|
||||
},
|
||||
{"href": "/otninformation/vs/0", "rep": {"otnStatus": "None"}},
|
||||
]
|
||||
|
||||
|
||||
class FakeSession:
|
||||
"""Stand-in for DtlsCoapSession that answers /device/0 for any path.
|
||||
|
||||
`reject_certs` models a device whose DTLS stack breaks the handshake off
|
||||
itself -- the library raises ConnectionError for that, as opposed to the
|
||||
TimeoutError it raises when nothing answers at all.
|
||||
"""
|
||||
|
||||
instances: ClassVar[list[FakeSession]] = []
|
||||
reject_certs: ClassVar[set[str]] = set()
|
||||
|
||||
def __init__(self, host, port, cert_pem=None, key_pem=None, **kwargs):
|
||||
self.host, self.port, self.cert_pem = host, port, cert_pem
|
||||
FakeSession.instances.append(self)
|
||||
|
||||
def connect(self):
|
||||
if self.cert_pem in FakeSession.reject_certs:
|
||||
raise ConnectionError("DTLS handshake error: bad_certificate")
|
||||
|
||||
def start_reader(self):
|
||||
pass
|
||||
|
||||
def get(self, path, timeout=15.0):
|
||||
import cbor2
|
||||
|
||||
return 0x45, cbor2.dumps(WASHER_DEVICE0)
|
||||
|
||||
def close(self):
|
||||
pass
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def fake_dtls(monkeypatch):
|
||||
"""Wire the probe path up to FakeSession with no real network anywhere."""
|
||||
from custom_components.localthings import config_flow
|
||||
|
||||
device0 = [
|
||||
{"rt": ["x.com.samsung.devcol"]},
|
||||
{
|
||||
"href": "/information/vs/0",
|
||||
"rep": {
|
||||
"x.com.samsung.da.modelNum": "DA_WM_TP1_21_COMMON|20375141|20010002001811424AA30217008A0000", # noqa: E501
|
||||
"x.com.samsung.da.description": "DA_WM_TP1_21_COMMON_WW5000C/DC92-03495A_B048",
|
||||
"x.com.samsung.da.serialNum": "DISHWASHER-49153",
|
||||
},
|
||||
},
|
||||
{"href": "/otninformation/vs/0", "rep": {"otnStatus": "None"}},
|
||||
]
|
||||
|
||||
class _FakeSession:
|
||||
def __init__(self, host, port, cert_pem=None, key_pem=None):
|
||||
self.host, self.port = host, port
|
||||
|
||||
def connect(self):
|
||||
pass
|
||||
|
||||
def start_reader(self):
|
||||
pass
|
||||
|
||||
def get(self, path, timeout=15.0):
|
||||
return 0x45, cbor2.dumps(device0)
|
||||
|
||||
def close(self):
|
||||
pass
|
||||
|
||||
FakeSession.instances = []
|
||||
FakeSession.reject_certs = set()
|
||||
monkeypatch.setattr(config_flow, "_fetch_samsung_uuid", lambda: "test-uuid")
|
||||
monkeypatch.setattr(
|
||||
config_flow,
|
||||
"_mint_leaf_cert",
|
||||
lambda ca_cert, ca_key, uuid: ("FULLCHAIN", "LEAFKEY"),
|
||||
)
|
||||
monkeypatch.setattr(
|
||||
"smartthings_local.protocol.dtls_session.DtlsCoapSession",
|
||||
FakeSession,
|
||||
)
|
||||
return FakeSession
|
||||
|
||||
|
||||
class _FakeProbeResult:
|
||||
def __init__(self, port, live):
|
||||
self.port, self.outcome = port, "live" if live else "dead"
|
||||
self.is_dtls_server = live
|
||||
|
||||
def __repr__(self):
|
||||
return f"<ProbeResult {self.port} {self.outcome}>"
|
||||
|
||||
|
||||
def _patch_clienthello(monkeypatch, live_ports):
|
||||
"""Patch the library's ClientHello probe to report `live_ports` as DTLS."""
|
||||
from custom_components.localthings import config_flow
|
||||
|
||||
calls: list[int] = []
|
||||
|
||||
def _probe(host, port, **kwargs):
|
||||
calls.append(port)
|
||||
return _FakeProbeResult(port, port in live_ports)
|
||||
|
||||
monkeypatch.setattr(config_flow, "_clienthello_probe", _probe)
|
||||
return calls
|
||||
|
||||
|
||||
async def test_clienthello_probe_picks_the_confirmed_port(
|
||||
hass: HomeAssistant, monkeypatch, fake_dtls
|
||||
) -> None:
|
||||
"""Issue #211: the stateless ClientHello probe identifies the real DTLS
|
||||
port, so exactly one port gets a full certificate handshake -- not every
|
||||
port the UDP sweep couldn't rule out, each costing 12s to time out."""
|
||||
from custom_components.localthings import config_flow
|
||||
|
||||
probed = _patch_clienthello(monkeypatch, {49153})
|
||||
|
||||
def _no_sweep(host, ports, timeout):
|
||||
raise AssertionError("UDP sweep must not run once a port is confirmed")
|
||||
|
||||
monkeypatch.setattr(config_flow, "_find_live_ports", _no_sweep)
|
||||
|
||||
result = await hass.config_entries.flow.async_init(DOMAIN, context={"source": "user"})
|
||||
result = await hass.config_entries.flow.async_configure(
|
||||
result["flow_id"],
|
||||
{
|
||||
CONF_HOST: MOCK_HOST,
|
||||
CONF_CA_CERT_PEM: MOCK_CA_CERT_PEM,
|
||||
CONF_CA_KEY_PEM: MOCK_CA_KEY_PEM,
|
||||
},
|
||||
)
|
||||
|
||||
assert result["type"] == FlowResultType.CREATE_ENTRY
|
||||
assert result["data"][CONF_PORT] == 49153
|
||||
# The whole range is probed (cheaply, in parallel) but only the confirmed
|
||||
# port is handed a handshake.
|
||||
assert set(probed) == set(config_flow.PROBE_PORT_RANGE)
|
||||
assert [s.port for s in FakeSession.instances] == [49153]
|
||||
|
||||
|
||||
async def test_probe_uses_discovered_low_port(hass: HomeAssistant, monkeypatch, fake_dtls) -> None:
|
||||
"""A device that only answers on 49153 — outside the historical
|
||||
49154/49155 pair — is found by the liveness sweep and its port is stored
|
||||
on the config entry (issue #13).
|
||||
|
||||
The sweep is the fallback now: it runs when the ClientHello probe confirms
|
||||
nothing, which covers both a path that eats our ClientHello and an install
|
||||
still on smartthings-local < 0.1.2.
|
||||
"""
|
||||
from custom_components.localthings import config_flow
|
||||
|
||||
_patch_clienthello(monkeypatch, set())
|
||||
monkeypatch.setattr(
|
||||
config_flow,
|
||||
"_find_live_ports",
|
||||
lambda host, ports, timeout: [49153],
|
||||
)
|
||||
monkeypatch.setattr(
|
||||
"smartthings_local.protocol.dtls_session.DtlsCoapSession",
|
||||
_FakeSession,
|
||||
)
|
||||
|
||||
result = await hass.config_entries.flow.async_init(DOMAIN, context={"source": "user"})
|
||||
result = await hass.config_entries.flow.async_configure(
|
||||
@@ -231,6 +321,148 @@ async def test_probe_uses_discovered_low_port(hass: HomeAssistant, monkeypatch)
|
||||
assert result["data"][CONF_PORT] == 49153
|
||||
|
||||
|
||||
async def test_probe_falls_back_when_library_lacks_the_clienthello_probe(
|
||||
hass: HomeAssistant, monkeypatch, fake_dtls
|
||||
) -> None:
|
||||
"""An install whose smartthings-local predates the probe still adds
|
||||
devices -- port detection degrades to the UDP sweep rather than failing."""
|
||||
from custom_components.localthings import config_flow
|
||||
|
||||
def _missing(host, port, **kwargs):
|
||||
raise ImportError("no module named dtls_probe")
|
||||
|
||||
monkeypatch.setattr(config_flow, "_clienthello_probe", _missing)
|
||||
monkeypatch.setattr(
|
||||
config_flow,
|
||||
"_find_live_ports",
|
||||
lambda host, ports, timeout: [49154],
|
||||
)
|
||||
|
||||
result = await hass.config_entries.flow.async_init(DOMAIN, context={"source": "user"})
|
||||
result = await hass.config_entries.flow.async_configure(
|
||||
result["flow_id"],
|
||||
{
|
||||
CONF_HOST: MOCK_HOST,
|
||||
CONF_CA_CERT_PEM: MOCK_CA_CERT_PEM,
|
||||
CONF_CA_KEY_PEM: MOCK_CA_KEY_PEM,
|
||||
},
|
||||
)
|
||||
assert result["type"] == FlowResultType.CREATE_ENTRY
|
||||
assert result["data"][CONF_PORT] == 49154
|
||||
|
||||
|
||||
async def test_entry_stores_resolved_identity(hass: HomeAssistant, monkeypatch, fake_dtls) -> None:
|
||||
"""The probe's identity lands on the entry (issue #236), so the
|
||||
coordinator can key its device and entities before the first poll."""
|
||||
from custom_components.localthings import config_flow
|
||||
from custom_components.localthings.const import (
|
||||
CONF_DEVICE_TYPE,
|
||||
CONF_MANUFACTURER,
|
||||
CONF_MODEL,
|
||||
CONF_SERIAL,
|
||||
)
|
||||
|
||||
_patch_clienthello(monkeypatch, {49154})
|
||||
|
||||
result = await hass.config_entries.flow.async_init(DOMAIN, context={"source": "user"})
|
||||
result = await hass.config_entries.flow.async_configure(
|
||||
result["flow_id"],
|
||||
{
|
||||
CONF_HOST: MOCK_HOST,
|
||||
CONF_CA_CERT_PEM: MOCK_CA_CERT_PEM,
|
||||
CONF_CA_KEY_PEM: MOCK_CA_KEY_PEM,
|
||||
},
|
||||
)
|
||||
|
||||
assert result["type"] == FlowResultType.CREATE_ENTRY
|
||||
assert result["data"][CONF_SERIAL] == "DISHWASHER-49153"
|
||||
assert result["data"][CONF_MODEL] == "DA_WM_TP1_21_COMMON"
|
||||
assert result["data"][CONF_MANUFACTURER] == "Samsung"
|
||||
assert result["data"][CONF_DEVICE_TYPE] == "washer"
|
||||
assert result["title"] == f"Samsung Washer ({MOCK_HOST})"
|
||||
assert result["result"].version == config_flow.LocalThingsConfigFlow.VERSION
|
||||
|
||||
|
||||
async def test_second_device_reuses_the_existing_leaf(
|
||||
hass: HomeAssistant, monkeypatch, fake_dtls
|
||||
) -> None:
|
||||
"""Adding a second appliance skips the Samsung-cloud round trip: every
|
||||
device accepts the same leaf, and the existing entry already has one
|
||||
(issue #211). That makes the add independent of cloud reachability, not
|
||||
just faster."""
|
||||
from custom_components.localthings import config_flow
|
||||
|
||||
existing = MockConfigEntry(domain=DOMAIN, data=ENTRY_DATA, unique_id="localthings_other")
|
||||
existing.add_to_hass(hass)
|
||||
_patch_clienthello(monkeypatch, {49154})
|
||||
|
||||
def _no_cloud():
|
||||
raise AssertionError("must not contact Samsung's cloud when a leaf is available")
|
||||
|
||||
monkeypatch.setattr(config_flow, "_fetch_samsung_uuid", _no_cloud)
|
||||
|
||||
result = await hass.config_entries.flow.async_init(DOMAIN, context={"source": "user"})
|
||||
result = await hass.config_entries.flow.async_configure(
|
||||
result["flow_id"], {CONF_HOST: MOCK_HOST}
|
||||
)
|
||||
|
||||
assert result["type"] == FlowResultType.CREATE_ENTRY
|
||||
assert result["data"][CONF_LEAF_CERT_PEM] == MOCK_LEAF_CERT_PEM
|
||||
assert FakeSession.instances[0].cert_pem == MOCK_LEAF_CERT_PEM
|
||||
|
||||
|
||||
async def test_rejected_reused_leaf_is_reminted(
|
||||
hass: HomeAssistant, monkeypatch, fake_dtls
|
||||
) -> None:
|
||||
"""The UUID behind the shared leaf does rotate. A confirmed-live device
|
||||
rejecting the reused one is unambiguous enough to mint a fresh cert and
|
||||
try again, so credential reuse stays self-correcting."""
|
||||
existing = MockConfigEntry(domain=DOMAIN, data=ENTRY_DATA, unique_id="localthings_other")
|
||||
existing.add_to_hass(hass)
|
||||
_patch_clienthello(monkeypatch, {49154})
|
||||
FakeSession.reject_certs = {MOCK_LEAF_CERT_PEM}
|
||||
|
||||
result = await hass.config_entries.flow.async_init(DOMAIN, context={"source": "user"})
|
||||
result = await hass.config_entries.flow.async_configure(
|
||||
result["flow_id"], {CONF_HOST: MOCK_HOST}
|
||||
)
|
||||
|
||||
assert result["type"] == FlowResultType.CREATE_ENTRY
|
||||
# Freshly minted, and it's the fresh one that got stored.
|
||||
assert result["data"][CONF_LEAF_CERT_PEM] == "FULLCHAIN"
|
||||
assert [s.cert_pem for s in FakeSession.instances] == [MOCK_LEAF_CERT_PEM, "FULLCHAIN"]
|
||||
|
||||
|
||||
async def test_unconfirmed_port_failure_is_not_reminted(
|
||||
hass: HomeAssistant, monkeypatch, fake_dtls
|
||||
) -> None:
|
||||
"""A timeout means nothing answered, which a fresh certificate can't fix
|
||||
-- so the re-mint retry stays scoped to a device that proved it is there
|
||||
and broke the handshake off itself."""
|
||||
from custom_components.localthings import config_flow
|
||||
|
||||
existing = MockConfigEntry(domain=DOMAIN, data=ENTRY_DATA, unique_id="localthings_other")
|
||||
existing.add_to_hass(hass)
|
||||
_patch_clienthello(monkeypatch, set())
|
||||
monkeypatch.setattr(config_flow, "_find_live_ports", lambda host, ports, timeout: [49154])
|
||||
|
||||
def _timeout(self):
|
||||
raise TimeoutError("DTLS handshake timeout")
|
||||
|
||||
monkeypatch.setattr(FakeSession, "connect", _timeout)
|
||||
|
||||
result = await hass.config_entries.flow.async_init(DOMAIN, context={"source": "user"})
|
||||
result = await hass.config_entries.flow.async_configure(
|
||||
result["flow_id"], {CONF_HOST: MOCK_HOST}
|
||||
)
|
||||
|
||||
assert result["type"] == FlowResultType.FORM
|
||||
errors = result["errors"]
|
||||
assert errors is not None
|
||||
assert errors["base"] == "cannot_connect"
|
||||
assert len(FakeSession.instances) == 1
|
||||
|
||||
|
||||
async def test_cannot_connect(hass: HomeAssistant) -> None:
|
||||
"""Failed probe: form re-shown with cannot_connect error."""
|
||||
from custom_components.localthings.config_flow import CannotConnect
|
||||
@@ -299,8 +531,20 @@ async def test_unknown_type_step_description_makes_no_version_claim(
|
||||
two, differing only in whether they blamed a missing oneUiVersion -- a
|
||||
distinction that stopped existing when detection stopped reading it."""
|
||||
import json
|
||||
import re
|
||||
from pathlib import Path
|
||||
|
||||
result = await hass.config_entries.flow.async_init(DOMAIN, context={"source": "user"})
|
||||
result = await hass.config_entries.flow.async_configure(
|
||||
result["flow_id"],
|
||||
{
|
||||
CONF_HOST: MOCK_HOST,
|
||||
CONF_CA_CERT_PEM: MOCK_CA_CERT_PEM,
|
||||
CONF_CA_KEY_PEM: MOCK_CA_KEY_PEM,
|
||||
},
|
||||
)
|
||||
assert result["step_id"] == "confirm_unknown_type"
|
||||
|
||||
steps = json.loads(
|
||||
(
|
||||
Path(__file__).parents[2]
|
||||
@@ -314,7 +558,13 @@ async def test_unknown_type_step_description_makes_no_version_claim(
|
||||
assert "confirm_unknown_type_no_version" not in steps
|
||||
description = steps["confirm_unknown_type"]["description"]
|
||||
assert "oneUiVersion" not in description
|
||||
assert "{" not in description # no unfilled placeholder
|
||||
# {model} is the only placeholder, and the step must supply it -- an
|
||||
# unfilled one renders as literal braces to the user.
|
||||
placeholders = re.findall(r"{(\w+)}", description)
|
||||
assert placeholders == ["model"]
|
||||
supplied = result["description_placeholders"]
|
||||
assert supplied is not None
|
||||
assert supplied["model"] == MOCK_MODEL
|
||||
|
||||
|
||||
async def test_duplicate_device_aborted(hass: HomeAssistant, mock_probe) -> None:
|
||||
@@ -586,18 +836,18 @@ def test_is_placeholder_serial_catches_nothing_svc():
|
||||
"""Issue #83: the ARTIK051_DONGLE_REF firmware family reports the
|
||||
literal string 'Nothing(SVC)' as serialNum on every unit -- non-empty,
|
||||
so it must be caught by name, not by the plain `if not serial` check."""
|
||||
from custom_components.localthings.config_flow import _is_placeholder_serial
|
||||
from custom_components.localthings.registry.identity import is_placeholder_serial
|
||||
|
||||
assert _is_placeholder_serial("Nothing(SVC)") is True
|
||||
assert _is_placeholder_serial("nothing(svc)") is True
|
||||
assert _is_placeholder_serial(" Nothing(SVC) ") is True
|
||||
assert is_placeholder_serial("Nothing(SVC)") is True
|
||||
assert is_placeholder_serial("nothing(svc)") is True
|
||||
assert is_placeholder_serial(" Nothing(SVC) ") is True
|
||||
|
||||
|
||||
def test_is_placeholder_serial_accepts_real_serials():
|
||||
from custom_components.localthings.config_flow import _is_placeholder_serial
|
||||
from custom_components.localthings.registry.identity import is_placeholder_serial
|
||||
|
||||
assert _is_placeholder_serial("0A1B2C3D4E5F") is False
|
||||
assert _is_placeholder_serial("") is False
|
||||
assert is_placeholder_serial("0A1B2C3D4E5F") is False
|
||||
assert is_placeholder_serial("") is False
|
||||
|
||||
|
||||
def test_is_placeholder_serial_catches_all_same_hex_digit():
|
||||
@@ -606,11 +856,25 @@ def test_is_placeholder_serial_catches_all_same_hex_digit():
|
||||
character the same repeated hex digit. A washer and a dryer, two
|
||||
different physical units, both reported the literal serialNum
|
||||
'FFFFFFFFFFFFFFF', colliding on the config-entry unique_id."""
|
||||
from custom_components.localthings.config_flow import _is_placeholder_serial
|
||||
from custom_components.localthings.registry.identity import is_placeholder_serial
|
||||
|
||||
assert _is_placeholder_serial("FFFFFFFFFFFFFFF") is True
|
||||
assert _is_placeholder_serial("ffffffffffffffff") is True
|
||||
assert _is_placeholder_serial("00000000") is True
|
||||
assert is_placeholder_serial("FFFFFFFFFFFFFFF") is True
|
||||
assert is_placeholder_serial("ffffffffffffffff") is True
|
||||
assert is_placeholder_serial("00000000") is True
|
||||
# Too short to be the flash-unset sentinel -- a real serial could
|
||||
# plausibly repeat one hex digit seven times by chance.
|
||||
assert _is_placeholder_serial("FFFFFFF") is False
|
||||
assert is_placeholder_serial("FFFFFFF") is False
|
||||
|
||||
|
||||
def test_resolve_serial_falls_back_to_host():
|
||||
"""Both sides of the identity -- the config flow's probe and the
|
||||
coordinator's first poll -- now resolve a serial through one function, so
|
||||
they cannot disagree about what a device is called. They used to: the
|
||||
flow fell back to `host:port` and the coordinator to `host`."""
|
||||
from custom_components.localthings.registry.identity import resolve_serial
|
||||
|
||||
assert resolve_serial("REAL-SERIAL", "10.0.0.5") == "REAL-SERIAL"
|
||||
assert resolve_serial(" REAL-SERIAL ", "10.0.0.5") == "REAL-SERIAL"
|
||||
assert resolve_serial("Nothing(SVC)", "10.0.0.5") == "10.0.0.5"
|
||||
assert resolve_serial("", "10.0.0.5") == "10.0.0.5"
|
||||
assert resolve_serial(None, "10.0.0.5") == "10.0.0.5"
|
||||
@@ -22,7 +22,6 @@ from custom_components.localthings.const import (
|
||||
)
|
||||
from custom_components.localthings.coordinator import (
|
||||
LocalThingsCoordinator,
|
||||
_is_placeholder_serial,
|
||||
_local_source_port,
|
||||
)
|
||||
from custom_components.localthings.observe import MODE_OBSERVE, MODE_POLL, PUSH_HEALTH_WINDOW_S
|
||||
@@ -31,7 +30,8 @@ from custom_components.localthings.registry.capabilities.common import (
|
||||
remote_control_required_for_write,
|
||||
)
|
||||
|
||||
from .conftest import ENTRY_DATA, MOCK_SERIAL
|
||||
from .conftest import ENTRY_DATA, MOCK_MODEL, MOCK_SERIAL
|
||||
from .conftest import _load_fridge_resources as _load_fridge
|
||||
|
||||
|
||||
async def test_first_refresh_runs_discovery(
|
||||
@@ -138,7 +138,7 @@ def test_run_discovery_detects_washer_via_model_fallback(hass: HomeAssistant, mo
|
||||
|
||||
|
||||
def test_run_discovery_falls_back_to_host_for_placeholder_serial(
|
||||
hass: HomeAssistant, mock_entry
|
||||
hass: HomeAssistant, legacy_entry
|
||||
) -> None:
|
||||
"""Issue #83: the ARTIK051_DONGLE_REF firmware family reports the
|
||||
literal string 'Nothing(SVC)' as serialNum on every unit. Left as-is,
|
||||
@@ -154,13 +154,13 @@ def test_run_discovery_falls_back_to_host_for_placeholder_serial(
|
||||
},
|
||||
"/otninformation/vs/0": {},
|
||||
}
|
||||
coordinator = LocalThingsCoordinator(hass, mock_entry)
|
||||
coordinator = LocalThingsCoordinator(hass, legacy_entry)
|
||||
coordinator._run_discovery(resources)
|
||||
assert coordinator.device_serial == mock_entry.data[CONF_HOST]
|
||||
assert coordinator.device_serial == legacy_entry.data[CONF_HOST]
|
||||
|
||||
|
||||
def test_run_discovery_falls_back_to_host_for_all_f_placeholder_serial(
|
||||
hass: HomeAssistant, mock_entry
|
||||
hass: HomeAssistant, legacy_entry
|
||||
) -> None:
|
||||
"""Issue #189: the DA_WM_A51_20_COMMON (ARTIK051) laundry board family
|
||||
reports a flash-unset sentinel instead of 'Nothing(SVC)' -- every
|
||||
@@ -176,23 +176,76 @@ def test_run_discovery_falls_back_to_host_for_all_f_placeholder_serial(
|
||||
},
|
||||
"/otninformation/vs/0": {},
|
||||
}
|
||||
coordinator = LocalThingsCoordinator(hass, legacy_entry)
|
||||
coordinator._run_discovery(resources)
|
||||
assert coordinator.device_serial == legacy_entry.data[CONF_HOST]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Identity is known before the first poll (issue #236)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_identity_is_resolved_before_any_poll(hass: HomeAssistant, mock_entry) -> None:
|
||||
"""The coordinator mints registry keys from the entry's stored identity at
|
||||
construction time.
|
||||
|
||||
`device_serial` is what entity unique_ids and device identifiers are built
|
||||
from, and those are permanent. Seeding it with the host meant anything that
|
||||
registered before the first poll returned -- the connection-mode sensor
|
||||
especially, added unconditionally rather than from `bound` -- was written
|
||||
into the registry keyed on the IP address forever, then orphaned when the
|
||||
real identity showed up moments later.
|
||||
"""
|
||||
coordinator = LocalThingsCoordinator(hass, mock_entry)
|
||||
|
||||
assert coordinator.device_serial == MOCK_SERIAL
|
||||
assert coordinator.device_info["identifiers"] == {(DOMAIN, MOCK_SERIAL)}
|
||||
assert coordinator.device_info["model"] == MOCK_MODEL
|
||||
assert coordinator.device_info["name"] == f"Samsung Refrigerator ({MOCK_MODEL})"
|
||||
assert mock_entry.data[CONF_HOST] not in str(coordinator.device_info["identifiers"])
|
||||
|
||||
|
||||
def test_identity_survives_a_first_poll_that_never_happens(hass: HomeAssistant, mock_entry) -> None:
|
||||
"""A device that is slow or unreachable at startup no longer changes what
|
||||
its entities are called -- there is no placeholder left to correct."""
|
||||
coordinator = LocalThingsCoordinator(hass, mock_entry)
|
||||
before = coordinator.device_info["identifiers"]
|
||||
|
||||
coordinator._run_discovery(_load_fridge())
|
||||
|
||||
assert coordinator.device_info["identifiers"] == before
|
||||
|
||||
|
||||
def test_discovery_keeps_the_registered_identity(hass: HomeAssistant, mock_entry) -> None:
|
||||
"""A different appliance answering on the same IP does not silently re-key
|
||||
the entry's existing devices and entities out from under the registry."""
|
||||
resources = {
|
||||
"/information/vs/0": {
|
||||
"x.com.samsung.da.modelNum": "DA_WM_TP1_21_COMMON|20375141|20010002001811424AA30217008A0000", # noqa: E501
|
||||
"x.com.samsung.da.description": "DA_WM_TP1_21_COMMON_WW5000C/DC92-03495A_B048",
|
||||
"x.com.samsung.da.serialNum": "SOME-OTHER-APPLIANCE",
|
||||
},
|
||||
"/otninformation/vs/0": {},
|
||||
}
|
||||
coordinator = LocalThingsCoordinator(hass, mock_entry)
|
||||
coordinator._run_discovery(resources)
|
||||
assert coordinator.device_serial == mock_entry.data[CONF_HOST]
|
||||
|
||||
assert coordinator.device_serial == MOCK_SERIAL
|
||||
|
||||
|
||||
def test_is_placeholder_serial_catches_all_same_hex_digit():
|
||||
assert _is_placeholder_serial("FFFFFFFFFFFFFFF") is True
|
||||
assert _is_placeholder_serial("ffffffffffffffff") is True
|
||||
assert _is_placeholder_serial("00000000") is True
|
||||
def test_discovery_backfills_a_legacy_entry_identity(hass: HomeAssistant, legacy_entry) -> None:
|
||||
"""An entry migrated from before identity was stored learns it on its
|
||||
first poll and keeps it, so the *next* restart registers the device fully
|
||||
named before any entity exists instead of renaming it a second time."""
|
||||
from custom_components.localthings.const import CONF_DEVICE_TYPE, CONF_MODEL, CONF_SERIAL
|
||||
|
||||
coordinator = LocalThingsCoordinator(hass, legacy_entry)
|
||||
coordinator._run_discovery(_load_fridge())
|
||||
|
||||
def test_is_placeholder_serial_accepts_real_serials_and_short_runs():
|
||||
assert _is_placeholder_serial("0A1B2C3D4E5F") is False
|
||||
assert _is_placeholder_serial("") is False
|
||||
# Too short to be the flash-unset sentinel -- a real serial could
|
||||
# plausibly repeat one hex digit seven times by chance.
|
||||
assert _is_placeholder_serial("FFFFFFF") is False
|
||||
assert legacy_entry.data[CONF_SERIAL] == MOCK_SERIAL
|
||||
assert legacy_entry.data[CONF_MODEL] == MOCK_MODEL
|
||||
assert legacy_entry.data[CONF_DEVICE_TYPE] == "refrigerator"
|
||||
|
||||
|
||||
def test_run_discovery_detects_cooktop_via_resource_signature(
|
||||
|
||||
@@ -0,0 +1,190 @@
|
||||
"""Config-entry migration and the placeholder-identity repair (issue #236)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from homeassistant.core import HomeAssistant
|
||||
from homeassistant.helpers import device_registry as dr
|
||||
from homeassistant.helpers import entity_registry as er
|
||||
from pytest_homeassistant_custom_component.common import MockConfigEntry
|
||||
|
||||
from custom_components.localthings.const import (
|
||||
CONF_HOST,
|
||||
CONF_SERIAL,
|
||||
DOMAIN,
|
||||
)
|
||||
|
||||
from .conftest import LEGACY_ENTRY_DATA, MOCK_HOST, MOCK_PORT, MOCK_SERIAL
|
||||
|
||||
|
||||
def _legacy_entry(hass: HomeAssistant, unique_id: str) -> MockConfigEntry:
|
||||
entry = MockConfigEntry(
|
||||
domain=DOMAIN,
|
||||
data=LEGACY_ENTRY_DATA,
|
||||
unique_id=unique_id,
|
||||
version=1,
|
||||
)
|
||||
entry.add_to_hass(hass)
|
||||
return entry
|
||||
|
||||
|
||||
async def test_migration_recovers_serial_from_unique_id(
|
||||
hass: HomeAssistant, mock_coordinator_session
|
||||
) -> None:
|
||||
"""A v1 entry's identity is recoverable without reaching the device: the
|
||||
config flow has always keyed the entry's unique_id on the serial its probe
|
||||
read."""
|
||||
entry = _legacy_entry(hass, f"{DOMAIN}_{MOCK_SERIAL}")
|
||||
|
||||
await hass.config_entries.async_setup(entry.entry_id)
|
||||
await hass.async_block_till_done()
|
||||
|
||||
assert entry.version == 2
|
||||
assert entry.data[CONF_SERIAL] == MOCK_SERIAL
|
||||
|
||||
|
||||
async def test_migration_collapses_the_host_port_unique_id(
|
||||
hass: HomeAssistant, mock_coordinator_session
|
||||
) -> None:
|
||||
"""A board with no usable serial (issues #83/#189) used to be keyed two
|
||||
different ways at once: `host:port` on the config entry, `host` in the
|
||||
device and entity registries. Migration collapses the entry onto the
|
||||
registry's form, so the two finally name the same thing."""
|
||||
entry = _legacy_entry(hass, f"{DOMAIN}_{MOCK_HOST}:{MOCK_PORT}")
|
||||
|
||||
await hass.config_entries.async_setup(entry.entry_id)
|
||||
await hass.async_block_till_done()
|
||||
|
||||
assert entry.data[CONF_SERIAL] == MOCK_HOST
|
||||
assert entry.unique_id == f"{DOMAIN}_{MOCK_HOST}"
|
||||
|
||||
|
||||
async def test_migration_rekeys_an_ip_keyed_device_and_entity(
|
||||
hass: HomeAssistant, mock_coordinator_session
|
||||
) -> None:
|
||||
"""The registry entries the old placeholder identity minted are rewritten
|
||||
in place, so an orphan keeps its entity_id, name, area and every
|
||||
automation that referenced it -- rather than being replaced by a
|
||||
serial-keyed duplicate with a `_2` suffix while it sits permanently
|
||||
unavailable (issue #236)."""
|
||||
entry = _legacy_entry(hass, f"{DOMAIN}_{MOCK_SERIAL}")
|
||||
dev_reg = dr.async_get(hass)
|
||||
ent_reg = er.async_get(hass)
|
||||
|
||||
orphan_device = dev_reg.async_get_or_create(
|
||||
config_entry_id=entry.entry_id,
|
||||
identifiers={(DOMAIN, MOCK_HOST)},
|
||||
name=f"Samsung Appliance ({MOCK_HOST})",
|
||||
)
|
||||
orphan_entity = ent_reg.async_get_or_create(
|
||||
"sensor",
|
||||
DOMAIN,
|
||||
f"{DOMAIN}_{MOCK_HOST}_connection_mode",
|
||||
config_entry=entry,
|
||||
device_id=orphan_device.id,
|
||||
)
|
||||
|
||||
await hass.config_entries.async_setup(entry.entry_id)
|
||||
await hass.async_block_till_done()
|
||||
|
||||
# Same registry rows, now keyed on the real identity.
|
||||
rekeyed_device = dev_reg.async_get(orphan_device.id)
|
||||
assert rekeyed_device is not None
|
||||
assert rekeyed_device.identifiers == {(DOMAIN, MOCK_SERIAL)}
|
||||
rekeyed = ent_reg.async_get(orphan_entity.entity_id)
|
||||
assert rekeyed is not None
|
||||
assert rekeyed.unique_id == f"{DOMAIN}_{MOCK_SERIAL}_connection_mode"
|
||||
# And nothing is left keyed on the IP.
|
||||
assert dev_reg.async_get_device(identifiers={(DOMAIN, MOCK_HOST)}) is None
|
||||
|
||||
|
||||
async def test_migration_removes_an_orphan_that_is_already_duplicated(
|
||||
hass: HomeAssistant, mock_coordinator_session
|
||||
) -> None:
|
||||
"""Where the serial-keyed entry already exists, the IP-keyed one is the
|
||||
dead duplicate the race left behind -- it has been unavailable since the
|
||||
restart that created it and nothing will ever update it, so it goes
|
||||
rather than being rewritten onto a key that is taken."""
|
||||
entry = _legacy_entry(hass, f"{DOMAIN}_{MOCK_SERIAL}")
|
||||
dev_reg = dr.async_get(hass)
|
||||
ent_reg = er.async_get(hass)
|
||||
|
||||
real_device = dev_reg.async_get_or_create(
|
||||
config_entry_id=entry.entry_id,
|
||||
identifiers={(DOMAIN, MOCK_SERIAL)},
|
||||
)
|
||||
real_entity = ent_reg.async_get_or_create(
|
||||
"sensor",
|
||||
DOMAIN,
|
||||
f"{DOMAIN}_{MOCK_SERIAL}_connection_mode",
|
||||
config_entry=entry,
|
||||
device_id=real_device.id,
|
||||
)
|
||||
orphan_device = dev_reg.async_get_or_create(
|
||||
config_entry_id=entry.entry_id,
|
||||
identifiers={(DOMAIN, MOCK_HOST)},
|
||||
)
|
||||
orphan_entity = ent_reg.async_get_or_create(
|
||||
"sensor",
|
||||
DOMAIN,
|
||||
f"{DOMAIN}_{MOCK_HOST}_connection_mode",
|
||||
config_entry=entry,
|
||||
device_id=orphan_device.id,
|
||||
)
|
||||
assert orphan_entity.entity_id != real_entity.entity_id
|
||||
|
||||
await hass.config_entries.async_setup(entry.entry_id)
|
||||
await hass.async_block_till_done()
|
||||
|
||||
assert ent_reg.async_get(orphan_entity.entity_id) is None
|
||||
assert dev_reg.async_get(orphan_device.id) is None
|
||||
# The working pair is untouched.
|
||||
assert ent_reg.async_get(real_entity.entity_id) is not None
|
||||
assert dev_reg.async_get(real_device.id) is not None
|
||||
|
||||
|
||||
async def test_migration_leaves_a_host_identity_device_alone(
|
||||
hass: HomeAssistant, mock_coordinator_session
|
||||
) -> None:
|
||||
"""A board whose serial resolves *to* the host was never keyed on a
|
||||
placeholder -- its host-keyed device is the real one, and re-keying or
|
||||
removing it would orphan a working device to fix a problem it doesn't
|
||||
have."""
|
||||
entry = _legacy_entry(hass, f"{DOMAIN}_{MOCK_HOST}")
|
||||
dev_reg = dr.async_get(hass)
|
||||
device = dev_reg.async_get_or_create(
|
||||
config_entry_id=entry.entry_id,
|
||||
identifiers={(DOMAIN, MOCK_HOST)},
|
||||
)
|
||||
|
||||
await hass.config_entries.async_setup(entry.entry_id)
|
||||
await hass.async_block_till_done()
|
||||
|
||||
assert entry.data[CONF_SERIAL] == MOCK_HOST
|
||||
unchanged = dev_reg.async_get(device.id)
|
||||
assert unchanged is not None
|
||||
assert unchanged.identifiers == {(DOMAIN, MOCK_HOST)}
|
||||
|
||||
|
||||
async def test_migration_rejects_a_future_entry_version(hass: HomeAssistant) -> None:
|
||||
"""A downgrade must fail the entry rather than silently mangling data
|
||||
written by a newer release."""
|
||||
from custom_components.localthings import async_migrate_entry
|
||||
|
||||
entry = MockConfigEntry(domain=DOMAIN, data=LEGACY_ENTRY_DATA, version=3)
|
||||
entry.add_to_hass(hass)
|
||||
|
||||
assert await async_migrate_entry(hass, entry) is False
|
||||
|
||||
|
||||
async def test_migration_without_a_unique_id_falls_back_to_host(hass: HomeAssistant) -> None:
|
||||
"""Nothing to recover the identity from means the host, which is exactly
|
||||
what the coordinator used to seed -- so the registry keys such an entry
|
||||
already holds stay valid."""
|
||||
from custom_components.localthings import async_migrate_entry
|
||||
|
||||
entry = MockConfigEntry(domain=DOMAIN, data=LEGACY_ENTRY_DATA, version=1)
|
||||
entry.add_to_hass(hass)
|
||||
|
||||
assert await async_migrate_entry(hass, entry) is True
|
||||
assert entry.data[CONF_SERIAL] == entry.data[CONF_HOST]
|
||||
assert entry.unique_id == f"{DOMAIN}_{MOCK_HOST}"
|
||||
Reference in new issue
Block a user