Add support for Mighty Mule MMS100 to Nice G.O. (#127765)

homeassistant/components/nice_go/const.py

@@ -2,6 +2,8 @@
 
 from datetime import timedelta
 
+from homeassistant.const import Platform
+
 DOMAIN = "nice_go"
 
 # Configuration
@@ -11,3 +13,22 @@ CONF_REFRESH_TOKEN = "refresh_token"
 CONF_REFRESH_TOKEN_CREATION_TIME = "refresh_token_creation_time"
 
 REFRESH_TOKEN_EXPIRY_TIME = timedelta(days=30)
+
+SUPPORTED_DEVICE_TYPES = {
+    Platform.LIGHT: ["WallStation"],
+    Platform.SWITCH: ["WallStation"],
+}
+KNOWN_UNSUPPORTED_DEVICE_TYPES = {
+    Platform.LIGHT: ["Mms100"],
+    Platform.SWITCH: ["Mms100"],
+}
+
+UNSUPPORTED_DEVICE_WARNING = (
+    "Device '%s' has unknown device type '%s', "
+    "which is not supported by this integration. "
+    "We try to support it with a cover and event entity, but nothing else. "
+    "Please create an issue with your device model in additional info"
+    " at https://github.com/home-assistant/core/issues/new"
+    "?assignees=&labels=&projects=&template=bug_report.yml"
+    "&title=New%%20Nice%%20G.O.%%20device%%20type%%20'%s'%%20found"
+)

homeassistant/components/nice_go/coordinator.py

@@ -44,13 +44,14 @@ RECONNECT_DELAY = 5
 class NiceGODevice:
     """Nice G.O. device dataclass."""
 
+    type: str
     id: str
     name: str
     barrier_status: str
     light_status: bool | None
     fw_version: str
     connected: bool
-    vacation_mode: bool
+    vacation_mode: bool | None
 
 
 class NiceGOUpdateCoordinator(DataUpdateCoordinator[dict[str, NiceGODevice]]):
@@ -85,7 +86,9 @@ class NiceGOUpdateCoordinator(DataUpdateCoordinator[dict[str, NiceGODevice]]):
         """Stop reconnecting if hass is stopping."""
         self._hass_stopping = True
 
-    async def _parse_barrier(self, barrier_state: BarrierState) -> NiceGODevice | None:
+    async def _parse_barrier(
+        self, device_type: str, barrier_state: BarrierState
+    ) -> NiceGODevice | None:
         """Parse barrier data."""
 
         device_id = barrier_state.deviceId
@@ -121,11 +124,15 @@ class NiceGOUpdateCoordinator(DataUpdateCoordinator[dict[str, NiceGODevice]]):
         fw_version = barrier_state.reported["deviceFwVersion"]
         if barrier_state.connectionState:
             connected = barrier_state.connectionState.connected
+        elif device_type == "Mms100":
+            connected = barrier_state.reported.get("radioConnected", 0) == 1
         else:
-            connected = False
+            # Assume connected
-        vacation_mode = barrier_state.reported["vcnMode"]
+            connected = True
+        vacation_mode = barrier_state.reported.get("vcnMode", None)
 
         return NiceGODevice(
+            type=device_type,
             id=device_id,
             name=name,
             barrier_status=barrier_status,
@@ -156,7 +163,8 @@ class NiceGOUpdateCoordinator(DataUpdateCoordinator[dict[str, NiceGODevice]]):
 
                 barriers = await self.api.get_all_barriers()
                 parsed_barriers = [
-                    await self._parse_barrier(barrier.state) for barrier in barriers
+                    await self._parse_barrier(barrier.type, barrier.state)
+                    for barrier in barriers
                 ]
 
                 # Parse the barriers and save them in a dictionary
@@ -226,6 +234,9 @@ class NiceGOUpdateCoordinator(DataUpdateCoordinator[dict[str, NiceGODevice]]):
         _LOGGER.debug(data)
         raw_data = data["data"]["devicesStatesUpdateFeed"]["item"]
         parsed_data = await self._parse_barrier(
+            self.data[
+                raw_data["deviceId"]
+            ].type,  # Device type is not sent in device state update, and it can't change, so we just reuse the existing one
             BarrierState(
                 deviceId=raw_data["deviceId"],
                 desired=json.loads(raw_data["desired"]),
@@ -238,7 +249,7 @@ class NiceGOUpdateCoordinator(DataUpdateCoordinator[dict[str, NiceGODevice]]):
                 else None,
                 version=raw_data["version"],
                 timestamp=raw_data["timestamp"],
-            )
+            ),
         )
         if parsed_data is None:
             return

homeassistant/components/nice_go/cover.py

@@ -18,6 +18,10 @@ from . import NiceGOConfigEntry
 from .const import DOMAIN
 from .entity import NiceGOEntity
 
+DEVICE_CLASSES = {
+    "WallStation": CoverDeviceClass.GARAGE,
+    "Mms100": CoverDeviceClass.GATE,
+}
 PARALLEL_UPDATES = 1
 
 
@@ -40,7 +44,11 @@ class NiceGOCoverEntity(NiceGOEntity, CoverEntity):
 
     _attr_supported_features = CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
     _attr_name = None
-    _attr_device_class = CoverDeviceClass.GARAGE
+
+    @property
+    def device_class(self) -> CoverDeviceClass:
+        """Return the class of this device, from component DEVICE_CLASSES."""
+        return DEVICE_CLASSES.get(self.data.type, CoverDeviceClass.GARAGE)
 
     @property
     def is_closed(self) -> bool:

homeassistant/components/nice_go/light.py

@@ -1,19 +1,28 @@
 """Nice G.O. light."""
 
+import logging
 from typing import TYPE_CHECKING, Any
 
 from aiohttp import ClientError
 from nice_go import ApiError
 
 from homeassistant.components.light import ColorMode, LightEntity
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from . import NiceGOConfigEntry
-from .const import DOMAIN
+from .const import (
+    DOMAIN,
+    KNOWN_UNSUPPORTED_DEVICE_TYPES,
+    SUPPORTED_DEVICE_TYPES,
+    UNSUPPORTED_DEVICE_WARNING,
+)
 from .entity import NiceGOEntity
 
+_LOGGER = logging.getLogger(__name__)
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -24,11 +33,20 @@ async def async_setup_entry(
 
     coordinator = config_entry.runtime_data
 
-    async_add_entities(
+    entities = []
-        NiceGOLightEntity(coordinator, device_id, device_data.name)
+
-        for device_id, device_data in coordinator.data.items()
+    for device_id, device_data in coordinator.data.items():
-        if device_data.light_status is not None
+        if device_data.type in SUPPORTED_DEVICE_TYPES[Platform.LIGHT]:
-    )
+            entities.append(NiceGOLightEntity(coordinator, device_id, device_data.name))
+        elif device_data.type not in KNOWN_UNSUPPORTED_DEVICE_TYPES[Platform.LIGHT]:
+            _LOGGER.warning(
+                UNSUPPORTED_DEVICE_WARNING,
+                device_data.name,
+                device_data.type,
+                device_data.type,
+            )
+
+    async_add_entities(entities)
 
 
 class NiceGOLightEntity(NiceGOEntity, LightEntity):

homeassistant/components/nice_go/switch.py

@@ -3,18 +3,24 @@
 from __future__ import annotations
 
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from aiohttp import ClientError
 from nice_go import ApiError
 
 from homeassistant.components.switch import SwitchDeviceClass, SwitchEntity
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from . import NiceGOConfigEntry
-from .const import DOMAIN
+from .const import (
+    DOMAIN,
+    KNOWN_UNSUPPORTED_DEVICE_TYPES,
+    SUPPORTED_DEVICE_TYPES,
+    UNSUPPORTED_DEVICE_WARNING,
+)
 from .entity import NiceGOEntity
 
 _LOGGER = logging.getLogger(__name__)
@@ -28,10 +34,22 @@ async def async_setup_entry(
     """Set up Nice G.O. switch."""
     coordinator = config_entry.runtime_data
 
-    async_add_entities(
+    entities = []
-        NiceGOSwitchEntity(coordinator, device_id, device_data.name)
+
-        for device_id, device_data in coordinator.data.items()
+    for device_id, device_data in coordinator.data.items():
-    )
+        if device_data.type in SUPPORTED_DEVICE_TYPES[Platform.SWITCH]:
+            entities.append(
+                NiceGOSwitchEntity(coordinator, device_id, device_data.name)
+            )
+        elif device_data.type not in KNOWN_UNSUPPORTED_DEVICE_TYPES[Platform.SWITCH]:
+            _LOGGER.warning(
+                UNSUPPORTED_DEVICE_WARNING,
+                device_data.name,
+                device_data.type,
+                device_data.type,
+            )
+
+    async_add_entities(entities)
 
 
 class NiceGOSwitchEntity(NiceGOEntity, SwitchEntity):
@@ -43,6 +61,8 @@ class NiceGOSwitchEntity(NiceGOEntity, SwitchEntity):
     @property
     def is_on(self) -> bool:
         """Return if switch is on."""
+        if TYPE_CHECKING:
+            assert self.data.vacation_mode is not None
         return self.data.vacation_mode
 
     async def async_turn_on(self, **kwargs: Any) -> None:

tests/components/nice_go/conftest.py

@@ -52,7 +52,9 @@ def mock_nice_go() -> Generator[AsyncMock]:
                 attr=barrier["attr"],
                 state=BarrierState(
                     **barrier["state"],
-                    connectionState=ConnectionState(**barrier["connectionState"]),
+                    connectionState=ConnectionState(**barrier["connectionState"])
+                    if barrier.get("connectionState")
+                    else None,
                 ),
                 api=client,
             )

tests/components/nice_go/fixtures/get_all_barriers.json

@@ -63,7 +63,7 @@
   },
   {
     "id": "3",
-    "type": "WallStation",
+    "type": "Mms100",
     "controlLevel": "Owner",
     "attr": [
       {
@@ -79,16 +79,42 @@
         "autoDisabled": false,
         "migrationStatus": "DONE",
         "deviceId": "3",
-        "vcnMode": false,
         "deviceFwVersion": "1.2.3.4.5.6",
-        "barrierStatus": "2,100,0,0,-1,0,3,0"
+        "barrierStatus": "1,100,0,0,1,0,0,0",
+        "radioConnected": 1,
+        "powerLevel": "LOW"
       },
       "timestamp": null,
       "version": null
     },
-    "connectionState": {
+    "connectionState": null
-      "connected": true,
+  },
-      "updatedTimestamp": "123"
+  {
-    }
+    "id": "4",
+    "type": "unknown-device-type",
+    "controlLevel": "Owner",
+    "attr": [
+      {
+        "key": "organization",
+        "value": "test_organization"
+      }
+    ],
+    "state": {
+      "deviceId": "4",
+      "desired": { "key": "value" },
+      "reported": {
+        "displayName": "Test Garage 4",
+        "autoDisabled": false,
+        "migrationStatus": "DONE",
+        "deviceId": "4",
+        "deviceFwVersion": "1.2.3.4.5.6",
+        "barrierStatus": "1,100,0,0,1,0,0,0",
+        "radioConnected": 1,
+        "powerLevel": "LOW"
+      },
+      "timestamp": null,
+      "version": null
+    },
+    "connectionState": null
   }
 ]

