"""ZonePlayer + Engine: frames reach pixel outputs, presets reach ESP32 drivers.""" import asyncio import pytest from engine.core import Engine, EngineError from engine.outputs.base import FrameOutput from engine.pattern_loader import PatternLibrary from engine.player import ZonePlayer from engine.zone_targets import ZoneTargets, resolve_zone LIB = PatternLibrary() class RecordingOutput(FrameOutput): protocol = "test" keepalive_s = 0.2 def __init__(self, cfg): super().__init__(cfg) self.sent = [] self.levels = [] self.closed = False async def send(self, rgb, global_brightness=255): self.levels.append(global_brightness) await super().send(rgb, global_brightness) async def _send_prepared(self, payload): self.sent.append(payload) async def close(self): await super().close() self.closed = True class RecordingDriver: kind = "preset" def __init__(self, names): self.names = names self.applied = [] self.closed = False async def apply(self, preset_id, payload): self.applied.append((preset_id, payload)) async def close(self): self.closed = True def status(self): return {"name": ",".join(self.names), "kind": "preset", "frames": len(self.applied), "packets": 0, "errors": 0, "last_error": None} def make_player(cfgs, drivers=(), brightness=255): made = {"outputs": [], "driver": None} def output_factory(cfg): out = RecordingOutput(cfg) made["outputs"].append(out) return out def driver_factory(names): made["driver"] = RecordingDriver(names) return made["driver"] targets = ZoneTargets("z1", cfgs, list(drivers)) player = ZonePlayer(targets, LIB, lambda: brightness, output_factory=output_factory, driver_factory=driver_factory) return player, made def test_frames_split_per_output_offset_and_brightness(): async def go(): player, made = make_player( [{"name": "a", "pixel_count": 2, "fps": 60}, {"name": "b", "pixel_count": 1, "pixel_offset": 2, "color_order": "grb", "fps": 60}], brightness=128, ) assert player.targets.frame_length == 3 await player.start() await player.apply("1", {"p": "on", "c": ["#ff8000"], "b": 255}) await asyncio.sleep(0.15) await player.stop() return made made = asyncio.run(go()) a, b = made["outputs"] assert a.sent[0] == bytes((128, 64, 0)) * 2 assert b.sent[0] == bytes((64, 128, 0)) # grb assert set(a.levels[:-1]) == {128} # last send is the black frame from close() assert a.closed and b.closed and a.sent[-1] == bytes(6) # black on stop def test_animated_pattern_streams_and_keepalive_resends_static(): async def go(): player, made = make_player([{"name": "a", "pixel_count": 8, "fps": 60}]) await player.start() await player.apply("1", {"p": "rainbow", "c": [], "d": 10, "b": 255, "n1": 8}) await asyncio.sleep(0.4) rainbow_frames = len(made["outputs"][0].sent) await player.apply("2", {"p": "on", "c": ["#00ff00"], "b": 255}) await asyncio.sleep(0.1) before = len(made["outputs"][0].sent) await asyncio.sleep(0.5) # static frame -> keepalive resends (0.2 s) after = len(made["outputs"][0].sent) await player.stop() return rainbow_frames, before, after, made rainbow_frames, before, after, made = asyncio.run(go()) assert rainbow_frames >= 10 assert after - before >= 2 assert made["outputs"][0].sent[before] == bytes((0, 255, 0)) * 8 def test_mixed_zone_drives_esp32_and_pixels_together(): async def go(): player, made = make_player([{"name": "ddp", "pixel_count": 4}], drivers=["dj"]) await player.start() await player.apply("7", {"p": "on", "c": ["#ffffff"], "b": 255}) await asyncio.sleep(0.1) status = player.status() await player.stop() return made, status made, status = asyncio.run(go()) assert made["driver"].applied == [("7", {"p": "on", "c": ["#ffffff"], "b": 255})] assert made["outputs"][0].sent assert status["preset_id"] == "7" and len(status["outputs"]) == 2 assert made["driver"].closed def test_drivers_false_skips_esp32(): async def go(): player, made = make_player([{"name": "ddp", "pixel_count": 1}], drivers=["dj"]) await player.start() await player.apply("1", {"p": "on", "c": ["#ffffff"], "b": 255}, drivers=False) await asyncio.sleep(0.05) await player.stop() return made made = asyncio.run(go()) assert made["driver"].applied == [] and made["outputs"][0].sent def test_driver_only_zone_has_no_render_thread(): async def go(): player, made = make_player([], drivers=["roof"]) await player.start() await player.apply("1", {"p": "rainbow"}) await player.stop() return player, made player, made = asyncio.run(go()) assert player.renderer is None and made["driver"].applied # -- Engine -------------------------------------------------------------------- class FakeZones(dict): def read(self, id): return self.get(str(id)) class FakeOutputs(dict): def by_name(self, name): return [o for o in self.values() if o.get("name") == name] def test_resolve_zone_splits_outputs_and_drivers(): zones = FakeZones({"1": {"names": ["roof", "wall", "wall", "dj"]}}) outputs = FakeOutputs({ "1": {"id": "1", "name": "wall", "pixel_count": 100, "enabled": True}, "2": {"id": "2", "name": "wall", "pixel_count": 50, "pixel_offset": 100, "enabled": True}, "3": {"id": "3", "name": "dj", "pixel_count": 10, "enabled": False}, }) t = resolve_zone("1", zones, outputs) assert [c["id"] for c in t.frame_cfgs] == ["1", "2"] assert t.driver_names == ["roof", "dj"] # disabled output falls back to device name assert t.frame_length == 150 assert resolve_zone("9", zones, outputs) is None def make_engine(targets_by_zone, payloads): created = [] def factory(targets, library, brightness): player, made = make_player(targets.frame_cfgs, targets.driver_names) created.append((player, made)) return player eng = Engine( library=LIB, zone_resolver=lambda zid: targets_by_zone.get(zid), payload_resolver=lambda pid: payloads.get(pid), player_factory=factory, sequences_model=FakeSequences(), ) return eng, created class FakeSequences(dict): def read(self, id): return self.get(str(id)) def update(self, id, data): if str(id) not in self: return False self[str(id)].update(data) return True def list(self): return list(self.keys()) def test_engine_play_reuses_player_and_rebuilds_on_target_change(): targets = {"1": ZoneTargets("1", [{"name": "a", "pixel_count": 2}], ["dj"])} payloads = {"10": {"p": "on", "c": ["#ff0000"]}, "11": {"p": "off"}} async def go(): eng, created = make_engine(targets, payloads) await eng.play("1", "10") await eng.play("1", "11") assert len(created) == 1 targets["1"] = ZoneTargets("1", [{"name": "a", "pixel_count": 3}], ["dj"]) await eng.play("1", "10") assert len(created) == 2 and created[0][1]["outputs"][0].closed with pytest.raises(EngineError): await eng.play("1", "missing") with pytest.raises(EngineError): await eng.play("nozone", "10") status = eng.status() assert status["zones"]["1"]["preset_id"] == "10" assert await eng.stop("1") is True assert eng.status()["zones"] == {} await eng.stop_all() return created created = asyncio.run(go()) assert [p for p, _ in created[0][1]["driver"].applied] == ["10", "11"]