set shorthand atrributes for supported_features in velux cover (#156524)

homeassistant/components/velux/cover.py

@@ -56,37 +56,32 @@ class VeluxCover(VeluxEntity, CoverEntity):
     def __init__(self, node: OpeningDevice, config_entry_id: str) -> None:
         """Initialize VeluxCover."""
         super().__init__(node, config_entry_id)
+        # Features common to all covers
+        self._attr_supported_features = (
+            CoverEntityFeature.OPEN
+            | CoverEntityFeature.CLOSE
+            | CoverEntityFeature.SET_POSITION
+            | CoverEntityFeature.STOP
+        )
         # Window is the default device class for covers
         self._attr_device_class = CoverDeviceClass.WINDOW
         if isinstance(node, Awning):
             self._attr_device_class = CoverDeviceClass.AWNING
-        if isinstance(node, Blind):
-            self._attr_device_class = CoverDeviceClass.BLIND
-            self._is_blind = True
         if isinstance(node, GarageDoor):
             self._attr_device_class = CoverDeviceClass.GARAGE
         if isinstance(node, Gate):
             self._attr_device_class = CoverDeviceClass.GATE
         if isinstance(node, RollerShutter):
             self._attr_device_class = CoverDeviceClass.SHUTTER
-
-    @property
-    def supported_features(self) -> CoverEntityFeature:
-        """Flag supported features."""
-        supported_features = (
-            CoverEntityFeature.OPEN
-            | CoverEntityFeature.CLOSE
-            | CoverEntityFeature.SET_POSITION
-            | CoverEntityFeature.STOP
-        )
-        if self.current_cover_tilt_position is not None:
-            supported_features |= (
+        if isinstance(node, Blind):
+            self._attr_device_class = CoverDeviceClass.BLIND
+            self._is_blind = True
+            self._attr_supported_features |= (
                 CoverEntityFeature.OPEN_TILT
                 | CoverEntityFeature.CLOSE_TILT
                 | CoverEntityFeature.SET_TILT_POSITION
                 | CoverEntityFeature.STOP_TILT
             )
-        return supported_features
 
     @property
     def current_cover_position(self) -> int:

tests/components/velux/snapshots/test_cover.ambr

@@ -0,0 +1,52 @@
+# serializer version: 1
+# name: test_cover_setup[cover.test_window-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': 'cover',
+    'entity_category': None,
+    'entity_id': 'cover.test_window',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <CoverDeviceClass.WINDOW: 'window'>,
+    'original_icon': None,
+    'original_name': None,
+    'platform': 'velux',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': <CoverEntityFeature: 15>,
+    'translation_key': None,
+    'unique_id': '123456789',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_cover_setup[cover.test_window-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'current_position': 70,
+      'device_class': 'window',
+      'friendly_name': 'Test Window',
+      'supported_features': <CoverEntityFeature: 15>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'cover.test_window',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'open',
+  })
+# ---

tests/components/velux/test_cover.py

@@ -1,32 +1,69 @@
 """Tests for the Velux cover platform."""
 
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock
 
-from freezegun.api import FrozenDateTimeFactory
 import pytest
 
+from homeassistant.components.velux import DOMAIN
 from homeassistant.const import STATE_CLOSED, STATE_OPEN, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 
 from . import update_callback_entity
 
-from tests.common import MockConfigEntry
+from tests.common import MockConfigEntry, SnapshotAssertion, snapshot_platform
 
 
-@pytest.mark.usefixtures("mock_pyvlx")
+@pytest.fixture
+def platform() -> Platform:
+    """Fixture to specify platform to test."""
+    return Platform.COVER
+
+
+@pytest.mark.usefixtures("setup_integration")
+async def test_cover_setup(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    entity_registry: er.EntityRegistry,
+    device_registry: dr.DeviceRegistry,
+    snapshot: SnapshotAssertion,
+) -> None:
+    """Snapshot the cover entity (registry + state)."""
+    await snapshot_platform(
+        hass,
+        entity_registry,
+        snapshot,
+        mock_config_entry.entry_id,
+    )
+
+    # Get the cover entity setup and test device association
+    entity_entries = er.async_entries_for_config_entry(
+        entity_registry, mock_config_entry.entry_id
+    )
+    assert len(entity_entries) == 1
+    entry = entity_entries[0]
+
+    assert entry.device_id is not None
+    device_entry = device_registry.async_get(entry.device_id)
+    assert device_entry is not None
+    assert (DOMAIN, f"{123456789}") in device_entry.identifiers
+    assert device_entry.via_device_id is not None
+    via_device_entry = device_registry.async_get(device_entry.via_device_id)
+    assert via_device_entry is not None
+    assert (
+        DOMAIN,
+        f"gateway_{mock_config_entry.entry_id}",
+    ) in via_device_entry.identifiers
+
+
+@pytest.mark.usefixtures("setup_integration")
 async def test_cover_closed(
     hass: HomeAssistant,
     mock_window: AsyncMock,
     mock_config_entry: MockConfigEntry,
-    freezer: FrozenDateTimeFactory,
 ) -> None:
     """Test the cover closed state."""
 
-    mock_config_entry.add_to_hass(hass)
-    with patch("homeassistant.components.velux.PLATFORMS", [Platform.COVER]):
-        assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-
     test_entity_id = "cover.test_window"
 
     # Initial state should be open