pySwitchbot/tests/test_lock.py

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