706 lines
35 KiB
Python
706 lines
35 KiB
Python
import json
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
GOLDEN = Path(__file__).parent / 'fixtures' / 'golden'
|
|
|
|
|
|
def _new_state_keys(name, resources):
|
|
from custom_components.localthings.registry.by_type import (
|
|
for_device, for_device_by_model, for_device_by_resources,
|
|
)
|
|
from custom_components.localthings.registry.discovery import discover
|
|
from custom_components.localthings.registry.adapter import flatten
|
|
otn = resources.get('/otninformation/vs/0', {})
|
|
one_ui = otn.get('swVersionInfo', {}).get('oneUiVersion', '')
|
|
info = resources.get('/information/vs/0', {})
|
|
reg = for_device(one_ui) if one_ui else None
|
|
if reg is None:
|
|
reg = for_device_by_model(
|
|
info.get('x.com.samsung.da.modelNum', ''),
|
|
info.get('x.com.samsung.da.description', ''),
|
|
)
|
|
if reg is None:
|
|
reg = for_device_by_resources(resources)
|
|
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_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'."""
|
|
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_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_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_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."""
|
|
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_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_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."""
|
|
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."""
|
|
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_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
|
|
hyphenated '-RAC-' modelNum fallback rather than for_device()."""
|
|
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_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)
|
|
|
|
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."""
|
|
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_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_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_air_purifier_tp1x_da_ac_air():
|
|
"""TP1X_DA-AC-AIR-01031_0000 (issue #130) self-reports oneUiVersion
|
|
'7.0 Air purifier' and resolves via for_device() 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_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}}
|