Bring test coverage to 100%

Author: puddly

tests/application/test_requests.py

@@ -917,3 +917,95 @@ async def test_route_discovery_concurrency(device, make_application):
     assert route_discovery2.call_count == 2
 
     await app.shutdown()
+
+
+@pytest.mark.parametrize("device", FORMED_DEVICES)
+async def test_send_security_and_packet_source_route(device, make_application, mocker):
+    app, znp_server = await make_application(server_cls=device)
+    await app.startup(auto_form=False)
+
+    packet = zigpy_t.ZigbeePacket(
+        src=zigpy_t.AddrModeAddress(
+            addr_mode=zigpy_t.AddrMode.NWK, address=app.state.node_info.nwk
+        ),
+        src_ep=0x9A,
+        dst=zigpy_t.AddrModeAddress(addr_mode=zigpy_t.AddrMode.NWK, address=0xEEFF),
+        dst_ep=0xBC,
+        tsn=0xDE,
+        profile_id=0x1234,
+        cluster_id=0x0006,
+        data=zigpy_t.SerializableBytes(b"test data"),
+        extended_timeout=False,
+        tx_options=(
+            zigpy_t.TransmitOptions.ACK | zigpy_t.TransmitOptions.APS_Encryption
+        ),
+        source_route=[0xAABB, 0xCCDD],
+    )
+
+    data_req = znp_server.reply_once_to(
+        request=c.AF.DataRequestSrcRtg.Req(
+            DstAddr=packet.dst.address,
+            DstEndpoint=packet.dst_ep,
+            # SrcEndpoint=packet.src_ep,
+            ClusterId=packet.cluster_id,
+            TSN=packet.tsn,
+            Data=packet.data.serialize(),
+            SourceRoute=packet.source_route,
+            partial=True,
+        ),
+        responses=[
+            c.AF.DataRequestSrcRtg.Rsp(Status=t.Status.SUCCESS),
+            c.AF.DataConfirm.Callback(
+                Status=t.Status.SUCCESS,
+                Endpoint=packet.dst_ep,
+                TSN=packet.tsn,
+            ),
+        ],
+    )
+
+    await app.send_packet(packet)
+    req = await data_req
+    assert c.af.TransmitOptions.ENABLE_SECURITY in req.Options
+
+    await app.shutdown()
+
+
+@pytest.mark.parametrize("device", FORMED_DEVICES)
+async def test_send_packet_failure(device, make_application, mocker):
+    app, znp_server = await make_application(server_cls=device)
+    await app.startup(auto_form=False)
+
+    packet = zigpy_t.ZigbeePacket(
+        src=zigpy_t.AddrModeAddress(addr_mode=zigpy_t.AddrMode.NWK, address=0x0000),
+        src_ep=0x9A,
+        dst=zigpy_t.AddrModeAddress(addr_mode=zigpy_t.AddrMode.NWK, address=0xEEFF),
+        dst_ep=0xBC,
+        tsn=0xDE,
+        profile_id=0x1234,
+        cluster_id=0x0006,
+        data=zigpy_t.SerializableBytes(b"test data"),
+    )
+
+    znp_server.reply_to(
+        request=c.ZDO.ExtRouteDisc.Req(Dst=packet.dst.address, partial=True),
+        responses=[c.ZDO.ExtRouteDisc.Rsp(Status=t.Status.SUCCESS)],
+    )
+
+    znp_server.reply_to(
+        request=c.AF.DataRequestExt.Req(partial=True),
+        responses=[
+            c.AF.DataRequestExt.Rsp(Status=t.Status.SUCCESS),
+            c.AF.DataConfirm.Callback(
+                Status=t.Status.MAC_NO_ACK,
+                Endpoint=packet.dst_ep,
+                TSN=packet.tsn,
+            ),
+        ],
+    )
+
+    with pytest.raises(zigpy.exceptions.DeliveryError) as excinfo:
+        await app.send_packet(packet)
+
+    assert excinfo.value.status == t.Status.MAC_NO_ACK
+
+    await app.shutdown()

tests/application/test_startup.py

@@ -1,4 +1,5 @@
 import pytest
+import voluptuous as vol
 from zigpy.exceptions import NetworkNotFormed
 
 import zigpy_znp.types as t
@@ -266,3 +267,18 @@ async def test_zstack_build_id_empty(device, make_application, mocker):
     assert app._zstack_build_id == 0x00000000
 
     await app.shutdown()
+
+
+@pytest.mark.parametrize("device", [FormedLaunchpadCC26X2R1])
+async def test_deprecated_concurrency_config(device, make_application, mocker):
+    with pytest.raises(vol.MultipleInvalid) as exc:
+        app, znp_server = await make_application(
+            server_cls=device,
+            client_config={
+                conf.CONF_ZNP_CONFIG: {
+                    conf.CONF_MAX_CONCURRENT_REQUESTS: 16,
+                }
+            },
+        )
+
+    assert "max_concurrent_requests" in str(exc.value)

