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

{lifx_emulator_core-3.2.0 → lifx_emulator_core-3.3.0}/.gitignore

@@ -92,3 +92,4 @@ Thumbs.db
 # Local storage
 .notes/
 .claude/settings.local.json
+.envrc

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

@@ -2,6 +2,19 @@
 
 <!-- version list -->
 
+## v3.3.0 (2026-02-03)
+
+### Bug Fixes
+
+- **device**: Apply error scenarios to unhandled-packet responses
+  ([`7571ab7`](https://github.com/Djelibeybi/lifx-emulator/commit/7571ab7a9d9833c1b79e0941d0d348c82ebcf34c))
+
+### Features
+
+- **server**: Send acks immediately before device processing
+  ([`3d4ec66`](https://github.com/Djelibeybi/lifx-emulator/commit/3d4ec66388099d2b672483cf85d47f100fe67549))
+
+
 ## v3.2.0 (2026-02-02)
 
 ### Bug Fixes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lifx-emulator-core
-Version: 3.2.0
+Version: 3.3.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.2.0 → lifx_emulator_core-3.3.0}/pyproject.toml

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

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

@@ -270,10 +270,8 @@ class EmulatedLifxDevice:
                 state_unhandled.PKT_TYPE,
                 len(unhandled_payload),
             )
-            responses.append((unhandled_header, state_unhandled))
-
-            # Still send acknowledgment if requested
-            if header.ack_required:
+            # Send ack before StateUnhandled when scenario controls ack behavior
+            if header.ack_required and scenario.affects_acks:
                 ack_packet = Device.Acknowledgement()
                 ack_payload = ack_packet.pack()
                 ack_header = self._create_response_header(
@@ -282,15 +280,18 @@ class EmulatedLifxDevice:
                     ack_packet.PKT_TYPE,
                     len(ack_payload),
                 )
-                responses.append((ack_header, ack_packet))
+                responses.append((ack_header, ack_packet, ack_payload))
 
-            return responses
+            responses.append((unhandled_header, state_unhandled, unhandled_payload))
+            return self._apply_error_scenarios(responses, scenario)
 
         # Update uptime
         self.state.uptime_ns = self.get_uptime_ns()
 
         # Handle acknowledgment (packet type 45, no payload)
-        if header.ack_required:
+        # Only generate ack here when a scenario targets ack behavior;
+        # otherwise the server sends the ack immediately before calling us.
+        if header.ack_required and scenario.affects_acks:
             ack_packet = Device.Acknowledgement()
             ack_payload = ack_packet.pack()
             ack_header = self._create_response_header(
@@ -336,16 +337,29 @@ class EmulatedLifxDevice:
             # Store both header and pre-packed payload for error scenario processing
             responses.append((resp_header, resp_packet, resp_payload))
 
-        # Apply error scenarios to responses
-        modified_responses = []
+        return self._apply_error_scenarios(responses, scenario)
+
+    def _apply_error_scenarios(
+        self,
+        responses: list[tuple],
+        scenario: ScenarioConfig,
+    ) -> list[tuple[LifxHeader, Any]]:
+        """Apply malformed/invalid-field error scenarios to response packets.
+
+        Args:
+            responses: List of (header, packet, payload) tuples
+            scenario: Resolved scenario config
+
+        Returns:
+            List of (header, packet) tuples with error scenarios applied
+        """
+        modified_responses: list[tuple[LifxHeader, Any]] = []
         for resp_header, resp_packet, resp_payload in responses:
             # Check if we should send malformed packet (truncate payload)
             if resp_header.pkt_type in scenario.malformed_packets:
-                # For malformed packets, truncate the pre-packed payload
                 truncated_len = len(resp_payload) // 2
                 resp_payload_modified = resp_payload[:truncated_len]
                 resp_header.size = LIFX_HEADER_SIZE + truncated_len + 10  # Wrong size
-                # Convert back to bytes for malformed case
                 modified_responses.append((resp_header, resp_payload_modified))
                 logger.info(
                     "Sending malformed packet type %s (truncated)", resp_header.pkt_type
@@ -354,7 +368,6 @@ class EmulatedLifxDevice:
 
             # Check if we should send invalid field values
             if resp_header.pkt_type in scenario.invalid_field_values:
-                # Corrupt the pre-packed payload
                 resp_payload_modified = b"\xff" * len(resp_payload)
                 modified_responses.append((resp_header, resp_payload_modified))
                 pkt_type = resp_header.pkt_type

{lifx_emulator_core-3.2.0 → lifx_emulator_core-3.3.0}/src/lifx_emulator/scenarios/models.py

@@ -6,6 +6,8 @@ of the application (domain, API, persistence, etc.).
 
 from pydantic import BaseModel, Field, field_validator
 
+ACK_PACKET_TYPE = 45
+
 
 class ScenarioConfig(BaseModel):
     """Scenario configuration for testing LIFX protocol behavior.
@@ -52,6 +54,16 @@ class ScenarioConfig(BaseModel):
         False, description="Send unhandled message responses for unknown packet types"
     )
 
+    @property
+    def affects_acks(self) -> bool:
+        """Whether this scenario configuration modifies acknowledgment behavior."""
+        return (
+            ACK_PACKET_TYPE in self.drop_packets
+            or ACK_PACKET_TYPE in self.response_delays
+            or ACK_PACKET_TYPE in self.malformed_packets
+            or ACK_PACKET_TYPE in self.invalid_field_values
+        )
+
     @field_validator("drop_packets", mode="before")
     @classmethod
     def convert_drop_packets_keys(cls, v):

{lifx_emulator_core-3.2.0 → lifx_emulator_core-3.3.0}/src/lifx_emulator/server.py

@@ -18,7 +18,7 @@ from lifx_emulator.devices import (
     PacketEvent,
 )
 from lifx_emulator.protocol.header import LifxHeader
-from lifx_emulator.protocol.packets import get_packet_class
+from lifx_emulator.protocol.packets import Device, get_packet_class
 from lifx_emulator.repositories import IScenarioStorageBackend
 from lifx_emulator.scenarios import HierarchicalScenarioManager
 
@@ -179,6 +179,54 @@ class EmulatedLifxServer:
                 # Fallback for edge case where loop not yet cached
                 asyncio.create_task(self.server.handle_packet(data, addr))
 
+    def _send_ack(
+        self,
+        device: EmulatedLifxDevice,
+        header: LifxHeader,
+        addr: tuple[str, int],
+    ) -> None:
+        """Send an acknowledgment packet immediately via UDP.
+
+        Args:
+            device: The device acknowledging the packet
+            header: Request header (source/sequence are copied)
+            addr: Client address (host, port)
+        """
+        ack_packet = Device.Acknowledgement()
+        ack_payload = ack_packet.pack()
+        ack_header = device._create_response_header(
+            header.source,
+            header.sequence,
+            ack_packet.PKT_TYPE,
+            len(ack_payload),
+        )
+        response_data = ack_header.pack() + ack_payload
+        if self.transport:
+            self.transport.sendto(response_data, addr)
+
+        self.packets_sent += 1
+        self.packets_sent_by_type[ack_header.pkt_type] += 1
+
+        logger.debug(
+            "→ TX %s to %s:%s (target=%s, seq=%s) [no fields]",
+            _get_packet_type_name(ack_header.pkt_type),
+            addr[0],
+            addr[1],
+            device.state.serial,
+            ack_header.sequence,
+        )
+
+        self.activity_observer.on_packet_sent(
+            PacketEvent(
+                timestamp=time.time(),
+                direction="tx",
+                packet_type=ack_header.pkt_type,
+                packet_name=_get_packet_type_name(ack_header.pkt_type),
+                addr=f"{addr[0]}:{addr[1]}",
+                device=device.state.serial,
+            )
+        )
+
     async def _process_device_packet(
         self,
         device: EmulatedLifxDevice,
@@ -194,10 +242,13 @@ class EmulatedLifxServer:
             packet: Parsed packet payload (or None)
             addr: Client address (host, port)
         """
-        responses = device.process_packet(header, packet)
-
-        # Get resolved scenario for response delays
+        # Send ack immediately before device processing when no scenario
+        # targets ack behavior (fast path for the common case)
         scenario = device._get_resolved_scenario()
+        if header.ack_required and not scenario.affects_acks:
+            self._send_ack(device, header, addr)
+
+        responses = device.process_packet(header, packet)
 
         # Send responses with delay if configured
         for resp_header, resp_packet in responses:

{lifx_emulator_core-3.2.0 → lifx_emulator_core-3.3.0}/tests/test_device.py

@@ -503,8 +503,12 @@ class TestTileHandlers:
 class TestAcknowledgment:
     """Test acknowledgment packet generation."""
 
-    def test_ack_required_generates_acknowledgment(self, color_device):
-        """Test ack_required flag generates Acknowledgement packet."""
+    def test_ack_not_generated_without_scenario(self, color_device):
+        """Test process_packet does not include ack when no scenario targets acks.
+
+        The server sends acks immediately before calling process_packet,
+        so the device should not include one in its response list.
+        """
         header = LifxHeader(
             source=12345,
             target=color_device.state.get_target_bytes(),
@@ -516,14 +520,75 @@ class TestAcknowledgment:
 
         responses = color_device.process_packet(header, None)
 
-        # Should have at least 2 responses: ACK + StatePower
+        # Should only have StatePower, no ACK (server handles ack)
+        assert len(responses) == 1
+        resp_header, resp_packet = responses[0]
+        assert resp_header.pkt_type == 22  # StatePower
+
+    def test_ack_generated_when_scenario_affects_acks(self, color_device):
+        """Test process_packet includes ack when scenario targets ack behavior."""
+        from lifx_emulator.scenarios import HierarchicalScenarioManager, ScenarioConfig
+
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            color_device.state.serial,
+            ScenarioConfig(response_delays={45: 1.0}),
+        )
+        color_device.scenario_manager = scenario_manager
+        color_device.invalidate_scenario_cache()
+
+        header = LifxHeader(
+            source=12345,
+            target=color_device.state.get_target_bytes(),
+            sequence=1,
+            pkt_type=20,  # GetPower
+            ack_required=True,
+            res_required=True,
+        )
+
+        responses = color_device.process_packet(header, None)
+
+        # Should have ACK + StatePower
         assert len(responses) >= 2
+        ack_header, ack_packet = responses[0]
+        assert ack_header.pkt_type == 45
+        assert isinstance(ack_packet, Device.Acknowledgement)
+
+    def test_ack_generated_for_unhandled_packet_when_scenario_affects_acks(
+        self, color_device
+    ):
+        """Test ACK included for unsupported packets when scenario targets acks."""
+        from lifx_emulator.scenarios import HierarchicalScenarioManager, ScenarioConfig
+
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            color_device.state.serial,
+            ScenarioConfig(response_delays={45: 1.0}),
+        )
+        color_device.scenario_manager = scenario_manager
+        color_device.invalidate_scenario_cache()
+
+        header = LifxHeader(
+            source=12345,
+            target=color_device.state.get_target_bytes(),
+            sequence=1,
+            pkt_type=501,  # MultiZone.GetColorZones — unsupported on color device
+            ack_required=True,
+            res_required=True,
+        )
+
+        responses = color_device.process_packet(header, None)
 
-        # First response should be ACK
+        # Should have ACK followed by StateUnhandled
+        assert len(responses) == 2
         ack_header, ack_packet = responses[0]
         assert ack_header.pkt_type == 45
         assert isinstance(ack_packet, Device.Acknowledgement)
 
+        unhandled_header, unhandled_packet = responses[1]
+        assert unhandled_header.pkt_type == 223  # StateUnhandled
+        assert unhandled_packet.unhandled_type == 501
+
     def test_no_ack_when_not_required(self, color_device):
         """Test no ACK when ack_required is False."""
         header = LifxHeader(

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

@@ -442,3 +442,42 @@ class TestDeviceIntegration:
 
         assert 101 in scenario.drop_packets
         assert 102 in scenario.drop_packets
+
+
+class TestAffectsAcks:
+    """Test ScenarioConfig.affects_acks property."""
+
+    def test_default_does_not_affect_acks(self):
+        """Test default ScenarioConfig does not affect acks."""
+        config = ScenarioConfig()
+        assert config.affects_acks is False
+
+    def test_drop_packets_with_ack_type(self):
+        """Test affects_acks when ack type 45 is in drop_packets."""
+        config = ScenarioConfig(drop_packets={45: 1.0})
+        assert config.affects_acks is True
+
+    def test_response_delays_with_ack_type(self):
+        """Test affects_acks when ack type 45 is in response_delays."""
+        config = ScenarioConfig(response_delays={45: 0.5})
+        assert config.affects_acks is True
+
+    def test_malformed_packets_with_ack_type(self):
+        """Test affects_acks when ack type 45 is in malformed_packets."""
+        config = ScenarioConfig(malformed_packets=[45])
+        assert config.affects_acks is True
+
+    def test_invalid_field_values_with_ack_type(self):
+        """Test affects_acks when ack type 45 is in invalid_field_values."""
+        config = ScenarioConfig(invalid_field_values=[45])
+        assert config.affects_acks is True
+
+    def test_other_packet_types_do_not_affect_acks(self):
+        """Test affects_acks is False when other types are configured but not 45."""
+        config = ScenarioConfig(
+            drop_packets={101: 1.0},
+            response_delays={107: 0.5},
+            malformed_packets=[102],
+            invalid_field_values=[103],
+        )
+        assert config.affects_acks is False

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

@@ -568,3 +568,128 @@ class TestSequenceHandling:
         sent_data, _ = server.transport.sendto.call_args[0]
         resp_header = LifxHeader.unpack(sent_data)
         assert resp_header.source == 99999
+
+
+class TestServerAckBehavior:
+    """Test server sends acks immediately before device processing."""
+
+    @pytest.mark.asyncio
+    async def test_ack_sent_first_before_handler_response(self, color_device):
+        """Test ack is the first sendto call when ack_required=True."""
+        from lifx_emulator.constants import HEADER_SIZE
+        from lifx_emulator.protocol.packets import Light
+        from lifx_emulator.protocol.protocol_types import LightHsbk
+
+        device_manager = DeviceManager(DeviceRepository())
+        server = EmulatedLifxServer([color_device], device_manager, "127.0.0.1", 56700)
+
+        color = LightHsbk(hue=10000, saturation=65535, brightness=50000, kelvin=3500)
+        set_color_packet = Light.SetColor(color=color, duration=0)
+        payload = set_color_packet.pack()
+
+        header = LifxHeader(
+            size=HEADER_SIZE + len(payload),
+            source=12345,
+            target=color_device.state.get_target_bytes(),
+            sequence=1,
+            pkt_type=102,  # SetColor
+            ack_required=True,
+            res_required=True,
+        )
+
+        packet_data = header.pack() + payload
+        addr = ("127.0.0.1", 56700)
+
+        server.transport = Mock()
+        server.transport.sendto = Mock()
+
+        await server.handle_packet(packet_data, addr)
+
+        # First sendto call should be the ack (type 45)
+        assert server.transport.sendto.call_count >= 2
+        first_call_data = server.transport.sendto.call_args_list[0][0][0]
+        first_resp_header = LifxHeader.unpack(first_call_data)
+        assert first_resp_header.pkt_type == 45  # Acknowledgement
+
+        # Second call should be the handler response (StateColor = 107)
+        second_call_data = server.transport.sendto.call_args_list[1][0][0]
+        second_resp_header = LifxHeader.unpack(second_call_data)
+        assert second_resp_header.pkt_type == 107  # StateColor
+
+    @pytest.mark.asyncio
+    async def test_server_does_not_send_ack_when_scenario_affects_acks(
+        self, color_device
+    ):
+        """Test server skips ack when scenario targets ack behavior."""
+        from lifx_emulator.scenarios.manager import (
+            HierarchicalScenarioManager,
+            ScenarioConfig,
+        )
+
+        scenario_manager = HierarchicalScenarioManager()
+        scenario_manager.set_device_scenario(
+            color_device.state.serial,
+            ScenarioConfig(response_delays={45: 0.0}),  # Targets ack type
+        )
+
+        device_manager = DeviceManager(DeviceRepository())
+        server = EmulatedLifxServer(
+            [color_device],
+            device_manager,
+            "127.0.0.1",
+            56700,
+            scenario_manager=scenario_manager,
+        )
+
+        header = LifxHeader(
+            source=12345,
+            target=color_device.state.get_target_bytes(),
+            sequence=1,
+            pkt_type=20,  # GetPower
+            ack_required=True,
+            res_required=True,
+        )
+
+        packet_data = header.pack()
+        addr = ("127.0.0.1", 56700)
+
+        server.transport = Mock()
+        server.transport.sendto = Mock()
+
+        await server.handle_packet(packet_data, addr)
+
+        # All responses should come from device.process_packet()
+        # The first should be the ack (device handles it when scenario targets acks)
+        assert server.transport.sendto.call_count >= 2
+        first_call_data = server.transport.sendto.call_args_list[0][0][0]
+        first_resp_header = LifxHeader.unpack(first_call_data)
+        assert first_resp_header.pkt_type == 45  # Ack from device
+
+    @pytest.mark.asyncio
+    async def test_no_ack_when_not_required(self, color_device):
+        """Test no ack is sent when ack_required=False."""
+        device_manager = DeviceManager(DeviceRepository())
+        server = EmulatedLifxServer([color_device], device_manager, "127.0.0.1", 56700)
+
+        header = LifxHeader(
+            source=12345,
+            target=color_device.state.get_target_bytes(),
+            sequence=1,
+            pkt_type=23,  # GetLabel
+            ack_required=False,
+            res_required=True,
+        )
+
+        packet_data = header.pack()
+        addr = ("127.0.0.1", 56700)
+
+        server.transport = Mock()
+        server.transport.sendto = Mock()
+
+        await server.handle_packet(packet_data, addr)
+
+        # Should have exactly 1 response (StateLabel), no ack
+        assert server.transport.sendto.call_count == 1
+        sent_data = server.transport.sendto.call_args_list[0][0][0]
+        resp_header = LifxHeader.unpack(sent_data)
+        assert resp_header.pkt_type == 25  # StateLabel

{lifx_emulator_core-3.2.0 → lifx_emulator_core-3.3.0}/tests/test_switch_devices.py

@@ -167,8 +167,12 @@ class TestSwitchStateUnhandled:
         assert resp_packet.PKT_TYPE == 223  # StateUnhandled
         assert resp_packet.unhandled_type == 102  # SetColor was rejected
 
-    def test_switch_returns_state_unhandled_with_ack(self):
-        """Test switch returns both StateUnhandled and Acknowledgement."""
+    def test_switch_returns_state_unhandled_without_ack(self):
+        """Test switch returns only StateUnhandled when no scenario targets acks.
+
+        The server sends acks before calling process_packet, so the device
+        should not include one in its response list by default.
+        """
         switch = create_switch("d073d7000001")
 
         header = LifxHeader(
@@ -184,17 +188,11 @@ class TestSwitchStateUnhandled:
 
         responses = switch.process_packet(header, None)
 
-        # Should get both StateUnhandled and Acknowledgement
-        assert len(responses) == 2
-
-        # First response: StateUnhandled
-        resp_header1, resp_packet1 = responses[0]
-        assert resp_packet1.PKT_TYPE == 223  # StateUnhandled
-        assert resp_packet1.unhandled_type == 101
-
-        # Second response: Acknowledgement
-        resp_header2, resp_packet2 = responses[1]
-        assert resp_packet2.PKT_TYPE == 45  # Acknowledgement
+        # Should get only StateUnhandled (server handles ack)
+        assert len(responses) == 1
+        resp_header, resp_packet = responses[0]
+        assert resp_packet.PKT_TYPE == 223  # StateUnhandled
+        assert resp_packet.unhandled_type == 101
 
     def test_switch_handles_device_packets_normally(self):
         """Test switch handles Device.* packets without StateUnhandled."""
@@ -321,7 +319,7 @@ class TestSwitchEdgeCases:
             tagged=False,
             pkt_type=101,  # Light.GetColor
             size=36,
-            ack_required=True,
+            ack_required=False,
             res_required=True,
         )