zigpy 1.4.1__tar.gz → 1.5.0__tar.gz

{zigpy-1.4.1/zigpy.egg-info → zigpy-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy
-Version: 1.4.1
+Version: 1.5.0
 Summary: Library implementing a Zigbee stack
 Author-email: Russell Cloran <rcloran@gmail.com>
 License: GPL-3.0

{zigpy-1.4.1 → zigpy-1.5.0}/tests/test_application.py

@@ -947,13 +947,7 @@ async def test_request(app, device, packet):
     app.send_packet.reset_mock()
 
 
-async def test_request_retrying_success(app, device, packet) -> None:
-    app.send_packet.side_effect = [
-        DeliveryError("Failure"),
-        DeliveryError("Failure"),
-        None,
-    ]
-
+async def test_force_route_discovery(app, device, packet) -> None:
     await app.request(
         device=device,
         profile=0x1234,
@@ -965,54 +959,10 @@ async def test_request_retrying_success(app, device, packet) -> None:
         expect_reply=True,
         use_ieee=False,
         extended_timeout=False,
+        force_route_discovery=True,
     )
 
     assert app.send_packet.mock_calls == [
-        call(packet.replace(priority=t.PacketPriority.NORMAL)),
-        call(
-            packet.replace(
-                tx_options=packet.tx_options | t.TransmitOptions.FORCE_ROUTE_DISCOVERY,
-                priority=t.PacketPriority.NORMAL,
-            )
-        ),
-        call(
-            packet.replace(
-                tx_options=packet.tx_options | t.TransmitOptions.FORCE_ROUTE_DISCOVERY,
-                priority=t.PacketPriority.NORMAL,
-            )
-        ),
-    ]
-
-
-async def test_request_retrying_failure(app, device, packet) -> None:
-    app.send_packet.side_effect = [
-        DeliveryError("Failure"),
-        DeliveryError("Failure"),
-        DeliveryError("Failure"),
-    ]
-
-    with pytest.raises(DeliveryError):
-        await app.request(
-            device=device,
-            profile=0x1234,
-            cluster=0x0006,
-            src_ep=0x9A,
-            dst_ep=0xBC,
-            sequence=0xDE,
-            data=b"test data",
-            expect_reply=True,
-            use_ieee=False,
-            extended_timeout=False,
-        )
-
-    assert app.send_packet.mock_calls == [
-        call(packet.replace(priority=t.PacketPriority.NORMAL)),
-        call(
-            packet.replace(
-                tx_options=packet.tx_options | t.TransmitOptions.FORCE_ROUTE_DISCOVERY,
-                priority=t.PacketPriority.NORMAL,
-            )
-        ),
         call(
             packet.replace(
                 tx_options=packet.tx_options | t.TransmitOptions.FORCE_ROUTE_DISCOVERY,

{zigpy-1.4.1 → zigpy-1.5.0}/tests/test_device.py

@@ -523,10 +523,6 @@ async def test_update_device_firmware_already_in_progress(dev, caplog):
 
 @patch("zigpy.ota.manager.MAX_TIME_WITHOUT_PROGRESS", 0.1)
 @patch("zigpy.device.AFTER_OTA_ATTR_READ_DELAY", 0.01)
-@patch(
-    "zigpy.device.OTA_RETRY_DECORATOR",
-    zigpy.util.retryable_request(tries=1, delay=0.01),
-)
 async def test_update_device_firmware(monkeypatch, dev, caplog):
     """Test that device firmware updates execute the expected calls."""
     ep = dev.add_endpoint(1)
@@ -947,10 +943,6 @@ async def test_update_device_firmware(monkeypatch, dev, caplog):
 
 @patch("zigpy.ota.manager.MAX_TIME_WITHOUT_PROGRESS", 0.1)
 @patch("zigpy.device.AFTER_OTA_ATTR_READ_DELAY", 0.01)
-@patch(
-    "zigpy.device.OTA_RETRY_DECORATOR",
-    zigpy.util.retryable_request(tries=1, delay=0.01),
-)
 async def test_update_legrand_device_firmware(monkeypatch, dev, caplog):
     """Legrand device (manufacturer_code == 4129) firmware update expects the "image_block" command "maximum_data_size" to be complied with."""
     ep = dev.add_endpoint(1)
@@ -1359,7 +1351,7 @@ async def test_request_exception_propagation(dev):
             data=t.SerializableBytes(
                 foundation.ZCLHeader(
                     frame_control=foundation.FrameControl(
-                        frame_type=foundation.FrameType.CLUSTER_COMMAND,
+                        frame_type=foundation.FrameType.GLOBAL_COMMAND,
                         is_manufacturer_specific=False,
                         direction=foundation.Direction.Server_to_Client,
                         disable_default_response=True,
@@ -2227,3 +2219,259 @@ async def test_update_firmware_triggers_reinterview(monkeypatch, dev):
 
     assert result == foundation.Status.SUCCESS
     dev.reinterview.assert_awaited_once()
+
+
+async def test_request_retry_success(app) -> None:
+    """Test retry logic succeeding after a few attempts."""
+    tsn = 0x12
+
+    dev = app.add_device(nwk=0x1234, ieee=t.EUI64.convert("aa:bb:cc:dd:ee:ff:00:11"))
+    dev.node_desc = make_node_desc()
+
+    ep = dev.add_endpoint(1)
+    ep.status = endpoint.Status.ZDO_INIT
+    ep.add_input_cluster(Basic.cluster_id)
+
+    attempt = 0
+
+    def send_packet(*args, **kwargs) -> None:
+        nonlocal attempt
+        attempt += 1
+
+        if attempt < 3:
+            raise zigpy.exceptions.DeliveryError("Failure")
+
+        asyncio.get_running_loop().call_soon(
+            dev.packet_received,
+            t.ZigbeePacket(
+                profile_id=260,
+                cluster_id=Basic.cluster_id,
+                src_ep=1,
+                dst_ep=1,
+                data=t.SerializableBytes(
+                    foundation.ZCLHeader(
+                        frame_control=foundation.FrameControl(
+                            frame_type=foundation.FrameType.GLOBAL_COMMAND,
+                            is_manufacturer_specific=False,
+                            direction=foundation.Direction.Server_to_Client,
+                            disable_default_response=True,
+                            reserved=0,
+                        ),
+                        tsn=tsn,
+                        command_id=foundation.GeneralCommand.Default_Response,
+                        manufacturer=None,
+                    ).serialize()
+                    + (
+                        foundation.GENERAL_COMMANDS[
+                            foundation.GeneralCommand.Default_Response
+                        ]
+                        .schema(
+                            command_id=Basic.ServerCommandDefs.reset_fact_default.id,
+                            status=foundation.Status.SUCCESS,
+                        )
+                        .serialize()
+                    )
+                ),
+                src=t.AddrModeAddress(
+                    addr_mode=t.AddrMode.NWK,
+                    address=dev.nwk,
+                ),
+                dst=t.AddrModeAddress(
+                    addr_mode=t.AddrMode.NWK,
+                    address=0x0000,
+                ),
+            ),
+        )
+
+    app.send_packet.side_effect = send_packet
+    dev.get_sequence = MagicMock(return_value=tsn)
+
+    rsp = await dev.endpoints[1].basic.reset_fact_default()
+    assert rsp == foundation.DefaultResponse(
+        command_id=Basic.ServerCommandDefs.reset_fact_default.id,
+        status=foundation.Status.SUCCESS,
+    )
+
+    assert len(app.send_packet.mock_calls) == 3
+
+
+async def test_request_retry_failure(app) -> None:
+    """Test retry logic when all attempts fail."""
+    dev = app.add_device(nwk=0x1234, ieee=t.EUI64.convert("aa:bb:cc:dd:ee:ff:00:11"))
+    dev.node_desc = make_node_desc()
+
+    ep = dev.add_endpoint(1)
+    ep.status = endpoint.Status.ZDO_INIT
+    ep.add_input_cluster(Basic.cluster_id)
+
+    app.send_packet.side_effect = [
+        zigpy.exceptions.DeliveryError("Failure"),
+        zigpy.exceptions.DeliveryError("Failure"),
+        zigpy.exceptions.DeliveryError("Failure"),
+        zigpy.exceptions.DeliveryError("Failure"),
+    ]
+
+    with pytest.raises(zigpy.exceptions.DeliveryError):
+        await dev.request(
+            profile=0x1234,
+            cluster=0x0006,
+            src_ep=1,
+            dst_ep=1,
+            sequence=0xDE,
+            data=b"test data",
+            expect_reply=True,
+            use_ieee=False,
+            retries=3,
+        )
+
+    packet = t.ZigbeePacket(
+        priority=None,
+        src=t.AddrModeAddress(addr_mode=t.AddrMode.NWK, address=0x0000),
+        src_ep=1,
+        dst=t.AddrModeAddress(addr_mode=t.AddrMode.NWK, address=dev.nwk),
+        dst_ep=1,
+        source_route=None,
+        extended_timeout=False,
+        tsn=222,
+        profile_id=4660,
+        cluster_id=6,
+        data=t.SerializableBytes(b"test data"),
+        tx_options=t.TransmitOptions.NONE,
+        radius=0,
+        non_member_radius=0,
+    )
+
+    assert app.send_packet.mock_calls == [
+        call(packet),
+        call(
+            packet.replace(
+                tx_options=packet.tx_options | t.TransmitOptions.FORCE_ROUTE_DISCOVERY
+            )
+        ),
+        call(
+            packet.replace(
+                tx_options=packet.tx_options | t.TransmitOptions.FORCE_ROUTE_DISCOVERY
+            )
+        ),
+        call(
+            packet.replace(
+                tx_options=packet.tx_options | t.TransmitOptions.FORCE_ROUTE_DISCOVERY
+            )
+        ),
+    ]
+
+
+async def test_request_retry_reply_timeout(app) -> None:
+    """Test retry logic when a request is enqueued but no reply arrives, then a later attempt succeeds."""
+    tsn = 0x12
+
+    dev = app.add_device(nwk=0x1234, ieee=t.EUI64.convert("aa:bb:cc:dd:ee:ff:00:11"))
+    dev.node_desc = make_node_desc()
+
+    ep = dev.add_endpoint(1)
+    ep.status = endpoint.Status.ZDO_INIT
+    ep.add_input_cluster(Basic.cluster_id)
+
+    attempt = 0
+
+    def send_packet(*args, **kwargs) -> None:
+        nonlocal attempt
+        attempt += 1
+
+        # The first two attempts are enqueued successfully but no reply ever arrives
+        if attempt < 3:
+            return
+
+        # The third attempt receives a reply
+        asyncio.get_running_loop().call_soon(
+            dev.packet_received,
+            t.ZigbeePacket(
+                profile_id=260,
+                cluster_id=Basic.cluster_id,
+                src_ep=1,
+                dst_ep=1,
+                data=t.SerializableBytes(
+                    foundation.ZCLHeader(
+                        frame_control=foundation.FrameControl(
+                            frame_type=foundation.FrameType.GLOBAL_COMMAND,
+                            is_manufacturer_specific=False,
+                            direction=foundation.Direction.Server_to_Client,
+                            disable_default_response=True,
+                            reserved=0,
+                        ),
+                        tsn=tsn,
+                        command_id=foundation.GeneralCommand.Default_Response,
+                        manufacturer=None,
+                    ).serialize()
+                    + (
+                        foundation.GENERAL_COMMANDS[
+                            foundation.GeneralCommand.Default_Response
+                        ]
+                        .schema(
+                            command_id=Basic.ServerCommandDefs.reset_fact_default.id,
+                            status=foundation.Status.SUCCESS,
+                        )
+                        .serialize()
+                    )
+                ),
+                src=t.AddrModeAddress(
+                    addr_mode=t.AddrMode.NWK,
+                    address=dev.nwk,
+                ),
+                dst=t.AddrModeAddress(
+                    addr_mode=t.AddrMode.NWK,
+                    address=0x0000,
+                ),
+            ),
+        )
+
+    app.send_packet.side_effect = send_packet
+    dev.get_sequence = MagicMock(return_value=tsn)
+
+    rsp = await dev.endpoints[1].basic.reset_fact_default(timeout=0.01, retry_delay=0)
+    assert rsp == foundation.DefaultResponse(
+        command_id=Basic.ServerCommandDefs.reset_fact_default.id,
+        status=foundation.Status.SUCCESS,
+    )
+
+    assert len(app.send_packet.mock_calls) == 3
+
+
+async def test_request_retry_delay_releases_concurrency(app) -> None:
+    """A request awaiting its post-retry delay must not hold a concurrency slot."""
+    dev = app.add_device(nwk=0x1234, ieee=t.EUI64.convert("aa:bb:cc:dd:ee:ff:00:11"))
+
+    # Every send fails, so each request enters its (long) post-retry delay
+    app.send_packet.side_effect = zigpy.exceptions.DeliveryError("Failure")
+
+    async def make_request(sequence: int) -> None:
+        await dev.request(
+            profile=0x1234,
+            cluster=0x0006,
+            src_ep=1,
+            dst_ep=1,
+            sequence=sequence,
+            data=b"",
+            expect_reply=False,
+            retries=1,
+            retry_delay=10,
+        )
+
+    async with asyncio.TaskGroup() as tg:
+        tasks = [
+            tg.create_task(make_request(seq))
+            for seq in range(2 * device.MAX_DEVICE_CONCURRENCY)
+        ]
+
+        # Each request is now parked in a 10s post-retry delay. Even so, every one
+        # should still get its first attempt sent: the concurrency slot is released
+        # *before* the delay, not held during it.
+        async with asyncio.timeout(1):
+            while len(app.send_packet.mock_calls) < len(tasks):
+                await asyncio.sleep(0)
+
+        assert len(app.send_packet.mock_calls) == len(tasks)
+
+        # Tear down the still-pending requests so the task group can exit
+        for task in tasks:
+            task.cancel()

{zigpy-1.4.1 → zigpy-1.5.0}/tests/test_endpoint.py

@@ -175,6 +175,8 @@ async def test_reply_change_profile_id(ep):
             use_ieee=False,
             ask_for_ack=None,
             priority=None,
+            retries=None,
+            retry_delay=None,
         )
     ]
 
@@ -193,6 +195,8 @@ async def test_reply_change_profile_id(ep):
             use_ieee=False,
             ask_for_ack=None,
             priority=None,
+            retries=None,
+            retry_delay=None,
         )
     ]
 
@@ -212,6 +216,8 @@ async def test_reply_change_profile_id(ep):
             use_ieee=False,
             ask_for_ack=None,
             priority=None,
+            retries=None,
+            retry_delay=None,
         )
     ]
 

{zigpy-1.4.1 → zigpy-1.5.0}/tests/test_topology.py

@@ -47,7 +47,7 @@ def patch_device_tables(
     neighbors: list | BaseException | zdo_t.Status,
     routes: list | BaseException | zdo_t.Status,
 ):
-    def mgmt_lqi_req(StartIndex: t.uint8_t):
+    def mgmt_lqi_req(StartIndex: t.uint8_t, **kwargs):
         status = zdo_t.Status.SUCCESS
         entries = 0
         start_index = 0
@@ -73,7 +73,7 @@ def patch_device_tables(
             }.values()
         )
 