tests/application/test_zigpy_callbacks.py

@@ -168,3 +168,128 @@ async def test_on_af_message_callback(device, make_application, mocker):
     )
 
     app.handle_message.reset_mock()
+
+
+@pytest.mark.parametrize("device", FORMED_DEVICES)
+async def test_receive_zdo_broadcast(device, make_application, mocker):
+    app, znp_server = await make_application(server_cls=device)
+    await app.startup(auto_form=False)
+
+    mocker.patch.object(app, "packet_received")
+
+    zdo_callback = c.ZDO.MsgCbIncoming.Callback(
+        Src=0x35D9,
+        IsBroadcast=t.Bool.true,
+        ClusterId=19,
+        SecurityUse=0,
+        TSN=129,
+        MacDst=0xFFFF,
+        Data=b"bogus",
+    )
+    znp_server.send(zdo_callback)
+    await asyncio.sleep(0.1)
+
+    assert app.packet_received.call_count == 1
+    packet = app.packet_received.mock_calls[0].args[0]
+    assert packet.src == zigpy_t.AddrModeAddress(
+        addr_mode=zigpy_t.AddrMode.NWK, address=0x35D9
+    )
+    assert packet.src_ep == 0x00
+    assert packet.dst == zigpy_t.AddrModeAddress(
+        addr_mode=zigpy_t.AddrMode.Broadcast,
+        address=zigpy_t.BroadcastAddress.ALL_ROUTERS_AND_COORDINATOR,
+    )
+    assert packet.dst_ep == 0x00
+    assert packet.cluster_id == zdo_callback.ClusterId
+    assert packet.tsn == zdo_callback.TSN
+    assert packet.data.serialize() == bytes([zdo_callback.TSN]) + zdo_callback.Data
+
+    await app.shutdown()
+
+
+@pytest.mark.parametrize("device", FORMED_DEVICES)
+async def test_receive_af_broadcast(device, make_application, mocker):
+    app, znp_server = await make_application(server_cls=device)
+    await app.startup(auto_form=False)
+
+    mocker.patch.object(app, "packet_received")
+
+    af_callback = c.AF.IncomingMsg.Callback(
+        GroupId=0x0000,
+        ClusterId=4096,
+        SrcAddr=0x1234,
+        SrcEndpoint=254,
+        DstEndpoint=2,
+        WasBroadcast=t.Bool.true,
+        LQI=90,
+        SecurityUse=t.Bool.false,
+        TimeStamp=4442962,
+        TSN=0,
+        Data=b"\x11\xA6\x00\x74\xB5\x7C\x00\x02\x5F",
+        MacSrcAddr=0x0000,
+        MsgResultRadius=0,
+    )
+    znp_server.send(af_callback)
+    await asyncio.sleep(0.1)
+
+    assert app.packet_received.call_count == 1
+    packet = app.packet_received.mock_calls[0].args[0]
+    assert packet.src == zigpy_t.AddrModeAddress(
+        addr_mode=zigpy_t.AddrMode.NWK,
+        address=0x1234,
+    )
+    assert packet.src_ep == af_callback.SrcEndpoint
+    assert packet.dst == zigpy_t.AddrModeAddress(
+        addr_mode=zigpy_t.AddrMode.Broadcast,
+        address=zigpy_t.BroadcastAddress.ALL_ROUTERS_AND_COORDINATOR,
+    )
+    assert packet.dst_ep == af_callback.DstEndpoint
+    assert packet.cluster_id == af_callback.ClusterId
+    assert packet.tsn == af_callback.TSN
+    assert packet.lqi == af_callback.LQI
+    assert packet.data.serialize() == af_callback.Data
+
+    await app.shutdown()
+
+
+@pytest.mark.parametrize("device", FORMED_DEVICES)
+async def test_receive_af_group(device, make_application, mocker):
+    app, znp_server = await make_application(server_cls=device)
+    await app.startup(auto_form=False)
+
+    mocker.patch.object(app, "packet_received")
+
+    af_callback = c.AF.IncomingMsg.Callback(
+        GroupId=0x1234,
+        ClusterId=4096,
+        SrcAddr=0x1234,
+        SrcEndpoint=254,
+        DstEndpoint=0,
+        WasBroadcast=t.Bool.false,
+        LQI=90,
+        SecurityUse=t.Bool.false,
+        TimeStamp=4442962,
+        TSN=0,
+        Data=b"\x11\xA6\x00\x74\xB5\x7C\x00\x02\x5F",
+        MacSrcAddr=0x0000,
+        MsgResultRadius=0,
+    )
+    znp_server.send(af_callback)
+    await asyncio.sleep(0.1)
+
+    assert app.packet_received.call_count == 1
+    packet = app.packet_received.mock_calls[0].args[0]
+    assert packet.src == zigpy_t.AddrModeAddress(
+        addr_mode=zigpy_t.AddrMode.NWK,
+        address=0x1234,
+    )
+    assert packet.src_ep == af_callback.SrcEndpoint
+    assert packet.dst == zigpy_t.AddrModeAddress(
+        addr_mode=zigpy_t.AddrMode.Group, address=0x1234
+    )
+    assert packet.cluster_id == af_callback.ClusterId
+    assert packet.tsn == af_callback.TSN
+    assert packet.lqi == af_callback.LQI
+    assert packet.data.serialize() == af_callback.Data
+
+    await app.shutdown()

