import logging from unittest.mock import AsyncMock, Mock, patch import pytest from switchbot import SwitchbotLockUltra, SwitchbotModel from switchbot.const.lock import LockStatus from switchbot.devices import lock from switchbot.devices.device import SwitchbotOperationError from switchbot.models import SwitchBotAdvertisement from .test_adv_parser import generate_ble_device def create_device_for_command_testing(model: str, cls=lock.SwitchbotLock): ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any") return cls(ble_device, "ff", "ffffffffffffffffffffffffffffffff", model=model) @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_ULTRA_MAX, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_lock_init(model: str): """Test the initialization of the lock device.""" device = create_device_for_command_testing(model) assert device._model == model @pytest.mark.parametrize( "model", [ SwitchbotModel.AIR_PURIFIER_JP, ], ) def test_lock_init_with_invalid_model(model: str): """Test that initializing with an invalid model raises ValueError.""" with pytest.raises( ValueError, match="initializing SwitchbotLock with a non-lock model" ): create_device_for_command_testing(model) def test_ultra_direct_construction(): device = generate_ble_device("aa:bb:cc:dd:ee:ff", "lock") assert ( SwitchbotLockUltra(device, "ff", "ff" * 16)._model is SwitchbotModel.LOCK_ULTRA ) def test_default_model_classvar(): """The classvar default is SwitchbotModel.LOCK.""" ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any") device = lock.SwitchbotLock(ble_device, "ff", "ffffffffffffffffffffffffffffffff") assert device._model == SwitchbotModel.LOCK @pytest.mark.asyncio @pytest.mark.parametrize( ("model", "command"), [ (SwitchbotModel.LOCK, b"W\x0fN\x01\x01\x10\x80"), (SwitchbotModel.LOCK_LITE, b"W\x0fN\x01\x01\x10\x81"), (SwitchbotModel.LOCK_PRO, b"W\x0fN\x01\x01\x10\x85"), (SwitchbotModel.LOCK_ULTRA, b"W\x0fN\x01\x01\x10\x86"), (SwitchbotModel.LOCK_ULTRA_MAX, b"W\x0fN\x01\x01\x00\x00"), (SwitchbotModel.LOCK_VISION, b"W\x0fN\x01\x01\x00\x80"), (SwitchbotModel.LOCK_VISION_PRO, b"W\x0fN\x01\x01\x00\x80"), (SwitchbotModel.LOCK_PRO_WIFI, b"W\x0fN\x01\x01\x10\x82"), ], ) async def test_lock(model: str, command: bytes): """Test lock method.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=LockStatus.UNLOCKED) with ( patch.object( device, "_send_command", return_value=b"\x01\x00" ) as mock_send_command, patch.object(device, "_enable_notifications", return_value=True), patch.object(device, "_get_basic_info", return_value=b"\x00\x64\x01"), ): result = await device.lock() assert result is True mock_send_command.assert_any_call(lock.COMMAND_LOCK[model]) @pytest.mark.asyncio @pytest.mark.parametrize( ("model", "command"), [ (SwitchbotModel.LOCK, b"W\x0fN\x01\x01\x10\x80"), (SwitchbotModel.LOCK_LITE, b"W\x0fN\x01\x01\x10\x81"), (SwitchbotModel.LOCK_PRO, b"W\x0fN\x01\x01\x10\x84"), (SwitchbotModel.LOCK_ULTRA, b"W\x0fN\x01\x01\x10\x83"), (SwitchbotModel.LOCK_ULTRA_MAX, b"W\x0fN\x01\x01\x00\x80"), (SwitchbotModel.LOCK_VISION, b"W\x0fN\x01\x01\x00\x80"), (SwitchbotModel.LOCK_VISION_PRO, b"W\x0fN\x01\x01\x00\x80"), (SwitchbotModel.LOCK_PRO_WIFI, b"W\x0fN\x01\x01\x10\x81"), ], ) async def test_unlock(model: str, command: bytes): """Test unlock method.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=LockStatus.LOCKED) with ( patch.object( device, "_send_command", return_value=b"\x01\x00" ) as mock_send_command, patch.object(device, "_enable_notifications", return_value=True), patch.object(device, "_get_basic_info", return_value=b"\x00\x64\x01"), ): result = await device.unlock() assert result is True mock_send_command.assert_any_call(lock.COMMAND_UNLOCK[model]) @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_ULTRA_MAX, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_unlock_without_unlatch(model: str): """Test unlock_without_unlatch method.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=LockStatus.LOCKED) with ( patch.object(device, "_send_command", return_value=b"\x01\x00"), patch.object(device, "_enable_notifications", return_value=True), patch.object(device, "_get_basic_info", return_value=b"\x00\x64\x01"), ): result = await device.unlock_without_unlatch() assert result is True @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_ULTRA_MAX, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_get_basic_info(model: str): """Test get_basic_info method.""" device = create_device_for_command_testing(model) lock_data = b"\x00\x80\x00\x00\x00\x00\x00\x00" basic_data = bytes.fromhex("01 64 01 21 14") with ( patch.object(device, "_get_lock_info", return_value=lock_data), patch.object(device, "_get_basic_info", return_value=basic_data), ): result = await device.get_basic_info() assert result is not None assert "battery" in result assert "firmware" in result assert "calibration" in result assert "status" in result @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_get_basic_info_no_lock_data(model: str): """Test get_basic_info when no lock data is returned.""" device = create_device_for_command_testing(model) with patch.object(device, "_get_lock_info", return_value=None): result = await device.get_basic_info() assert result is None @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_get_basic_info_no_basic_data(model: str): """Test get_basic_info when no basic data is returned.""" device = create_device_for_command_testing(model) lock_data = b"\x00\x80\x00\x00\x00\x00\x00\x00" with ( patch.object(device, "_get_lock_info", return_value=lock_data), patch.object(device, "_get_basic_info", return_value=None), ): result = await device.get_basic_info() assert result is None @pytest.mark.parametrize("battery", [100, 255]) def test_parse_basic_data(battery): """Test _parse_basic_data method.""" device = create_device_for_command_testing(SwitchbotModel.LOCK) basic_data = bytes([0, battery, 1]) result = device._parse_basic_data(basic_data) assert result["battery"] == battery assert result["firmware"] == 0.1 @pytest.mark.asyncio @pytest.mark.parametrize( "model", [SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_ULTRA_MAX] ) @pytest.mark.parametrize( ("basic_info", "battery", "firmware"), [ ("01 4b 28 21 14", 75, 3.3), # Main battery in use. ("01 85 28 21 14", 40, 3.3), # Backup battery in use. ("01 f3 28 21 14", 40, 3.3), # Byte 1 must never appear as 243%. ("01 80 ff 21 14", 255, 3.3), # Report the backup battery byte as received. ("01 4b 28", 60, 2.1), # Truncated reply: keep the last readings. ], ) async def test_lock2_basic_info(model, basic_info, battery, firmware): device = create_device_for_command_testing(model, SwitchbotLockUltra) device.update_from_advertisement( SwitchBotAdvertisement( device._device.address, {"data": {"battery": 60, "firmware": 2.1}}, device._device, -60, ) ) with ( patch.object( device, "_get_lock_info", return_value=bytes.fromhex("01 80 00 00 00 00 00") ), patch.object(device, "_get_basic_info", return_value=bytes.fromhex(basic_info)), ): await device.update() assert device.get_battery_percent() == battery assert device.parsed_data["firmware"] == firmware assert device.get_lock_status() is LockStatus.LOCKED @pytest.mark.asyncio @pytest.mark.parametrize( "model", [SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_ULTRA_MAX] ) async def test_lock2_battery_after_lock(model): device = create_device_for_command_testing(model, SwitchbotLockUltra) device.update_from_advertisement( SwitchBotAdvertisement( device._device.address, {"data": {"status": LockStatus.UNLOCKED}}, device._device, -60, ) ) with ( patch.object(device, "_enable_notifications", return_value=True), patch.object(device, "_send_command", return_value=bytes.fromhex("01")), patch.object( device, "_get_basic_info", return_value=bytes.fromhex("01 f3 28 21 14") ), ): assert await device.lock() assert device.get_battery_percent() == 40 assert device.parsed_data["firmware"] == 3.3 @pytest.mark.asyncio async def test_lock_ultra_max_verifies_encryption_key(): """Lock Ultra Max verifies a valid encryption key.""" lock_data = b"\x00\x80\x00\x00\x00\x00\x00\x00" basic_data = bytes.fromhex("01 64 01 21 14") ble_device = generate_ble_device("aa:bb:cc:dd:ee:ff", "any") with ( patch.object(lock.SwitchbotLock, "_get_lock_info", return_value=lock_data), patch.object(lock.SwitchbotLock, "_get_basic_info", return_value=basic_data), ): assert await SwitchbotLockUltra.verify_encryption_key( ble_device, "ff", "ffffffffffffffffffffffffffffffff", SwitchbotModel.LOCK_ULTRA_MAX, ) @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_is_calibrated(model: str): """Test is_calibrated method.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=True) assert device.is_calibrated() is True @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_get_lock_status(model: str): """Test get_lock_status method.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=LockStatus.LOCKED) assert device.get_lock_status() == LockStatus.LOCKED @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_is_door_open(model: str): """Test is_door_open method.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=True) assert device.is_door_open() is True @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_is_unclosed_alarm_on(model: str): """Test is_unclosed_alarm_on method.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=True) assert device.is_unclosed_alarm_on() is True @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_is_unlocked_alarm_on(model: str): """Test is_unlocked_alarm_on method.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=True) assert device.is_unlocked_alarm_on() is True @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, ], ) def test_is_auto_lock_paused(model: str): """Test is_auto_lock_paused method.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=True) assert device.is_auto_lock_paused() is True @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_is_night_latch_enabled(model: str): """Test is_night_latch_enabled method.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=True) assert device.is_night_latch_enabled() is True @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_get_lock_info(model: str): """Test _get_lock_info method.""" device = create_device_for_command_testing(model) expected_data = b"\x01\x00\x80\x00\x00\x00\x00\x00" with patch.object(device, "_send_command", return_value=expected_data): result = await device._get_lock_info() assert result == expected_data @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_get_lock_info_failure(model: str): """Test _get_lock_info method when command fails.""" device = create_device_for_command_testing(model) with patch.object(device, "_send_command", return_value=b"\x00\x00"): result = await device._get_lock_info() assert result is None @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_enable_notifications(model: str): """Test _enable_notifications method.""" device = create_device_for_command_testing(model) with patch.object(device, "_send_command", return_value=b"\x01\x00"): result = await device._enable_notifications() assert result is True @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_disable_notifications(model: str): """Test _disable_notifications method.""" device = create_device_for_command_testing(model) device._notifications_enabled = True with patch.object(device, "_send_command", return_value=b"\x01\x00"): result = await device._disable_notifications() assert result is True assert device._notifications_enabled is False @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_disable_notifications_already_disabled(model: str): """Test _disable_notifications when already disabled.""" device = create_device_for_command_testing(model) device._notifications_enabled = False with patch.object(device, "_send_command") as mock_send: result = await device._disable_notifications() assert result is True mock_send.assert_not_called() @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_notification_handler(model: str): """Test _notification_handler method.""" device = create_device_for_command_testing(model) device._notifications_enabled = True data = bytearray(b"\x0f\x00\x00\x00\x80\x00\x00\x00\x00\x00") with patch.object(device, "_update_lock_status") as mock_update: device._notification_handler(0, data) mock_update.assert_called_once_with(data) @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_notification_handler_not_enabled(model: str): """Test _notification_handler when notifications not enabled.""" device = create_device_for_command_testing(model) device._notifications_enabled = False data = bytearray(b"\x01\x00\x00\x00\x80\x00\x00\x00\x00\x00") with ( patch.object(device, "_update_lock_status") as mock_update, patch.object( lock.SwitchbotSequenceDevice, "_notification_handler" ) as mock_super, ): device._notification_handler(0, data) mock_update.assert_not_called() mock_super.assert_called_once() @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_notification_handler_during_disconnect( model: str, caplog: pytest.LogCaptureFixture ) -> None: """Test _notification_handler during expected disconnect.""" device = create_device_for_command_testing(model) device._notifications_enabled = True device._expected_disconnect = True data = bytearray(b"\x0f\x00\x00\x00\x80\x00\x00\x00\x00\x00") with ( patch.object(device, "_update_lock_status") as mock_update, caplog.at_level(logging.DEBUG), ): device._notification_handler(0, data) # Should not update lock status during disconnect mock_update.assert_not_called() # Should log debug message assert "Ignoring lock notification during expected disconnect" in caplog.text @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) def test_update_lock_status(model: str): """Test _update_lock_status method.""" device = create_device_for_command_testing(model) data = bytearray(b"\x0f\x00\x00\x00\x80\x00\x00\x00\x00\x00") with ( patch.object(device, "_decrypt", return_value=b"\x80\x00\x00\x00\x00\x00"), patch.object(device, "_update_parsed_data", return_value=True), patch.object(device, "_reset_disconnect_timer"), patch.object(device, "_fire_callbacks"), ): device._update_lock_status(data) @pytest.mark.parametrize( ("model", "data", "expected"), [ ( SwitchbotModel.LOCK, b"\x80\x00\x00\x00\x00\x00", { "calibration": True, "status": LockStatus.LOCKED, # (0x80 & 0b01110000) >> 4 = 0 = LOCKED "door_open": False, "unclosed_alarm": False, "unlocked_alarm": False, }, ), ( SwitchbotModel.LOCK_LITE, b"\x80\x00\x00\x00\x00\x00", { "calibration": True, "status": LockStatus.LOCKED, # (0x80 & 0b01110000) >> 4 = 0 = LOCKED "unlocked_alarm": False, }, ), ( SwitchbotModel.LOCK_PRO, b"\x80\x00\x00\x00\x00\x00", { "calibration": True, "status": LockStatus.LOCKED, # (0x80 & 0b01111000) >> 3 = 0 = LOCKED "door_open": False, "unclosed_alarm": False, "unlocked_alarm": False, }, ), ( SwitchbotModel.LOCK_ULTRA, b"\x88\x10\x00\x00\x00\xc0", { "calibration": True, "status": LockStatus.UNLOCKED, # (0x88 & 0b01111000) >> 3 = 0x08 >> 3 = 1 = UNLOCKED "door_open": True, "unclosed_alarm": True, "unlocked_alarm": True, "half_lock_calibration": False, }, ), ( SwitchbotModel.LOCK_VISION, b"\x80\x00\x00\x00\x00\x00", { "calibration": True, "status": LockStatus.LOCKED, # (0x80 & 0b01110000) >> 4 = 0 = LOCKED "unlocked_alarm": False, }, ), ( SwitchbotModel.LOCK_VISION_PRO, b"\x80\x00\x00\x00\x00\x00", { "calibration": True, "status": LockStatus.LOCKED, # (0x80 & 0b01111000) >> 3 = 0 = LOCKED "door_open": False, "unclosed_alarm": False, "unlocked_alarm": False, }, ), ( SwitchbotModel.LOCK_PRO_WIFI, b"\x80\x00\x00\x00\x00\x00", { "calibration": True, "status": LockStatus.LOCKED, # (0x80 & 0b01111000) >> 3 = 0 = LOCKED "door_open": False, "unclosed_alarm": False, "unlocked_alarm": False, }, ), ], ) def test_parse_lock_data(model: str, data: bytes, expected: dict): """Test _parse_lock_data static method.""" result = lock.SwitchbotLock._parse_lock_data(data, model) assert result == expected @pytest.mark.parametrize( ("model", "data", "expected"), [ # Test LOCK with different status bits and flags ( SwitchbotModel.LOCK, b"\x94\x00\x00\x00\x00\x00", # Unlocked status (0x10 >> 4 = 1) with door open { "calibration": True, "status": LockStatus.UNLOCKED, "door_open": True, "unclosed_alarm": False, "unlocked_alarm": False, }, ), # Test LOCK_LITE without door_open field ( SwitchbotModel.LOCK_LITE, b"\x90\x10\x00\x00\x00\x00", # Unlocked with unlocked alarm { "calibration": True, "status": LockStatus.UNLOCKED, "unlocked_alarm": True, }, ), # Test LOCK_PRO with new bit positions ( SwitchbotModel.LOCK_PRO, b"\x90\x10\x00\x00\x00\xc0", # New format: status bits 3-6, door open bit 4 of byte 1 { "calibration": True, "status": LockStatus.LOCKING, # (0x90 & 0b01111000) >> 3 = 0x10 >> 3 = 2 (LOCKING) "door_open": True, # bit 4 of byte 1 (0x10) "unclosed_alarm": True, # bit 7 of byte 5 (0xc0) "unlocked_alarm": True, # bit 6 of byte 5 (0xc0) }, ), # Test LOCK_ULTRA with same format as PRO ( SwitchbotModel.LOCK_ULTRA, b"\x88\x00\x00\x00\x00\x40", # Unlocked with unlocked alarm only { "calibration": True, "status": LockStatus.UNLOCKED, # (0x88 & 0b01111000) >> 3 = 0x08 >> 3 = 1 "door_open": False, "unclosed_alarm": False, "unlocked_alarm": True, # bit 6 of byte 5 "half_lock_calibration": False, }, ), ( SwitchbotModel.LOCK_PRO_WIFI, b"\x90\x10\x00\x00\x00\xc0", # New format: status bits 3-6, door open bit 4 of byte 1 { "calibration": True, "status": LockStatus.LOCKING, # (0x90 & 0b01111000) >> 3 = 0x10 >> 3 = 2 (LOCKING) "door_open": True, # bit 4 of byte 1 (0x10) "unclosed_alarm": True, # bit 7 of byte 5 (0xc0) "unlocked_alarm": True, # bit 6 of byte 5 (0xc0) }, ), ], ) def test_parse_lock_data_new_formats(model: str, data: bytes, expected: dict): """Test _parse_lock_data with new format changes.""" result = lock.SwitchbotLock._parse_lock_data(data, model) assert result == expected @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_lock_with_update(model: str): """Test lock method with status update.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(side_effect=[None, LockStatus.UNLOCKED]) with ( patch.object(device, "update", new_callable=AsyncMock), patch.object(device, "_send_command", return_value=b"\x01\x00"), patch.object(device, "_enable_notifications", return_value=True), patch.object(device, "_get_basic_info", return_value=b"\x00\x64\x01"), ): result = await device.lock() assert result is True def test_is_half_lock_calibrated(): """Test is_half_lock_calibrated method.""" device = create_device_for_command_testing(SwitchbotModel.LOCK_ULTRA) device._get_adv_value = Mock(return_value=True) assert device.is_half_lock_calibrated() is True device._get_adv_value = Mock(return_value=False) assert device.is_half_lock_calibrated() is False @pytest.mark.asyncio async def test_half_lock_calibrated(): """Test half_lock succeeds when calibrated.""" device = create_device_for_command_testing(SwitchbotModel.LOCK_ULTRA) device._get_adv_value = Mock(side_effect=[True, LockStatus.LOCKED]) with ( patch.object(device, "_send_command", return_value=b"\x01\x00"), patch.object(device, "_enable_notifications", return_value=True), patch.object(device, "_get_basic_info", return_value=b"\x01\x64\x01"), ): result = await device.half_lock() assert result is True @pytest.mark.asyncio async def test_half_lock_not_calibrated(): """Test half_lock raises SwitchbotOperationError when not calibrated.""" device = create_device_for_command_testing(SwitchbotModel.LOCK_ULTRA) device._get_adv_value = Mock(return_value=False) with pytest.raises(SwitchbotOperationError, match="not calibrated"): await device.half_lock() @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA_MAX, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_half_lock_unsupported_model(model: str): """Test half_lock raises SwitchbotOperationError on unsupported models.""" device = create_device_for_command_testing(model) with pytest.raises(SwitchbotOperationError, match="not supported"): await device.half_lock() @pytest.mark.asyncio async def test_half_lock(): """Test half_lock method.""" device = create_device_for_command_testing(SwitchbotModel.LOCK_ULTRA) device._get_adv_value = Mock(side_effect=[True, LockStatus.LOCKED]) with ( patch.object(device, "_send_command", return_value=b"\x01\x00") as mock_send, patch.object(device, "_enable_notifications", return_value=True), patch.object(device, "_get_basic_info", return_value=b"\x01\x64\x01"), ): result = await device.half_lock() assert result is True mock_send.assert_awaited_once_with( lock.COMMAND_HALF_LOCK[SwitchbotModel.LOCK_ULTRA] ) @pytest.mark.asyncio @pytest.mark.parametrize( ("model", "status"), [ (SwitchbotModel.LOCK, LockStatus.LOCKED), (SwitchbotModel.LOCK_LITE, LockStatus.LOCKING), (SwitchbotModel.LOCK_PRO, LockStatus.LOCKED), (SwitchbotModel.LOCK_ULTRA, LockStatus.LOCKING), (SwitchbotModel.LOCK_VISION, LockStatus.LOCKED), (SwitchbotModel.LOCK_VISION_PRO, LockStatus.LOCKED), (SwitchbotModel.LOCK_PRO_WIFI, LockStatus.LOCKED), ], ) async def test_lock_already_locked(model: str, status: LockStatus): """Test lock method when already locked.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=status) with patch.object(device, "_send_command") as mock_send: result = await device.lock() assert result is True mock_send.assert_not_called() @pytest.mark.asyncio @pytest.mark.parametrize( "model", [ SwitchbotModel.LOCK, SwitchbotModel.LOCK_LITE, SwitchbotModel.LOCK_PRO, SwitchbotModel.LOCK_ULTRA, SwitchbotModel.LOCK_VISION, SwitchbotModel.LOCK_VISION_PRO, SwitchbotModel.LOCK_PRO_WIFI, ], ) async def test_lock_with_invalid_basic_data(model: str): """Test lock method with invalid basic data.""" device = create_device_for_command_testing(model) device._get_adv_value = Mock(return_value=LockStatus.UNLOCKED) with ( patch.object(device, "_send_command", return_value=b"\x01\x00"), patch.object(device, "_enable_notifications", return_value=True), patch.object(device, "_get_basic_info", return_value=b"\x00"), ): result = await device.lock() assert result is True