zigpy-deconz 0.25.2__tar.gz → 0.25.4__tar.gz

{zigpy_deconz-0.25.2/zigpy_deconz.egg-info → zigpy_deconz-0.25.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy-deconz
-Version: 0.25.2
+Version: 0.25.4
 Summary: A library which communicates with Deconz radios for zigpy
 Author-email: Daniel Schmidt <schmidt.d@aon.at>
 License: GPL-3.0

{zigpy_deconz-0.25.2 → zigpy_deconz-0.25.4}/tests/test_application.py

@@ -553,10 +553,20 @@ async def test_add_endpoint_no_unnecessary_writes(app):
 
 
 async def test_reset_network_info(app):
-    app.form_network = AsyncMock()
+    app.write_network_info = AsyncMock()
     await app.reset_network_info()
 
-    app.form_network.assert_called_once()
+    assert len(app.write_network_info.mock_calls) == 1
+    network_info = app.write_network_info.mock_calls[0].kwargs["network_info"]
+    node_info = app.write_network_info.mock_calls[0].kwargs["node_info"]
+
+    # Verify invalid network settings are written
+    assert network_info.pan_id == 0xFFFF
+    assert network_info.extended_pan_id == zigpy.types.EUI64.convert(
+        "FF:FF:FF:FF:FF:FF:FF:FF"
+    )
+    assert network_info.channel is None
+    assert node_info.nwk == 0xFFFF
 
 
 async def test_energy_scan_conbee_2(app):

{zigpy_deconz-0.25.2 → zigpy_deconz-0.25.4}/tests/test_network_state.py

@@ -1,9 +1,10 @@
 """Test `load_network_info` and `write_network_info` methods."""
 
 import importlib.metadata
+from unittest.mock import ANY, call
 
 import pytest
-from zigpy.exceptions import ControllerException, NetworkNotFormed
+from zigpy.exceptions import CannotWriteNetworkSettings, NetworkNotFormed
 import zigpy.state as app_state
 import zigpy.types as t
 import zigpy.zdo.types as zdo_t
@@ -11,6 +12,7 @@ import zigpy.zdo.types as zdo_t
 import zigpy_deconz
 import zigpy_deconz.api
 import zigpy_deconz.exception
+import zigpy_deconz.types
 import zigpy_deconz.zigbee.application as application
 
 from tests.async_mock import AsyncMock, patch
@@ -70,28 +72,55 @@ def network_info(node_info):
 @patch.object(application, "CHANGE_NETWORK_POLL_TIME", 0.001)
 @patch.object(application, "CHANGE_NETWORK_STATE_DELAY", 0.001)
 @pytest.mark.parametrize(
-    "channel_mask, channel, security_level, fw_supports_fc, logical_type",
+    (
+        "channel_mask",
+        "channel",
+        "security_level",
+        "fw_supports_fc",
+        "logical_type",
+        "tx_counter",
+        "should_error",
+    ),
     [
+        # FW supports frame counter
         (
             t.Channels.from_channel_list([15]),
             15,
             0,
             True,
             zdo_t.LogicalType.Coordinator,
+            39009277,
+            False,
+        ),
+        # FW doesn't support but we're writing blank settings (tx_counter == 0)
+        (
+            t.Channels.from_channel_list([15]),
+            15,
+            5,
+            False,
+            zdo_t.LogicalType.Coordinator,
+            0,
+            False,
         ),
+        # FW doesn't support and we're writing real settings (should error)
         (
             t.Channels.from_channel_list([15]),
             15,
             0,
             False,
             zdo_t.LogicalType.Coordinator,
+            39009277,
+            True,
         ),
+        # Additional test cases with FW support
         (
             t.Channels.from_channel_list([15, 20]),
             15,
             5,
             True,
             zdo_t.LogicalType.Coordinator,
+            39009277,
+            False,
         ),
         (
             t.Channels.from_channel_list([15, 20, 25]),
@@ -99,8 +128,18 @@ def network_info(node_info):
             5,
             True,
             zdo_t.LogicalType.Router,
+            39009277,
+            False,
+        ),
+        (
+            None,
+            15,
+            5,
+            True,
+            zdo_t.LogicalType.Coordinator,
+            39009277,
+            False,
         ),
-        (None, 15, 5, True, zdo_t.LogicalType.Coordinator),
     ],
 )
 async def test_write_network_info(
@@ -112,6 +151,8 @@ async def test_write_network_info(
     security_level,
     fw_supports_fc,
     logical_type,
+    tx_counter,
+    should_error,
 ):
     """Test that network info is correctly written."""
 
@@ -137,13 +178,14 @@ async def test_write_network_info(
         channel=channel,
         channel_mask=channel_mask,
         security_level=security_level,
+        network_key=network_info.network_key.replace(tx_counter=tx_counter),
     )
 
     node_info = node_info.replace(logical_type=logical_type)
 
-    if not fw_supports_fc:
+    if should_error:
         with pytest.raises(
-            ControllerException,
+            CannotWriteNetworkSettings,
             match=(
                 "Please upgrade your adapter firmware. Firmware version 0x26580700 does"
                 " not support writing the network key frame counter, which is required"
@@ -166,7 +208,9 @@ async def test_write_network_info(
         for call in app._api.write_parameter.await_args_list
     }
 
-    assert params["nwk_frame_counter"] == (network_info.network_key.tx_counter,)
+    # Only check frame counter if firmware supports it
+    if fw_supports_fc:
+        assert params["nwk_frame_counter"] == (network_info.network_key.tx_counter,)
 
     if node_info.logical_type == zdo_t.LogicalType.Coordinator:
         assert params["aps_designed_coordinator"] == (1,)
@@ -328,3 +372,64 @@ async def test_load_network_info(
     assert app.state.network_info == network_info
 
     assert app.state.node_info == node_info.replace(**node_state_changes)
+
+
+@patch.object(application, "CHANGE_NETWORK_POLL_TIME", 0.001)
+@patch.object(application, "CHANGE_NETWORK_STATE_DELAY", 0.001)
+async def test_form_network_fast_without_frame_counter_support(app):  # noqa: F811
+    """Test that form_network(fast=True) works when FW doesn't support frame counter."""
+
+    async def write_parameter(param, *args):
+        if param == zigpy_deconz.api.NetworkParameter.nwk_frame_counter:
+            raise zigpy_deconz.exception.CommandError(
+                "Command is unsupported",
+                status=zigpy_deconz.api.Status.UNSUPPORTED,
+                command=None,
+            )
+
+    app._change_network_state = AsyncMock()
+    app._api.write_parameter = AsyncMock(side_effect=write_parameter)
+    app.backups = AsyncMock()
+    app.backups.restore_backup = AsyncMock()
+
+    # This should not raise an error because fast=True sets form_quickly
+    await app.form_network(fast=True)
+
+    # Verify that restore_backup was called with create_new=False (due to fast=True)
+    assert app.backups.restore_backup.mock_calls == [
+        call(backup=ANY, counter_increment=0, allow_incomplete=True, create_new=False)
+    ]
+
+
+@patch.object(application, "CHANGE_NETWORK_POLL_TIME", 0.001)
+@patch.object(application, "CHANGE_NETWORK_STATE_DELAY", 0.001)
+async def test_reset_network_info_without_frame_counter_support(app):  # noqa: F811
+    """Test that reset_network_info works even when FW doesn't support frame counter."""
+
+    async def write_parameter(param, *args):
+        if param == zigpy_deconz.api.NetworkParameter.nwk_frame_counter:
+            raise zigpy_deconz.exception.CommandError(
+                "Command is unsupported",
+                status=zigpy_deconz.api.Status.UNSUPPORTED,
+                command=None,
+            )
+
+    app._change_network_state = AsyncMock()
+    app._api.write_parameter = AsyncMock(side_effect=write_parameter)
+    app._api.read_parameter = AsyncMock(
+        return_value=t.EUI64.convert("00:11:22:33:44:55:66:77")
+    )
+
+    # Should not raise an error despite frame counter not being supported
+    await app.reset_network_info()
+
+    # Verify that write_parameter was called (including the frame counter attempt)
+    assert any(
+        mock_call.args[0] == zigpy_deconz.api.NetworkParameter.nwk_frame_counter
+        for mock_call in app._api.write_parameter.mock_calls
+    )
+
+    # Verify network state changes were awaited
+    assert app._change_network_state.mock_calls == [
+        call(zigpy_deconz.api.NetworkState.OFFLINE)
+    ]

{zigpy_deconz-0.25.2 → zigpy_deconz-0.25.4}/zigpy_deconz/zigbee/application.py

@@ -180,7 +180,29 @@ class ControllerApplication(zigpy.application.ControllerApplication):
 
     async def reset_network_info(self):
         # TODO: There does not appear to be a way to factory reset a Conbee
-        await self.form_network()
+        await self.write_network_info(
+            network_info=zigpy.state.NetworkInfo(
+                pan_id=0xFFFF,
+                extended_pan_id=zigpy.types.EUI64.convert("FF:FF:FF:FF:FF:FF:FF:FF"),
+                channel=None,
+                channel_mask=zigpy.types.Channels(0),
+                nwk_update_id=0,
+                network_key=zigpy.state.Key(
+                    key=zigpy.types.KeyData.convert(
+                        "FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF"
+                    )
+                ),
+                tc_link_key=zigpy.state.Key(
+                    key=zigpy.types.KeyData.convert(b"ZigBeeAlliance09".hex())
+                ),
+                security_level=0x05,
+            ),
+            node_info=zigpy.state.NodeInfo(
+                logical_type=zdo_t.LogicalType.Coordinator,
+                ieee=zigpy.types.EUI64.UNKNOWN,
+                nwk=0xFFFF,
+            ),
+        )
 
     async def write_network_info(self, *, network_info, node_info):
         try:
@@ -189,12 +211,19 @@ class ControllerApplication(zigpy.application.ControllerApplication):
             )
         except zigpy_deconz.exception.CommandError as ex:
             assert ex.status == Status.UNSUPPORTED
-            fw_version = f"{int(self._api.firmware_version):#010x}"
-            raise zigpy.exceptions.ControllerException(
-                f"Please upgrade your adapter firmware. Firmware version {fw_version}"
-                f" does not support writing the network key frame counter, which is"
-                f" required for migration to succeed."
-            )
+
+            # If we are resetting the adapter or forming a brand new network, we can
+            # skip this check
+            if not (
+                network_info.stack_specific.get("form_quickly", False)
+                or network_info.network_key.tx_counter == 0
+            ):
+                fw_version = f"{int(self._api.firmware_version):#010x}"
+                raise zigpy.exceptions.CannotWriteNetworkSettings(
+                    f"Please upgrade your adapter firmware. Firmware version"
+                    f" {fw_version} does not support writing the network key frame"
+                    f" counter, which is required for migration to succeed."
+                )
 
         if node_info.logical_type == zdo_t.LogicalType.Coordinator:
             await self._api.write_parameter(
@@ -284,6 +313,14 @@ class ControllerApplication(zigpy.application.ControllerApplication):
         # Note: Changed network configuration parameters become only affective after
         # sending a Leave Network Request followed by a Create or Join Network Request
         await self._change_network_state(NetworkState.OFFLINE)
+
+        if (
+            network_info.pan_id == 0xFFFF
+            or network_info.channel_mask == zigpy.types.Channels(0)
+        ):
+            # Network is being reset, it will never enter the CONNECTED state
+            return
+
         await asyncio.sleep(CHANGE_NETWORK_STATE_DELAY)
         await self._change_network_state(NetworkState.CONNECTED)
 
@@ -334,7 +371,7 @@ class ControllerApplication(zigpy.application.ControllerApplication):
             NetworkParameter.aps_extended_panid
         )
 
-        if network_info.extended_pan_id == zigpy.types.EUI64.convert(
+        if network_info.extended_pan_id == zigpy.types.ExtendedPanId.convert(
             "00:00:00:00:00:00:00:00"
         ):
             network_info.extended_pan_id = await self._api.read_parameter(
@@ -351,8 +388,16 @@ class ControllerApplication(zigpy.application.ControllerApplication):
             NetworkParameter.nwk_update_id
         )
 
-        if network_info.channel == 0:
-            raise NetworkNotFormed("Network channel is zero")
+        if (
+            node_info.nwk == 0xFFFF
+            or network_info.pan_id == 0xFFFF
+            or (
+                network_info.extended_pan_id
+                == zigpy.types.ExtendedPanId.convert("FF:FF:FF:FF:FF:FF:FF:FF")
+            )
+            or network_info.channel == 0
+        ):
+            raise NetworkNotFormed("Network is not formed")
 
         indexed_key = await self._api.read_parameter(NetworkParameter.network_key, 0)
 

{zigpy_deconz-0.25.2 → zigpy_deconz-0.25.4/zigpy_deconz.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy-deconz
-Version: 0.25.2
+Version: 0.25.4
 Summary: A library which communicates with Deconz radios for zigpy
 Author-email: Daniel Schmidt <schmidt.d@aon.at>
 License: GPL-3.0