tests/components/nice_go/snapshots/test_cover.ambr

@@ -117,7 +117,7 @@
     'name': None,
     'options': dict({
     }),
-    'original_device_class': <CoverDeviceClass.GARAGE: 'garage'>,
+    'original_device_class': <CoverDeviceClass.GATE: 'gate'>,
     'original_icon': None,
     'original_name': None,
     'platform': 'nice_go',
@@ -131,7 +131,7 @@
 # name: test_covers[cover.test_garage_3-state]
   StateSnapshot({
     'attributes': ReadOnlyDict({
-      'device_class': 'garage',
+      'device_class': 'gate',
       'friendly_name': 'Test Garage 3',
       'supported_features': <CoverEntityFeature: 3>,
     }),
@@ -140,6 +140,54 @@
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': 'closed',
+    'state': 'open',
+  })
+# ---
+# name: test_covers[cover.test_garage_4-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'cover',
+    'entity_category': None,
+    'entity_id': 'cover.test_garage_4',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': <CoverDeviceClass.GARAGE: 'garage'>,
+    'original_icon': None,
+    'original_name': None,
+    'platform': 'nice_go',
+    'previous_unique_id': None,
+    'supported_features': <CoverEntityFeature: 3>,
+    'translation_key': None,
+    'unique_id': '4',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_covers[cover.test_garage_4-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'garage',
+      'friendly_name': 'Test Garage 4',
+      'supported_features': <CoverEntityFeature: 3>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'cover.test_garage_4',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'open',
   })
 # ---