-    def mgmt_rtg_req(StartIndex: t.uint8_t):
+    def mgmt_rtg_req(StartIndex: t.uint8_t, **kwargs):
         status = zdo_t.Status.SUCCESS
         entries = 0
         start_index = 0

{zigpy-1.4.1 → zigpy-1.5.0}/tests/test_zcl.py

@@ -21,10 +21,12 @@ import zigpy.endpoint
 import zigpy.profiles.zha
 import zigpy.types as t
 from zigpy.zcl import (
+    MAX_ATTRIBUTE_RECORDS_BYTES,
     AttributeReadEvent,
     AttributeReportedEvent,
     AttributeUpdatedEvent,
     AttributeWrittenEvent,
+    _chunk_records_by_size,
     foundation,
 )
 from zigpy.zcl.clusters.general import Basic, OnOff, Ota
@@ -1612,6 +1614,8 @@ async def test_received_onoff_toggle_generates_default_response():
             use_ieee=False,
             ask_for_ack=None,
             priority=t.PacketPriority.LOW,
+            retries=None,
+            retry_delay=None,
         )
     ]
 
@@ -2401,6 +2405,200 @@ async def test_configure_reporting_multiple_manufacturer_groups(app_mock) -> Non
     assert manuf_call.args[0][0].reportable_change == 5
 
 
