1580 lines
78 KiB
Python
1580 lines
78 KiB
Python
import json
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
GOLDEN = Path(__file__).parent / "fixtures" / "golden"
|
|
|
|
|
|
def _new_state_keys(name, resources, device_types=()):
|
|
from custom_components.localthings.registry.adapter import flatten
|
|
from custom_components.localthings.registry.by_type import resolve
|
|
from custom_components.localthings.registry.discovery import discover
|
|
|
|
reg = resolve(resources, device_types=device_types)
|
|
if reg is None:
|
|
from custom_components.localthings.registry.registry import CAPABILITIES
|
|
|
|
caps, pats = CAPABILITIES, []
|
|
else:
|
|
caps, pats = reg.capabilities, reg.pattern_capabilities
|
|
bound = discover(resources, caps, pats)
|
|
state = flatten(bound, resources)
|
|
return sorted(state.keys())
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"name,ip",
|
|
[
|
|
("dishwasher", "10.0.0.129"),
|
|
("refrigerator", "10.0.0.254"),
|
|
],
|
|
)
|
|
def test_registry_reproduces_golden_state_keys(name, ip, request):
|
|
from tests.conftest import _load_resources
|
|
|
|
resources = _load_resources(ip)
|
|
golden = json.loads((GOLDEN / f"{name}.json").read_text())
|
|
state_keys = _new_state_keys(name, resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_washer():
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("washer")
|
|
golden = json.loads((GOLDEN / "washer.json").read_text())
|
|
state_keys = _new_state_keys("washer", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_ehs():
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("ehs")
|
|
golden = json.loads((GOLDEN / "ehs.json").read_text())
|
|
state_keys = _new_state_keys("ehs", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_washer_wa8000t():
|
|
"""Top-load washer (WA8000T, issue #106) reports no oneUiVersion and
|
|
used the 'WA' consumer-model prefix, previously unmapped in
|
|
_CONSUMER_PREFIX_TO_KEY -- fell back to 'unknown'.
|
|
|
|
Also gains drum_clean_last_cleaned (issue #258): this fixture's
|
|
DrumCleanLog_ is a '|'-joined multi-entry history, which always failed
|
|
datetime.fromisoformat and silently returned None before
|
|
laundry.drum_clean_last_cleaned learned to take the last entry."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("washer_wa8000t")
|
|
golden = json.loads((GOLDEN / "washer_wa8000t.json").read_text())
|
|
state_keys = _new_state_keys("washer_wa8000t", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_dryer():
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("dryer")
|
|
golden = json.loads((GOLDEN / "dryer.json").read_text())
|
|
state_keys = _new_state_keys("dryer", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_dryer_dve50a8600():
|
|
"""DVE50A8600V/A3 (issue #79) -- description pairs two model numbers
|
|
('..._DVE50A8800_8600/...'), so the true 'DV' consumer-model token sits
|
|
one segment before the actual last segment ('8600'). The old
|
|
last-segment-only check missed it and fell back to 'unknown'; resolved
|
|
via _consumer_model_key scanning segments from the end."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("dryer_dve50a8600")
|
|
golden = json.loads((GOLDEN / "dryer_dve50a8600.json").read_text())
|
|
state_keys = _new_state_keys("dryer_dve50a8600", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_dryer_dv6800n():
|
|
"""DA_WM_A51_20_COMMON/DV6800N (issue #394) resolves via /oic/d's
|
|
'oic.d.dryer' device type, not board-token guessing -- its modelNum's
|
|
board tokens ('DA', 'WM', 'COMMON') are all deliberately excluded from
|
|
_BOARD_TOKEN_TO_KEY (see registry/by_type's module docstring)."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("dryer_dv6800n")
|
|
golden = json.loads((GOLDEN / "dryer_dv6800n.json").read_text())
|
|
state_keys = _new_state_keys(
|
|
"dryer_dv6800n", resources, device_types=("oic.wk.d", "oic.d.dryer")
|
|
)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner():
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner")
|
|
golden = json.loads((GOLDEN / "airconditioner.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_ailp_fac():
|
|
"""AILP_DA-AC-FAC-02011_0000 (issue #319) resolves both ways --
|
|
modelNum's 'FAC' board token and /oic/d's oic.d.airconditioner type
|
|
independently agree on the airconditioner registry. Passes
|
|
device_types through resolve() to exercise that agreement, not because
|
|
the board token is absent."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_ailp_fac")
|
|
golden = json.loads((GOLDEN / "airconditioner_ailp_fac.json").read_text())
|
|
state_keys = _new_state_keys(
|
|
"airconditioner_ailp_fac", resources, device_types=("oic.wk.d", "oic.d.airconditioner")
|
|
)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_oven_tp2x_ks_walloven():
|
|
"""TP2X_DA-KS-WALLOVEN-000002 (issue #300), a steam-oven-class board
|
|
(water tank, descale, pyro-free) quite unlike the NV7000BS-class board
|
|
oven.py's write comments were written against. /diagnosis/vs/0 was the
|
|
dump's only unbound href, now covered via dishwasher.DIAGNOSIS. The
|
|
board's options[] also has no UpperLamp_ token at all -- confirms
|
|
LAMP's new exists_fn keeps it from registering a phantom switch here,
|
|
same fastpreheat/NaturalSteam-class gap issue #183 fixed on its
|
|
siblings."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("oven_tp2x_ks_walloven")
|
|
golden = json.loads((GOLDEN / "oven_tp2x_ks_walloven.json").read_text())
|
|
state_keys = _new_state_keys(
|
|
"oven_tp2x_ks_walloven", resources, device_types=("oic.wk.d", "oic.d.oven")
|
|
)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_dehumidifier():
|
|
"""TP1X_DA_AC_DHM_01001_0000 (issue #88, AY18CG7500GED) shares the DA_AC_
|
|
board family with the room-AC models but carries the '_DHM_' token;
|
|
resolved via the '_DHM_' modelNum fallback in for_device_by_model into a
|
|
dedicated dehumidifier registry (target humidity, operating mode, reused
|
|
AC filter/auto-clean/mute-once capabilities)."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("dehumidifier")
|
|
golden = json.loads((GOLDEN / "dehumidifier.json").read_text())
|
|
state_keys = _new_state_keys("dehumidifier", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_water_purifier():
|
|
"""TP2X_WATERPURIFIER_20K (issue #90) reports no oneUiVersion; resolved
|
|
via the 'WATERPURIFIER' modelNum/description fallback into a dedicated
|
|
water_purifier registry (dispense settings, sterilize/filter status,
|
|
favorite capacity, and the three lock switches)."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("water_purifier")
|
|
golden = json.loads((GOLDEN / "water_purifier.json").read_text())
|
|
state_keys = _new_state_keys("water_purifier", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_water_purifier_ailite_25k():
|
|
"""AILITE_WATERPURIFIER_25K (issue #196, RWP70F15ANW) -- a coffee-capable
|
|
water purifier on an AILITE_DA-REF-WATERPURIFIER board, whose modelNum's
|
|
'REF' token would otherwise misroute it to the refrigerator registry (see
|
|
TestBoardTokenAmbiguity's carve-out). Also the first dump to expose
|
|
/cup/state/vs/0, /statistic/pour/vs/0, and the settings/sound/* trio on
|
|
this device type, and a hot_water_temperature select that must gate off
|
|
(no supportedHotTemperatures reported) rather than surface as 'unknown'."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("water_purifier_ailite_25k")
|
|
golden = json.loads((GOLDEN / "water_purifier_ailite_25k.json").read_text())
|
|
state_keys = _new_state_keys("water_purifier_ailite_25k", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_water_purifier_coffee():
|
|
"""TP2X_WATERPURIFIER_20K coffee-capable variant (issue #107) adds
|
|
/favorite/coffee/vs/0, /favorite/hotwater/vs/0, and three static
|
|
coffee-recipe resources not present in issue #90's original dump.
|
|
|
|
This fixture's /setting/waterpurifier/vs/0 turns out to report no
|
|
supportedHotTemperatures either (only hotwaterLevel/hotwaterRange, the
|
|
same shape issue #196 surfaced) -- so hot_water_temperature dropped out
|
|
of this golden when the #196 fix (see water_purifier.DISPENSE's
|
|
exists_fn) landed. This fixture was quietly hitting the same 'unknown'
|
|
bug all along; the registry-level golden just had no way to show it
|
|
since flatten()'s state dict doesn't model select option membership."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("water_purifier_coffee")
|
|
golden = json.loads((GOLDEN / "water_purifier_coffee.json").read_text())
|
|
state_keys = _new_state_keys("water_purifier_coffee", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_gas_cooktop_tp2x_ks():
|
|
"""TP2X_DA-KS-COOKTOP-000001 (issue #314) -- routes via
|
|
for_device_by_resources' DeviceType_/OperationState signature, same as
|
|
the original cooktop fixture. /alarms/vs/0 and /kidslock/vs/0 were the
|
|
dump's only unbound hrefs; both are common.UNIVERSAL shapes this
|
|
registry now picks up individually (common.ALARMS,
|
|
common.KIDS_LOCK_VS_FALLBACK)."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("gas_cooktop_tp2x_ks")
|
|
golden = json.loads((GOLDEN / "gas_cooktop_tp2x_ks.json").read_text())
|
|
state_keys = _new_state_keys("gas_cooktop_tp2x_ks", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_cooktop():
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("cooktop")
|
|
golden = json.loads((GOLDEN / "cooktop.json").read_text())
|
|
state_keys = _new_state_keys("cooktop", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_tp1x_ref_21k_us():
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_tp1x_ref_21k_us")
|
|
golden = json.loads((GOLDEN / "refrigerator_tp1x_ref_21k_us.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_tp1x_ref_21k_us", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_tp1x_ref_21k_eu():
|
|
"""TP1X_REF_21K, EU region variant (issue #165) -- self-reports
|
|
oneUiVersion "7.0 Refrigerator" like the US variant, but additionally
|
|
carries /rm/control/vs/0 (a bare resource-monitoring poll-interval
|
|
config, added to the global ignore list) that the US dump doesn't
|
|
report at all. Door sensors (the reporter's actual ask) were already
|
|
covered by fridge.DOOR_GENERIC/DOORS_FALLBACK -- this href was the only
|
|
gap keeping the coverage repair open."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_tp1x_ref_21k_eu")
|
|
golden = json.loads((GOLDEN / "refrigerator_tp1x_ref_21k_eu.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_tp1x_ref_21k_eu", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_tp1x_ref_21k_airfilter():
|
|
"""TP1X_REF_21K, air-filter-equipped variant (issue #318) -- reports
|
|
/filter/airdustfilter/vs/0 (internal deodorizing filter), the one
|
|
unbound href on this dump. Unlike airconditioner.AIR_FILTER's
|
|
filterUsage/filterCapacity pair, this board's filterUsage is already a
|
|
0-100 percentage with no filterCapacity to divide by."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_tp1x_ref_21k_airfilter")
|
|
golden = json.loads((GOLDEN / "refrigerator_tp1x_ref_21k_airfilter.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_tp1x_ref_21k_airfilter", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_range_hood():
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("range_hood")
|
|
golden = json.loads((GOLDEN / "range_hood.json").read_text())
|
|
state_keys = _new_state_keys("range_hood", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_washer_flexwash():
|
|
"""FlexWash twin washers (WV-prefix consumer model, e.g. WV55M9600AW)
|
|
report no oneUiVersion and previously fell through for_device_by_model's
|
|
consumer-prefix map entirely -- issue #19.
|
|
|
|
Also gains drum_clean_last_cleaned (issue #258) -- see the wa8000t test
|
|
above for why."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("washer_flexwash")
|
|
golden = json.loads((GOLDEN / "washer_flexwash.json").read_text())
|
|
state_keys = _new_state_keys("washer_flexwash", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_washer_dryer_combo():
|
|
"""Washer/dryer combo units carry a writable dryLevel field on
|
|
/washer/vs/0 itself, with no separate dryer resource -- issue #22.
|
|
|
|
Also gains drum_clean_last_cleaned (issue #258) -- see the wa8000t test
|
|
above for why."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("washer_dryer_combo")
|
|
golden = json.loads((GOLDEN / "washer_dryer_combo.json").read_text())
|
|
state_keys = _new_state_keys("washer_dryer_combo", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_washer_ww6500():
|
|
"""DA_WM_A51_20 front-loader, typed solely by the WW consumer prefix in
|
|
its /information/vs/0 description: A51 is not a board token, so with the
|
|
description blanked this device resolves to nothing and drops to the
|
|
unknown-device fallback. That is the fragile route this test pins.
|
|
Reports the AddWash tokens and an empty /wm/editcourse/vs/0, so its cycle
|
|
list comes from supportedOptions."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("washer_ww6500")
|
|
golden = json.loads((GOLDEN / "washer_ww6500.json").read_text())
|
|
state_keys = _new_state_keys("washer_ww6500", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_artik051_ref_17k():
|
|
"""ARTIK051_REF_17K's Cool Select Zone pantry compartment
|
|
(/status/pantry/one/vs/0) -- issue #20."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_artik051_ref_17k")
|
|
golden = json.loads((GOLDEN / "refrigerator_artik051_ref_17k.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_artik051_ref_17k", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_artik051_dongle_ref_cooler():
|
|
"""RR40M7165WW (issue #78) -- the same ARTIK051_DONGLE_REF household
|
|
dongle family as issue #77's freezer, but the fridge half: reports
|
|
/door/cooler/0 *and* /door/onedoorfreezer/vs/0 (the latter apparently
|
|
shared firmware naming, not an actual second freezer compartment) plus
|
|
/temperature/{current,desired}/cooler/0. Same pipe-delimited modelNum
|
|
detection gap and DOOR_GENERIC field-name gap as #77, same fix."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_artik051_dongle_ref_cooler")
|
|
golden = json.loads((GOLDEN / "refrigerator_artik051_dongle_ref_cooler.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_artik051_dongle_ref_cooler", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_artik051_dongle_ref():
|
|
"""ARTIK051_DONGLE_REF standalone freezer (issues #77/#83) -- reports no
|
|
oneUiVersion and a pipe-delimited modelNum ('..._DONGLE_REF|<rest>')
|
|
that the old '_REF_' substring check missed entirely; resolved via the
|
|
segment-based check in for_device_by_model. Its door
|
|
(/door/onedoorfreezer/vs/0) and temperature
|
|
(/temperature/{current,desired}/freezer/0) hrefs only bind through
|
|
fridge.py's pattern capabilities, which the 'unknown' fallback never
|
|
tries -- so this also regression-tests that those resources bind at
|
|
all once routed to the right registry."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_artik051_dongle_ref")
|
|
golden = json.loads((GOLDEN / "refrigerator_artik051_dongle_ref.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_artik051_dongle_ref", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_tp2x_ref_20k():
|
|
"""TP2X_REF_20K -- CV_FDR_-prefixed flex zone (issue #32) plus the extra
|
|
energy fields (cumulativeConsumption/monthlyConsumption/
|
|
thismonthlyConsumption) surfaced by issue #26."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_tp2x_ref_20k")
|
|
golden = json.loads((GOLDEN / "refrigerator_tp2x_ref_20k.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_tp2x_ref_20k", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_tp2x_ref_20k_kimchi():
|
|
"""A different physical unit reporting the same "TP2X_REF_20K" modelNum
|
|
string as the fixture above (issue #26's second reporter) -- a
|
|
3-compartment kimchi refrigerator with no flex zone, doors/icemaker, or
|
|
freezer/cooler split, but its own /status/kimchi/<slot>/vs/0 and
|
|
/kimchidoors/top/vs/0 resources (fridge.KIMCHI_ZONE/KIMCHI_DOOR_GENERIC)."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_tp2x_ref_20k_kimchi")
|
|
golden = json.loads((GOLDEN / "refrigerator_tp2x_ref_20k_kimchi.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_tp2x_ref_20k_kimchi", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_ac_tp1x_da_ac_rac_01011():
|
|
"""Newer AC firmware (Tizen Lite, oneUiVersion "7.0 Air conditioner"; model
|
|
TP1X_DA-AC-RAC-01011) reports temperature via the vendor /temperatures/vs/0
|
|
items[] resource and adds a /light/vs/0 display light, with extra vendor
|
|
housekeeping hrefs -- issue #17 for this model class (PR #36)."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_tp1x_da_ac_rac_01011")
|
|
golden = json.loads((GOLDEN / "airconditioner_tp1x_da_ac_rac_01011.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_tp1x_da_ac_rac_01011", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_tp2x_rac_20k():
|
|
"""TP2X_RAC_20K (issue #37) -- reports no oneUiVersion; resolved via the
|
|
'_RAC_' modelNum token fallback in for_device_by_model."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_tp2x_rac_20k")
|
|
golden = json.loads((GOLDEN / "airconditioner_tp2x_rac_20k.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_tp2x_rac_20k", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_caww_tp2():
|
|
"""A-CAWW-TP2-20-COMMON (issue #52, System AC / multi-indoor-unit
|
|
commercial install) reports no oneUiVersion and no '_RAC_'/'_PRAC_'
|
|
token; resolved via the '-CAWW-' modelNum fallback in
|
|
for_device_by_model. Otherwise binds cleanly against the existing
|
|
airconditioner registry -- same TP1X/TP2X-class resource surface, plus
|
|
one SAC-only installation-topology resource (ignored)."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_caww_tp2")
|
|
golden = json.loads((GOLDEN / "airconditioner_caww_tp2.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_caww_tp2", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_window_ac():
|
|
"""TP1X_DA_AC_WAC_01001_0000 (issue #87, Bespoke Window AC AW06C7155EWAZ)
|
|
reports no oneUiVersion and carries the '_WAC_' (Window Air Conditioner)
|
|
token instead of '_RAC_'/'_PRAC_'; resolved via the '_WAC_' modelNum
|
|
fallback in for_device_by_model. Otherwise binds cleanly against the
|
|
existing airconditioner registry with zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_window_ac")
|
|
golden = json.loads((GOLDEN / "airconditioner_window_ac.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_window_ac", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_tp1x_rac():
|
|
"""TP1X_DA-AC-RAC-01001_0000 (issue #38) -- fuller RAC board with display
|
|
light, self-check, mute-once, and a current-limit setting."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_tp1x_rac")
|
|
golden = json.loads((GOLDEN / "airconditioner_tp1x_rac.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_tp1x_rac", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_tp1x_rac_coolonly():
|
|
"""TP1X_DA-AC-RAC-01001 cool-only global variant (issue #91) whose
|
|
/otninformation/vs/0 ships no swVersionInfo block -- resolves via the
|
|
'RAC' board token in its modelNum."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_tp1x_rac_coolonly")
|
|
golden = json.loads((GOLDEN / "airconditioner_tp1x_rac_coolonly.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_tp1x_rac_coolonly", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_windfree():
|
|
"""ARTIK051_PRAC_20K, WindFree-capable unit (issue #75) -- same modelNum
|
|
family as the original issue #17 fixture, but its /mode/convenient/vs/0
|
|
additionally reports Nano/NanoSleep/MotionDirect/MotionIndirect, its
|
|
/wind/direction/vs/0 reports Left_And_Right, and /humidity/vs/0's
|
|
fivepercentHumidity is actually populated."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_windfree")
|
|
golden = json.loads((GOLDEN / "airconditioner_windfree.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_windfree", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_lnx_rac_heatpump():
|
|
"""Lennox-branded heat pump on the Samsung RAC board family (issue #173,
|
|
modelNum TP1X_LNX-AC-RAC-01001_0000) -- routes via the existing '-RAC-'
|
|
token, same registry as the plain RAC family. Adds two AI-feature
|
|
resources not seen on prior AC dumps: /mds/absencepowersaving/vs/0
|
|
(absence-detection power saving) and /option/motiondetectwind/stateful/vs/0
|
|
(avoid-direct-wind-on-motion), both exposed read-only per the 'don't
|
|
guess' rule."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_lnx_rac_heatpump")
|
|
golden = json.loads((GOLDEN / "airconditioner_lnx_rac_heatpump.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_lnx_rac_heatpump", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_range():
|
|
"""Range/cooktop-oven combo (model TP1X_DA-KS-RANGE-0102X, issue #44) --
|
|
reports no oneUiVersion; resolved via the '-RANGE-' modelNum token
|
|
fallback in for_device_by_model. Reuses the oven family's cavity/
|
|
setpoint/mode/operational-state capabilities and adds range.py's
|
|
per-burner capabilities for the 4 burners this dump reports."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("range")
|
|
golden = json.loads((GOLDEN / "range.json").read_text())
|
|
state_keys = _new_state_keys("range", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_induction_cooktop():
|
|
"""Standalone induction cooktop, no oven attached (model
|
|
TP1X_DA-KS-COOKTOP-01011, issue #86) -- reports no oneUiVersion and a
|
|
hyphenated '-COOKTOP-' modelNum token, resolved via
|
|
for_device_by_model into its own 'induction_cooktop' registry (not
|
|
cooktop.REGISTRY, which is the unrelated NA9300K gas-cooktop family)."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("induction_cooktop")
|
|
golden = json.loads((GOLDEN / "induction_cooktop.json").read_text())
|
|
state_keys = _new_state_keys("induction_cooktop", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_induction_cooktop_nv9000d():
|
|
"""NV9000D-/KO2 compatibility fixture: the same three-burner registry,
|
|
with the safety-shutoff status but without optional probe/hood resources."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("induction_cooktop_nv9000d")
|
|
golden = json.loads((GOLDEN / "induction_cooktop_nv9000d.json").read_text())
|
|
state_keys = _new_state_keys("induction_cooktop_nv9000d", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_range_no_info():
|
|
"""NE63B8411SS (issue #74) -- reports no oneUiVersion *and* no
|
|
/information/vs/0 at all, so neither for_device nor
|
|
for_device_by_model has anything to key off; resolved via the 'Bake'-
|
|
in-supportedModes + /cooktopmonitoring/vs/0 signature in
|
|
for_device_by_resources. This board's local API has no per-burner
|
|
/cooktop/status/vs/0 array either -- only the coarse
|
|
/cooktopmonitoring/vs/0 monitoring resource covered by range.py's
|
|
COOKTOP_MONITORING."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("range_no_info")
|
|
golden = json.loads((GOLDEN / "range_no_info.json").read_text())
|
|
state_keys = _new_state_keys("range_no_info", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_air_purifier():
|
|
"""ARTIK051_TVTL_18K (issue #56) -- reports no oneUiVersion; resolved via
|
|
the '_TVTL_' modelNum token fallback in for_device_by_model."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("air_purifier")
|
|
golden = json.loads((GOLDEN / "air_purifier.json").read_text())
|
|
state_keys = _new_state_keys("air_purifier", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_oven():
|
|
"""Wall oven (model TP1X_DA-KS-OVEN-0107X, issue #55) -- reports no
|
|
oneUiVersion; resolved via the '-OVEN-' modelNum token fallback in
|
|
for_device_by_model, mirroring the '-RANGE-' fallback added for
|
|
issue #44. Before that fallback existed the device type came back
|
|
'unknown' and every href fell through to the global CAPABILITIES
|
|
registry instead of the oven family's own."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("oven")
|
|
golden = json.loads((GOLDEN / "oven.json").read_text())
|
|
state_keys = _new_state_keys("oven", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_washer_wa55a7700av():
|
|
"""DA_WM_TP1_21_COMMON top-load washer (model WA55A7700AV, issue #111)
|
|
-- a different board generation than the WA8000T's TP2_20_COMMON,
|
|
reached through the same 'WA' consumer-model-prefix fallback (issue
|
|
#106). Binds cleanly against the existing washer registry with zero
|
|
unbound hrefs.
|
|
|
|
Also gains drum_clean_last_cleaned (issue #258) -- see the wa8000t test
|
|
above for why."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("washer_wa55a7700av")
|
|
golden = json.loads((GOLDEN / "washer_wa55a7700av.json").read_text())
|
|
state_keys = _new_state_keys("washer_wa55a7700av", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_range_ne8300d():
|
|
"""TP1X_DA-KS-RANGE-0102X (model NE8300D, issue #112) -- reports no
|
|
oneUiVersion; resolved via the '-RANGE-' modelNum token fallback.
|
|
Binds cleanly against the existing range registry, including
|
|
/cooktopmonitoring/vs/0 via range.COOKTOP_MONITORING, with zero
|
|
unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("range_ne8300d")
|
|
golden = json.loads((GOLDEN / "range_ne8300d.json").read_text())
|
|
state_keys = _new_state_keys("range_ne8300d", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_range_ne63a6511():
|
|
"""NE63A6511SS/AA (issue #138) -- reports no /information/vs/0 at all,
|
|
same shape as issue #74's NE63B8411SS; resolved via the same
|
|
'Bake'-in-supportedModes + /cooktopmonitoring/vs/0 signature in
|
|
for_device_by_resources. Binds cleanly against the existing range
|
|
registry with zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("range_ne63a6511")
|
|
golden = json.loads((GOLDEN / "range_ne63a6511.json").read_text())
|
|
state_keys = _new_state_keys("range_ne63a6511", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_ara_ww_tp1_22():
|
|
"""ARA-WW-TP1-22-COMMON wall-mount RACs (model AR10/13/18BYEAAWKNME,
|
|
issues #115/#116/#117/#120) report no oneUiVersion and no
|
|
'_RAC_'/'-RAC-' token -- resolved via the 'ARA-WW-' modelNum fallback.
|
|
Same resource surface as the other TP1X-class room ACs; binds cleanly
|
|
against the existing airconditioner registry with zero unbound hrefs,
|
|
so no new device type was needed."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_ara_ww_tp1_22")
|
|
golden = json.loads((GOLDEN / "airconditioner_ara_ww_tp1_22.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_ara_ww_tp1_22", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_windfree_oscillation():
|
|
"""TP1X_DA-AC-RAC-01011_0000 Bespoke AI WindFree Deluxe (model
|
|
AR60H10D1JWNME, issue #126) -- the same board family as the
|
|
airconditioner_tp1x_da_ac_rac_01011 fixture, but a newer firmware
|
|
variant reporting no /wind/direction/vs/0 at all: swing lives on the
|
|
2-axis /wind/oscillation/vs/0 resource instead (airconditioner.
|
|
HREF_WIND_OSCILLATION, climate.py's oscillation fallback), and it adds
|
|
an /anomalyload/vs/0 overload-response resource (airconditioner.
|
|
ANOMALY_LOAD, read-only per the 'don't guess' rule). Binds cleanly
|
|
with zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_windfree_oscillation")
|
|
golden = json.loads((GOLDEN / "airconditioner_windfree_oscillation.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_windfree_oscillation", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_microwave_mw7300b():
|
|
"""TP1X_DA-KS-MICROWAVE-01041 combi microwave (model MW7300B, issue
|
|
#121) -- reports no oneUiVersion; resolved via the '-MICROWAVE-'
|
|
modelNum token fallback onto its own microwave registry. Shares the
|
|
oven board family's operational-state/door/connected/recipe-cook
|
|
Capability objects (reused directly from oven.py), but has its own
|
|
cooking-mode vocabulary, setpoint bounds, and cavity power-level sensor
|
|
(capabilities/microwave.py) -- this device's initial routing folded it
|
|
into the oven registry (issue #121); split into its own device type per
|
|
user feedback that microwaves shouldn't show up as ovens."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("microwave_mw7300b")
|
|
golden = json.loads((GOLDEN / "microwave_mw7300b.json").read_text())
|
|
state_keys = _new_state_keys("microwave_mw7300b", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_qooker_mw7500a():
|
|
"""Bespoke Qooker MW7500A uses Samsung's OVEN board/type metadata but
|
|
proves its microwave semantics through MicroWave mode plus cavity
|
|
powerLevel. The routing correction must expose microwave state keys
|
|
without the misleading oven_mode/oven_state entities."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("qooker_mw7500a")
|
|
golden = json.loads((GOLDEN / "qooker_mw7500a.json").read_text())
|
|
state_keys = _new_state_keys("qooker_mw7500a", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_microwave_me7500d():
|
|
"""TP1X_DA-KS-MICROWAVE-01051 plain microwave (model ME7500D, issues
|
|
#137/#142) -- the same microwave registry as MW7300B above, but this
|
|
board also reports the built-in vent fan's `/hood/fanspeed/vs/0`
|
|
resource, previously unbound. Bound via range_hood.HOOD_FAN (reused
|
|
directly, same resource shape a standalone range hood reports); unlike
|
|
a standalone hood this board has no sibling `/power/0` or
|
|
`/power/vs/0` resource, so fan.py's LocalThingsRangeHoodFan treats
|
|
fan speed 0 as the off state instead of writing a separate power
|
|
resource -- see its `_speed_zero_is_off` check. This board also has
|
|
no `/temperatures/vs/0` or `x.com.samsung.da.hood.autoOperation`
|
|
field, unlike MW7300B, so `setpoint`/`current_temp_c` and
|
|
`automatic_operation` are correctly absent here."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("microwave_me7500d")
|
|
golden = json.loads((GOLDEN / "microwave_me7500d.json").read_text())
|
|
state_keys = _new_state_keys("microwave_me7500d", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_microwave_me7500d_lamp_high():
|
|
"""Same TP1X_DA-KS-MICROWAVE-01051/ME7500D board as microwave_me7500d
|
|
above, but this live capture (issue #152) is the first to report a
|
|
non-Off Lamp token ('Lamp_High'). Locks in that the lamp switch reads
|
|
it as on rather than the previously-hardcoded 'On'-only comparison."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("microwave_me7500d_lamp_high")
|
|
golden = json.loads((GOLDEN / "microwave_me7500d_lamp_high.json").read_text())
|
|
state_keys = _new_state_keys("microwave_me7500d_lamp_high", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_air_purifier_tp1x_da_ac_air():
|
|
"""TP1X_DA-AC-AIR-01031_0000 (issue #130) self-reports oneUiVersion
|
|
'7.0 Air purifier' (unused for routing) and resolves via its 'AIR'
|
|
board token onto the existing
|
|
air_purifier registry (shared with the older ARTIK051_TVTL family via
|
|
per-href match_fn discrimination -- see capabilities/air_purifier.py).
|
|
Its /mode/vs/0 reports modes/supportedModes directly (Smart/Max/Mid/
|
|
WindFree/Sleep) rather than the older family's packed options[] scheme,
|
|
which the new air_purifier.FAN capability now binds to a real `fan`
|
|
entity (PRESET_MODE, not an ordered speed -- see fan.py). Binds with
|
|
zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("air_purifier_tp1x_da_ac_air")
|
|
golden = json.loads((GOLDEN / "air_purifier_tp1x_da_ac_air.json").read_text())
|
|
state_keys = _new_state_keys("air_purifier_tp1x_da_ac_air", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_vacuum_station():
|
|
"""A-VSKR-TP1-22-VS9500AL stick-vacuum clean/auto-empty station (issue
|
|
#131) -- reports no oneUiVersion; resolved via the new '-VSKR-'
|
|
modelNum fallback onto a new vacuum_station registry (see
|
|
capabilities/vacuum_station.py's module docstring for why this needed
|
|
a new device type rather than reusing an existing one: the dump has no
|
|
vacuum-body state at all, only station-specific dustbag/dustbin/
|
|
UV-sanitize resources that share no hrefs with anything else already
|
|
modeled). Binds with zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("vacuum_station")
|
|
golden = json.loads((GOLDEN / "vacuum_station.json").read_text())
|
|
state_keys = _new_state_keys("vacuum_station", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_artik051_krac_18k():
|
|
"""ARTIK051_KRAC_18K (issue #136) -- reports no oneUiVersion, and its
|
|
'_KRAC_' token was invisible to for_device_by_model's '_RAC_' check (the
|
|
'K' sits between the underscore and 'RAC'), so it fell back to 'unknown'
|
|
and exposed nothing but power. Same ARTIK051 board generation as the
|
|
'_TVTL_' air purifier: no /wind/* resources at all (fan and vane live in
|
|
/airflow/vs/0), no /mode/convenient/vs/0 (the preset is a Comode_* token),
|
|
and several settings carried as /mode/vs/0 options[] tokens."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_artik051_krac_18k")
|
|
golden = json.loads((GOLDEN / "airconditioner_artik051_krac_18k.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_artik051_krac_18k", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_tp1x_rac_01001():
|
|
"""TP1X_DA-AC-RAC-01001_0000 (model AR07C9150HZN, issue #155) -- binds
|
|
cleanly against the existing airconditioner registry with zero unbound
|
|
hrefs (the registry/discovery side was never the gap here). Its
|
|
/wind/strength/vs/0 reports supportedModes "0"/"31"-"35" instead of the
|
|
"0"-"4" scale climate.py's _DEVICE_TO_FAN was built from, which silently
|
|
dropped every fan speed but Auto -- see
|
|
test_airconditioner_tp1x_rac_01001_fan.py for the climate-level fix."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_tp1x_rac_01001")
|
|
golden = json.loads((GOLDEN / "airconditioner_tp1x_rac_01001.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_tp1x_rac_01001", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_tp1x_rac_odor_controller():
|
|
"""TP1X_DA-AC-RAC-01001_0000 -- reporter's dump: fan (0-4 wind-strength
|
|
scale) and WindFree (Nano/NanoSleep convenient-mode codes) already bind
|
|
via the composite climate entity, no code change needed there. The
|
|
genuine gap was /mode/vs/0's SmartCoolClean_/ProgressSmartClean_ option
|
|
tokens (the cloud custom.airConditionerOdorController capability),
|
|
previously unbound to any entity -- now odor_controller_active/
|
|
odor_controller_progress."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_tp1x_rac_odor_controller")
|
|
golden = json.loads((GOLDEN / "airconditioner_tp1x_rac_odor_controller.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_tp1x_rac_odor_controller", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_air_dresser():
|
|
"""DA_DF_A51_20_COMMON AirDresser (model DF8600T, issue #162) -- reports
|
|
no oneUiVersion; resolved via the '_DF_' modelNum token fallback. Has no
|
|
/wm/editcourse/vs/0 at all, so the course select's option list comes
|
|
entirely from laundry.cycle_options' supportedOptions fallback. Binds
|
|
cleanly against the new air_dresser registry with zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("air_dresser")
|
|
golden = json.loads((GOLDEN / "air_dresser.json").read_text())
|
|
state_keys = _new_state_keys("air_dresser", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_air_dresser_tp2_20():
|
|
"""DA_DF_TP2_20_COMMON AirDresser (model DF9500A, issue #157) -- a
|
|
different board generation than issue #162's DA_DF_A51_20_COMMON, also
|
|
routed via the '_DF_' modelNum fallback into the same air_dresser
|
|
registry. Unlike #162's board, this one populates /wm/editcourse/vs/0's
|
|
editCourseList directly (no supportedOptions fallback needed) and
|
|
reports two AirDresser-specific resources #162 doesn't have:
|
|
/st/airdressercourse/vs/0 (course table id, ignored.py) and
|
|
/airdresseroption/sanitize/vs/0 (air_dresser.AIR_DRESSER_SANITIZE).
|
|
Binds cleanly with zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("air_dresser_tp2_20")
|
|
golden = json.loads((GOLDEN / "air_dresser_tp2_20.json").read_text())
|
|
state_keys = _new_state_keys("air_dresser_tp2_20", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_air_dresser_tp1_21():
|
|
"""DA_DF_TP1_21_COMMON AirDresser (model DF3000B, issue #208) -- another
|
|
board generation routed via the '_DF_' modelNum token fallback into the
|
|
same air_dresser registry as #162's and #157's boards (its dump also
|
|
happens to be the first AirDresser one to carry /oic/d's device type,
|
|
'x.com.st.d.steamcloset' -- see test_by_type.py's
|
|
TestForDeviceByOicType for that mapping's own coverage). The first
|
|
AirDresser dump to report /buzzersound/vs/0 (laundry.BUZZER_SOUND,
|
|
added for this issue -- #162's and #157's boards don't report it at
|
|
all). Binds cleanly with zero unbound hrefs; course codes for this
|
|
board's table still aren't identified (same as #162's), so 'cycle'
|
|
remains the raw code rather than a table-specific translation."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("air_dresser_tp1_21")
|
|
golden = json.loads((GOLDEN / "air_dresser_tp1_21.json").read_text())
|
|
state_keys = _new_state_keys("air_dresser_tp1_21", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_air_monitor():
|
|
"""Samsung Air Monitor Plus (ASM-KR-TP1-22-ACMB1M, issue #210) -- a
|
|
standalone battery-powered air-quality sensor puck, the first device
|
|
this integration has no controllable-appliance concept for at all (no
|
|
/power/*, only /energy/battery/vs/0). Routes via both /oic/d
|
|
('x.com.st.d.airqualitysensor') and the 'ASM' modelNum board token.
|
|
Reuses air_purifier.AIR_QUALITY's /sensors/vs/0 decode
|
|
(common.sensor_item_value) for dust/fine_dust/super_fine_dust/odor/
|
|
clean_level, adding a CO2 reading those families don't report. Binds
|
|
cleanly with zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("air_monitor")
|
|
golden = json.loads((GOLDEN / "air_monitor.json").read_text())
|
|
state_keys = _new_state_keys("air_monitor", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_air_purifier_vtww():
|
|
"""A-VTWW-TP2-21-COMMON BESPOKE Cube Air (issue #151) -- reports no
|
|
oneUiVersion; resolved via the '-VTWW-' modelNum token fallback into
|
|
the existing air_purifier registry. Its fan lives on
|
|
/wind/strength/vs/0 (air_purifier.WIND_STRENGTH_FAN) rather than the
|
|
/mode/vs/0 FAN the other two board generations in this registry use.
|
|
Binds cleanly with zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("air_purifier_vtww")
|
|
golden = json.loads((GOLDEN / "air_purifier_vtww.json").read_text())
|
|
state_keys = _new_state_keys("air_purifier_vtww", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_fac_bora():
|
|
"""TP2X_FAC_BORA_21K Wind-Free 2-in-1 (floor-standing + wall-mounted
|
|
indoor units sharing one outdoor unit and one local IP, issues
|
|
#150/#153) -- reports no oneUiVersion; resolved via the '_FAC_'
|
|
modelNum fallback. Binds cleanly against the existing airconditioner
|
|
registry (including a real climate entity, the actual reported gap)
|
|
with zero unbound hrefs -- /subdevices/vs/0 and /runn/vs/0 are the only
|
|
hrefs this board reports that no other AC family does, both added to
|
|
_AC_IGNORED as undocumented/not-locally-actionable."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_fac_bora")
|
|
golden = json.loads((GOLDEN / "airconditioner_fac_bora.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_fac_bora", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def _new_subdevice_aware_state_keys(name, device_types=()):
|
|
"""Like _new_state_keys, but runs the full subdevice-aware pipeline
|
|
(enumerate_subdevices + discover_partitioned, issue #177) instead of a
|
|
single discover() call, so the golden for a composite-device fixture
|
|
captures every materialized subdevice's keys
|
|
(subdevice1_-/subdevice_<uuid>_-prefixed), not just the master's.
|
|
|
|
`device_types` threads through to discover_partitioned's own
|
|
`oic_device_types` -- needed for a board with no /information/vs/0 at
|
|
all to route from (issue #324's range)."""
|
|
from custom_components.localthings.registry.adapter import flatten
|
|
from tests.conftest import _discover_full, _load_device_full
|
|
|
|
resources, oic_res, seeds = _load_device_full(name)
|
|
bound, _materialized, _skipped, full_resources, _device_type_name = _discover_full(
|
|
resources,
|
|
oic_res,
|
|
seeds,
|
|
device_types,
|
|
)
|
|
state = flatten(bound, full_resources)
|
|
return sorted(state.keys())
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_artik051_dongle_fac_18k():
|
|
"""The reporter's ARTIK051_DONGLE_FAC_18K (issue #177, Pattern A -- indexed
|
|
siblings): a real v0.16.0 dump with a genuine second indoor subdevice at
|
|
`/device/1` (subdevice1_-prefixed keys below) and an unused SmartThings
|
|
slot at `/device/2` that answers its seed but never produces a
|
|
materialized subdevice (see DESIGN-177.md section 4 and
|
|
test_subdevice_discovery.py's explicit "/device/2 produces no entities"
|
|
assertion) -- so this golden has no `subdevice2_`-prefixed keys at all,
|
|
which is the point."""
|
|
name = "airconditioner_artik051_dongle_fac_18k"
|
|
golden = json.loads((GOLDEN / f"{name}.json").read_text())
|
|
state_keys = _new_subdevice_aware_state_keys(name)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_cac():
|
|
"""TP1X_DA-AC-CAC-01001_0000 (issue #191) -- fell back to 'unknown' in
|
|
0.16.0 when oneUiVersion detection was dropped, since 'CAC' had never
|
|
been added to the modelNum board-token table. Resolved via the new 'CAC'
|
|
token onto the existing airconditioner registry. Not fully covered yet --
|
|
two hrefs remain unbound (sound-optimization, smart-sensing-cooling),
|
|
both genuinely new to this board generation and out of scope for the
|
|
routing fix; see test_airconditioner_cac.py for the documented gap."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_cac")
|
|
golden = json.loads((GOLDEN / "airconditioner_cac.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_cac", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_fac_bora_2in1():
|
|
"""The reporter's TP2X_FAC_BORA_21K (issue #177, Pattern B -- UUID-prefixed
|
|
tree): device0/oic_res are real; the wall-mounted subdevice's own
|
|
/information/vs/0 is real (confirmed live by the reporter), the rest of
|
|
its seed tree is constructed (see the fixture's own seeds_note) -- just
|
|
enough to bind a real climate card under the
|
|
`subdevice_6c2dff6dee5cdad16a5e000000000001_` prefix below. Distinct from
|
|
tests/fixtures/airconditioner_fac_bora_device.json, which is
|
|
deliberately left unchanged as the redacted-subdeviceIdList regression
|
|
case (zero subdevices)."""
|
|
name = "airconditioner_fac_bora_2in1"
|
|
golden = json.loads((GOLDEN / f"{name}.json").read_text())
|
|
state_keys = _new_subdevice_aware_state_keys(name)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_fac_bora_205_flat():
|
|
"""The same reporter's same physical TP2X_FAC_BORA_21K unit as the _2in1
|
|
fixture above, but a later capture (issue #205) where /<uuid>/device/0 doesn't
|
|
answer -- contrary to what that fixture's own seed batch assumed the
|
|
Collection endpoint would do. device0/oic_res are real; the only
|
|
UUID-prefixed data is the one href ever actually confirmed live
|
|
(/information/vs/0, same real capture the _2in1 fixture uses), fed
|
|
through registry.subdevices.enumerate_subdevices' per-href flat
|
|
fallback instead of a Collection batch. /information/vs/0 alone binds
|
|
no entity, so the candidate is found but never materializes -- this
|
|
golden has no `subdevice_...`-prefixed keys at all, same shape as
|
|
tests/fixtures/golden/airconditioner_fac_bora.json, which is the point:
|
|
a device whose sibling can't yet be confirmed live must regress to
|
|
exactly the master-only state, never a phantom or partial subdevice."""
|
|
name = "airconditioner_fac_bora_205_flat"
|
|
golden = json.loads((GOLDEN / f"{name}.json").read_text())
|
|
state_keys = _new_subdevice_aware_state_keys(name)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_artik051_krac_18k_slot():
|
|
"""The issue #214 reporter's single-split AR12NXWXCWKNEU: a
|
|
non-composite ARTIK051_KRAC_18K whose `/device/1` answers a full-shaped
|
|
batch with every operational rep empty {} and a populated
|
|
/energy/consumption/vs/1. The lifetime kWh counter used to be enough to
|
|
pass discover_partitioned's liveness gate, materializing a phantom
|
|
second air conditioner in HA; a meter is now excluded from that gate
|
|
(subdevices._has_live_primary_entity), so this golden must stay
|
|
byte-identical to airconditioner_artik051_krac_18k.json -- master keys
|
|
only, no `subdevice1_` prefix anywhere -- which is what
|
|
test_krac_18k_energy_only_slot_is_not_materialized asserts structurally."""
|
|
name = "airconditioner_artik051_krac_18k_slot"
|
|
golden = json.loads((GOLDEN / f"{name}.json").read_text())
|
|
state_keys = _new_subdevice_aware_state_keys(name)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
master_golden = json.loads((GOLDEN / "airconditioner_artik051_krac_18k.json").read_text())
|
|
assert set(state_keys) == set(master_golden["state_keys"])
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_air_purifier_avt_ww():
|
|
"""AVT-WW-TP1-23-AXX500 (issue #190) -- next-gen BESPOKE Cube Air board;
|
|
reports device_type 'unknown' with empty oneUiVersion because 'VTWW' as a
|
|
whole token doesn't match this board's 'AVT'/'WW' split. Resolved via the
|
|
new 'AVT' modelNum board-token fallback into the existing air_purifier
|
|
registry. Binds cleanly with zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("air_purifier_avt_ww")
|
|
golden = json.loads((GOLDEN / "air_purifier_avt_ww.json").read_text())
|
|
state_keys = _new_state_keys("air_purifier_avt_ww", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_artik051_krac_energy():
|
|
"""AR12NXWXCWKNEU/ARTIK051_KRAC_18K (issue #193) -- same legacy board
|
|
generation as the artik051_krac_18k fixture, but this dump has a nonzero
|
|
cumulativePower. Locks in state_keys; the actual /100000 scale fix is
|
|
asserted separately in test_airconditioner_capabilities.py since golden
|
|
only compares key sets, not values."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_artik051_krac_energy")
|
|
golden = json.loads((GOLDEN / "airconditioner_artik051_krac_energy.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_artik051_krac_energy", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_refrigerator_definite_cooler():
|
|
"""RT42DG6630B1FZ (issue #186) -- a single-door "cooler only" fridge whose
|
|
/temperature/definite/cooler/vs/0 doesn't match either
|
|
TEMP_CURRENT_GENERIC's '/temperature/current/' or TEMP_SETPOINT's
|
|
'/temperature/desired/' href prefix, so temperature control was entirely
|
|
unbound. Resolved via the new DEFINITE_TEMPERATURE_COOLER capability
|
|
(a select over the device's own discrete supportedList, not a
|
|
continuous NumberDesc range -- 5 and 6 aren't valid setpoints on this
|
|
model). Binds cleanly with zero unbound hrefs."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_definite_cooler")
|
|
golden = json.loads((GOLDEN / "refrigerator_definite_cooler.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_definite_cooler", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_range_ne6516a():
|
|
"""NE6516A-class range (issue #183) -- no /information/vs/0, resolved via
|
|
the same 'Bake'-in-supportedModes + /cooktopmonitoring/vs/0 signature as
|
|
the other no-info range fixtures. Its /mode/vs/0 options[] carries
|
|
EnergySaving_On and BurnerOnAlert_Off (previously unbound entirely) but
|
|
no fastpreheat_*/NaturalSteam_* tokens at all -- locks in that those two
|
|
switches now correctly stay unbound instead of binding as always-off,
|
|
does-nothing phantom controls."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("range_ne6516a")
|
|
golden = json.loads((GOLDEN / "range_ne6516a.json").read_text())
|
|
state_keys = _new_state_keys("range_ne6516a", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_dehumidifier_tp1x_dhm01001():
|
|
"""TP1X_DA_AC_DHM_01001_0000 revision (issues #271/#231) additionally
|
|
reports /display/vs/0 (air_purifier.DISPLAY's exact shape, reused as-is)
|
|
and /watertank/lighting/vs/0 (new WATERTANK_LIGHTING capability), both
|
|
unbound on the original issue #88 dump."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("dehumidifier_tp1x_dhm01001")
|
|
golden = json.loads((GOLDEN / "dehumidifier_tp1x_dhm01001.json").read_text())
|
|
state_keys = _new_state_keys("dehumidifier_tp1x_dhm01001", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_airconditioner_tp1x_fac_time_23k():
|
|
"""TP1X_FAC_TIME_23K (issue #270) reports a UV-C LED, a ventilation-alarm
|
|
toggle, and a second (PM1-rated, no live usage field) dust filter, none
|
|
previously modeled. Also a 2-in-1 system on this dump (numofsubdevice=2,
|
|
a UUID-prefixed sibling materializes via the flat fallback) -- the three
|
|
new/ignored hrefs are fixed on their canonical form so the sibling picks
|
|
them up too, per the adding-device-support skill's 'never index or
|
|
prefix a registry href' rule."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("airconditioner_tp1x_fac_time_23k")
|
|
golden = json.loads((GOLDEN / "airconditioner_tp1x_fac_time_23k.json").read_text())
|
|
state_keys = _new_state_keys("airconditioner_tp1x_fac_time_23k", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_dryer_tp1_21_drum_clean():
|
|
"""DA_WM_TP1_21_COMMON/DV9400B (issue #258) is the first dryer dump with
|
|
live DrumCleanProposal_/WashingTimes_ tokens (dryer's default fixture
|
|
only ever had 'DrumCleanLog_Empty', same as the parallel washer capability
|
|
started from) -- locks in the new drum_clean_cycles_remaining/
|
|
drum_clean_last_cleaned entities, including the dryer-specific
|
|
'|'-joined multi-timestamp DrumCleanLog_ shape."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("dryer_tp1_21_drum_clean")
|
|
golden = json.loads((GOLDEN / "dryer_tp1_21_drum_clean.json").read_text())
|
|
state_keys = _new_state_keys("dryer_tp1_21_drum_clean", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_refrigerator_tp1x_ref_21k_definite():
|
|
"""TP1X_REF_21K (issue #229) reports the discrete definite-setpoint
|
|
pattern (issue #186) on *both* compartments -- previously only the
|
|
cooler half was modeled; DEFINITE_TEMPERATURE_FREEZER covers the
|
|
freezer's identical-shape /temperature/definite/freezer/vs/0."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_tp1x_ref_21k_definite")
|
|
golden = json.loads((GOLDEN / "refrigerator_tp1x_ref_21k_definite.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_tp1x_ref_21k_definite", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_refrigerator_tp1x_ref_21k_autodoor():
|
|
"""TP1X_REF_21K, single-freezer-door Auto Door Open variant (issue
|
|
#328): /autodoor/single/vs/0 + /autodoor/timer/vs/0, plus
|
|
STATUS_LOCK's ado.voicecontrol sibling toggle."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_tp1x_ref_21k_autodoor")
|
|
golden = json.loads((GOLDEN / "refrigerator_tp1x_ref_21k_autodoor.json").read_text())
|
|
state_keys = _new_state_keys("refrigerator_tp1x_ref_21k_autodoor", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_refrigerator_tp1x_ref_21k_kimchi():
|
|
"""Kimchi-refrigerator Auto Door Open variant (issue #328) -- resolves
|
|
via /oic/d's oic.d.krefrigerator, not modelNum (the board is the same
|
|
TP1X_REF_21K as the regular fridge, so only the OCF type tells them
|
|
apart before checking hrefs)."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_tp1x_ref_21k_kimchi")
|
|
golden = json.loads((GOLDEN / "refrigerator_tp1x_ref_21k_kimchi.json").read_text())
|
|
state_keys = _new_state_keys(
|
|
"refrigerator_tp1x_ref_21k_kimchi",
|
|
resources,
|
|
device_types=("oic.wk.d", "oic.d.krefrigerator"),
|
|
)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_refrigerator_winecellar():
|
|
"""Wine-cellar refrigerator variant (issue #328) -- resolves via /oic/d's
|
|
x.com.st.d.winecellar, same TP1X_REF_21K board as the other two. Adds
|
|
the deodorizing filter at its own href, the multi-compartment pantry
|
|
select, and the table-revision info resource."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("refrigerator_winecellar")
|
|
golden = json.loads((GOLDEN / "refrigerator_winecellar.json").read_text())
|
|
state_keys = _new_state_keys(
|
|
"refrigerator_winecellar",
|
|
resources,
|
|
device_types=("oic.wk.d", "x.com.st.d.winecellar"),
|
|
)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_range_tp1x_da_ks_range_0101x():
|
|
"""Dual-cavity range (issue #324): no /information/vs/0 at all, so
|
|
routing depends entirely on /oic/d's oic.d.range -- and the second
|
|
cavity is a genuine Pattern A indexed subdevice at /device/1."""
|
|
name = "range_tp1x_da_ks_range_0101x"
|
|
golden = json.loads((GOLDEN / f"{name}.json").read_text())
|
|
state_keys = _new_subdevice_aware_state_keys(name, device_types=("oic.wk.d", "oic.d.range"))
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_resources_from_batch_preferred_over_flat():
|
|
from tests.conftest import _resources_from_dump
|
|
|
|
dump = {
|
|
"device0": [
|
|
{"di": "device"}, # [0] device-level rep, skipped
|
|
{"href": "/foo", "rep": {"x": 1}},
|
|
],
|
|
"resources": {"/foo": {"x": 99}},
|
|
}
|
|
result = _resources_from_dump(dump)
|
|
assert result == {"/foo": {"x": 1}}
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_washer_ww5000c_cloud():
|
|
"""The issue #342 reporter's WW5000C (DA_WM_TP1_21_COMMON, Table_02),
|
|
captured while sitting on its Download course with a one-time Jeans
|
|
program loaded over a saved Sports default.
|
|
|
|
The cloud "Download" programs it advertises add no entity of their own
|
|
-- they ride in the existing cycle select -- so this golden is the guard
|
|
that discovering them never grows the entity set.
|
|
|
|
Its /wm/editcourse/vs/0 is empty, so its course list comes from the
|
|
supportedOptions fallback (issue #1)."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("washer_ww5000c_cloud")
|
|
golden = json.loads((GOLDEN / "washer_ww5000c_cloud.json").read_text())
|
|
state_keys = _new_state_keys("washer_ww5000c_cloud", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|
|
|
|
|
|
def test_registry_reproduces_golden_state_keys_for_dishwasher_dw5000c_cloud():
|
|
"""A DW5000C dishwasher (issues #113/#123) that advertises four
|
|
downloaded programs it has never loaded -- CloudExtraCourse_ with no
|
|
CloudCourse_/OneTimeCloudCourse_ payload alongside it (issue #342).
|
|
|
|
Proves the cloud-cycle machinery is not washer-only and, more usefully,
|
|
that a device can advertise programs whose payloads have never been
|
|
seen. It adds no entity of its own either way."""
|
|
from tests.conftest import _load_device
|
|
|
|
resources = _load_device("dishwasher_dw5000c_cloud")
|
|
golden = json.loads((GOLDEN / "dishwasher_dw5000c_cloud.json").read_text())
|
|
state_keys = _new_state_keys("dishwasher_dw5000c_cloud", resources)
|
|
assert set(state_keys) == set(golden["state_keys"]), (
|
|
f"state_keys mismatch:\n"
|
|
f" extra: {sorted(set(state_keys) - set(golden['state_keys']))}\n"
|
|
f" missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
|
|
)
|