Support schema 42 (#1237)

* Handle breaking change in schema 41

* support schema 42

* bump schema version

* Move the remaing firmware code to the driver

* format

* format

* revert ruff change

Author: MindFreeze

test/conftest.py

@@ -246,7 +246,7 @@ def version_data_fixture() -> dict[str, Any]:
         "serverVersion": "test_server_version",
         "homeId": "test_home_id",
         "minSchemaVersion": 0,
-        "maxSchemaVersion": 40,
+        "maxSchemaVersion": 42,
     }
 
 

test/model/test_controller.py

@@ -28,7 +28,6 @@
     controller as controller_pkg,
 )
 from zwave_js_server.model.controller import Controller
-from zwave_js_server.model.controller.firmware import ControllerFirmwareUpdateStatus
 from zwave_js_server.model.controller.rebuild_routes import (
     RebuildRoutesOptions,
     RebuildRoutesStatus,
@@ -2227,48 +2226,6 @@ async def test_inclusion_aborted(controller):
     assert {k: v for k, v in event.data.items() if k != "controller"} == event_data
 
 
-async def test_firmware_events(controller):
-    """Test firmware events."""
-    assert controller.firmware_update_progress is None
-    event = Event(
-        type="firmware update progress",
-        data={
-            "source": "controller",
-            "event": "firmware update progress",
-            "progress": {
-                "sentFragments": 1,
-                "totalFragments": 10,
-                "progress": 10.0,
-            },
-        },
-    )
-
-    controller.receive_event(event)
-    progress = event.data["firmware_update_progress"]
-    assert progress.sent_fragments == 1
-    assert progress.total_fragments == 10
-    assert progress.progress == 10.0
-    assert controller.firmware_update_progress
-    assert controller.firmware_update_progress.sent_fragments == 1
-    assert controller.firmware_update_progress.total_fragments == 10
-    assert controller.firmware_update_progress.progress == 10.0
-
-    event = Event(
-        type="firmware update finished",
-        data={
-            "source": "controller",
-            "event": "firmware update finished",
-            "result": {"status": 255, "success": True},
-        },
-    )
-
-    controller.receive_event(event)
-    result = event.data["firmware_update_finished"]
-    assert result.status == ControllerFirmwareUpdateStatus.OK
-    assert result.success
-    assert controller.firmware_update_progress is None
-
-
 async def test_unknown_event(controller):
     """Test that an unknown event type causes an exception."""
     with pytest.raises(KeyError):

test/model/test_driver.py

@@ -11,6 +11,7 @@
     log_config as log_config_pkg,
     log_message as log_message_pkg,
 )
+from zwave_js_server.model.driver.firmware import DriverFirmwareUpdateStatus
 
 from .. import load_fixture
 
@@ -409,3 +410,45 @@ def test_config_manager(driver):
     """Test the driver has the config manager property."""
     assert driver.config_manager is not None
     assert driver.config_manager._client is driver.client
+
+
+async def test_firmware_events(driver):
+    """Test firmware events."""
+    assert driver.firmware_update_progress is None
+    event = Event(
+        type="firmware update progress",
+        data={
+            "source": "driver",
+            "event": "firmware update progress",
+            "progress": {
+                "sentFragments": 1,
+                "totalFragments": 10,
+                "progress": 10.0,
+            },
+        },
+    )
+
+    driver.receive_event(event)
+    progress = event.data["firmware_update_progress"]
+    assert progress.sent_fragments == 1
+    assert progress.total_fragments == 10
+    assert progress.progress == 10.0
+    assert driver.firmware_update_progress
+    assert driver.firmware_update_progress.sent_fragments == 1
+    assert driver.firmware_update_progress.total_fragments == 10
+    assert driver.firmware_update_progress.progress == 10.0
+
+    event = Event(
+        type="firmware update finished",
+        data={
+            "source": "driver",
+            "event": "firmware update finished",
+            "result": {"status": 255, "success": True},
+        },
+    )
+
+    driver.receive_event(event)
+    result = event.data["firmware_update_finished"]
+    assert result.status == DriverFirmwareUpdateStatus.OK
+    assert result.success
+    assert driver.firmware_update_progress is None

test/test_client.py

