alexei.dolgolyov
17dd2e02ba
Multi-dimension review of v0.8.2. Excludes the deliberately deferred default_config.yaml weak-default-key item (C1). Backend: - calibration: create_default_calibration no longer exceeds led_count for small odd counts (bounded trim + regression test) - game-integration: generic webhook now requires auth_token; constant-time compare_digest in all adapters; per-IP failed-auth rate limit on the ingest route; auth_token encrypted at rest via secret_box (migration-safe) - playlist engine: serialize _state/_task under the lifecycle lock to close a delete-mid-play race (+ concurrency tests) - main: stop the calibration session on shutdown (restore prior target) - home_assistant: validate HA host via the LAN classifier on create/update - perf: drop slow preview-WS clients instead of blocking the send loop; cache composite full-strip resize linspaces; effect_stream lava reuses scratch Frontend: - setup/auto-calibration wizard: guard _state after awaits (cancel-safe), await session teardown before output start, busy-gate skip-calibration, manual display input keeps focus, move focus on step change - calibration: destroy EntitySelect on modal close - color-strips test: dirty-flag-gated render + cached ctx/ImageData - a11y/TV: focus-visible for new wizard/auto-cal/corner controls, aria-labels on the spatial corner/edge picker; theme-aware syntax tokens; dead/undefined CSS tokens removed; .modal-error styled; i18n titles (en/ru/zh) Android: - ApiKeyManager: EncryptedSharedPreferences with verified, data-safe legacy migration that never rotates an existing key - CaptureService: validate MediaProjection token before promoting; satisfy the startForeground 5s contract on the bail path - NotificationListener: connection-scoped executor with lazy fallback - BLE: request BLUETOOTH_SCAN/CONNECT at runtime + guard handler-thread SecurityExceptions - Root: cancellation-aware su grant probe Adds 14 tests. Gate: ruff + tsc 5.9.3 + esbuild + pytest (2185 passed) + compileDebugKotlin all green.
381 lines
11 KiB
Python
381 lines
11 KiB
Python
"""Tests for calibration system."""
|
|
|
|
import numpy as np
|
|
import pytest
|
|
|
|
from ledgrab.core.capture.calibration import (
|
|
CalibrationSegment,
|
|
CalibrationConfig,
|
|
PixelMapper,
|
|
create_default_calibration,
|
|
calibration_from_dict,
|
|
calibration_to_dict,
|
|
EDGE_ORDER,
|
|
EDGE_REVERSE,
|
|
)
|
|
from ledgrab.core.capture.screen_capture import BorderPixels
|
|
|
|
|
|
def test_calibration_segment():
|
|
"""Test calibration segment creation."""
|
|
segment = CalibrationSegment(
|
|
edge="top",
|
|
led_start=0,
|
|
led_count=40,
|
|
reverse=False,
|
|
)
|
|
|
|
assert segment.edge == "top"
|
|
assert segment.led_start == 0
|
|
assert segment.led_count == 40
|
|
assert segment.reverse is False
|
|
|
|
|
|
def test_calibration_config_validation():
|
|
"""Test calibration configuration validation."""
|
|
config = CalibrationConfig(
|
|
layout="clockwise",
|
|
start_position="bottom_left",
|
|
leds_bottom=40,
|
|
leds_right=30,
|
|
leds_top=40,
|
|
leds_left=40,
|
|
)
|
|
|
|
assert config.validate() is True
|
|
assert config.get_total_leds() == 150
|
|
|
|
|
|
def test_calibration_config_all_zero_leds():
|
|
"""Test validation fails when all LED counts are zero."""
|
|
config = CalibrationConfig(
|
|
layout="clockwise",
|
|
start_position="bottom_left",
|
|
)
|
|
|
|
with pytest.raises(ValueError, match="at least one LED"):
|
|
config.validate()
|
|
|
|
|
|
def test_calibration_config_negative_led_count():
|
|
"""Test validation fails with negative LED counts."""
|
|
config = CalibrationConfig(
|
|
layout="clockwise",
|
|
start_position="bottom_left",
|
|
leds_top=-5,
|
|
leds_bottom=40,
|
|
)
|
|
|
|
with pytest.raises(ValueError, match="non-negative"):
|
|
config.validate()
|
|
|
|
|
|
def test_get_segment_for_edge():
|
|
"""Test getting segment by edge name."""
|
|
config = CalibrationConfig(
|
|
layout="clockwise",
|
|
start_position="bottom_left",
|
|
leds_bottom=40,
|
|
leds_right=30,
|
|
)
|
|
|
|
bottom_seg = config.get_segment_for_edge("bottom")
|
|
assert bottom_seg is not None
|
|
assert bottom_seg.led_count == 40
|
|
|
|
missing_seg = config.get_segment_for_edge("top")
|
|
assert missing_seg is None
|
|
|
|
|
|
def test_build_segments_basic():
|
|
"""Test that build_segments produces correct output."""
|
|
config = CalibrationConfig(
|
|
layout="clockwise",
|
|
start_position="bottom_left",
|
|
leds_bottom=10,
|
|
leds_right=20,
|
|
leds_top=10,
|
|
leds_left=20,
|
|
)
|
|
|
|
segments = config.build_segments()
|
|
assert len(segments) == 4
|
|
|
|
# Clockwise from bottom_left: left(up), top(right), right(down), bottom(left)
|
|
assert segments[0].edge == "left"
|
|
assert segments[0].led_start == 0
|
|
assert segments[0].led_count == 20
|
|
assert segments[0].reverse is True
|
|
|
|
assert segments[1].edge == "top"
|
|
assert segments[1].led_start == 20
|
|
assert segments[1].led_count == 10
|
|
assert segments[1].reverse is False
|
|
|
|
assert segments[2].edge == "right"
|
|
assert segments[2].led_start == 30
|
|
assert segments[2].led_count == 20
|
|
assert segments[2].reverse is False
|
|
|
|
assert segments[3].edge == "bottom"
|
|
assert segments[3].led_start == 50
|
|
assert segments[3].led_count == 10
|
|
assert segments[3].reverse is True
|
|
|
|
|
|
def test_build_segments_skips_zero_edges():
|
|
"""Test that edges with 0 LEDs are skipped."""
|
|
config = CalibrationConfig(
|
|
layout="clockwise",
|
|
start_position="bottom_left",
|
|
leds_right=288,
|
|
leds_top=358,
|
|
leds_left=288,
|
|
)
|
|
|
|
segments = config.build_segments()
|
|
assert len(segments) == 3
|
|
edges = [s.edge for s in segments]
|
|
assert "bottom" not in edges
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"start_position,layout",
|
|
[
|
|
("bottom_left", "clockwise"),
|
|
("bottom_left", "counterclockwise"),
|
|
("bottom_right", "clockwise"),
|
|
("bottom_right", "counterclockwise"),
|
|
("top_left", "clockwise"),
|
|
("top_left", "counterclockwise"),
|
|
("top_right", "clockwise"),
|
|
("top_right", "counterclockwise"),
|
|
],
|
|
)
|
|
def test_build_segments_all_combinations(start_position, layout):
|
|
"""Test build_segments matches lookup tables for all 8 combinations."""
|
|
config = CalibrationConfig(
|
|
layout=layout,
|
|
start_position=start_position,
|
|
leds_top=10,
|
|
leds_right=10,
|
|
leds_bottom=10,
|
|
leds_left=10,
|
|
)
|
|
|
|
segments = config.build_segments()
|
|
assert len(segments) == 4
|
|
|
|
# Verify edge order matches EDGE_ORDER table
|
|
expected_order = EDGE_ORDER[(start_position, layout)]
|
|
actual_order = [s.edge for s in segments]
|
|
assert actual_order == expected_order
|
|
|
|
# Verify reverse flags match EDGE_REVERSE table
|
|
expected_reverse = EDGE_REVERSE[(start_position, layout)]
|
|
for seg in segments:
|
|
assert (
|
|
seg.reverse == expected_reverse[seg.edge]
|
|
), f"Mismatch for {start_position}/{layout}/{seg.edge}: expected reverse={expected_reverse[seg.edge]}"
|
|
|
|
# Verify led_start values are cumulative
|
|
expected_start = 0
|
|
for seg in segments:
|
|
assert seg.led_start == expected_start
|
|
expected_start += seg.led_count
|
|
|
|
|
|
def test_pixel_mapper_initialization():
|
|
"""Test pixel mapper initialization."""
|
|
config = create_default_calibration(150)
|
|
mapper = PixelMapper(config, interpolation_mode="average")
|
|
|
|
assert mapper.calibration == config
|
|
assert mapper.interpolation_mode == "average"
|
|
|
|
|
|
def test_pixel_mapper_invalid_mode():
|
|
"""Test pixel mapper with invalid interpolation mode."""
|
|
config = create_default_calibration(150)
|
|
|
|
with pytest.raises(ValueError):
|
|
PixelMapper(config, interpolation_mode="invalid")
|
|
|
|
|
|
def test_pixel_mapper_map_border_to_leds():
|
|
"""Test mapping border pixels to LED colors."""
|
|
config = create_default_calibration(40) # 10 per edge
|
|
mapper = PixelMapper(config)
|
|
|
|
# Create test border pixels (all red)
|
|
border_pixels = BorderPixels(
|
|
top=np.full((10, 100, 3), [255, 0, 0], dtype=np.uint8),
|
|
right=np.full((100, 10, 3), [0, 255, 0], dtype=np.uint8),
|
|
bottom=np.full((10, 100, 3), [0, 0, 255], dtype=np.uint8),
|
|
left=np.full((100, 10, 3), [255, 255, 0], dtype=np.uint8),
|
|
)
|
|
|
|
led_colors = mapper.map_border_to_leds(border_pixels)
|
|
|
|
assert led_colors.shape == (40, 3)
|
|
assert led_colors.dtype == np.uint8
|
|
|
|
# Verify colors are reasonable (allowing for some rounding)
|
|
# Bottom LEDs should be mostly blue
|
|
bottom_seg = config.get_segment_for_edge("bottom")
|
|
bottom_color = led_colors[bottom_seg.led_start]
|
|
assert bottom_color[2] > 200 # Blue channel high
|
|
|
|
# Top LEDs should be mostly red
|
|
top_seg = config.get_segment_for_edge("top")
|
|
top_color = led_colors[top_seg.led_start]
|
|
assert top_color[0] > 200 # Red channel high
|
|
|
|
|
|
def test_pixel_mapper_test_calibration():
|
|
"""Test calibration testing pattern."""
|
|
config = create_default_calibration(100)
|
|
mapper = PixelMapper(config)
|
|
|
|
# Test top edge
|
|
led_colors = mapper.test_calibration("top", (255, 0, 0))
|
|
|
|
assert len(led_colors) == 100
|
|
|
|
# Top edge should be lit (red)
|
|
top_segment = config.get_segment_for_edge("top")
|
|
top_leds = led_colors[top_segment.led_start : top_segment.led_start + top_segment.led_count]
|
|
assert all(color == (255, 0, 0) for color in top_leds)
|
|
|
|
# Other LEDs should be off
|
|
other_leds = led_colors[: top_segment.led_start]
|
|
assert all(color == (0, 0, 0) for color in other_leds)
|
|
|
|
|
|
def test_pixel_mapper_test_calibration_invalid_edge():
|
|
"""Test calibration testing with invalid edge."""
|
|
config = CalibrationConfig(
|
|
layout="clockwise",
|
|
start_position="bottom_left",
|
|
leds_bottom=40,
|
|
)
|
|
mapper = PixelMapper(config)
|
|
|
|
with pytest.raises(ValueError):
|
|
mapper.test_calibration("top", (255, 0, 0)) # Top not in config
|
|
|
|
|
|
def test_create_default_calibration():
|
|
"""Test creating default calibration."""
|
|
config = create_default_calibration(150)
|
|
|
|
assert config.layout == "clockwise"
|
|
assert config.start_position == "bottom_left"
|
|
assert len(config.segments) == 4
|
|
assert config.get_total_leds() == 150
|
|
|
|
# Check all edges have LEDs
|
|
assert config.leds_top > 0
|
|
assert config.leds_right > 0
|
|
assert config.leds_bottom > 0
|
|
assert config.leds_left > 0
|
|
|
|
# Check all edges are present in derived segments
|
|
edges = {seg.edge for seg in config.segments}
|
|
assert edges == {"top", "right", "bottom", "left"}
|
|
|
|
|
|
def test_create_default_calibration_small_count():
|
|
"""Test default calibration with small LED count."""
|
|
config = create_default_calibration(4)
|
|
assert config.get_total_leds() == 4
|
|
|
|
|
|
@pytest.mark.parametrize("led_count", [4, 5, 6, 7, 9, 11, 13, 60, 144, 300])
|
|
def test_create_default_calibration_total_matches_count(led_count):
|
|
"""Total LED count must equal led_count exactly, with every edge >= 1.
|
|
|
|
Regression for small odd counts where the per-edge max(1, ...) floor used
|
|
to push the total above led_count (e.g. led_count=5 produced a total of 6).
|
|
"""
|
|
config = create_default_calibration(led_count)
|
|
|
|
assert config.get_total_leds() == led_count
|
|
assert config.leds_top >= 1
|
|
assert config.leds_right >= 1
|
|
assert config.leds_bottom >= 1
|
|
assert config.leds_left >= 1
|
|
|
|
|
|
def test_create_default_calibration_invalid():
|
|
"""Test default calibration with invalid LED count."""
|
|
with pytest.raises(ValueError):
|
|
create_default_calibration(3) # Too few LEDs
|
|
|
|
|
|
def test_calibration_from_dict():
|
|
"""Test creating calibration from new format dictionary."""
|
|
data = {
|
|
"layout": "clockwise",
|
|
"start_position": "bottom_left",
|
|
"offset": 5,
|
|
"leds_top": 40,
|
|
"leds_right": 30,
|
|
"leds_bottom": 40,
|
|
"leds_left": 30,
|
|
}
|
|
|
|
config = calibration_from_dict(data)
|
|
|
|
assert config.layout == "clockwise"
|
|
assert config.start_position == "bottom_left"
|
|
assert config.offset == 5
|
|
assert config.leds_top == 40
|
|
assert config.leds_right == 30
|
|
assert config.leds_bottom == 40
|
|
assert config.leds_left == 30
|
|
assert config.get_total_leds() == 140
|
|
|
|
|
|
def test_calibration_from_dict_missing_field():
|
|
"""Test calibration from dict with missing field."""
|
|
data = {
|
|
"layout": "clockwise",
|
|
# Missing start_position
|
|
"leds_top": 10,
|
|
}
|
|
|
|
with pytest.raises(ValueError):
|
|
calibration_from_dict(data)
|
|
|
|
|
|
def test_calibration_to_dict():
|
|
"""Test converting calibration to dictionary."""
|
|
config = create_default_calibration(100)
|
|
data = calibration_to_dict(config)
|
|
|
|
assert "layout" in data
|
|
assert "start_position" in data
|
|
assert "leds_top" in data
|
|
assert "leds_right" in data
|
|
assert "leds_bottom" in data
|
|
assert "leds_left" in data
|
|
assert "segments" not in data
|
|
assert data["leds_top"] + data["leds_right"] + data["leds_bottom"] + data["leds_left"] == 100
|
|
|
|
|
|
def test_calibration_round_trip():
|
|
"""Test converting calibration to dict and back."""
|
|
original = create_default_calibration(120)
|
|
data = calibration_to_dict(original)
|
|
restored = calibration_from_dict(data)
|
|
|
|
assert restored.layout == original.layout
|
|
assert restored.start_position == original.start_position
|
|
assert restored.leds_top == original.leds_top
|
|
assert restored.leds_right == original.leds_right
|
|
assert restored.leds_bottom == original.leds_bottom
|
|
assert restored.leds_left == original.leds_left
|
|
assert restored.get_total_leds() == original.get_total_leds()
|
|
assert len(restored.segments) == len(original.segments)
|