mirror of
https://github.com/ChuckBuilds/LEDMatrix.git
synced 2026-10-04 06:15:09 +00:00
ChuckandClaude Opus 5.5
6bc13a8934
- Vegas: a live-priority pause was only lifted from inside run_frame(), which returns before that check while paused, so the ticker never came back until a restart. run_iteration() now resumes it (the controller only calls it when nothing preempts Vegas); start()/stop() clear the pause state. Iteration length is timed with the monotonic clock. - Dim schedule: a per-day disabled day now updates the minute-gate cache, so brightness no longer flips back to dim within each minute. - On-demand: a second request no longer overwrites the rotation resume index with the first request's mode. - Render pipeline: reset() drops the prepared group and deferred queue, and a prefetch in flight across a reset discards its result. - Sync: stop() removes the status file (and the controller's cleanup now calls it), standalone removes a stale one at startup, and writes use a unique mkstemp temp file. - render_gate.swap_releases_gil() delegates to frame_timing. - Stale docstrings/comments corrected. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
299 lines
11 KiB
Python
299 lines
11 KiB
Python
"""
|
|
Behavioral tests for DisplayController._check_schedule and
|
|
_check_dim_schedule — the on/off window and night-dimming logic.
|
|
|
|
test_display_controller_optimizations.py::TestScheduleMinuteGate already
|
|
covers the once-per-minute gating; this file covers what it doesn't:
|
|
midnight-crossing windows, mode selection (global / per-day / legacy
|
|
inference), per-day disabled days, invalid time strings, unknown
|
|
timezones, boundary equality, and the transition-tracking flags.
|
|
|
|
Both methods read only self.config and a handful of instance attributes,
|
|
so a bare stub via object.__new__ (the test_display_controller_vegas_tick
|
|
pattern) is enough — no managers needed.
|
|
"""
|
|
|
|
import os
|
|
from datetime import datetime
|
|
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
os.environ.setdefault("EMULATOR", "true")
|
|
|
|
from src.display_controller import DisplayController # noqa: E402
|
|
|
|
|
|
def make_controller(config=None, *, normal_brightness=90):
|
|
dc = object.__new__(DisplayController)
|
|
dc.config = config or {}
|
|
dc._tz = None
|
|
dc._schedule_checked_minute = None
|
|
dc.is_display_active = True
|
|
dc._was_display_active = True
|
|
dc._normal_brightness = normal_brightness
|
|
dc._dim_checked_minute = None
|
|
dc._cached_target_brightness = None
|
|
dc.is_dimmed = False
|
|
dc._was_dimmed = False
|
|
return dc
|
|
|
|
|
|
def at(time_str, day="monday"):
|
|
"""Context manager patching the controller module's clock."""
|
|
patcher = patch("src.display_controller.datetime")
|
|
mock_dt = patcher.start()
|
|
mock_dt.strptime = datetime.strptime
|
|
mock_dt.now.return_value.time.return_value = (
|
|
datetime.strptime(time_str, "%H:%M").time())
|
|
mock_dt.now.return_value.strftime.return_value.lower.return_value = day
|
|
mock_dt.now.return_value.hour = int(time_str.split(":")[0])
|
|
mock_dt.now.return_value.minute = int(time_str.split(":")[1])
|
|
return patcher
|
|
|
|
|
|
@pytest.fixture
|
|
def clock():
|
|
patchers = []
|
|
|
|
def _at(time_str, day="monday"):
|
|
patchers.append(p := at(time_str, day))
|
|
return p
|
|
|
|
yield _at
|
|
for p in patchers:
|
|
p.stop()
|
|
|
|
|
|
def check_at(dc, time_str, day="monday", clock=None):
|
|
"""Run _check_schedule at a mocked wall time, resetting the minute gate."""
|
|
dc._schedule_checked_minute = None
|
|
p = at(time_str, day)
|
|
try:
|
|
dc._check_schedule()
|
|
finally:
|
|
p.stop()
|
|
return dc.is_display_active
|
|
|
|
|
|
def dim_at(dc, time_str, day="monday"):
|
|
dc._dim_checked_minute = None
|
|
p = at(time_str, day)
|
|
try:
|
|
return dc._check_dim_schedule()
|
|
finally:
|
|
p.stop()
|
|
|
|
|
|
class TestScheduleWindows:
|
|
def _config(self, start, end, **extra):
|
|
return {"schedule": {"enabled": True, "start_time": start,
|
|
"end_time": end, **extra},
|
|
"timezone": "UTC"}
|
|
|
|
def test_same_day_window(self):
|
|
dc = make_controller(self._config("09:00", "17:00"))
|
|
assert check_at(dc, "12:00") is True
|
|
assert check_at(dc, "20:00") is False
|
|
assert check_at(dc, "08:59") is False
|
|
|
|
def test_boundaries_are_inclusive(self):
|
|
dc = make_controller(self._config("09:00", "17:00"))
|
|
assert check_at(dc, "09:00") is True # now == start
|
|
assert check_at(dc, "17:00") is True # now == end
|
|
|
|
def test_midnight_crossing_window(self):
|
|
# 21:00 -> 07:00: active late evening AND early morning, inactive
|
|
# mid-day.
|
|
dc = make_controller(self._config("21:00", "07:00"))
|
|
assert check_at(dc, "23:00") is True
|
|
assert check_at(dc, "03:00") is True
|
|
assert check_at(dc, "12:00") is False
|
|
assert check_at(dc, "21:00") is True # boundary
|
|
assert check_at(dc, "07:00") is True # boundary
|
|
|
|
def test_no_schedule_config_is_always_active(self):
|
|
dc = make_controller({"timezone": "UTC"})
|
|
dc.is_display_active = False
|
|
dc._check_schedule()
|
|
assert dc.is_display_active is True
|
|
|
|
def test_invalid_time_string_falls_back_to_active(self):
|
|
dc = make_controller(self._config("9 o'clock", "17:00"))
|
|
dc.is_display_active = False
|
|
assert check_at(dc, "03:00") is True # ValueError -> stay on
|
|
|
|
def test_unknown_timezone_falls_back_to_utc(self):
|
|
dc = make_controller({"schedule": {"enabled": True,
|
|
"start_time": "09:00",
|
|
"end_time": "17:00"},
|
|
"timezone": "Mars/Olympus_Mons"})
|
|
assert check_at(dc, "12:00") is True
|
|
import pytz
|
|
assert dc._tz is pytz.UTC
|
|
|
|
|
|
class TestScheduleModes:
|
|
DAYS = {
|
|
"monday": {"enabled": True, "start_time": "10:00",
|
|
"end_time": "18:00"},
|
|
"tuesday": {"enabled": False},
|
|
}
|
|
|
|
def test_global_mode_ignores_days(self):
|
|
dc = make_controller({"schedule": {
|
|
"enabled": True, "mode": "global",
|
|
"start_time": "09:00", "end_time": "17:00",
|
|
"days": self.DAYS}, "timezone": "UTC"})
|
|
# 09:30 is inside the global window but outside monday's per-day one.
|
|
assert check_at(dc, "09:30", day="monday") is True
|
|
|
|
def test_per_day_mode_uses_day_window(self):
|
|
dc = make_controller({"schedule": {
|
|
"enabled": True, "mode": "per-day",
|
|
"start_time": "09:00", "end_time": "17:00",
|
|
"days": self.DAYS}, "timezone": "UTC"})
|
|
assert check_at(dc, "09:30", day="monday") is False # before 10:00
|
|
assert check_at(dc, "12:00", day="monday") is True
|
|
|
|
def test_per_day_underscore_spelling_accepted(self):
|
|
dc = make_controller({"schedule": {
|
|
"enabled": True, "mode": "per_day",
|
|
"days": self.DAYS}, "timezone": "UTC"})
|
|
assert check_at(dc, "12:00", day="monday") is True
|
|
|
|
def test_legacy_no_mode_infers_per_day_from_days_config(self):
|
|
dc = make_controller({"schedule": {
|
|
"enabled": True,
|
|
"start_time": "09:00", "end_time": "17:00",
|
|
"days": self.DAYS}, "timezone": "UTC"})
|
|
assert check_at(dc, "09:30", day="monday") is False # per-day won
|
|
|
|
def test_per_day_disabled_day_turns_display_off(self):
|
|
dc = make_controller({"schedule": {
|
|
"enabled": True, "mode": "per-day",
|
|
"days": self.DAYS}, "timezone": "UTC"})
|
|
assert check_at(dc, "12:00", day="tuesday") is False
|
|
|
|
def test_per_day_missing_day_falls_back_to_global(self):
|
|
dc = make_controller({"schedule": {
|
|
"enabled": True, "mode": "per-day",
|
|
"start_time": "09:00", "end_time": "17:00",
|
|
"days": self.DAYS}, "timezone": "UTC"})
|
|
# Wednesday has no per-day entry -> global window applies.
|
|
assert check_at(dc, "09:30", day="wednesday") is True
|
|
|
|
def test_missing_enabled_key_means_enabled(self):
|
|
# Backward compat: schedules written before the enabled flag.
|
|
dc = make_controller({"schedule": {
|
|
"start_time": "09:00", "end_time": "17:00"}, "timezone": "UTC"})
|
|
assert check_at(dc, "20:00") is False
|
|
|
|
|
|
class TestScheduleTransitions:
|
|
def test_was_display_active_tracks_state(self):
|
|
dc = make_controller({"schedule": {"enabled": True,
|
|
"start_time": "09:00",
|
|
"end_time": "17:00"},
|
|
"timezone": "UTC"})
|
|
check_at(dc, "12:00")
|
|
assert dc._was_display_active is True
|
|
check_at(dc, "20:00")
|
|
assert dc._was_display_active is False
|
|
check_at(dc, "12:05")
|
|
assert dc._was_display_active is True
|
|
|
|
|
|
class TestDimSchedule:
|
|
def _config(self, start="20:00", end="07:00", **extra):
|
|
return {"dim_schedule": {"enabled": True, "start_time": start,
|
|
"end_time": end, "dim_brightness": 25,
|
|
**extra},
|
|
"timezone": "UTC"}
|
|
|
|
def test_disabled_by_default(self):
|
|
dc = make_controller({"dim_schedule": {"start_time": "20:00",
|
|
"end_time": "07:00"},
|
|
"timezone": "UTC"})
|
|
# Unlike the on/off schedule, dimming defaults to DISABLED when the
|
|
# enabled key is missing.
|
|
assert dim_at(dc, "23:00") == 90
|
|
assert dc.is_dimmed is False
|
|
|
|
def test_overnight_dim_window(self):
|
|
dc = make_controller(self._config())
|
|
assert dim_at(dc, "23:00") == 25
|
|
assert dc.is_dimmed is True
|
|
assert dim_at(dc, "03:00") == 25
|
|
assert dim_at(dc, "12:00") == 90
|
|
assert dc.is_dimmed is False
|
|
|
|
def test_dim_brightness_defaults_to_30(self):
|
|
dc = make_controller({"dim_schedule": {"enabled": True,
|
|
"start_time": "20:00",
|
|
"end_time": "07:00"},
|
|
"timezone": "UTC"})
|
|
assert dim_at(dc, "23:00") == 30
|
|
|
|
def test_inactive_display_short_circuits_undimmed(self):
|
|
dc = make_controller(self._config())
|
|
dc.is_display_active = False
|
|
dc.is_dimmed = True
|
|
assert dim_at(dc, "23:00") == 90
|
|
assert dc.is_dimmed is False
|
|
|
|
def test_per_day_mode(self):
|
|
dc = make_controller(self._config(mode="per-day", days={
|
|
"monday": {"enabled": True, "start_time": "22:00",
|
|
"end_time": "06:00"},
|
|
"tuesday": {"enabled": False},
|
|
}))
|
|
assert dim_at(dc, "23:00", day="monday") == 25
|
|
assert dim_at(dc, "21:00", day="monday") == 90 # before per-day start
|
|
assert dim_at(dc, "23:00", day="tuesday") == 90 # day disabled
|
|
assert dc.is_dimmed is False
|
|
|
|
def test_disabled_day_stays_normal_within_the_minute(self):
|
|
# Dim late Monday, then Tuesday (dimming disabled) begins. The second
|
|
# call in the same minute is served from the minute-gate cache, which
|
|
# the disabled-day branch used to leave holding Monday's dim value --
|
|
# so brightness flipped back to dim for the rest of every minute.
|
|
dc = make_controller(self._config(mode="per-day", days={
|
|
"monday": {"enabled": True, "start_time": "22:00",
|
|
"end_time": "06:00"},
|
|
"tuesday": {"enabled": False},
|
|
}))
|
|
assert dim_at(dc, "23:59", day="monday") == 25
|
|
dc._dim_checked_minute = None
|
|
p = at("00:00", day="tuesday")
|
|
try:
|
|
assert dc._check_dim_schedule() == 90
|
|
assert dc._check_dim_schedule() == 90 # cached, same minute
|
|
finally:
|
|
p.stop()
|
|
assert dc.is_dimmed is False
|
|
assert dc._was_dimmed is False
|
|
|
|
def test_no_legacy_inference_for_dim(self):
|
|
# Unlike _check_schedule, dim mode defaults to GLOBAL even when a
|
|
# days config exists — no legacy inference.
|
|
dc = make_controller(self._config(days={
|
|
"monday": {"enabled": True, "start_time": "22:00",
|
|
"end_time": "06:00"},
|
|
}))
|
|
# 21:00 is inside the global 20:00-07:00 window but outside monday's
|
|
# per-day 22:00 start; global mode wins.
|
|
assert dim_at(dc, "21:00", day="monday") == 25
|
|
|
|
def test_invalid_time_string_returns_normal(self):
|
|
dc = make_controller(self._config(start="late"))
|
|
assert dim_at(dc, "23:00") == 90
|
|
|
|
def test_was_dimmed_tracks_transitions(self):
|
|
dc = make_controller(self._config())
|
|
dim_at(dc, "23:00")
|
|
assert dc._was_dimmed is True
|
|
dim_at(dc, "12:00")
|
|
assert dc._was_dimmed is False
|