tests/components/nice_go/snapshots/test_diagnostics.ambr

@@ -9,6 +9,7 @@
         'id': '1',
         'light_status': True,
         'name': 'Test Garage 1',
+        'type': 'WallStation',
         'vacation_mode': False,
       }),
       '2': dict({
@@ -18,16 +19,28 @@
         'id': '2',
         'light_status': False,
         'name': 'Test Garage 2',
+        'type': 'WallStation',
         'vacation_mode': True,
       }),
       '3': dict({
-        'barrier_status': 'closed',
+        'barrier_status': 'open',
         'connected': True,
         'fw_version': '1.2.3.4.5.6',
         'id': '3',
         'light_status': None,
         'name': 'Test Garage 3',
-        'vacation_mode': False,
+        'type': 'Mms100',
+        'vacation_mode': None,
+      }),
+      '4': dict({
+        'barrier_status': 'open',
+        'connected': True,
+        'fw_version': '1.2.3.4.5.6',
+        'id': '4',
+        'light_status': None,
+        'name': 'Test Garage 4',
+        'type': 'unknown-device-type',
+        'vacation_mode': None,
       }),
     }),
     'entry': dict({

tests/components/nice_go/test_init.py

@@ -347,7 +347,7 @@ async def test_no_connection_state(
         }
     )
 
-    assert hass.states.get("cover.test_garage_1").state == "unavailable"
+    assert hass.states.get("cover.test_garage_1").state == "open"
 
 
 async def test_connection_attempts_exhausted(

tests/components/nice_go/test_light.py

@@ -134,3 +134,29 @@ async def test_error(
             {ATTR_ENTITY_ID: entity_id},
             blocking=True,
         )
+
+
+async def test_unsupported_device_type(
+    hass: HomeAssistant,
+    mock_nice_go: AsyncMock,
+    mock_config_entry: MockConfigEntry,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that unsupported device types are handled appropriately."""
+
+    await setup_integration(hass, mock_config_entry, [Platform.LIGHT])
+
+    assert hass.states.get("light.test_garage_4_light") is None
+    assert (
+        "Device 'Test Garage 4' has unknown device type 'unknown-device-type'"
+        in caplog.text
+    )
+    assert "which is not supported by this integration" in caplog.text
+    assert (
+        "We try to support it with a cover and event entity, but nothing else."
+        in caplog.text
+    )
+    assert (
+        "Please create an issue with your device model in additional info"
+        in caplog.text
+    )