Add method to send multicast requests. (#81)

* Fix DeconzAddressEndpoint group mode serialization.
* Send multicast requests method.
* Fix test typo.
* Update test coverage.

Author: Adminiuga

tests/test_api.py

@@ -93,7 +93,7 @@ def mock_api_frame(name, *args):
 
 
 def test_api_frame(api):
-    addr = t.DeconzAddress()
+    addr = t.DeconzAddressEndpoint()
     addr.address_mode = t.ADDRESS_MODE.NWK
     addr.address = t.uint8_t(0)
     addr.endpoint = t.uint8_t(0)

tests/test_application.py

@@ -469,3 +469,42 @@ def test_tx_confirm_unexpcted(app, caplog):
     app.handle_tx_confirm(123, 0x00)
     assert any(r.levelname == 'WARNING' for r in caplog.records)
     assert "Unexpected transmit confirm for request id" in caplog.text
+
+
+async def _test_mrequest(app, send_success=True, aps_data_error=False,
+                         **kwargs):
+    seq = 123
+    req_id = mock.sentinel.req_id
+    app.get_sequence = mock.MagicMock(return_value=req_id)
+
+    async def req_mock(req_id, dst_addr_ep, profile, cluster, src_ep, data):
+        if aps_data_error:
+            raise zigpy_deconz.exception.CommandError(1, "Command Error")
+        if send_success:
+            app._pending[req_id].result.set_result(0)
+        else:
+            app._pending[req_id].result.set_result(1)
+
+    app._api.aps_data_request = mock.MagicMock(side_effect=req_mock)
+    device = zigpy.device.Device(app, mock.sentinel.ieee, 0x1122)
+    app.get_device = mock.MagicMock(return_value=device)
+
+    return await app.mrequest(0x55aa, 0x0260, 1, 2, seq, b'\x01\x02\x03', **kwargs)
+
+
+@pytest.mark.asyncio
+async def test_mrequest_send_success(app):
+    r = await _test_mrequest(app, True)
+    assert r[0] == 0
+
+
+@pytest.mark.asyncio
+async def test_mrequest_send_fail(app):
+    r = await _test_mrequest(app, False)
+    assert r[0] != 0
+
+
+@pytest.mark.asyncio
+async def test_mrequest_send_aps_data_error(app):
+    r = await _test_mrequest(app, False, aps_data_error=True)
+    assert r[0] != 0

tests/test_types.py

@@ -230,3 +230,48 @@ def test_addr_ep_ieee():
     assert r.address_mode == t.ADDRESS_MODE.IEEE
     assert repr(r.address) == "31:32:33:34:35:36:37:38"
     assert r.endpoint == 0xcc
+
+
+def test_deconz_addr_ep():
+    data = b'\x01\xaa\x55'
+    extra = b'the rest of the owl'
+
+    r, rest = t.DeconzAddressEndpoint.deserialize(data + extra)
+    assert rest == extra
+    assert r.address_mode == t.ADDRESS_MODE.GROUP
+    assert r.address == 0x55aa
+    assert r.serialize() == data
+    a = t.DeconzAddressEndpoint()
+    a.address_mode = 1
+    a.address = 0x55aa
+    assert a.serialize() == data
+
+    data = b'\x02\xaa\x55\xcc'
+    r, rest = t.DeconzAddressEndpoint.deserialize(data + extra)
+    assert rest == extra
+    assert r.address_mode == t.ADDRESS_MODE.NWK
+    assert r.address == 0x55aa
+    assert r.endpoint == 0xcc
+    assert r.serialize() == data
+    a = t.DeconzAddressEndpoint()
+    a.address_mode = 2
+    a.address = 0x55aa
+    with pytest.raises(AttributeError):
+        a.serialize()
+    a.endpoint = 0xcc
+    assert a.serialize() == data
+
+    data = b'\x03\x31\x32\x33\x34\x35\x36\x37\x38\xcc'
+    r, rest = t.DeconzAddressEndpoint.deserialize(data + extra)
+    assert rest == extra
+    assert r.address_mode == t.ADDRESS_MODE.IEEE
+    assert r.address == [0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38]
+    assert r.endpoint == 0xcc
+    assert r.serialize() == data
+    a = t.DeconzAddressEndpoint()
+    a.address_mode = 3
+    a.address = [0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38]
+    with pytest.raises(AttributeError):
+        a.serialize()
+    a.endpoint = 0xcc
+    assert a.serialize() == data

zigpy_deconz/types.py

@@ -209,6 +209,10 @@ def __str__(self):
         return ('0x{:0' + str(self._size * 2) + 'x}').format(self)
 
 
+class GroupId(HexRepr, uint16_t):
+    pass
+
+
 class NWK(HexRepr, uint16_t):
     pass
 
@@ -225,7 +229,7 @@ class DeconzAddress(Struct):
     _fields = [
         # The address format (AddressMode)
         ('address_mode', ADDRESS_MODE),
-        ('address', uint64_t),
+        ('address', EUI64),
     ]
 
     @classmethod
@@ -254,7 +258,7 @@ class DeconzAddressEndpoint(Struct):
     _fields = [
         # The address format (AddressMode)
         ('address_mode', ADDRESS_MODE),
-        ('address', uint64_t),
+        ('address', EUI64),
         ('endpoint', uint8_t)
     ]
 
@@ -264,7 +268,9 @@ def deserialize(cls, data):
         mode, data = ADDRESS_MODE.deserialize(data)
         r.address_mode = mode
         a = e = None
-        if mode in [ADDRESS_MODE.GROUP, ADDRESS_MODE.NWK]:
+        if mode == ADDRESS_MODE.GROUP:
+            a, data = GroupId.deserialize(data)
+        elif mode == ADDRESS_MODE.NWK:
             a, data = NWK.deserialize(data)
         elif mode == ADDRESS_MODE.IEEE:
             a, data = EUI64.deserialize(data)
@@ -274,6 +280,18 @@ def deserialize(cls, data):
         setattr(r, cls._fields[2][0], e)
         return r, data
 
+    def serialize(self):
+        r = uint8_t(self.address_mode).serialize()
+        if self.address_mode == ADDRESS_MODE.NWK:
+            r += NWK(self.address).serialize()
+        elif self.address_mode == ADDRESS_MODE.GROUP:
+            r += GroupId(self.address).serialize()
+        elif self.address_mode == ADDRESS_MODE.IEEE:
+            r += EUI64(self.address).serialize()
+        if self.address_mode in (ADDRESS_MODE.NWK, ADDRESS_MODE.IEEE, ):
+            r += uint8_t(self.endpoint).serialize()
+        return r
+
 
 class Key(FixedList):
     _itemtype = uint8_t

zigpy_deconz/zigbee/application.py

@@ -10,7 +10,7 @@
 import zigpy.util
 import zigpy_deconz.exception
 from zigpy_deconz import types as t
-from zigpy_deconz.api import NetworkParameter, NetworkState
+from zigpy_deconz.api import NetworkParameter, NetworkState, Status
 
 LOGGER = logging.getLogger(__name__)
 
@@ -83,6 +83,61 @@ async def form_network(self, channel=15, pan_id=None, extended_pan_id=None):
             await asyncio.sleep(CHANGE_NETWORK_WAIT)
         raise Exception("Could not form network.")
 
+    async def mrequest(
+        self,
+        group_id,
+        profile,
+        cluster,
+        src_ep,
+        sequence,
+        data,
+        *,
+        hops=0,
+        non_member_radius=3
+    ):
+        """Submit and send data out as a multicast transmission.
+
+        :param group_id: destination multicast address
+        :param profile: Zigbee Profile ID to use for outgoing message
+        :param cluster: cluster id where the message is being sent
+        :param src_ep: source endpoint id
+        :param sequence: transaction sequence number of the message
+        :param data: Zigbee message payload
+        :param hops: the message will be delivered to all nodes within this number of
+                     hops of the sender. A value of zero is converted to MAX_HOPS
+        :param non_member_radius: the number of hops that the message will be forwarded
+                                  by devices that are not members of the group. A value
+                                  of 7 or greater is treated as infinite
+        :returns: return a tuple of a status and an error_message. Original requestor
+                  has more context to provide a more meaningful error message
+        """
+        req_id = self.get_sequence()
+        LOGGER.debug("Sending Zigbee multicast with tsn %s under %s request id, data: %s",
+                     sequence, req_id, binascii.hexlify(data))
+        dst_addr_ep = t.DeconzAddressEndpoint()
+        dst_addr_ep.address_mode = t.ADDRESS_MODE.GROUP
+        dst_addr_ep.address = group_id
+
+        with self._pending.new(req_id) as req:
+            try:
+                await self._api.aps_data_request(
+                    req_id,
+                    dst_addr_ep,
+                    profile,
+                    cluster,
+                    min(1, src_ep),
+                    data
+                )
+            except zigpy_deconz.exception.CommandError as ex:
+                return ex.status, "Couldn't enqueue send data request: {}".format(ex)
+
+            r = await asyncio.wait_for(req.result, SEND_CONFIRM_TIMEOUT)
+            if r:
+                LOGGER.warning("Error while sending %s req id frame: 0x%02x", req_id, r)
+                return r, "message send failure"
+
+        return Status.SUCCESS, "message send success"
+
     @zigpy.util.retryable_request
     async def request(self, device, profile, cluster, src_ep, dst_ep, sequence, data,
                       expect_reply=True, use_ieee=False):