Add Homee lock platform (#140893)

* Add homee lock platform

* finish tests

* add locking & unlocking

* add PARALLEL_UPDATES

* fix review comments

* fix test review comment.

* fix another review comment

homeassistant/components/homee/__init__.py

@@ -19,6 +19,7 @@ PLATFORMS = [
     Platform.BUTTON,
     Platform.COVER,
     Platform.LIGHT,
+    Platform.LOCK,
     Platform.NUMBER,
     Platform.SELECT,
     Platform.SENSOR,

homeassistant/components/homee/lock.py

@@ -0,0 +1,73 @@
+"""The Homee lock platform."""
+
+from typing import Any
+
+from pyHomee.const import AttributeChangedBy, AttributeType
+
+from homeassistant.components.lock import LockEntity
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import HomeeConfigEntry
+from .entity import HomeeEntity
+from .helpers import get_name_for_enum
+
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: HomeeConfigEntry,
+    async_add_devices: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Add the Homee platform for the lock component."""
+
+    async_add_devices(
+        HomeeLock(attribute, config_entry)
+        for node in config_entry.runtime_data.nodes
+        for attribute in node.attributes
+        if (attribute.type == AttributeType.LOCK_STATE and attribute.editable)
+    )
+
+
+class HomeeLock(HomeeEntity, LockEntity):
+    """Representation of a Homee lock."""
+
+    _attr_name = None
+
+    @property
+    def is_locked(self) -> bool:
+        """Return if lock is locked."""
+        return self._attribute.current_value == 1.0
+
+    @property
+    def is_locking(self) -> bool:
+        """Return if lock is locking."""
+        return self._attribute.target_value > self._attribute.current_value
+
+    @property
+    def is_unlocking(self) -> bool:
+        """Return if lock is unlocking."""
+        return self._attribute.target_value < self._attribute.current_value
+
+    @property
+    def changed_by(self) -> str:
+        """Return by whom or what the lock was last changed."""
+        changed_id = str(self._attribute.changed_by_id)
+        changed_by_name = get_name_for_enum(
+            AttributeChangedBy, self._attribute.changed_by
+        )
+        if self._attribute.changed_by == AttributeChangedBy.USER:
+            changed_id = self._entry.runtime_data.get_user_by_id(
+                self._attribute.changed_by_id
+            ).username
+
+        return f"{changed_by_name}-{changed_id}"
+
+    async def async_lock(self, **kwargs: Any) -> None:
+        """Lock specified lock. A code to lock the lock with may be specified."""
+        await self.async_set_homee_value(1)
+
+    async def async_unlock(self, **kwargs: Any) -> None:
+        """Unlock specified lock. A code to unlock the lock with may be specified."""
+        await self.async_set_homee_value(0)

tests/components/homee/fixtures/lock.json

@@ -0,0 +1,52 @@
+{
+  "id": 1,
+  "name": "Test Lock",
+  "profile": 2007,
+  "image": "default",
+  "favorite": 0,
+  "order": 31,
+  "protocol": 1,
+  "routing": 0,
+  "state": 1,
+  "state_changed": 1711799526,
+  "added": 1645036891,
+  "history": 1,
+  "cube_type": 1,
+  "note": "",
+  "services": 3,
+  "phonetic_name": "",
+  "owner": 2,
+  "security": 0,
+  "attributes": [
+    {
+      "id": 1,
+      "node_id": 1,
+      "instance": 0,
+      "minimum": 0,
+      "maximum": 1,
+      "current_value": 0.0,
+      "target_value": 0.0,
+      "last_value": 1.0,
+      "unit": "",
+      "step_value": 1.0,
+      "editable": 1,
+      "type": 232,
+      "state": 1,
+      "last_changed": 1711897362,
+      "changed_by": 4,
+      "changed_by_id": 5,
+      "based_on": 1,
+      "data": "",
+      "name": "",
+      "options": {
+        "automations": ["toggle"],
+        "history": {
+          "day": 35,
+          "week": 5,
+          "month": 1,
+          "stepped": true
+        }
+      }
+    }
+  ]
+}

tests/components/homee/snapshots/test_lock.ambr

@@ -0,0 +1,50 @@
+# serializer version: 1
+# name: test_lock_snapshot[lock.test_lock-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'lock',
+    'entity_category': None,
+    'entity_id': 'lock.test_lock',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': None,
+    'platform': 'homee',
+    'previous_unique_id': None,
+    'supported_features': 0,
+    'translation_key': None,
+    'unique_id': '00055511EECC-1-1',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_lock_snapshot[lock.test_lock-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'changed_by': 'unknown-5',
+      'friendly_name': 'Test Lock',
+      'supported_features': <LockEntityFeature: 0>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'lock.test_lock',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'unlocked',
+  })
+# ---

tests/components/homee/test_lock.py

@@ -0,0 +1,125 @@
+"""Test Homee locks."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from syrupy.assertion import SnapshotAssertion
+
+from homeassistant.components.lock import (
+    DOMAIN as LOCK_DOMAIN,
+    SERVICE_LOCK,
+    SERVICE_UNLOCK,
+    LockState,
+)
+from homeassistant.const import ATTR_ENTITY_ID, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
+
+from . import build_mock_node, setup_integration
+
+from tests.common import MockConfigEntry, snapshot_platform
+
+
+async def setup_lock(
+    hass: HomeAssistant, mock_config_entry: MockConfigEntry, mock_homee: MagicMock
+) -> None:
+    """Setups the integration lock tests."""
+    mock_homee.nodes = [build_mock_node("lock.json")]
+    mock_homee.get_node_by_id.return_value = mock_homee.nodes[0]
+    await setup_integration(hass, mock_config_entry)
+
+
+@pytest.mark.parametrize(
+    ("service", "target_value"),
+    [
+        (SERVICE_LOCK, 1),
+        (SERVICE_UNLOCK, 0),
+    ],
+)
+async def test_lock_services(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_homee: MagicMock,
+    service: str,
+    target_value: int,
+) -> None:
+    """Test lock services."""
+    await setup_lock(hass, mock_config_entry, mock_homee)
+
+    await hass.services.async_call(
+        LOCK_DOMAIN,
+        service,
+        {ATTR_ENTITY_ID: "lock.test_lock"},
+    )
+    mock_homee.set_value.assert_called_once_with(1, 1, target_value)
+
+
+@pytest.mark.parametrize(
+    ("target_value", "current_value", "expected"),
+    [
+        (1.0, 1.0, LockState.LOCKED),
+        (0.0, 0.0, LockState.UNLOCKED),
+        (1.0, 0.0, LockState.LOCKING),
+        (0.0, 1.0, LockState.UNLOCKING),
+    ],
+)
+async def test_lock_state(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_homee: MagicMock,
+    target_value: float,
+    current_value: float,
+    expected: LockState,
+) -> None:
+    """Test lock state."""
+    mock_homee.nodes = [build_mock_node("lock.json")]
+    mock_homee.get_node_by_id.return_value = mock_homee.nodes[0]
+    attribute = mock_homee.nodes[0].attributes[0]
+    attribute.target_value = target_value
+    attribute.current_value = current_value
+    await setup_integration(hass, mock_config_entry)
+
+    assert hass.states.get("lock.test_lock").state == expected
+
+
+@pytest.mark.parametrize(
+    ("attr_changed_by", "changed_by_id", "expected"),
+    [
+        (1, 0, "itself-0"),
+        (2, 1, "user-testuser"),
+        (3, 54, "homeegram-54"),
+        (6, 0, "ai-0"),
+    ],
+)
+async def test_lock_changed_by(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_homee: MagicMock,
+    attr_changed_by: int,
+    changed_by_id: int,
+    expected: str,
+) -> None:
+    """Test lock changed by entries."""
+    mock_homee.nodes = [build_mock_node("lock.json")]
+    mock_homee.get_node_by_id.return_value = mock_homee.nodes[0]
+    mock_homee.get_user_by_id.return_value = MagicMock(username="testuser")
+    attribute = mock_homee.nodes[0].attributes[0]
+    attribute.changed_by = attr_changed_by
+    attribute.changed_by_id = changed_by_id
+    await setup_integration(hass, mock_config_entry)
+
+    assert hass.states.get("lock.test_lock").attributes["changed_by"] == expected
+
+
+async def test_lock_snapshot(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_homee: MagicMock,
+    entity_registry: er.EntityRegistry,
+    snapshot: SnapshotAssertion,
+) -> None:
+    """Test the lock snapshots."""
+    with patch("homeassistant.components.homee.PLATFORMS", [Platform.LOCK]):
+        await setup_lock(hass, mock_config_entry, mock_homee)
+
+    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)