+async def test_configure_reporting_multiple_chunked_by_size(app_mock) -> None:
+    """Configure_reporting_multiple splits requests so no single one exceeds
+    MAX_ATTRIBUTE_RECORDS_BYTES of serialized records.
+    """
+
+    class TestCluster(Basic):
+        _skip_registry = True
+
+        class AttributeDefs(Basic.AttributeDefs):
+            # 6 uint8 attrs, each serializing to 9 bytes as a SendReports config
+            # (1 dir + 2 attrid + 1 type + 2 min + 2 max + 1 reportable_change).
+            # 6 * 9 = 54 bytes > 50, so the request must split into 2 chunks.
+            attr_a = foundation.ZCLAttributeDef(id=0xFF00, type=t.uint8_t)
+            attr_b = foundation.ZCLAttributeDef(id=0xFF01, type=t.uint8_t)
+            attr_c = foundation.ZCLAttributeDef(id=0xFF02, type=t.uint8_t)
+            attr_d = foundation.ZCLAttributeDef(id=0xFF03, type=t.uint8_t)
+            attr_e = foundation.ZCLAttributeDef(id=0xFF04, type=t.uint8_t)
+            attr_f = foundation.ZCLAttributeDef(id=0xFF05, type=t.uint8_t)
+
+    dev = add_initialized_device(app_mock, nwk=0x1234, ieee=make_ieee(1))
+    cluster = TestCluster(dev.endpoints[1])
+    dev.endpoints[1].add_input_cluster(TestCluster.cluster_id, cluster)
+
+    cfg_success = zcl.foundation.ConfigureReportingResponse(
+        [zcl.foundation.ConfigureReportingResponseRecord(zcl.foundation.Status.SUCCESS)]
+    )
+
+    cfg = ReportingConfig(min_interval=1, max_interval=2, reportable_change=3)
+    attrs = [
+        TestCluster.AttributeDefs.attr_a,
+        TestCluster.AttributeDefs.attr_b,
+        TestCluster.AttributeDefs.attr_c,
+        TestCluster.AttributeDefs.attr_d,
+        TestCluster.AttributeDefs.attr_e,
+        TestCluster.AttributeDefs.attr_f,
+    ]
+
+    with patch.object(
+        cluster,
+        "_configure_reporting",
+        new_callable=AsyncMock,
+        side_effect=[[cfg_success], [cfg_success]],
+    ) as mock_configure:
+        results = await cluster.configure_reporting_multiple(dict.fromkeys(attrs, cfg))
+
+    assert mock_configure.await_count == 2
+
+    sent_attrids = []
+    for call_obj in mock_configure.call_args_list:
+        chunk_configs = call_obj.args[0]
+        chunk_size = sum(len(c.serialize()) for c in chunk_configs)
+        assert chunk_size <= MAX_ATTRIBUTE_RECORDS_BYTES
+        sent_attrids.extend(c.attrid for c in chunk_configs)
+
+    assert sent_attrids == [a.id for a in attrs]
+
+    assert len(results) == 6
+    assert all(s == zcl.foundation.Status.SUCCESS for s in results.values())
+
+
+async def test_read_attributes_chunked_by_count(app_mock) -> None:
+    """Read_attributes splits requests into chunks of at most five."""
+
+    class TestCluster(Basic):
+        _skip_registry = True
+
+        class AttributeDefs(Basic.AttributeDefs):
+            attr_0 = foundation.ZCLAttributeDef(id=0xFF00, type=t.uint8_t)
+            attr_1 = foundation.ZCLAttributeDef(id=0xFF01, type=t.uint8_t)
+            attr_2 = foundation.ZCLAttributeDef(id=0xFF02, type=t.uint8_t)
+            attr_3 = foundation.ZCLAttributeDef(id=0xFF03, type=t.uint8_t)
+            attr_4 = foundation.ZCLAttributeDef(id=0xFF04, type=t.uint8_t)
+            attr_5 = foundation.ZCLAttributeDef(id=0xFF05, type=t.uint8_t)
+            attr_6 = foundation.ZCLAttributeDef(id=0xFF06, type=t.uint8_t)
+            attr_7 = foundation.ZCLAttributeDef(id=0xFF07, type=t.uint8_t)
+            attr_8 = foundation.ZCLAttributeDef(id=0xFF08, type=t.uint8_t)
+            attr_9 = foundation.ZCLAttributeDef(id=0xFF09, type=t.uint8_t)
+            attr_10 = foundation.ZCLAttributeDef(id=0xFF0A, type=t.uint8_t)
+
+    dev = add_initialized_device(app_mock, nwk=0x1234, ieee=make_ieee(1))
+    cluster = TestCluster(dev.endpoints[1])
+    dev.endpoints[1].add_input_cluster(TestCluster.cluster_id, cluster)
+
+    attrs = [getattr(TestCluster.AttributeDefs, f"attr_{i}") for i in range(11)]
+
+    # Exclude 2 and 7 so the mock returns UNSUPPORTED
+    supported = {attr: i for i, attr in enumerate(attrs) if i not in (2, 7)}
+    with mock_attribute_reads(cluster, supported) as (mock_read, _):
+        success, failure = await cluster.read_attributes(attrs)
+
+    # 11 attributes, at most MAX_READ_ATTRIBUTES_PER_REQ (5) per request -> 5 + 5 + 1
+    chunks = [call_obj.args[0] for call_obj in mock_read.call_args_list]
+    assert [len(chunk) for chunk in chunks] == [5, 5, 1]
+
+    # Every attribute was requested exactly once, in order, across the chunks
+    requested_ids = []
+    for chunk in chunks:
+        requested_ids.extend(chunk)
+    assert requested_ids == [attr.id for attr in attrs]
+
+    # Supported attributes succeed; the two omitted ones fail
+    assert success == supported
+    assert failure == {
+        attrs[2]: foundation.Status.UNSUPPORTED_ATTRIBUTE,
+        attrs[7]: foundation.Status.UNSUPPORTED_ATTRIBUTE,
+    }
+
+
+async def test_write_attributes_chunked_by_size(app_mock) -> None:
+    """Write_attributes splits requests if a single one would exceed the limit."""
+
+    class TestCluster(Basic):
+        _skip_registry = True
+
+        class AttributeDefs(Basic.AttributeDefs):
+            attr_a = foundation.ZCLAttributeDef(id=0xFF00, type=t.uint64_t)
+            attr_b = foundation.ZCLAttributeDef(id=0xFF01, type=t.uint64_t)
+            attr_c = foundation.ZCLAttributeDef(id=0xFF02, type=t.uint64_t)
+            attr_d = foundation.ZCLAttributeDef(id=0xFF03, type=t.uint64_t)
+            attr_e = foundation.ZCLAttributeDef(id=0xFF04, type=t.uint64_t)
+            attr_f = foundation.ZCLAttributeDef(id=0xFF05, type=t.uint64_t)
+
+    dev = add_initialized_device(app_mock, nwk=0x1234, ieee=make_ieee(1))
+    cluster = TestCluster(dev.endpoints[1])
+    dev.endpoints[1].add_input_cluster(TestCluster.cluster_id, cluster)
+
+    attrs = [
+        TestCluster.AttributeDefs.attr_a,
+        TestCluster.AttributeDefs.attr_b,
+        TestCluster.AttributeDefs.attr_c,
+        TestCluster.AttributeDefs.attr_d,
+        TestCluster.AttributeDefs.attr_e,
+        TestCluster.AttributeDefs.attr_f,
+    ]
+
+    with mock_attribute_writes(
+        cluster, dict.fromkeys(attrs, foundation.Status.SUCCESS)
+    ) as (mock_write, _):
+        [results] = await cluster.write_attributes(dict.fromkeys(attrs, 1))
+
+    # 6 records of 11 bytes each split into 2 chunks: 44 bytes + 22 bytes
+    assert mock_write.call_count == 2
+
+    sent_attrids = []
+    for call_obj in mock_write.call_args_list:
+        chunk_attrs = call_obj.args[0]
+        chunk_size = sum(len(a.serialize()) for a in chunk_attrs)
+        assert chunk_size <= MAX_ATTRIBUTE_RECORDS_BYTES
+        sent_attrids.extend(a.attrid for a in chunk_attrs)
+
+    assert sent_attrids == [attr.id for attr in attrs]
+
+    assert len(results) == 6
+    assert all(r.status == foundation.Status.SUCCESS for r in results)
+
+
+@pytest.mark.parametrize(
+    ("sizes", "max_bytes", "expected"),
+    [
+        # No records produces no chunks
+        ([], 10, []),
+        # Records that all fit stay in a single chunk
+        ([3, 3, 3], 10, [[3, 3, 3]]),
+        # Filling exactly to the limit does not start a new chunk
+        ([5, 5], 10, [[5, 5]]),
+        # A single record exactly at the limit is allowed
+        ([10], 10, [[10]]),
+        # Exceeding the limit rolls over into a new chunk
+        ([5, 5, 1], 10, [[5, 5], [1]]),
+    ],
+)
+def test_chunk_records_by_size(sizes, max_bytes, expected) -> None:
+    """The chunker packs records into chunks that never exceed max_bytes."""
+    chunks = _chunk_records_by_size(sizes, lambda size: size, max_bytes=max_bytes)
+    assert chunks == expected
+
+
+@pytest.mark.parametrize(
+    ("sizes", "max_bytes"),
+    [
+        # A single record larger than the limit, on its own
+        ([15], 10),
+        # An oversized record surrounded by ones that would otherwise fit
+        ([3, 15, 4], 10),
+    ],
+)
+def test_chunk_records_by_size_oversized_record(sizes, max_bytes) -> None:
+    """A record that on its own exceeds max_bytes can never be sent, so the chunker
+    fails loudly instead of emitting an oversized chunk the transport would reject.
+    """
+    with pytest.raises(ValueError, match="too large to fit in a single request"):
+        _chunk_records_by_size(sizes, lambda size: size, max_bytes=max_bytes)
+
+
 def test_manufacturer_id_override_manuf_specific_cluster(app_mock) -> None:
     """Test class-level `manufacturer_id_override` for custom clusters."""