pyg90alarm 1.15.1__tar.gz → 1.16.1__tar.gz

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/.github/workflows/main.yml

@@ -31,6 +31,9 @@ jobs:
           - os: ubuntu-latest
             python: '3.12'
             toxenv: py
+          - os: ubuntu-latest
+            python: '3.13'
+            toxenv: py
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout the code

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyg90alarm
-Version: 1.15.1
+Version: 1.16.1
 Summary: G90 Alarm system protocol
 Home-page: https://github.com/hostcc/pyg90alarm
 Author: Ilia Sotnikov
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.8, <4
 Description-Content-Type: text/x-rst

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/setup.py

@@ -41,6 +41,7 @@ setup(
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
         'Programming Language :: Python :: 3 :: Only',
     ],
 

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/src/pyg90alarm/alarm.py

@@ -60,7 +60,8 @@ from .const import (
     G90Commands, REMOTE_PORT,
     REMOTE_TARGETED_DISCOVERY_PORT,
     LOCAL_TARGETED_DISCOVERY_PORT,
-    NOTIFICATIONS_PORT,
+    LOCAL_NOTIFICATIONS_HOST,
+    LOCAL_NOTIFICATIONS_PORT,
     G90ArmDisarmTypes,
 )
 from .base_cmd import (G90BaseCommand, G90BaseCommandData)
@@ -140,11 +141,14 @@ class G90Alarm(G90DeviceNotifications):
     # pylint: disable=too-many-instance-attributes,too-many-arguments
     def __init__(self, host: str, port: int = REMOTE_PORT,
                  reset_occupancy_interval: float = 3.0,
-                 notifications_host: str = '0.0.0.0',
-                 notifications_port: int = NOTIFICATIONS_PORT):
-        super().__init__(host=notifications_host, port=notifications_port)
-        self._host = host
-        self._port = port
+                 notifications_local_host: str = LOCAL_NOTIFICATIONS_HOST,
+                 notifications_local_port: int = LOCAL_NOTIFICATIONS_PORT):
+        super().__init__(
+            local_host=notifications_local_host,
+            local_port=notifications_local_port
+        )
+        self._host: str = host
+        self._port: int = port
         self._sensors: List[G90Sensor] = []
         self._devices: List[G90Device] = []
         self._notifications: Optional[G90DeviceNotifications] = None
@@ -336,7 +340,9 @@ class G90Alarm(G90DeviceNotifications):
         :return: Device information
         """
         res = await self.command(G90Commands.GETHOSTINFO)
-        return G90HostInfo(*res)
+        info = G90HostInfo(*res)
+        self.device_id = info.host_guid
+        return info
 
     @property
     async def host_status(self) -> G90HostStatus:
@@ -813,7 +819,7 @@ class G90Alarm(G90DeviceNotifications):
                         # code as alert, as if it came from the device and its
                         # notifications port
                         self._handle_alert(
-                            (self._host, self._notifications_port),
+                            (self._host, self._notifications_local_port),
                             item.as_device_alert()
                         )
 

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/src/pyg90alarm/base_cmd.py

@@ -154,7 +154,12 @@ class G90BaseCommand(DatagramProtocol):
         Parses the response from the alarm panel.
         """
         _LOGGER.debug('To be decoded from wire format %s', data)
-        self._parse(data.decode('utf-8', errors='ignore'))
+        try:
+            self._parse(data.decode('utf-8'))
+        except UnicodeDecodeError as exc:
+            raise G90Error(
+                'Unable to decode response from UTF-8'
+            ) from exc
         return self._resp.data or []
 
     def _parse(self, data: str) -> None:

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/src/pyg90alarm/const.py

@@ -28,7 +28,8 @@ from typing import Optional
 REMOTE_PORT = 12368
 REMOTE_TARGETED_DISCOVERY_PORT = 12900
 LOCAL_TARGETED_DISCOVERY_PORT = 12901
-NOTIFICATIONS_PORT = 12901
+LOCAL_NOTIFICATIONS_HOST = '0.0.0.0'
+LOCAL_NOTIFICATIONS_PORT = 12901
 
 CMD_PAGE_SIZE = 10
 