@@ -463,7 +463,7 @@ async def test_additional_user_agent_components(client_session, url):
             {
                 "command": "initialize",
                 "messageId": "initialize",
-                "schemaVersion": 40,
+                "schemaVersion": 42,
                 "additionalUserAgentComponents": {
                     "zwave-js-server-python": __version__,
                     "foo": "bar",

test/test_dump.py

@@ -106,7 +106,7 @@ async def test_dump_additional_user_agent_components(
         {
             "command": "initialize",
             "messageId": "initialize",
-            "schemaVersion": 40,
+            "schemaVersion": 42,
             "additionalUserAgentComponents": {
                 "zwave-js-server-python": __version__,
                 "foo": "bar",

test/test_firmware.py

@@ -2,10 +2,10 @@
 
 from unittest.mock import patch
 
-from zwave_js_server.firmware import controller_firmware_update_otw, update_firmware
-from zwave_js_server.model.controller.firmware import (
-    ControllerFirmwareUpdateData,
-    ControllerFirmwareUpdateStatus,
+from zwave_js_server.firmware import driver_firmware_update_otw, update_firmware
+from zwave_js_server.model.driver.firmware import (
+    DriverFirmwareUpdateData,
+    DriverFirmwareUpdateStatus,
 )
 from zwave_js_server.model.node.firmware import (
     NodeFirmwareUpdateData,
@@ -94,26 +94,26 @@ async def test_update_firmware_known_format_and_target(
         disconnect_mock.assert_called_once()
 
 
-async def test_controller_firmware_update_otw_guess_format(url, client_session):
-    """Test controller_firmware_update_otw with guessed format."""
+async def test_driver_firmware_update_otw_guess_format(url, client_session):
+    """Test driver_firmware_update_otw with guessed format."""
     with (
         patch("zwave_js_server.firmware.Client.connect") as connect_mock,
         patch("zwave_js_server.firmware.Client.initialize") as initialize_mock,
         patch("zwave_js_server.firmware.Client.async_send_command") as cmd_mock,
         patch("zwave_js_server.firmware.Client.disconnect") as disconnect_mock,
     ):
         cmd_mock.return_value = {"result": {"status": 255, "success": True}}
-        result = await controller_firmware_update_otw(
-            url, ControllerFirmwareUpdateData("test", bytes(10)), client_session
+        result = await driver_firmware_update_otw(
+            url, DriverFirmwareUpdateData("test", bytes(10)), client_session
         )
-        assert result.status == ControllerFirmwareUpdateStatus.OK
+        assert result.status == DriverFirmwareUpdateStatus.OK
         assert result.success
 
         connect_mock.assert_called_once()
         initialize_mock.assert_called_once()
         cmd_mock.assert_called_once_with(
             {
-                "command": "controller.firmware_update_otw",
+                "command": "driver.firmware_update_otw",
                 "filename": "test",
                 "file": "AAAAAAAAAAAAAA==",
             },
@@ -122,30 +122,28 @@ async def test_controller_firmware_update_otw_guess_format(url, client_session):
         disconnect_mock.assert_called_once()
 
 
-async def test_controller_firmware_update_otw_known_format_and_target(
-    url, client_session
-):
-    """Test controller_firmware_update_otw with known format."""
+async def test_driver_firmware_update_otw_known_format_and_target(url, client_session):
+    """Test driver_firmware_update_otw with known format."""
     with (
         patch("zwave_js_server.firmware.Client.connect") as connect_mock,
         patch("zwave_js_server.firmware.Client.initialize") as initialize_mock,
         patch("zwave_js_server.firmware.Client.async_send_command") as cmd_mock,
         patch("zwave_js_server.firmware.Client.disconnect") as disconnect_mock,
     ):
         cmd_mock.return_value = {"result": {"status": 255, "success": True}}
-        result = await controller_firmware_update_otw(
+        result = await driver_firmware_update_otw(
             url=url,
-            firmware_file=ControllerFirmwareUpdateData("test", bytes(10), "test"),
+            firmware_file=DriverFirmwareUpdateData("test", bytes(10), "test"),
             session=client_session,
         )
-        assert result.status == ControllerFirmwareUpdateStatus.OK
+        assert result.status == DriverFirmwareUpdateStatus.OK
         assert result.success
 
         connect_mock.assert_called_once()
         initialize_mock.assert_called_once()
         cmd_mock.assert_called_once_with(
             {
-                "command": "controller.firmware_update_otw",
+                "command": "driver.firmware_update_otw",
                 "filename": "test",
                 "file": "AAAAAAAAAAAAAA==",
                 "fileFormat": "test",

test/test_main.py

@@ -58,7 +58,7 @@ def test_dump_state(
     assert captured.out == (
         "{'type': 'version', 'driverVersion': 'test_driver_version', "
         "'serverVersion': 'test_server_version', 'homeId': 'test_home_id', "
-        "'minSchemaVersion': 0, 'maxSchemaVersion': 40}\n"
+        "'minSchemaVersion': 0, 'maxSchemaVersion': 42}\n"
         "{'type': 'result', 'success': True, 'result': {}, 'messageId': 'initialize'}\n"
         "test_result\n"
     )

zwave_js_server/const/__init__.py

@@ -11,9 +11,9 @@
 __version__ = "0.63.0"
 
 # minimal server schema version we can handle
-MIN_SERVER_SCHEMA_VERSION = 39
+MIN_SERVER_SCHEMA_VERSION = 41
 # max server schema version we can handle (and our code is compatible with)
-MAX_SERVER_SCHEMA_VERSION = 40
+MAX_SERVER_SCHEMA_VERSION = 42
 
 VALUE_UNKNOWN = "unknown"
 

zwave_js_server/firmware.py

@@ -7,10 +7,7 @@
 import aiohttp
 
 from .client import Client
-from .model.controller.firmware import (
-    ControllerFirmwareUpdateData,
-    ControllerFirmwareUpdateResult,
-)
+from .model.driver.firmware import DriverFirmwareUpdateData, DriverFirmwareUpdateResult
 from .model.node import Node
 from .model.node.firmware import NodeFirmwareUpdateData, NodeFirmwareUpdateResult
 
@@ -45,16 +42,16 @@ async def update_firmware(
     return NodeFirmwareUpdateResult(node, data["result"])
 
 
-async def controller_firmware_update_otw(
+async def driver_firmware_update_otw(
     url: str,
-    firmware_file: ControllerFirmwareUpdateData,
+    firmware_file: DriverFirmwareUpdateData,
     session: aiohttp.ClientSession,
     additional_user_agent_components: dict[str, str] | None = None,
-) -> ControllerFirmwareUpdateResult:
+) -> DriverFirmwareUpdateResult:
     """
-    Send firmwareUpdateOTW command to Controller.
+    Send firmwareUpdateOTW command to Driver.
 
-    Sending the wrong firmware to a controller can brick it and make it unrecoverable.
+    Sending the wrong firmware to a driver can brick it and make it unrecoverable.
     Consumers of this library should build mechanisms to ensure that users understand
     the risks.
     """
@@ -68,7 +65,7 @@ async def controller_firmware_update_otw(
 
     data = await client.async_send_command(
         {
-            "command": "controller.firmware_update_otw",
+            "command": "driver.firmware_update_otw",
             **firmware_file.to_dict(),
         },
         require_schema=29,
@@ -77,4 +74,4 @@ async def controller_firmware_update_otw(
     if not receive_task.done():
         receive_task.cancel()
 
-    return ControllerFirmwareUpdateResult(data["result"])
+    return DriverFirmwareUpdateResult(data["result"])

zwave_js_server/model/controller/__init__.py

@@ -27,7 +27,6 @@
 from ..node.firmware import NodeFirmwareUpdateResult
 from .data_model import ControllerDataType
 from .event_model import CONTROLLER_EVENT_MODEL_MAP
-from .firmware import ControllerFirmwareUpdateProgress, ControllerFirmwareUpdateResult
 from .inclusion_and_provisioning import (
     InclusionGrant,
     ProvisioningEntry,
@@ -80,7 +79,6 @@ def __init__(self, client: Client, state: dict) -> None:
         self._rebuild_routes_progress: dict[Node, RebuildRoutesStatus] | None = None
         self._last_rebuild_routes_result: dict[Node, RebuildRoutesStatus] | None = None
         self._statistics = ControllerStatistics(DEFAULT_CONTROLLER_STATISTICS)
-        self._firmware_update_progress: ControllerFirmwareUpdateProgress | None = None
         for node_state in state["nodes"]:
             node = Node(client, node_state)
             self.nodes[node.node_id] = node
@@ -235,11 +233,6 @@ def rf_region(self) -> RFRegion | None:
             return None
         return RFRegion(rf_region)
 
-    @property
-    def firmware_update_progress(self) -> ControllerFirmwareUpdateProgress | None:
-        """Return firmware update progress."""
-        return self._firmware_update_progress
-
     @property
     def status(self) -> ControllerStatus:
         """Return status."""
@@ -902,19 +895,6 @@ def receive_event(self, event: Event) -> None:
         event.data["controller"] = self
         self.emit(event.type, event.data)
 
-    def handle_firmware_update_progress(self, event: Event) -> None:
-        """Process a firmware update progress event."""
-        self._firmware_update_progress = event.data["firmware_update_progress"] = (
-            ControllerFirmwareUpdateProgress(event.data["progress"])
-        )
-
-    def handle_firmware_update_finished(self, event: Event) -> None:
-        """Process a firmware update finished event."""
-        self._firmware_update_progress = None
-        event.data["firmware_update_finished"] = ControllerFirmwareUpdateResult(
-            event.data["result"]
-        )
-
     def handle_inclusion_failed(self, event: Event) -> None:
         """Process an inclusion failed event."""