zigpy_znp/config.py

@@ -76,6 +76,18 @@ def bool_to_upper_str(value: typing.Any) -> str:
         return str(value).upper()
 
 
+def cv_deprecated(message: str) -> typing.Callable[[typing.Any], None]:
+    """
+    Raises a deprecation exception when a value is passed in.
+    """
+
+    def validator(value: typing.Any) -> None:
+        if value is not None:
+            raise vol.Invalid(message)
+
+    return validator
+
+
 CONF_ZNP_CONFIG = "znp_config"
 CONF_TX_POWER = "tx_power"
 CONF_LED_MODE = "led_mode"
@@ -104,8 +116,11 @@ def bool_to_upper_str(value: typing.Any) -> str:
                     vol.Optional(CONF_LED_MODE, default=LEDMode.OFF): vol.Any(
                         None, EnumValue(LEDMode, transformer=bool_to_upper_str)
                     ),
-                    vol.Optional(CONF_MAX_CONCURRENT_REQUESTS, default=None): vol.Any(
-                        None, "auto", VolPositiveNumber
+                    vol.Optional(CONF_MAX_CONCURRENT_REQUESTS, default=None): (
+                        cv_deprecated(
+                            "`zigpy_config: znp_config: max_concurrent_requests` has"
+                            " been renamed to `zigpy_config: max_concurrent_requests`."
+                        )
                     ),
                     vol.Optional(
                         CONF_CONNECT_RTS_STATES, default=[False, True, False]

zigpy_znp/zigbee/application.py

@@ -220,16 +220,13 @@ async def start_network(self, *, read_only=False):
 
         # Deprecate ZNP-specific config
         if self.znp_config[conf.CONF_MAX_CONCURRENT_REQUESTS] is not None:
-            LOGGER.warning(
+            raise RuntimeError(
                 "`zigpy_config:znp_config:max_concurrent_requests` is deprecated,"
-                " move this key up to `zigpy_config:max_concurrent_requests` instead"
+                " move this key up to `zigpy_config:max_concurrent_requests` instead."
             )
-            concurrency = self.znp_config[conf.CONF_MAX_CONCURRENT_REQUESTS]
-        else:
-            concurrency = self._config[conf.CONF_MAX_CONCURRENT_REQUESTS]
 
         # Now that we know what device we are, set the max concurrent requests
-        if concurrency in (None, "auto"):
+        if self._config[conf.CONF_MAX_CONCURRENT_REQUESTS] is None:
             max_concurrent_requests = 16 if self._znp.nvram.align_structs else 2
         else:
             max_concurrent_requests = self._config[conf.CONF_MAX_CONCURRENT_REQUESTS]
@@ -554,7 +551,7 @@ async def on_af_message(self, msg: c.AF.IncomingMsg.Callback) -> None:
         """
 
         # XXX: Is it possible to receive messages on non-assigned endpoints?
-        if msg.DstEndpoint in self._device.endpoints:
+        if msg.DstEndpoint != 0 and msg.DstEndpoint in self._device.endpoints:
             profile = self._device.endpoints[msg.DstEndpoint].profile_id
         else:
             LOGGER.warning("Received a message on an unregistered endpoint: %s", msg)
@@ -794,9 +791,6 @@ async def _send_request_raw(
         Picks the correct request sending mechanism and fixes endpoint information.
         """
 
-        if radius is None:
-            radius = 0
-
         # Zigpy just sets src == dst, which doesn't work for devices with many endpoints
         # We pick ours based on the registered endpoints when using an older firmware
         src_ep = self._find_endpoint(dst_ep=dst_ep, profile=profile, cluster=cluster)
@@ -1022,11 +1016,12 @@ async def send_packet(self, packet: zigpy.types.ZigbeePacket) -> None:
                             cluster=packet.cluster_id,
                             sequence=packet.tsn,
                             options=options,
-                            radius=packet.radius,
+                            radius=packet.radius or 0,
                             data=packet.data.serialize(),
                             relays=force_relays,
                             extended_timeout=packet.extended_timeout,
                         )
+                        status = response.Status
                         break
                     except InvalidCommandResponse as e:
                         status = e.response.Status
@@ -1159,8 +1154,3 @@ async def send_packet(self, packet: zigpy.types.ZigbeePacket) -> None:
                         NodeRelation=association.Device.nodeRelation,
                     )
                 )
-
-        if response.Status != t.Status.SUCCESS:
-            raise DeliveryError(
-                f"Failed to send request: {response.Status}", status=response.Status
-            )