@@ -165,7 +166,10 @@ class G90NotificationTypes(IntEnum):
     Defines types of notifications sent by the alarm panel.
     """
     ARM_DISARM = 1
+    SENSOR_ADDED = 4
     SENSOR_ACTIVITY = 5
+    DOOR_OPEN_WHEN_ARMING = 6
+    FIRMWARE_UPDATING = 8
 
 
 class G90ArmDisarmTypes(IntEnum):
@@ -194,7 +198,10 @@ class G90AlertSources(IntEnum):
     """
     DEVICE = 0
     SENSOR = 1
+    REMOTE = 10
+    RFID = 11
     DOORBELL = 12
+    FINGERPRINT = 15
 
 
 class G90AlertStates(IntEnum):
@@ -203,6 +210,7 @@ class G90AlertStates(IntEnum):
     """
     DOOR_CLOSE = 0
     DOOR_OPEN = 1
+    SOS = 2
     TAMPER = 3
     LOW_BATTERY = 4
 

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/src/pyg90alarm/device_notifications.py

@@ -41,7 +41,6 @@ from .const import (
     G90AlertStates,
 )
 
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -107,12 +106,29 @@ class G90DeviceAlert:  # pylint: disable=too-many-instance-attributes
 class G90DeviceNotifications(DatagramProtocol):
     """
     Implements support for notifications/alerts sent by alarm panel.
+
+    There is a basic check to ensure only notifications/alerts from the correct
+    device are processed - the check uses the host and port of the device, and
+    the device ID (GUID) that is set by the ancestor class that implements the
+    commands (e.g. :class:`G90Alarm`). The latter to work correctly needs a
+    command to be performed first, one that fetches device GUID and then stores
+    it using :attr:`.device_id` (e.g. :meth:`G90Alarm.get_host_info`).
     """
-    def __init__(self, port: int, host: str):
+    def __init__(self, local_port: int, local_host: str):
         # pylint: disable=too-many-arguments
         self._notification_transport: Optional[BaseTransport] = None
-        self._notifications_host = host
-        self._notifications_port = port
+        self._notifications_local_host = local_host
+        self._notifications_local_port = local_port
+        # Host/port of the device is configured to communicating via commands.
+        # Inteded to validate if notifications/alert are received from the
+        # correct device.
+        self._host: Optional[str] = None
+        self._port: Optional[int] = None
+        # Same but for device ID (GUID) - the notifications logic uses it to
+        # perform validation, but doesn't set it from messages received (it
+        # will diminish the purpose of the validation, should be done by an
+        # ancestor class).
+        self._device_id: Optional[str] = None
 
     def _handle_notification(
         self, addr: Tuple[str, int], notification: G90Notification
@@ -145,6 +161,15 @@ class G90DeviceNotifications(DatagramProtocol):
     def _handle_alert(
         self, addr: Tuple[str, int], alert: G90DeviceAlert
     ) -> None:
+        # Stop processing when alert is received from the device with different
+        # GUID
+        if self.device_id and alert.device_id != self.device_id:
+            _LOGGER.error(
+                "Received alert from wrong device: expected '%s', got '%s'",
+                self.device_id, alert.device_id
+            )
+            return
+
         if alert.type == G90AlertTypes.DOOR_OPEN_CLOSE:
             if alert.state in (
                 G90AlertStates.DOOR_OPEN, G90AlertStates.DOOR_CLOSE
@@ -219,11 +244,23 @@ class G90DeviceNotifications(DatagramProtocol):
     def datagram_received(  # pylint:disable=R0911
         self, data: bytes, addr: Tuple[str, int]
     ) -> None:
-
         """
-        Invoked from datagram is received from the device.
+        Invoked when datagram is received from the device.
         """
-        s_data = data.decode('utf-8')
+        if self._host and self._host != addr[0]:
+            _LOGGER.error(
+                "Received notification/alert from wrong host '%s',"
+                " expected from '%s'",
+                addr[0], self._host
+            )
+            return
+
+        try:
+            s_data = data.decode('utf-8')
+        except UnicodeDecodeError:
+            _LOGGER.error('Unable to decode device message from UTF-8')
+            return
+
         if not s_data.endswith('\0'):
             _LOGGER.error('Missing end marker in data')
             return
@@ -304,13 +341,13 @@ class G90DeviceNotifications(DatagramProtocol):
             loop = asyncio.get_event_loop()
 
         _LOGGER.debug('Creating UDP endpoint for %s:%s',
-                      self._notifications_host,
-                      self._notifications_port)
+                      self._notifications_local_host,
+                      self._notifications_local_port)
         (self._notification_transport,
          _protocol) = await loop.create_datagram_endpoint(
             lambda: self,
             local_addr=(
-                self._notifications_host, self._notifications_port
+                self._notifications_local_host, self._notifications_local_port
             ))
 
     @property
@@ -328,3 +365,17 @@ class G90DeviceNotifications(DatagramProtocol):
             _LOGGER.debug('No longer listening for device notifications')
             self._notification_transport.close()
             self._notification_transport = None
+
+    @property
+    def device_id(self) -> Optional[str]:
+        """
+        The ID (GUID) of the panel being communicated with thru commands.
+
+        Available when any panel command receives it from the device
+        (:meth:`G90Alarm.get_host_info` currently).
+        """
+        return self._device_id
+
+    @device_id.setter
+    def device_id(self, device_id: str) -> None:
+        self._device_id = device_id

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/src/pyg90alarm/history.py

@@ -21,6 +21,8 @@
 """
 History protocol entity.
 """
+import logging
+
 from typing import Any, Optional, Dict
 from dataclasses import dataclass
 from datetime import datetime, timezone
@@ -33,12 +35,13 @@ from .const import (
 )
 from .device_notifications import G90DeviceAlert
 
+_LOGGER = logging.getLogger(__name__)
+
 
 # The state of the incoming history entries are mixed of `G90AlertStates` and
-# `G90AlertStateChangeTypes`, depending on entry type - the mapping
-# consilidates them into unified `G90HistoryStates`. The latter enum can't be
-# just an union of former two, since those have conflicting values
-states_mapping = {
+# `G90AlertStateChangeTypes`, depending on entry type - hence two separate
+# dictionaries, since enums used for keys have conflicting values
+states_mapping_alerts = {
     G90AlertStates.DOOR_CLOSE:
         G90HistoryStates.DOOR_CLOSE,
     G90AlertStates.DOOR_OPEN:
@@ -47,6 +50,9 @@ states_mapping = {
         G90HistoryStates.TAMPER,
     G90AlertStates.LOW_BATTERY:
         G90HistoryStates.LOW_BATTERY,
+}
+
+states_mapping_state_changes = {
     G90AlertStateChangeTypes.AC_POWER_FAILURE:
         G90HistoryStates.AC_POWER_FAILURE,
     G90AlertStateChangeTypes.AC_POWER_RECOVER:
@@ -87,6 +93,7 @@ class G90History:
     Represents a history entry from the alarm panel.
     """
     def __init__(self, *args: Any, **kwargs: Any):
+        self._raw_data = args
         self._protocol_data = ProtocolData(*args, **kwargs)
 
     @property
@@ -99,55 +106,79 @@ class G90History:
         )
 
     @property
-    def type(self) -> G90AlertTypes:
+    def type(self) -> Optional[G90AlertTypes]:
         """
         Type of the history entry.
         """
-        return G90AlertTypes(self._protocol_data.type)
+        try:
+            return G90AlertTypes(self._protocol_data.type)
+        except ValueError:
+            _LOGGER.warning(
+                "Can't interpret '%s' as alert type (decoded protocol"
+                " data '%s', raw data '%s')",
+                self._protocol_data.type, self._protocol_data, self._raw_data
+            )
+            return None
 
     @property
-    def state(self) -> G90HistoryStates:
+    def state(self) -> Optional[G90HistoryStates]:
         """
         State for the history entry.
         """
