lifx-emulator-core 3.1.0__tar.gz → 3.2.0__tar.gz

{lifx_emulator_core-3.1.0 → lifx_emulator_core-3.2.0}/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 <!-- version list -->
 
+## v3.2.0 (2026-02-02)
+
+### Bug Fixes
+
+- **tests**: Replace flaky probabilistic drop rate tests with deterministic mocks
+  ([`5070d6e`](https://github.com/Djelibeybi/lifx-emulator/commit/5070d6e88495dfeffaffb8f54f6eb5e6098d0f43))
+
+### Features
+
+- **core**: Wire partial_responses scenario through packet handlers
+  ([`a799dba`](https://github.com/Djelibeybi/lifx-emulator/commit/a799dba3f2d04501dd5b0694359e3e71e2ed5bbb))
+
+
+## v3.1.1 (2026-02-01)
+
+### Bug Fixes
+
+- **tests**: Relax timing threshold in test_no_delay_by_default
+  ([`dd1b416`](https://github.com/Djelibeybi/lifx-emulator/commit/dd1b4162e7b6111a13818aad0450f15367c7c9ac))
+
+
 ## v3.1.0 (2026-01-11)
 
 ### Features

{lifx_emulator_core-3.1.0 → lifx_emulator_core-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-emulator-core
-Version: 3.1.0
+Version: 3.2.0
 Summary: Core LIFX Emulator library for testing LIFX LAN protocol libraries
 Author-email: Avi Miller <me@dje.li>
 Maintainer-email: Avi Miller <me@dje.li>

{lifx_emulator_core-3.1.0 → lifx_emulator_core-3.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lifx-emulator-core"
-version = "3.1.0"
+version = "3.2.0"
 description = "Core LIFX Emulator library for testing LIFX LAN protocol libraries"
 readme = "README.md"
 requires-python = ">=3.10"

{lifx_emulator_core-3.1.0 → lifx_emulator_core-3.2.0}/src/lifx_emulator/devices/device.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import copy
 import logging
+import random
 import time
 from typing import Any
 
@@ -304,6 +305,24 @@ class EmulatedLifxDevice:
 
         # Handle specific packet types - handlers always return list
         response_packets = self._handle_packet_type(header, packet)
+
+        # Apply partial_responses: truncate multi-packet responses to random subset
+        if len(response_packets) > 1:
+            first_pkt = response_packets[0]
+            if (
+                hasattr(first_pkt, "PKT_TYPE")
+                and first_pkt.PKT_TYPE in scenario.partial_responses
+            ):
+                original_count = len(response_packets)
+                partial_count = random.randint(1, original_count - 1)  # nosec
+                response_packets = response_packets[:partial_count]
+                logger.info(
+                    "Sending partial response for packet type %s (%d of %d packets)",
+                    first_pkt.PKT_TYPE,
+                    partial_count,
+                    original_count,
+                )
+
         # Handlers now always return list (empty if no response)
         for resp_packet in response_packets:
             # Cache packed payload to avoid double packing (performance optimization)

{lifx_emulator_core-3.1.0 → lifx_emulator_core-3.2.0}/src/lifx_emulator/handlers/multizone_handlers.py

@@ -124,22 +124,26 @@ class ExtendedGetColorZonesHandler(PacketHandler):
         if not device_state.has_multizone:
             return []
 
-        colors_count = min(82, len(device_state.zone_colors))
-        colors = []
-        for i in range(colors_count):
-            colors.append(device_state.zone_colors[i])
-        # Pad to 82 colors
-        while len(colors) < 82:
-            colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
-
-        return [
-            MultiZone.ExtendedStateMultiZone(
-                count=device_state.zone_count,
-                index=0,
-                colors_count=colors_count,
-                colors=colors,
+        responses = []
+        index = 0
+        while index < device_state.zone_count:
+            end = min(index + 82, device_state.zone_count)
+            colors_count = end - index
+            colors = list(device_state.zone_colors[index:end])
+            # Pad to 82 colors
+            while len(colors) < 82:
+                colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
+            responses.append(
+                MultiZone.ExtendedStateMultiZone(
+                    count=device_state.zone_count,
+                    index=index,
+                    colors_count=colors_count,
+                    colors=colors,
+                )
             )
-        ]
+            index += 82
+
+        return responses
 
 
 class ExtendedSetColorZonesHandler(PacketHandler):

{lifx_emulator_core-3.1.0 → lifx_emulator_core-3.2.0}/src/lifx_emulator/handlers/tile_handlers.py

@@ -128,64 +128,71 @@ class Get64Handler(PacketHandler):
         if not device_state.has_matrix or not packet:
             return []
 
-        tile_index = packet.tile_index
         rect = packet.rect
+        length = max(1, packet.length)
 
-        if tile_index >= len(device_state.tile_devices):
-            return []
-
-        tile = device_state.tile_devices[tile_index]
-        tile_width = tile["width"]
-        tile_height = tile["height"]
-
-        # Get64 always returns framebuffer 0 (the visible buffer)
-        # regardless of which fb_index is in the request
-        tile_colors = tile["colors"]
-
-        # Calculate how many rows fit in 64 zones
-        rows_to_return = 64 // rect.width if rect.width > 0 else 1
-        rows_to_return = min(rows_to_return, tile_height - rect.y)
-
-        # Extract colors from the requested rectangle
-        colors = []
-        zones_extracted = 0
-
-        for row in range(rows_to_return):
-            y = rect.y + row
-            if y >= tile_height:
+        responses = []
+        for i in range(length):
+            idx = packet.tile_index + i
+            if idx >= len(device_state.tile_devices):
                 break
 
-            for col in range(rect.width):
-                x = rect.x + col
-                if x >= tile_width or zones_extracted >= 64:
-                    colors.append(
-                        LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
-                    )
+            tile = device_state.tile_devices[idx]
+            tile_width = tile["width"]
+            tile_height = tile["height"]
+
+            # Get64 always returns framebuffer 0 (the visible buffer)
+            # regardless of which fb_index is in the request
+            tile_colors = tile["colors"]
+
+            # Calculate how many rows fit in 64 zones
+            rows_to_return = 64 // rect.width if rect.width > 0 else 1
+            rows_to_return = min(rows_to_return, tile_height - rect.y)
+
+            # Extract colors from the requested rectangle
+            colors = []
+            zones_extracted = 0
+
+            for row in range(rows_to_return):
+                y = rect.y + row
+                if y >= tile_height:
+                    break
+
+                for col in range(rect.width):
+                    x = rect.x + col
+                    if x >= tile_width or zones_extracted >= 64:
+                        colors.append(
+                            LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+                        )
+                        zones_extracted += 1
+                        continue
+
+                    # Calculate zone index in flat color array
+                    zone_idx = y * tile_width + x
+                    if zone_idx < len(tile_colors):
+                        colors.append(tile_colors[zone_idx])
+                    else:
+                        colors.append(
+                            LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
+                        )
                     zones_extracted += 1
-                    continue
 
-                # Calculate zone index in flat color array
-                zone_idx = y * tile_width + x
-                if zone_idx < len(tile_colors):
-                    colors.append(tile_colors[zone_idx])
-                else:
-                    colors.append(
-                        LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500)
-                    )
-                zones_extracted += 1
-
-        # Pad to exactly 64 colors
-        while len(colors) < 64:
-            colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
-
-        # Return with fb_index forced to 0 (visible buffer)
-        return_rect = TileBufferRect(
-            fb_index=0,  # Always return FB0
-            x=rect.x,
-            y=rect.y,
-            width=rect.width,
-        )
-        return [Tile.State64(tile_index=tile_index, rect=return_rect, colors=colors)]
+            # Pad to exactly 64 colors
+            while len(colors) < 64:
+                colors.append(LightHsbk(hue=0, saturation=0, brightness=0, kelvin=3500))
+
+            # Return with fb_index forced to 0 (visible buffer)
+            return_rect = TileBufferRect(
+                fb_index=0,  # Always return FB0
+                x=rect.x,
+                y=rect.y,
+                width=rect.width,
+            )
+            responses.append(
+                Tile.State64(tile_index=idx, rect=return_rect, colors=colors)
+            )
+
+        return responses
 
 
 class Set64Handler(PacketHandler):

lifx_emulator_core-3.2.0/tests/test_partial_responses.py

@@ -0,0 +1,301 @@
+"""Tests for partial_responses, extended multizone >82 zones, and Get64 length."""
+
+from unittest.mock import patch
+
+from lifx_emulator.factories import create_multizone_light, create_tile_device
+from lifx_emulator.protocol.header import LifxHeader
+from lifx_emulator.protocol.packets import MultiZone, Tile
+from lifx_emulator.protocol.protocol_types import TileBufferRect
+from lifx_emulator.scenarios import HierarchicalScenarioManager, ScenarioConfig
+
+# --- Helpers ---
+
+
+def _make_header(device, pkt_type, res_required=True):
+    return LifxHeader(
+        source=1,
+        target=device.state.get_target_bytes(),
+        sequence=1,
+        pkt_type=pkt_type,
+        res_required=res_required,
+    )
+
+
+def _responses_of_type(responses, pkt_type):
+    return [r for r in responses if r[0].pkt_type == pkt_type]
+
+
+# --- Extended multizone fix tests ---
+
+
+class TestExtendedMultizoneMultiplePackets:
+    """ExtendedGetColorZonesHandler should return multiple packets for >82 zones."""
+
+    def test_120_zones_returns_two_packets(self):
+        device = create_multizone_light(
+            "d073d5100001", zone_count=120, extended_multizone=True
+        )
+        header = _make_header(device, 511)
+        responses = device.process_packet(header, None)
+
+        ext_responses = _responses_of_type(responses, 512)
+        assert len(ext_responses) == 2
+
+        _, pkt0 = ext_responses[0]
+        assert pkt0.index == 0
+        assert pkt0.colors_count == 82
+        assert pkt0.count == 120
+
+        _, pkt1 = ext_responses[1]
+        assert pkt1.index == 82
+        assert pkt1.colors_count == 38
+        assert pkt1.count == 120
+
+    def test_60_zones_returns_one_packet(self):
+        device = create_multizone_light(
+            "d073d5100002", zone_count=60, extended_multizone=True
+        )
+        header = _make_header(device, 511)
+        responses = device.process_packet(header, None)
+
+        ext_responses = _responses_of_type(responses, 512)
+        assert len(ext_responses) == 1
+        assert ext_responses[0][1].colors_count == 60
+
+    def test_82_zones_returns_one_packet(self):
+        device = create_multizone_light(
+            "d073d5100003", zone_count=82, extended_multizone=True
+        )
+        header = _make_header(device, 511)
+        responses = device.process_packet(header, None)
+
+        ext_responses = _responses_of_type(responses, 512)
+        assert len(ext_responses) == 1
+        assert ext_responses[0][1].colors_count == 82
+
+
+# --- Get64 length fix tests ---
+
+
+class TestGet64Length:
+    """Get64Handler should respect the length field."""
+
+    def test_length_1(self):
+        device = create_tile_device("d073d5200001", tile_count=5)
+        packet = Tile.Get64(
+            tile_index=0,
+            length=1,
+            rect=TileBufferRect(fb_index=0, x=0, y=0, width=8),
+        )
+        header = _make_header(device, 707)
+        responses = device.process_packet(header, packet)
+
+        tile_responses = _responses_of_type(responses, 711)
+        assert len(tile_responses) == 1
+        assert tile_responses[0][1].tile_index == 0
+
+    def test_length_3(self):
+        device = create_tile_device("d073d5200002", tile_count=5)
+        packet = Tile.Get64(
+            tile_index=0,
+            length=3,
+            rect=TileBufferRect(fb_index=0, x=0, y=0, width=8),
+        )
+        header = _make_header(device, 707)
+        responses = device.process_packet(header, packet)
+
+        tile_responses = _responses_of_type(responses, 711)
+        assert len(tile_responses) == 3
+        assert [r[1].tile_index for r in tile_responses] == [0, 1, 2]
+
+    def test_length_5_full_chain(self):
+        device = create_tile_device("d073d5200003", tile_count=5)
+        packet = Tile.Get64(
+            tile_index=0,
+            length=5,
+            rect=TileBufferRect(fb_index=0, x=0, y=0, width=8),
+        )
+        header = _make_header(device, 707)
+        responses = device.process_packet(header, packet)
+
+        tile_responses = _responses_of_type(responses, 711)
+        assert len(tile_responses) == 5
+        assert [r[1].tile_index for r in tile_responses] == [0, 1, 2, 3, 4]
+
+    def test_length_exceeds_chain(self):
+        device = create_tile_device("d073d5200004", tile_count=5)
+        packet = Tile.Get64(
+            tile_index=3,
+            length=5,
+            rect=TileBufferRect(fb_index=0, x=0, y=0, width=8),
+        )
+        header = _make_header(device, 707)
+        responses = device.process_packet(header, packet)
+
+        tile_responses = _responses_of_type(responses, 711)
+        assert len(tile_responses) == 2
+        assert [r[1].tile_index for r in tile_responses] == [3, 4]
+
+
+# --- Partial response tests ---
+
+
+class TestPartialResponsesMultizone:
+    """partial_responses should truncate multi-packet multizone responses."""
+
+    def test_standard_multizone_partial(self):
+        """120 zones = 15 StateMultiZone packets; partial should return 1..14."""
+        device = create_multizone_light("d073d5300001", zone_count=120)
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            "d073d5300001", ScenarioConfig(partial_responses=[506])
+        )
+        device.scenario_manager = scenario_manager
+        device.invalidate_scenario_cache()
+
+        packet = MultiZone.GetColorZones(start_index=0, end_index=119)
+        header = _make_header(device, 502)
+        responses = device.process_packet(header, packet)
+
+        mz_responses = _responses_of_type(responses, 506)
+        assert 1 <= len(mz_responses) < 15
+
+    def test_standard_multizone_no_partial(self):
+        """Without partial_responses, all 15 packets should be returned."""
+        device = create_multizone_light("d073d5300002", zone_count=120)
+        packet = MultiZone.GetColorZones(start_index=0, end_index=119)
+        header = _make_header(device, 502)
+        responses = device.process_packet(header, packet)
+
+        mz_responses = _responses_of_type(responses, 506)
+        assert len(mz_responses) == 15
+
+    def test_extended_multizone_partial(self):
+        """120 zones = 2 ExtendedStateMultiZone; partial should return 1."""
+        device = create_multizone_light(
+            "d073d5300003", zone_count=120, extended_multizone=True
+        )
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            "d073d5300003", ScenarioConfig(partial_responses=[512])
+        )
+        device.scenario_manager = scenario_manager
+        device.invalidate_scenario_cache()
+
+        header = _make_header(device, 511)
+        responses = device.process_packet(header, None)
+
+        ext_responses = _responses_of_type(responses, 512)
+        # 2 packets, partial -> exactly 1 (randint(1,1) = 1)
+        assert len(ext_responses) == 1
+
+    def test_extended_multizone_not_affected_by_standard_partial(self):
+        """partial_responses=[506] should not affect ExtendedStateMultiZone (512)."""
+        device = create_multizone_light(
+            "d073d5300004", zone_count=120, extended_multizone=True
+        )
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            "d073d5300004", ScenarioConfig(partial_responses=[506])
+        )
+        device.scenario_manager = scenario_manager
+        device.invalidate_scenario_cache()
+
+        header = _make_header(device, 511)
+        responses = device.process_packet(header, None)
+
+        ext_responses = _responses_of_type(responses, 512)
+        assert len(ext_responses) == 2
+
+
+class TestPartialResponsesTile:
+    """partial_responses should truncate multi-packet tile responses."""
+
+    def test_tile_partial(self):
+        """5 tiles = 5 State64 packets; partial should return 1..4."""
+        device = create_tile_device("d073d5400001", tile_count=5)
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            "d073d5400001", ScenarioConfig(partial_responses=[711])
+        )
+        device.scenario_manager = scenario_manager
+        device.invalidate_scenario_cache()
+
+        packet = Tile.Get64(
+            tile_index=0,
+            length=5,
+            rect=TileBufferRect(fb_index=0, x=0, y=0, width=8),
+        )
+        header = _make_header(device, 707)
+        responses = device.process_packet(header, packet)
+
+        tile_responses = _responses_of_type(responses, 711)
+        assert 1 <= len(tile_responses) < 5
+
+
+class TestPartialResponsesDeterministic:
+    """Verify partial truncation with mocked randomness."""
+
+    def test_deterministic_truncation(self):
+        """With randint mocked to return 3, should get exactly 3 packets."""
+        device = create_multizone_light("d073d5500001", zone_count=120)
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            "d073d5500001", ScenarioConfig(partial_responses=[506])
+        )
+        device.scenario_manager = scenario_manager
+        device.invalidate_scenario_cache()
+
+        packet = MultiZone.GetColorZones(start_index=0, end_index=119)
+        header = _make_header(device, 502)
+
+        with patch("lifx_emulator.devices.device.random.randint", return_value=3):
+            responses = device.process_packet(header, packet)
+
+        mz_responses = _responses_of_type(responses, 506)
+        assert len(mz_responses) == 3
+
+    def test_partial_coexists_with_other_scenarios(self):
+        """partial_responses should work alongside response_delays."""
+        device = create_multizone_light("d073d5500002", zone_count=120)
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            "d073d5500002",
+            ScenarioConfig(
+                partial_responses=[506],
+                response_delays={506: 0.01},
+            ),
+        )
+        device.scenario_manager = scenario_manager
+        device.invalidate_scenario_cache()
+
+        packet = MultiZone.GetColorZones(start_index=0, end_index=119)
+        header = _make_header(device, 502)
+
+        with patch("lifx_emulator.devices.device.random.randint", return_value=5):
+            responses = device.process_packet(header, packet)
+
+        mz_responses = _responses_of_type(responses, 506)
+        assert len(mz_responses) == 5
+
+    def test_randomness_varies(self):
+        """Without mocking, repeated runs should not all return the same count."""
+        device = create_multizone_light("d073d5500003", zone_count=120)
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            "d073d5500003", ScenarioConfig(partial_responses=[506])
+        )
+        device.scenario_manager = scenario_manager
+        device.invalidate_scenario_cache()
+
+        packet = MultiZone.GetColorZones(start_index=0, end_index=119)
+        header = _make_header(device, 502)
+
+        counts = set()
+        for _ in range(20):
+            responses = device.process_packet(header, packet)
+            mz_responses = _responses_of_type(responses, 506)
+            counts.add(len(mz_responses))
+
+        # With 14 possible values (1..14), 20 runs should produce >1 unique count
+        assert len(counts) > 1

{lifx_emulator_core-3.1.0 → lifx_emulator_core-3.2.0}/tests/test_scenario_manager.py

@@ -1,5 +1,7 @@
 """Tests for hierarchical scenario manager."""
 
+from unittest.mock import patch
+
 from lifx_emulator.factories import (
     create_color_light,
     create_multizone_light,
@@ -293,29 +295,40 @@ class TestScenarioManagerMethods:
             assert manager.should_respond(102, scenario) is False
         assert manager.should_respond(103, scenario) is True
 
-    def test_should_respond_probabilistic(self):
-        """Test probabilistic packet dropping."""
+    def test_should_respond_drops_below_threshold(self):
+        """Test that a random roll below the drop rate causes a drop."""
         manager = HierarchicalScenarioManager()
         scenario = ScenarioConfig(drop_packets={101: 0.5})
 
-        # With drop_rate=0.5, approximately 50% should be dropped
-        responses = [manager.should_respond(101, scenario) for _ in range(100)]
-        dropped = responses.count(False)
+        # random() returns 0.3, which is < 0.5 drop_rate → should drop
+        with patch("lifx_emulator.scenarios.manager.random.random", return_value=0.3):
+            assert manager.should_respond(101, scenario) is False
 
-        # Should be roughly 50%, allowing 30-70% range for randomness
-        assert 30 <= dropped <= 70
+    def test_should_respond_keeps_at_or_above_threshold(self):
+        """Test that a random roll at or above the drop rate keeps the packet."""
+        manager = HierarchicalScenarioManager()
+        scenario = ScenarioConfig(drop_packets={101: 0.5})
 
-    def test_should_respond_never_drop(self):
-        """Test with very low drop rate."""
+        # random() returns 0.5, which is >= 0.5 drop_rate → should keep
+        with patch("lifx_emulator.scenarios.manager.random.random", return_value=0.5):
+            assert manager.should_respond(101, scenario) is True
+
+        # random() returns 0.9, which is >= 0.5 drop_rate → should keep
+        with patch("lifx_emulator.scenarios.manager.random.random", return_value=0.9):
+            assert manager.should_respond(101, scenario) is True
+
+    def test_should_respond_boundary_with_low_drop_rate(self):
+        """Test boundary behavior with a low drop rate."""
         manager = HierarchicalScenarioManager()
         scenario = ScenarioConfig(drop_packets={101: 0.1})
 
-        # With drop_rate=0.1, approximately 10% should be dropped
-        responses = [manager.should_respond(101, scenario) for _ in range(100)]
-        dropped = responses.count(False)
+        # random() returns 0.09, which is < 0.1 → drop
+        with patch("lifx_emulator.scenarios.manager.random.random", return_value=0.09):
+            assert manager.should_respond(101, scenario) is False
 
-        # Should be roughly 10%, allowing 0-20% range for randomness
-        assert 0 <= dropped <= 20
+        # random() returns 0.1, which is >= 0.1 → keep
+        with patch("lifx_emulator.scenarios.manager.random.random", return_value=0.1):
+            assert manager.should_respond(101, scenario) is True
 
     def test_get_response_delay(self):
         """Test response delay retrieval."""

{lifx_emulator_core-3.1.0 → lifx_emulator_core-3.2.0}/tests/test_server.py

@@ -298,8 +298,8 @@ class TestResponseDelays:
         await server.handle_packet(packet_data, addr)
         elapsed = time.time() - start_time
 
-        # Should be very fast (< 10ms)
-        assert elapsed < 0.01
+        # Should be very fast (< 100ms, generous for CI runners)
+        assert elapsed < 0.1
 
 
 class TestServerLifecycle: