refactor: route all API endpoints through CommandBus + fix test fixtures

- Delete _led_route() anti-pattern; all 9 LED endpoints now dispatch
  through TrccApp.get().led_bus with typed commands (SetLEDModeCommand,
  ToggleLEDCommand, SetZoneSyncCommand, etc.)
- themes.py load_theme: direct load_theme_by_name() → LoadThemeByNameCommand
- devices.py select_device: direct load_last_theme() → RestoreLastThemeCommand
- display.py: remaining direct dispatcher calls replaced with bus dispatch

Tests:
- conftest.py: replace MagicMock(spec=CommandBus) with build_lcd_bus(mock_lcd)
  so fixtures return real CommandResult objects, not garbage MagicMocks
- test_api_buses.py: rewritten — resolution from FBL_PROFILES/SCSI_DEVICES,
  payload round-trip verified (not just call presence)
- test_api.py: wire _lcd_bus/_led_bus in all setUp methods that hit the bus;
  replace all hardcoded DeviceInfo(vid=0x0402) with _scsi_dev() helper
  derived from SCSI_DEVICES + FBL_PROFILES (single source of truth);
  fix assertions for LEDMode enum values, toggle_global(False), sync interval

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Lexonight1

src/trcc/api/devices.py

@@ -133,10 +133,14 @@ def select_device(device_id: int) -> dict:
             api.set_current_image(ImageService.solid_color(0, 0, 0, w_res, h_res))
 
             lcd.restore_device_settings()
-            result = lcd.load_last_theme()
-            if result.get("image"):
-                api.set_current_image(result["image"])
-                log.info("Restored last theme for preview")
+            try:
+                from trcc.core.commands.lcd import RestoreLastThemeCommand
+                result = TrccApp.get().lcd_bus.dispatch(RestoreLastThemeCommand()).payload
+                if result.get("image"):
+                    api.set_current_image(result["image"])
+                    log.info("Restored last theme for preview")
+            except RuntimeError:
+                pass
 
     # Mount static file directories for this device's resolution
     w, h = dev.resolution or (0, 0)

src/trcc/api/display.py

@@ -42,21 +42,6 @@ def _get_display():
     return _display_dispatcher
 
 
-def _display_frame_route(method: str, *args, **kwargs) -> dict:
-    """Route to lcd.frame capability, stop video/overlay first."""
-    from trcc.api import stop_overlay_loop, stop_video_playback
-
-    stop_video_playback()
-    stop_overlay_loop()
-    result = getattr(_get_display().frame, method)(*args, **kwargs)
-    return dispatch_result(result)
-
-
-def _display_settings_route(method: str, *args, **kwargs) -> dict:
-    """Route to lcd.settings capability."""
-    result = getattr(_get_display().settings, method)(*args, **kwargs)
-    return dispatch_result(result)
-
 
 @router.post("/color")
 def set_color(body: HexColorRequest) -> dict:
@@ -68,8 +53,8 @@ def set_color(body: HexColorRequest) -> dict:
     stop_video_playback()
     stop_overlay_loop()
     r, g, b = parse_hex_or_400(body.hex)
-    lcd = _get_display()
-    result = TrccApp.get().build_lcd_bus(lcd).dispatch(SendColorCommand(r=r, g=g, b=b))
+    _get_display()
+    result = TrccApp.get().lcd_bus.dispatch(SendColorCommand(r=r, g=g, b=b))
     return dispatch_result(result.payload)
 
 
@@ -79,8 +64,8 @@ def set_brightness(body: BrightnessRequest) -> dict:
     from trcc.core.app import TrccApp
     from trcc.core.commands.lcd import SetBrightnessCommand
 
-    lcd = _get_display()
-    result = TrccApp.get().build_lcd_bus(lcd).dispatch(SetBrightnessCommand(level=body.level))
+    _get_display()
+    result = TrccApp.get().lcd_bus.dispatch(SetBrightnessCommand(level=body.level))
     return dispatch_result(result.payload)
 
 
@@ -90,8 +75,8 @@ def set_rotation(body: RotationRequest) -> dict:
     from trcc.core.app import TrccApp
     from trcc.core.commands.lcd import SetRotationCommand
 
-    lcd = _get_display()
-    result = TrccApp.get().build_lcd_bus(lcd).dispatch(SetRotationCommand(degrees=body.degrees))
+    _get_display()
+    result = TrccApp.get().lcd_bus.dispatch(SetRotationCommand(degrees=body.degrees))
     return dispatch_result(result.payload)
 
 
@@ -101,15 +86,23 @@ def set_split(body: SplitRequest) -> dict:
     from trcc.core.app import TrccApp
     from trcc.core.commands.lcd import SetSplitModeCommand
 
-    lcd = _get_display()
-    result = TrccApp.get().build_lcd_bus(lcd).dispatch(SetSplitModeCommand(mode=body.mode))
+    _get_display()
+    result = TrccApp.get().lcd_bus.dispatch(SetSplitModeCommand(mode=body.mode))
     return dispatch_result(result.payload)
 
 
 @router.post("/reset")
 def reset_display() -> dict:
     """Reset device by sending solid red frame."""
-    return _display_frame_route("reset")
+    from trcc.api import stop_overlay_loop, stop_video_playback
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.lcd import ResetDisplayCommand
+
+    stop_video_playback()
+    stop_overlay_loop()
+    _get_display()
+    result = TrccApp.get().lcd_bus.dispatch(ResetDisplayCommand())
+    return dispatch_result(result.payload)
 
 
 @router.post("/mask")
@@ -118,7 +111,7 @@ async def load_mask(image: UploadFile) -> dict:
     import tempfile
     from pathlib import Path
 
-    lcd = _get_display()
+    _get_display()
 
     data = await image.read()
     if len(data) > 10 * 1024 * 1024:
@@ -130,8 +123,10 @@ async def load_mask(image: UploadFile) -> dict:
         tmp_path = tmp.name
 
     try:
-        result = lcd.load_mask_standalone(tmp_path)
-        return dispatch_result(result)
+        from trcc.core.app import TrccApp
+        from trcc.core.commands.lcd import LoadMaskCommand
+        result = TrccApp.get().lcd_bus.dispatch(LoadMaskCommand(mask_path=tmp_path))
+        return dispatch_result(result.payload)
     finally:
         Path(tmp_path).unlink(missing_ok=True)
 
@@ -153,12 +148,13 @@ async def render_overlay(dc_path: str, send: bool = True) -> dict:
     if not safe_path.startswith(allowed_dir + os.sep) and safe_path != allowed_dir:
         raise HTTPException(status_code=400, detail="Invalid overlay path")
 
-    import trcc.api as api
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.lcd import RenderOverlayFromDCCommand
 
-    lcd = _get_display()
-    metrics = api._system_svc.all_metrics if api._system_svc is not None else None
-    result = lcd.render_overlay_from_dc(safe_path, send=send, metrics=metrics)
-    return dispatch_result(result)
+    _get_display()
+    result = TrccApp.get().lcd_bus.dispatch(
+        RenderOverlayFromDCCommand(dc_path=safe_path, send=send))
+    return dispatch_result(result.payload)
 
 
 @router.get("/status")
@@ -252,11 +248,14 @@ def test_display() -> dict:
         (255, 255, 255, "White"),
     ]
 
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.lcd import SendColorCommand
     from trcc.services import ImageService
 
+    bus = TrccApp.get().lcd_bus
     for r, g, b, _name in colors:
         img = ImageService.solid_color(r, g, b, w, h)
-        lcd.frame.send_color(r, g, b)
+        bus.dispatch(SendColorCommand(r=r, g=g, b=b))
         time.sleep(1)
 
     # Update preview with last frame
@@ -406,10 +405,13 @@ async def create_theme(
         raise HTTPException(status_code=400, detail="Failed to open background image")
 
     if mask_path:
-        result = lcd.load_mask_standalone(str(mask_path))
-        if not result.get("success"):
-            raise HTTPException(status_code=400, detail=result.get("error", "Mask load failed"))
-        img = result.get("image", img)
+        from trcc.core.app import TrccApp
+        from trcc.core.commands.lcd import LoadMaskCommand
+        mask_result = TrccApp.get().lcd_bus.dispatch(
+            LoadMaskCommand(mask_path=str(mask_path))).payload
+        if not mask_result.get("success"):
+            raise HTTPException(status_code=400, detail=mask_result.get("error", "Mask load failed"))
+        img = mask_result.get("image", img)
 
     if overlay_config:
         from trcc.adapters.infra.dc_config import DcConfig
@@ -427,10 +429,10 @@ async def create_theme(
         api._overlay_svc = overlay_svc
         from trcc.services.system import get_all_metrics
         frame = overlay_svc.render(get_all_metrics())
-        lcd.frame.send_frame(frame)
+        lcd.send(frame)
         api.set_current_image(frame)
     else:
-        lcd.frame.send_frame(img)
+        lcd.send(img)
         api.set_current_image(img)
 
     return {"success": True, "animated": False, "resolution": f"{w}x{h}"}

src/trcc/api/led.py

@@ -32,11 +32,6 @@ def _get_led():
     return _led_dispatcher
 
 
-def _led_route(method: str, *args, **kwargs) -> dict:
-    """Generic: get LEDDevice, call method, return dispatch result."""
-    return dispatch_result(getattr(_get_led(), method)(*args, **kwargs))
-
-
 # ── Global operations ──────────────────────────────────────────────────
 
 @router.post("/color")
@@ -48,17 +43,28 @@ def set_color(body: HexColorRequest) -> dict:
 
     stop_led_loop()
     r, g, b = parse_hex_or_400(body.hex)
-    led = _get_led()
-    result = TrccApp.get().build_led_bus(led).dispatch(SetLEDColorCommand(r=r, g=g, b=b))
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(SetLEDColorCommand(r=r, g=g, b=b))
     return dispatch_result(result.payload)
 
 
 @router.post("/mode")
 def set_mode(body: ModeRequest) -> dict:
     """Set LED effect mode (static, breathing, colorful, rainbow, temp_linked, load_linked)."""
     from trcc.api import start_led_loop, stop_led_loop
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.led import SetLEDModeCommand
+    from trcc.core.models import LEDMode
 
-    result = _led_route("set_mode", body.mode)
+    _get_led()
+    try:
+        mode = LEDMode[body.mode.upper()]
+    except KeyError:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unknown mode '{body.mode}'. Choose: {', '.join(m.name.lower() for m in LEDMode)}",
+        )
+    result = dispatch_result(TrccApp.get().led_bus.dispatch(SetLEDModeCommand(mode=mode)).payload)
     if result.get("animated"):
         start_led_loop()
     else:
@@ -72,18 +78,22 @@ def set_brightness(body: LEDBrightnessRequest) -> dict:
     from trcc.core.app import TrccApp
     from trcc.core.commands.led import SetLEDBrightnessCommand
 
-    led = _get_led()
-    result = TrccApp.get().build_led_bus(led).dispatch(SetLEDBrightnessCommand(level=body.level))
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(SetLEDBrightnessCommand(level=body.level))
     return dispatch_result(result.payload)
 
 
 @router.post("/off")
 def turn_off() -> dict:
     """Turn LEDs off."""
     from trcc.api import stop_led_loop
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.led import ToggleLEDCommand
 
     stop_led_loop()
-    return _led_route("off")
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(ToggleLEDCommand(on=False))
+    return dispatch_result(result.payload)
 
 
 @router.post("/sensor")
@@ -92,8 +102,8 @@ def set_sensor(body: LEDSensorRequest) -> dict:
     from trcc.core.app import TrccApp
     from trcc.core.commands.led import SetLEDSensorSourceCommand
 
-    led = _get_led()
-    result = TrccApp.get().build_led_bus(led).dispatch(SetLEDSensorSourceCommand(source=body.source))
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(SetLEDSensorSourceCommand(source=body.source))
     return dispatch_result(result.payload)
 
 
@@ -106,53 +116,96 @@ def set_zone_color(zone: int, body: HexColorRequest) -> dict:
     from trcc.core.commands.led import SetZoneColorCommand
 
     r, g, b = parse_hex_or_400(body.hex)
-    led = _get_led()
-    result = TrccApp.get().build_led_bus(led).dispatch(SetZoneColorCommand(zone=zone, r=r, g=g, b=b))
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(SetZoneColorCommand(zone=zone, r=r, g=g, b=b))
     return dispatch_result(result.payload)
 
 
 @router.post("/zones/{zone}/mode")
 def set_zone_mode(zone: int, body: ModeRequest) -> dict:
     """Set effect mode for a specific LED zone."""
-    return _led_route("set_zone_mode", zone, body.mode)
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.led import SetZoneModeCommand
+    from trcc.core.models import LEDMode
+
+    _get_led()
+    try:
+        mode = LEDMode[body.mode.upper()]
+    except KeyError:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unknown mode '{body.mode}'. Choose: {', '.join(m.name.lower() for m in LEDMode)}",
+        )
+    result = TrccApp.get().led_bus.dispatch(SetZoneModeCommand(zone=zone, mode=mode))
+    return dispatch_result(result.payload)
 
 
 @router.post("/zones/{zone}/brightness")
 def set_zone_brightness(zone: int, body: LEDBrightnessRequest) -> dict:
     """Set brightness for a specific LED zone (0-100)."""
-    return _led_route("set_zone_brightness", zone, body.level)
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.led import SetZoneBrightnessCommand
+
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(SetZoneBrightnessCommand(zone=zone, level=body.level))
+    return dispatch_result(result.payload)
 
 
 @router.post("/zones/{zone}/toggle")
 def toggle_zone(zone: int, body: ToggleRequest) -> dict:
     """Toggle a specific LED zone on/off."""
-    return _led_route("toggle_zone", zone, body.on)
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.led import ToggleZoneCommand
+
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(ToggleZoneCommand(zone=zone, on=body.on))
+    return dispatch_result(result.payload)
 
 
 @router.post("/sync")
 def set_sync(body: ZoneSyncRequest) -> dict:
     """Enable/disable zone sync (circulate/select-all)."""
-    return _led_route("set_zone_sync", body.enabled, body.interval)
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.led import SetZoneSyncCommand
+
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(SetZoneSyncCommand(enabled=body.enabled, interval=body.interval or 0))
+    return dispatch_result(result.payload)
 
 
 # ── Segment operations ─────────────────────────────────────────────────
 
 @router.post("/segments/{index}/toggle")
 def toggle_segment(index: int, body: ToggleRequest) -> dict:
     """Toggle a specific LED segment on/off."""
-    return _led_route("toggle_segment", index, body.on)
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.led import ToggleSegmentCommand
+
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(ToggleSegmentCommand(index=index, on=body.on))
+    return dispatch_result(result.payload)
 
 
 @router.post("/clock")
 def set_clock(body: ClockFormatRequest) -> dict:
     """Set LED segment display clock format (12h/24h)."""
-    return _led_route("set_clock_format", body.is_24h)
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.led import SetClockFormatCommand
+
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(SetClockFormatCommand(is_24h=body.is_24h))
+    return dispatch_result(result.payload)
 
 
 @router.post("/temp-unit")
 def set_temp_unit(body: TempUnitRequest) -> dict:
     """Set LED segment display temperature unit (C/F)."""
-    return _led_route("set_temp_unit", body.unit)
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.led import SetTempUnitLEDCommand
+
+    _get_led()
+    result = TrccApp.get().led_bus.dispatch(SetTempUnitLEDCommand(unit=body.unit))
+    return dispatch_result(result.payload)
 
 
 # ── Test endpoint ─────────────────────────────────────────────────────

src/trcc/api/themes.py

@@ -237,7 +237,11 @@ def load_theme(body: ThemeLoadRequest) -> dict:
     if body.resolution:
         w, h = _parse_resolution(body.resolution)
 
-    result = api._display_dispatcher.load_theme_by_name(body.name, w, h)
+    from trcc.core.app import TrccApp
+    from trcc.core.commands.lcd import LoadThemeByNameCommand
+
+    result = TrccApp.get().lcd_bus.dispatch(
+        LoadThemeByNameCommand(name=body.name, width=w, height=h)).payload
     if not result.get("success"):
         return dispatch_result(result)