|
|
@@ -0,0 +1,479 @@
|
|
|
+import asyncio
|
|
|
+from decimal import Decimal
|
|
|
+from unittest.mock import AsyncMock
|
|
|
+
|
|
|
+import pytest
|
|
|
+from bleak.backends.device import BLEDevice
|
|
|
+from bleak.exc import BleakError
|
|
|
+
|
|
|
+from switchbot import (
|
|
|
+ MeterProWeatherIcon,
|
|
|
+ SwitchbotDevice,
|
|
|
+ SwitchbotMeterPro,
|
|
|
+ SwitchbotMeterProCO2,
|
|
|
+ SwitchbotOperationError,
|
|
|
+)
|
|
|
+from switchbot.adv_parsers._sensor_th import decode_temp_humidity
|
|
|
+from switchbot.devices.meter_pro import _encode_weather_temperature
|
|
|
+
|
|
|
+READ = "570f6906"
|
|
|
+BASELINE = bytes.fromhex("01003292b5008000008000000080000000")
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("temperature", "expected"),
|
|
|
+ [(tenths / 10, tenths / 10) for tenths in range(-9, 10)]
|
|
|
+ + [
|
|
|
+ (19.3, 19.3),
|
|
|
+ (-11.7, -11.7),
|
|
|
+ (127.9, 127.9),
|
|
|
+ (-127.9, -127.9),
|
|
|
+ (18.25, 18.3),
|
|
|
+ (-18.25, -18.3),
|
|
|
+ (0.04, 0.0),
|
|
|
+ (-0.04, 0.0),
|
|
|
+ ],
|
|
|
+)
|
|
|
+def test_temperature_round_trip_with_sensor_decoder(temperature, expected):
|
|
|
+ encoded = _encode_weather_temperature(temperature)
|
|
|
+ assert len(encoded) == 2
|
|
|
+ assert encoded[0] <= 9
|
|
|
+ assert bool(encoded[1] & 0x80) == (expected >= 0)
|
|
|
+ decoded = decode_temp_humidity(encoded + bytes((53,)), None)
|
|
|
+ assert decoded["temperature"] == expected
|
|
|
+ assert decoded["humidity"] == 53
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("temperature", "expected_bytes"),
|
|
|
+ [(0.5, "0580"), (-0.5, "0500"), (0, "0080")],
|
|
|
+)
|
|
|
+def test_sub_degree_temperature_sign_bytes(temperature, expected_bytes):
|
|
|
+ assert _encode_weather_temperature(temperature).hex() == expected_bytes
|
|
|
+
|
|
|
+
|
|
|
+def create_device(device_class: type[SwitchbotMeterPro] = SwitchbotMeterProCO2):
|
|
|
+ device = device_class(BLEDevice("aa:bb:cc:dd:ee:ff", "meter", {}))
|
|
|
+ device._send_command = AsyncMock(return_value=BASELINE)
|
|
|
+ device._send_command_locked_with_retry = AsyncMock()
|
|
|
+ return device
|
|
|
+
|
|
|
+
|
|
|
+def configure_write(device, icon=1, network=BASELINE[2:5]):
|
|
|
+ after = bytes((1, icon)) + network + BASELINE[5:]
|
|
|
+ device._send_command_locked_with_retry.side_effect = [BASELINE, b"\x01", after]
|
|
|
+ return after
|
|
|
+
|
|
|
+
|
|
|
+def sent_keys(device):
|
|
|
+ return [
|
|
|
+ entry.args[0] for entry in device._send_command_locked_with_retry.call_args_list
|
|
|
+ ]
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ "response", [BASELINE, BASELINE[:5], BASELINE[:5] + b"\xff", BASELINE + b"\xff"]
|
|
|
+)
|
|
|
+@pytest.mark.parametrize("device_class", [SwitchbotMeterPro, SwitchbotMeterProCO2])
|
|
|
+async def test_get_weather(response: bytes, device_class: type[SwitchbotMeterPro]):
|
|
|
+ device = create_device(device_class)
|
|
|
+ device._send_command.return_value = response
|
|
|
+ state = await device.get_weather()
|
|
|
+ assert state == {
|
|
|
+ "icon": MeterProWeatherIcon.NONE,
|
|
|
+ "temperature_c": 18.2,
|
|
|
+ "humidity": 53,
|
|
|
+ "fahrenheit_display": True,
|
|
|
+ }
|
|
|
+ device._send_command.assert_awaited_once_with(READ)
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("network", "temperature", "humidity", "fahrenheit"),
|
|
|
+ [
|
|
|
+ ("008000", 0.0, None, False),
|
|
|
+ ("000000", 0.0, None, False),
|
|
|
+ ("008080", 0.0, None, True),
|
|
|
+ ("079200", 18.7, None, False),
|
|
|
+ ("070b00", -11.7, None, False),
|
|
|
+ ("008035", 0.0, 53, False),
|
|
|
+ ("000035", 0.0, 53, False),
|
|
|
+ ("050001", -0.5, 1, False),
|
|
|
+ ],
|
|
|
+)
|
|
|
+async def test_get_weather_unset_humidity_and_independent_temperature(
|
|
|
+ network, temperature, humidity, fahrenheit
|
|
|
+):
|
|
|
+ device = create_device()
|
|
|
+ device._send_command.return_value = bytes.fromhex("0101" + network)
|
|
|
+ state = await device.get_weather()
|
|
|
+ assert state["temperature_c"] == temperature
|
|
|
+ assert state["humidity"] == humidity
|
|
|
+ assert state["fahrenheit_display"] == fahrenheit
|
|
|
+ if temperature == 0:
|
|
|
+ assert str(state["temperature_c"]) == "0.0"
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("response", "message"),
|
|
|
+ [
|
|
|
+ ("0108008000", "Unknown weather icon 8"),
|
|
|
+ ("01000a8000", "Invalid weather measurements"),
|
|
|
+ ("0100008064", "Invalid weather measurements"),
|
|
|
+ ],
|
|
|
+)
|
|
|
+async def test_weather_parse_error_includes_response_context(response, message):
|
|
|
+ device = create_device()
|
|
|
+ device._send_command.return_value = bytes.fromhex(response)
|
|
|
+ with pytest.raises(SwitchbotOperationError, match=message) as exc_info:
|
|
|
+ await device.get_weather()
|
|
|
+ assert f"result={response}" in str(exc_info.value)
|
|
|
+ assert f"rssi={device.rssi}" in str(exc_info.value)
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ "response",
|
|
|
+ [
|
|
|
+ None,
|
|
|
+ b"",
|
|
|
+ b"\x00",
|
|
|
+ b"\x01",
|
|
|
+ bytes.fromhex("01008000"),
|
|
|
+ ],
|
|
|
+)
|
|
|
+async def test_bad_weather_response(response):
|
|
|
+ device = create_device()
|
|
|
+ device._send_command.return_value = response
|
|
|
+ with pytest.raises(SwitchbotOperationError):
|
|
|
+ await device.get_weather()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("icon", "protocol_value"),
|
|
|
+ [
|
|
|
+ (MeterProWeatherIcon.NONE, 0),
|
|
|
+ (MeterProWeatherIcon.SUNNY, 1),
|
|
|
+ (MeterProWeatherIcon.CLOUDY, 2),
|
|
|
+ (MeterProWeatherIcon.OVERCAST, 3),
|
|
|
+ (MeterProWeatherIcon.LIGHT_RAIN, 4),
|
|
|
+ (MeterProWeatherIcon.HEAVY_RAIN, 5),
|
|
|
+ (MeterProWeatherIcon.LIGHT_SNOW, 6),
|
|
|
+ (MeterProWeatherIcon.HEAVY_SNOW, 7),
|
|
|
+ ],
|
|
|
+)
|
|
|
+@pytest.mark.parametrize("device_class", [SwitchbotMeterPro, SwitchbotMeterProCO2])
|
|
|
+async def test_set_icon_preserves_network(
|
|
|
+ icon: MeterProWeatherIcon,
|
|
|
+ protocol_value: int,
|
|
|
+ device_class: type[SwitchbotMeterPro],
|
|
|
+):
|
|
|
+ device = create_device(device_class)
|
|
|
+ configure_write(device, protocol_value)
|
|
|
+ assert await device.set_weather(icon) is None
|
|
|
+ payload = f"570f680601{protocol_value:02x}3292b5"
|
|
|
+ assert len(bytes.fromhex(payload)) == 9
|
|
|
+ assert sent_keys(device) == [READ, payload, READ]
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("temperature", "humidity", "encoded"),
|
|
|
+ [
|
|
|
+ (18.2, 53, "3292b5"),
|
|
|
+ (-11.7, 57, "370bb9"),
|
|
|
+ (-0.5, 1, "350081"),
|
|
|
+ (0.5, 1, "358081"),
|
|
|
+ (0, 99, "3080e3"),
|
|
|
+ (127.9, 99, "39ffe3"),
|
|
|
+ (-127.9, 1, "397f81"),
|
|
|
+ (18.25, 53.5, "3392b6"),
|
|
|
+ (Decimal("18.25"), Decimal("53.5"), "3392b6"),
|
|
|
+ ],
|
|
|
+)
|
|
|
+async def test_explicit_values_preserve_flags(temperature, humidity, encoded):
|
|
|
+ device = create_device()
|
|
|
+ configure_write(device, network=bytes.fromhex(encoded))
|
|
|
+ result = await device.set_weather(
|
|
|
+ MeterProWeatherIcon.SUNNY, temperature_c=temperature, humidity=humidity
|
|
|
+ )
|
|
|
+ assert result is None
|
|
|
+ assert sent_keys(device) == [READ, "570f68060101" + encoded, READ]
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize("icon", [-1, 8, True, "sunny", 1.0])
|
|
|
+async def test_invalid_icon_before_io(icon):
|
|
|
+ device = create_device()
|
|
|
+ with pytest.raises(
|
|
|
+ SwitchbotOperationError, match=r"Weather icon|MeterProWeatherIcon"
|
|
|
+ ):
|
|
|
+ await device.set_weather(icon)
|
|
|
+ device._send_command_locked_with_retry.assert_not_awaited()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("temperature", "humidity"),
|
|
|
+ [
|
|
|
+ (128, 53),
|
|
|
+ (-128, 53),
|
|
|
+ (0, 0),
|
|
|
+ (0, 100),
|
|
|
+ (float("nan"), 53),
|
|
|
+ (float("inf"), 53),
|
|
|
+ (0, float("nan")),
|
|
|
+ (True, 53),
|
|
|
+ (0, False),
|
|
|
+ ("invalid", 53),
|
|
|
+ ("18.2", 53),
|
|
|
+ (18.2, "53"),
|
|
|
+ (object(), 53),
|
|
|
+ (18.2, object()),
|
|
|
+ (float("nan"), None),
|
|
|
+ (None, 100),
|
|
|
+ (Decimal("NaN"), 53),
|
|
|
+ (18.2, Decimal("Infinity")),
|
|
|
+ ],
|
|
|
+)
|
|
|
+async def test_invalid_values_before_io(temperature, humidity):
|
|
|
+ device = create_device()
|
|
|
+ with pytest.raises(
|
|
|
+ SwitchbotOperationError, match=r"Temperature|temperature|humidity"
|
|
|
+ ):
|
|
|
+ await device.set_weather(
|
|
|
+ MeterProWeatherIcon.SUNNY, temperature_c=temperature, humidity=humidity
|
|
|
+ )
|
|
|
+ device._send_command_locked_with_retry.assert_not_awaited()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+async def test_no_fields_rejected_before_io():
|
|
|
+ device = create_device()
|
|
|
+ with pytest.raises(
|
|
|
+ SwitchbotOperationError, match="Supply at least one weather field"
|
|
|
+ ):
|
|
|
+ await device.set_weather()
|
|
|
+ device._send_command_locked_with_retry.assert_not_awaited()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("kwargs", "expected_icon", "network"),
|
|
|
+ [
|
|
|
+ ({"temperature_c": -11.7}, 0, "370bb5"),
|
|
|
+ ({"humidity": 57}, 0, "3292b9"),
|
|
|
+ ({"temperature_c": -11.7, "humidity": 57}, 0, "370bb9"),
|
|
|
+ ({"icon": MeterProWeatherIcon.SUNNY, "temperature_c": -11.7}, 1, "370bb5"),
|
|
|
+ ({"icon": MeterProWeatherIcon.SUNNY, "humidity": 57}, 1, "3292b9"),
|
|
|
+ ({"temperature_c": 0}, 0, "3080b5"),
|
|
|
+ ({"icon": MeterProWeatherIcon.NONE, "humidity": 57}, 0, "3292b9"),
|
|
|
+ ],
|
|
|
+)
|
|
|
+async def test_partial_updates(kwargs, expected_icon, network):
|
|
|
+ device = create_device()
|
|
|
+ configure_write(device, expected_icon, bytes.fromhex(network))
|
|
|
+ assert await device.set_weather(**kwargs) is None
|
|
|
+ assert sent_keys(device) == [READ, f"570f680601{expected_icon:02x}{network}", READ]
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("kwargs", "network"),
|
|
|
+ [({"temperature_c": -0.5}, "050000"), ({"humidity": 57}, "008039")],
|
|
|
+)
|
|
|
+async def test_partial_updates_preserve_unavailable_fields(kwargs, network):
|
|
|
+ device = create_device()
|
|
|
+ before = bytes.fromhex("0106008000")
|
|
|
+ after = bytes((1, 6)) + bytes.fromhex(network)
|
|
|
+ device._send_command_locked_with_retry.side_effect = [before, b"\x01", after]
|
|
|
+ assert await device.set_weather(**kwargs) is None
|
|
|
+ assert sent_keys(device) == [READ, "570f68060106" + network, READ]
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("responses", "count"),
|
|
|
+ [
|
|
|
+ ([b"\x00"], 1),
|
|
|
+ ([BASELINE, b"\x00"], 2),
|
|
|
+ ],
|
|
|
+)
|
|
|
+async def test_failures_do_not_rollback(responses, count):
|
|
|
+ device = create_device()
|
|
|
+ device._send_command_locked_with_retry.side_effect = responses
|
|
|
+ with pytest.raises(SwitchbotOperationError):
|
|
|
+ await device.set_weather(MeterProWeatherIcon.SUNNY)
|
|
|
+ assert device._send_command_locked_with_retry.await_count == count
|
|
|
+ assert not device._operation_lock.locked()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize(
|
|
|
+ ("after", "actual_icon", "actual_network"),
|
|
|
+ [(BASELINE, 0, "3292b5"), (bytes.fromhex("01013293b5"), 1, "3293b5")],
|
|
|
+)
|
|
|
+async def test_readback_mismatch_includes_expected_and_actual_values(
|
|
|
+ after, actual_icon, actual_network
|
|
|
+):
|
|
|
+ device = create_device()
|
|
|
+ device._send_command_locked_with_retry.side_effect = [BASELINE, b"\x01", after]
|
|
|
+ with pytest.raises(
|
|
|
+ SwitchbotOperationError, match="Weather readback mismatch"
|
|
|
+ ) as exc_info:
|
|
|
+ await device.set_weather(MeterProWeatherIcon.SUNNY)
|
|
|
+ message = str(exc_info.value)
|
|
|
+ assert "expected_icon=1 expected_network=3292b5" in message
|
|
|
+ assert f"actual_icon={actual_icon} actual_network={actual_network}" in message
|
|
|
+ assert "no rollback attempted" in message
|
|
|
+ assert device._send_command_locked_with_retry.await_count == 3
|
|
|
+ assert not device._operation_lock.locked()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize("icon", [0, 7])
|
|
|
+async def test_integer_icon_supported(icon):
|
|
|
+ device = create_device()
|
|
|
+ configure_write(device, icon)
|
|
|
+ await device.set_weather(icon)
|
|
|
+ assert sent_keys(device) == [READ, f"570f680601{icon:02x}3292b5", READ]
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize("read_step", ["before", "after"])
|
|
|
+async def test_transient_read_failure_retries_without_replaying_write(read_step):
|
|
|
+ device = create_device()
|
|
|
+ device._send_command_locked_with_retry = (
|
|
|
+ SwitchbotDevice._send_command_locked_with_retry.__get__(device)
|
|
|
+ )
|
|
|
+ after = bytes((1, 1)) + BASELINE[2:]
|
|
|
+ if read_step == "before":
|
|
|
+ responses = [BleakError("transient read error"), BASELINE, b"\x01", after]
|
|
|
+ expected_keys = [READ, READ, "570f680601013292b5", READ]
|
|
|
+ else:
|
|
|
+ responses = [BASELINE, b"\x01", BleakError("transient read error"), after]
|
|
|
+ expected_keys = [READ, "570f680601013292b5", READ, READ]
|
|
|
+ device._send_command_locked = AsyncMock(side_effect=responses)
|
|
|
+ await device.set_weather(MeterProWeatherIcon.SUNNY)
|
|
|
+ assert [
|
|
|
+ entry.args[0] for entry in device._send_command_locked.call_args_list
|
|
|
+ ] == expected_keys
|
|
|
+ assert not device._operation_lock.locked()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize("error_type", [BleakError, TimeoutError])
|
|
|
+async def test_actual_retry_engine_does_not_replay_failed_write(error_type):
|
|
|
+ device = create_device()
|
|
|
+ device._send_command_locked_with_retry = (
|
|
|
+ SwitchbotDevice._send_command_locked_with_retry.__get__(device)
|
|
|
+ )
|
|
|
+ device._send_command_locked = AsyncMock(
|
|
|
+ side_effect=[BASELINE, error_type("lost write acknowledgement")]
|
|
|
+ )
|
|
|
+ with pytest.raises(error_type, match="lost write acknowledgement"):
|
|
|
+ await device.set_weather(MeterProWeatherIcon.SUNNY)
|
|
|
+ assert [entry.args[0] for entry in device._send_command_locked.call_args_list] == [
|
|
|
+ READ,
|
|
|
+ "570f680601013292b5",
|
|
|
+ ]
|
|
|
+ assert not device._operation_lock.locked()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+@pytest.mark.parametrize("read_step", ["before", "after"])
|
|
|
+async def test_read_retry_exhaustion_does_not_replay_write(read_step):
|
|
|
+ device = create_device()
|
|
|
+ device._retry_count = 2
|
|
|
+ device._send_command_locked_with_retry = (
|
|
|
+ SwitchbotDevice._send_command_locked_with_retry.__get__(device)
|
|
|
+ )
|
|
|
+ failures = [BleakError("persistent read error") for _ in range(3)]
|
|
|
+ prefix = [] if read_step == "before" else [BASELINE, b"\x01"]
|
|
|
+ device._send_command_locked = AsyncMock(side_effect=prefix + failures)
|
|
|
+ with pytest.raises(BleakError, match="persistent read error"):
|
|
|
+ await device.set_weather(MeterProWeatherIcon.SUNNY)
|
|
|
+ expected_keys = [] if read_step == "before" else [READ, "570f680601013292b5"]
|
|
|
+ expected_keys += [READ] * 3
|
|
|
+ assert [
|
|
|
+ entry.args[0] for entry in device._send_command_locked.call_args_list
|
|
|
+ ] == expected_keys
|
|
|
+ assert not device._operation_lock.locked()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+async def test_update_ignores_extra_response_bytes():
|
|
|
+ device = create_device()
|
|
|
+ before = BASELINE[:5] + b"\x11\x22"
|
|
|
+ after = bytes((1, 1)) + BASELINE[2:5] + bytes(range(20))
|
|
|
+ device._send_command_locked_with_retry.side_effect = [before, b"\x01", after]
|
|
|
+ await device.set_weather(MeterProWeatherIcon.SUNNY)
|
|
|
+ assert sent_keys(device) == [READ, "570f680601013292b5", READ]
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+async def test_cancellation_releases_lock():
|
|
|
+ device = create_device()
|
|
|
+ started = asyncio.Event()
|
|
|
+
|
|
|
+ async def command(*_args):
|
|
|
+ started.set()
|
|
|
+ await asyncio.Future()
|
|
|
+
|
|
|
+ device._send_command_locked_with_retry.side_effect = command
|
|
|
+ task = asyncio.create_task(device.set_weather(MeterProWeatherIcon.SUNNY))
|
|
|
+ await started.wait()
|
|
|
+ task.cancel()
|
|
|
+ with pytest.raises(asyncio.CancelledError):
|
|
|
+ await task
|
|
|
+ assert not device._operation_lock.locked()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+async def test_concurrent_updates_do_not_interleave():
|
|
|
+ device = create_device()
|
|
|
+ responses = iter(
|
|
|
+ [
|
|
|
+ BASELINE,
|
|
|
+ b"\x01",
|
|
|
+ bytes((1, 1)) + BASELINE[2:],
|
|
|
+ bytes((1, 1)) + BASELINE[2:],
|
|
|
+ b"\x01",
|
|
|
+ bytes((1, 2)) + BASELINE[2:],
|
|
|
+ ]
|
|
|
+ )
|
|
|
+ keys = []
|
|
|
+
|
|
|
+ async def command(key, _payload, retry, max_attempts):
|
|
|
+ assert device._operation_lock.locked()
|
|
|
+ expected_retry = device._retry_count if key == READ else 0
|
|
|
+ assert (retry, max_attempts) == (expected_retry, expected_retry + 1)
|
|
|
+ keys.append(key)
|
|
|
+ await asyncio.sleep(0)
|
|
|
+ return next(responses)
|
|
|
+
|
|
|
+ device._send_command_locked_with_retry.side_effect = command
|
|
|
+ first, second = await asyncio.gather(
|
|
|
+ device.set_weather(MeterProWeatherIcon.SUNNY),
|
|
|
+ device.set_weather(MeterProWeatherIcon.CLOUDY),
|
|
|
+ )
|
|
|
+ assert (first, second) == (None, None)
|
|
|
+ assert keys == [READ, "570f680601013292b5", READ, READ, "570f680601023292b5", READ]
|
|
|
+ assert not device._operation_lock.locked()
|
|
|
+
|
|
|
+
|
|
|
+@pytest.mark.asyncio
|
|
|
+async def test_unavailable_measurements_are_preserved():
|
|
|
+ device = create_device()
|
|
|
+ before = bytes.fromhex("0100008000")
|
|
|
+ device._send_command_locked_with_retry.side_effect = [
|
|
|
+ before,
|
|
|
+ b"\x01",
|
|
|
+ bytes.fromhex("0101008000"),
|
|
|
+ ]
|
|
|
+ assert await device.set_weather(MeterProWeatherIcon.SUNNY) is None
|
|
|
+ assert sent_keys(device) == [READ, "570f68060101008000", READ]
|