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:
Marc Billow committed 2026-08-03 20:14:54 +00:00
1 parent cdaff4a1ca
commit 15be379243
18 files changed
+1186 -210

No files matched your search

+60 -15
View File
@@ -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
+316 -52
View File
@@ -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"
+70 -17
View File
@@ -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(
+190
View File
@@ -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}"