-        # Door open/close type, mapped against `G90AlertStates` using `state`
-        # incoming field
-        if self.type == G90AlertTypes.DOOR_OPEN_CLOSE:
-            return G90HistoryStates(
-                states_mapping[G90AlertStates(self._protocol_data.state)]
+        try:
+            # Door open/close or alert types, mapped against `G90AlertStates`
+            # using `state` incoming field
+            if self.type in [
+                G90AlertTypes.DOOR_OPEN_CLOSE, G90AlertTypes.ALARM
+            ]:
+                return G90HistoryStates(
+                    states_mapping_alerts[
+                        G90AlertStates(self._protocol_data.state)
+                    ]
+                )
+        except ValueError:
+            _LOGGER.warning(
+                "Can't interpret '%s' as alert state (decoded protocol"
+                " data '%s', raw data '%s')",
+                self._protocol_data.state, self._protocol_data, self._raw_data
             )
+            return None
 
-        # Device state change, mapped against `G90AlertStateChangeTypes` using
-        # `event_id` incoming field
-        if self.type == G90AlertTypes.STATE_CHANGE:
+        try:
+            # Other types are mapped against `G90AlertStateChangeTypes`
             return G90HistoryStates(
-                states_mapping[
+                states_mapping_state_changes[
                     G90AlertStateChangeTypes(self._protocol_data.event_id)
                 ]
             )
-
-        # Alarm gets mapped to its counterpart in `G90HistoryStates`
-        if self.type == G90AlertTypes.ALARM:
-            return G90HistoryStates.ALARM
-
-        # Other types are mapped against `G90AlertStateChangeTypes`
-        return G90HistoryStates(
-            states_mapping[
-                G90AlertStateChangeTypes(self._protocol_data.event_id)
-            ]
-        )
+        except ValueError:
+            _LOGGER.warning(
+                "Can't interpret '%s' as state change (decoded protocol"
+                " data '%s', raw data '%s')",
+                self._protocol_data.event_id, self._protocol_data,
+                self._raw_data
+            )
+            return None
 
     @property
-    def source(self) -> G90AlertSources:
+    def source(self) -> Optional[G90AlertSources]:
         """
         Source of the history entry.
         """
-        # Device state changes or open/close events are mapped against
-        # `G90AlertSources` using `source` incoming field
-        if self.type in [
-            G90AlertTypes.STATE_CHANGE, G90AlertTypes.DOOR_OPEN_CLOSE
-        ]:
-            return G90AlertSources(self._protocol_data.source)
+        try:
+            # Device state changes or open/close events are mapped against
+            # `G90AlertSources` using `source` incoming field
+            if self.type in [
+                G90AlertTypes.STATE_CHANGE, G90AlertTypes.DOOR_OPEN_CLOSE
+            ]:
+                return G90AlertSources(self._protocol_data.source)
+        except ValueError:
+            _LOGGER.warning(
+                "Can't interpret '%s' as alert source (decoded protocol"
+                " data '%s', raw data '%s')",
+                self._protocol_data.source, self._protocol_data, self._raw_data
+            )
+            return None
 
         # Alarm will have `SENSOR` as the source, since that is likely what
         # triggered it
@@ -182,6 +213,7 @@ class G90History:
         Returns the history entry represented as device alert structure,
         suitable for :meth:`G90DeviceNotifications._handle_alert`.
         """
+
         return G90DeviceAlert(
             type=self._protocol_data.type,
             event_id=self._protocol_data.event_id,

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/src/pyg90alarm/targeted_discovery.py

@@ -103,7 +103,12 @@ class G90TargetedDiscovery(G90BaseCommand):
         """
         try:
             _LOGGER.debug('Received from %s:%s: %s', addr[0], addr[1], data)
-            decoded = data.decode('utf-8', errors='ignore')
+            try:
+                decoded = data.decode('utf-8')
+            except UnicodeDecodeError as exc:
+                raise G90Error(
+                    'Unable to decode discovery response from UTF-8'
+                ) from exc
             if not decoded.endswith('\0'):
                 raise G90Error('Invalid discovery response')
             host_info = G90TargetedDiscoveryInfo(*decoded[:-1].split(','))

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/src/pyg90alarm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyg90alarm
-Version: 1.15.1
+Version: 1.16.1
 Summary: G90 Alarm system protocol
 Home-page: https://github.com/hostcc/pyg90alarm
 Author: Ilia Sotnikov
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.8, <4
 Description-Content-Type: text/x-rst

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/tests/test_alarm.py

@@ -308,8 +308,8 @@ async def test_sensor_event(mock_device: DeviceMock) -> None:
     reset_interval = 0.5
     g90 = G90Alarm(host=mock_device.host, port=mock_device.port,
                    reset_occupancy_interval=reset_interval,
-                   notifications_host=mock_device.notification_host,
-                   notifications_port=mock_device.notification_port)
+                   notifications_local_host=mock_device.notification_host,
+                   notifications_local_port=mock_device.notification_port)
 
     sensors = await g90.get_sensors()
     prop_sensors = await g90.sensors
@@ -352,8 +352,8 @@ async def test_sensor_low_battery_event(mock_device: DeviceMock) -> None:
     Tests for sensor low battery callback.
     """
     g90 = G90Alarm(host=mock_device.host, port=mock_device.port,
-                   notifications_host=mock_device.notification_host,
-                   notifications_port=mock_device.notification_port)
+                   notifications_local_host=mock_device.notification_host,
+                   notifications_local_port=mock_device.notification_port)
 
     sensors = await g90.get_sensors()
     prop_sensors = await g90.sensors
@@ -401,8 +401,8 @@ async def test_armdisarm_callback(mock_device: DeviceMock) -> None:
     armdisarm_cb = MagicMock()
     armdisarm_cb.side_effect = lambda *args: future.set_result(True)
     g90 = G90Alarm(host=mock_device.host, port=mock_device.port,
-                   notifications_host=mock_device.notification_host,
-                   notifications_port=mock_device.notification_port)
+                   notifications_local_host=mock_device.notification_host,
+                   notifications_local_port=mock_device.notification_port)
     g90.armdisarm_callback = armdisarm_cb
     await g90.listen_device_notifications()
     await mock_device.send_next_notification()
@@ -434,8 +434,8 @@ async def test_door_open_close_callback(mock_device: DeviceMock) -> None:
     door_open_close_cb.side_effect = lambda *args: future.set_result(True)
 
     g90 = G90Alarm(host=mock_device.host, port=mock_device.port,
-                   notifications_host=mock_device.notification_host,
-                   notifications_port=mock_device.notification_port)
+                   notifications_local_host=mock_device.notification_host,
+                   notifications_local_port=mock_device.notification_port)
     g90.door_open_close_callback = door_open_close_cb
 
     # Simulate two device alerts - for opening (this one) and then closing the
@@ -492,8 +492,8 @@ async def test_alarm_callback(mock_device: DeviceMock) -> None:
     alarm_cb.side_effect = lambda *args: future.set_result(True)
 
     g90 = G90Alarm(host=mock_device.host, port=mock_device.port,
-                   notifications_host=mock_device.notification_host,
-                   notifications_port=mock_device.notification_port)
+                   notifications_local_host=mock_device.notification_host,
+                   notifications_local_port=mock_device.notification_port)
     sensors = await g90.get_sensors()
     # Set extra data for the 1st sensor
     sensors[0].extra_data = 'Dummy extra data'
@@ -575,7 +575,7 @@ async def test_disarm(mock_device: DeviceMock) -> None:
 
 @pytest.mark.g90device(sent_data=[
     b'ISTART[200,[[50,1,5],'
-    b'[3,33,7,254,"Sensor 1",1630147285,""],'
+    b'[3,33,7,1,"Sensor 1",1630147285,""],'
     b'[2,3,0,0,"",1630142877,""],'
     b'[2,5,0,0,"",1630142871,""],'
     b'[2,4,0,0,"",1630142757,""],'
@@ -595,6 +595,33 @@ async def test_history(mock_device: DeviceMock) -> None:
     assert isinstance(history[0]._asdict(), dict)
 
 
+@pytest.mark.g90device(sent_data=[
+    b'ISTART[200,[[3,1,3],'
+    # Wrong state
+    b'[3,33,7,254,"Sensor 1",1630147285,""],'
+    # Wrong source
+    b'[2,33,254,1,"Sensor 1",1630147285,""],'
+    # Wrong type
+    b'[254,33,1,1,"Sensor 1",1630147285,""]'
+    b']]IEND\0',
+])
+async def test_history_parsing_error(mock_device: DeviceMock) -> None:
+    """
+    Tests for processing history from the device, when the parsing error
+    occurs.
+    """
+    g90 = G90Alarm(host=mock_device.host, port=mock_device.port)
+    history = await g90.history(count=5)
+    assert len(history) == 3
+    assert isinstance(history[0], G90History)
+    assert isinstance(history[0]._asdict(), dict)
+    # Wrong entry element should result in corresponding key having 'None'
+    # value
+    assert history[0]._asdict()['state'] is None
+    assert history[1]._asdict()['source'] is None
+    assert history[2]._asdict()['type'] is None
+
+
 @pytest.mark.g90device(sent_data=[
     # Simulate empty history initially
     b'ISTART[200,[[0,0,0]]]IEND\0',
@@ -606,7 +633,7 @@ async def test_history(mock_device: DeviceMock) -> None:
     # The records will be used to simulate the device alerts, but only for
     # those newer that one above
     b'ISTART[200,[[3,1,3],'
-    b'[3,33,7,254,"Sensor 1",1630147285,""],'
+    b'[3,33,7,1,"Sensor 1",1630147285,""],'
     b'[2,3,0,0,"",1630142877,""],'
     b'[2,5,0,0,"",1630142871,""]'
     b']]IEND\0',
@@ -753,8 +780,8 @@ async def test_sms_alert_when_armed(mock_device: DeviceMock) -> None:
     armdisarm_cb = MagicMock()
     armdisarm_cb.side_effect = lambda *args: future.set_result(True)
     g90 = G90Alarm(host=mock_device.host, port=mock_device.port,
-                   notifications_host=mock_device.notification_host,
-                   notifications_port=mock_device.notification_port)
+                   notifications_local_host=mock_device.notification_host,
+                   notifications_local_port=mock_device.notification_port)
     g90.armdisarm_callback = armdisarm_cb
     g90.sms_alert_when_armed = True
     await g90.listen_device_notifications()
@@ -787,8 +814,8 @@ async def test_sms_alert_when_disarmed(mock_device: DeviceMock) -> None:
     armdisarm_cb = MagicMock()
     armdisarm_cb.side_effect = lambda *args: future.set_result(True)
     g90 = G90Alarm(host=mock_device.host, port=mock_device.port,
-                   notifications_host=mock_device.notification_host,
-                   notifications_port=mock_device.notification_port)
+                   notifications_local_host=mock_device.notification_host,
+                   notifications_local_port=mock_device.notification_port)
     g90.armdisarm_callback = armdisarm_cb
     g90.sms_alert_when_armed = True
     await g90.listen_device_notifications()

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/tests/test_base_commands.py

@@ -117,6 +117,26 @@ async def test_timeout(mock_device: DeviceMock) -> None:
     ]
 
 
+@pytest.mark.g90device(sent_data=[
+    b'\xdeadbeef\0',
+])
+async def test_invalid_utf8_encoding(mock_device: DeviceMock) -> None:
+    """
+    Verifies that invalid UTF-8 encoding of response is handled properly.
+    """
+    g90 = G90BaseCommand(
+        host=mock_device.host, port=mock_device.port,
+        code=G90Commands.GETHOSTINFO
+    )
+
+    with pytest.raises(
+        G90Error,
+        match=re.escape("Unable to decode response from UTF-8")
+    ):
+        await g90.process()
+    assert mock_device.recv_data == [b'ISTART[206,206,""]IEND\0']
+
+
 @pytest.mark.g90device(sent_data=[
     b'ISTART[IEND\0',
 ])

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/tests/test_discovery.py

@@ -57,6 +57,31 @@ async def test_targeted_discovery(mock_device: DeviceMock) -> None:
     assert mock_device.recv_data == [b'IWTAC_PROBE_DEVICE,DUMMYGUID\0']
 
 
+@pytest.mark.g90device(sent_data=[
+    b'\xdeadbeef'
+])
+async def test_targeted_discovery_invalid_utf_response(
+    mock_device: DeviceMock, caplog: LogCaptureFixture
+) -> None:
+    """
+    Verifies that invalid UTF-8 data in response to targeted discovery is
+    logged but ignored.
+    """
+    g90 = G90TargetedDiscovery(
+        device_id='DUMMYGUID',
+        host=mock_device.host,
+        port=mock_device.port,
+        local_port=LOCAL_TARGETED_DISCOVERY_PORT,
+        timeout=0.1)
+
+    caplog.set_level('WARNING')
+    await g90.process()
+    assert ''.join(caplog.messages) == (
+        'Got exception, ignoring:'
+        ' Unable to decode discovery response from UTF-8'
+    )
+
+
 @pytest.mark.g90device(sent_data=[
     b'IWTAC_PROBE_DEVICE_ACK_BAD,TSV018-3SIA'
     b',1.2,1.1,206,1.8,3,3,1,0,2,50,100\0',

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/tests/test_notifications.py

@@ -10,10 +10,34 @@ from pytest import LogCaptureFixture
 from pyg90alarm.device_notifications import (
     G90DeviceNotifications,
 )
+from pyg90alarm.alarm import G90Alarm
 
 from .device_mock import DeviceMock
 
 
+@pytest.mark.g90device(notification_data=[
+    b'\xdeadbeef\0',
+])
+async def test_device_notification_invalid_utf_data(
+    mock_device: DeviceMock, caplog: LogCaptureFixture
+) -> None:
+    """
+    Verifies that wrong UTF encoded data in device notification is handled
+    correctly.
+    """
+    notifications = G90DeviceNotifications(
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
+    )
+    caplog.set_level('ERROR')
+    await notifications.listen()
+    await mock_device.send_next_notification()
+    assert ''.join(caplog.messages) == (
+        "Unable to decode device message from UTF-8"
+    )
+    notifications.close()
+
+
 @pytest.mark.g90device(notification_data=[
     b'[170]\0',
 ])
@@ -24,7 +48,8 @@ async def test_device_notification_missing_header(
     Verifies that missing header in device notification is handled correctly.
     """
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
     caplog.set_level('ERROR')
     await notifications.listen()
@@ -49,7 +74,8 @@ async def test_device_notification_malformed_message(
     correctly.
     """
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
     caplog.set_level('ERROR')
     await notifications.listen()
@@ -72,7 +98,8 @@ async def test_device_notification_missing_end_marker(
     correctly.
     """
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
     caplog.set_level('ERROR')
     await notifications.listen()
@@ -91,7 +118,8 @@ async def test_wrong_device_notification_format(
     Verifies that wrong device notification format is handled correctly.
     """
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
     caplog.set_level('ERROR')
     await notifications.listen()
@@ -114,7 +142,8 @@ async def test_wrong_device_alert_format(
     Verifies that wrong device alert format is handled correctly.
     """
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
 
     caplog.set_level('ERROR')
@@ -140,7 +169,8 @@ async def test_unknown_device_notification(
     Verifies that unknown device notification is handled correctly.
     """
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
     caplog.set_level('WARNING')
     await notifications.listen()
@@ -164,7 +194,8 @@ async def test_unknown_device_alert(
     Verifies that unknown device alert is handled correctly.
     """
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
     caplog.set_level('WARNING')
     await notifications.listen()
@@ -179,6 +210,79 @@ async def test_unknown_device_alert(
     notifications.close()
 
 
+@pytest.mark.g90device(notification_data=[
+    b'[208,[999,100,1,1,"Hall","DUMMYGUID",'
+    b'1631545189,0,[""]]]\0',
+])
+async def test_wrong_host(
+    mock_device: DeviceMock, caplog: LogCaptureFixture
+) -> None:
+    """
+    Verifies that unknown device alert is handled correctly.
+    """
+    g90 = G90Alarm(
+        host='1.2.3.4',
+        notifications_local_host=mock_device.notification_host,
+        notifications_local_port=mock_device.notification_port
+    )
+    # pylint: disable=protected-access
+    g90._handle_alert = (  # type: ignore[method-assign]
+        MagicMock()
+    )
+    # pylint: disable=protected-access
+    g90._handle_notification = (  # type: ignore[method-assign]
+        MagicMock()
+    )
+    caplog.set_level('WARNING')
+    await g90.listen()
+    await mock_device.send_next_notification()
+    assert ''.join(caplog.messages) == (
+        "Received notification/alert from wrong host '127.0.0.1'"
+        ", expected from '1.2.3.4'"
+    )
+    g90.close()
+    # pylint: disable=protected-access
+    g90._handle_alert.assert_not_called()
+    # pylint: disable=protected-access
+    g90._handle_notification.assert_not_called()
+
+
+@pytest.mark.g90device(
+    sent_data=[
+        b'ISTART[206,'
+        b'["DUMMYGUID","DUMMYPRODUCT",'
+        b'"1.2","1.1","206","206",3,3,0,2,"4242",50,100]]IEND\0',
+    ],
+    notification_data=[
+        b'[208,[2,4,0,0,"","DIFFERENTGUID",1630876128,0,[""]]]\0'
+    ],
+)
+async def test_wrong_device_guid(
+    mock_device: DeviceMock, caplog: LogCaptureFixture
+) -> None:
+    """
+    Verifies that alert from device with different GUID is ignored.
+    """
+    g90 = G90Alarm(
+        host=mock_device.host, port=mock_device.port,
+        notifications_local_host=mock_device.notification_host,
+        notifications_local_port=mock_device.notification_port
+    )
+    caplog.set_level('WARNING')
+    # The command will fetch the host info and store the GIUD
+    await g90.get_host_info()
+    g90.on_armdisarm = MagicMock()  # type: ignore[method-assign]
+    await g90.listen()
+    await mock_device.send_next_notification()
+    assert ''.join(caplog.messages) == (
+        "Received alert from wrong device: expected 'DUMMYGUID'"
+        ", got 'DIFFERENTGUID'"
+    )
+    g90.close()
+    # Verify the associated callback was not called
+    g90.on_armdisarm.assert_not_called()
+
+
 @pytest.mark.g90device(notification_data=[
     b'[170,[5,[100,"Hall"]]]\0',
 ])
@@ -188,8 +292,8 @@ async def test_sensor_callback(mock_device: DeviceMock) -> None:
     """
     future = asyncio.get_running_loop().create_future()
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host,
-        port=mock_device.notification_port,
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port,
     )
 
     notifications.on_sensor_activity = (  # type: ignore[method-assign]
@@ -216,7 +320,8 @@ async def test_armdisarm_notification_callback(
     """
     future = asyncio.get_running_loop().create_future()
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port,
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
     notifications.on_armdisarm = MagicMock()  # type: ignore[method-assign]
     notifications.on_armdisarm.side_effect = (
@@ -238,7 +343,8 @@ async def test_armdisarm_alert_callback(mock_device: DeviceMock) -> None:
     """
     future = asyncio.get_running_loop().create_future()
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port,
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
     notifications.on_armdisarm = MagicMock()  # type: ignore[method-assign]
     notifications.on_armdisarm.side_effect = (
@@ -260,7 +366,8 @@ async def test_door_open_callback(mock_device: DeviceMock) -> None:
     """
     future = asyncio.get_running_loop().create_future()
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port,
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
 
     notifications.on_door_open_close = (  # type: ignore[method-assign]
@@ -285,7 +392,8 @@ async def test_door_close_callback(mock_device: DeviceMock) -> None:
     """
     future = asyncio.get_running_loop().create_future()
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port,
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
 
     notifications.on_door_open_close = (  # type: ignore[method-assign]
@@ -312,7 +420,8 @@ async def test_doorbell_callback(mock_device: DeviceMock) -> None:
     """
     future = asyncio.get_running_loop().create_future()
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port,
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
 
     notifications.on_door_open_close = (  # type: ignore[method-assign]
@@ -339,7 +448,8 @@ async def test_alarm_callback(mock_device: DeviceMock) -> None:
     """
     future = asyncio.get_running_loop().create_future()
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port,
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
     notifications.on_alarm = MagicMock()  # type: ignore[method-assign]
     notifications.on_alarm.side_effect = (
@@ -361,7 +471,8 @@ async def test_low_battery_callback(mock_device: DeviceMock) -> None:
     """
     future = asyncio.get_running_loop().create_future()
     notifications = G90DeviceNotifications(
-        host=mock_device.notification_host, port=mock_device.notification_port,
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
     )
     notifications.on_low_battery = MagicMock()  # type: ignore[method-assign]
     notifications.on_low_battery.side_effect = (

{pyg90alarm-1.15.1 → pyg90alarm-1.16.1}/tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist = py{38,39,310,311,312}
+envlist = py{38,39,310,311,312,313}
 
 # Define the minimal tox version required to run;
 # if the host tox is less than this the tool with create an environment and