mirror of
https://github.com/kuhyx/testsAndMisc.git
synced 2026-07-04 18:23:07 +02:00
Krzysztof kuhy Rudnicki
f6b6995b0e
- C/lichess_random_engine, vocabulary_curve, misc/split, 1dvelocitysimulator, opening_learner: test suites added - CPP/miscelanious: tests added - TS/battery-status, champions_leauge_scores, two-inputs: tests added - python_pkg/fm24_searcher, wake_alarm: new packages added - Fix ruff/cppcheck/eslint/clang-format failures - Update .gitignore for C/C++ build artifacts
720 lines
22 KiB
Python
720 lines
22 KiB
Python
"""Tests for _alarm.py — wake alarm daemon, UI, and beep logic."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import tkinter as tk
|
|
from typing import TYPE_CHECKING
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Generator
|
|
|
|
from python_pkg.wake_alarm._alarm import (
|
|
WakeAlarm,
|
|
_beep_loud,
|
|
_beep_medium,
|
|
_beep_soft,
|
|
_generate_code,
|
|
_is_alarm_day,
|
|
_should_run_alarm,
|
|
_speaker_test_path,
|
|
main,
|
|
)
|
|
from python_pkg.wake_alarm._constants import (
|
|
DISMISS_CODE_LENGTH,
|
|
PHASE_MEDIUM_END,
|
|
PHASE_SOFT_END,
|
|
)
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _make_mock_tk() -> MagicMock:
|
|
"""Build a MagicMock that stands in for the tkinter module."""
|
|
mock = MagicMock()
|
|
mock_root = MagicMock()
|
|
mock_root.winfo_screenwidth.return_value = 1920
|
|
mock_root.winfo_screenheight.return_value = 1080
|
|
mock.Tk.return_value = mock_root
|
|
mock.Frame.return_value = MagicMock()
|
|
mock.Label.return_value = MagicMock()
|
|
mock.Entry.return_value = MagicMock()
|
|
mock.TclError = tk.TclError
|
|
mock.END = tk.END
|
|
return mock
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _block_real_tk() -> Generator[MagicMock]:
|
|
"""Prevent any real Tk windows in tests."""
|
|
mock = _make_mock_tk()
|
|
with patch("python_pkg.wake_alarm._alarm.tk", mock):
|
|
yield mock
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_tk_module() -> Generator[MagicMock]:
|
|
"""Provide explicit access to the mocked tk module."""
|
|
mock = _make_mock_tk()
|
|
with patch("python_pkg.wake_alarm._alarm.tk", mock):
|
|
yield mock
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Unit tests for pure functions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestGenerateCode:
|
|
"""Tests for _generate_code."""
|
|
|
|
def test_correct_length(self) -> None:
|
|
"""Generated code has the configured length."""
|
|
code = _generate_code()
|
|
assert len(code) == DISMISS_CODE_LENGTH
|
|
|
|
def test_all_digits(self) -> None:
|
|
"""Generated code contains only digits."""
|
|
code = _generate_code()
|
|
assert code.isdigit()
|
|
|
|
def test_different_codes(self) -> None:
|
|
"""Two calls produce different codes (probabilistic, but safe)."""
|
|
codes = {_generate_code() for _ in range(50)}
|
|
assert len(codes) > 1
|
|
|
|
|
|
class TestIsAlarmDay:
|
|
"""Tests for _is_alarm_day."""
|
|
|
|
def test_monday_is_alarm_day(self) -> None:
|
|
"""Monday (weekday=0) is an alarm day."""
|
|
from datetime import datetime
|
|
|
|
# Create a date that is Monday
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.datetime",
|
|
) as mock_dt:
|
|
mock_now = MagicMock()
|
|
mock_now.weekday.return_value = 0 # Monday
|
|
mock_dt.now.return_value = mock_now
|
|
mock_dt.side_effect = datetime
|
|
assert _is_alarm_day() is True
|
|
|
|
def test_tuesday_is_not_alarm_day(self) -> None:
|
|
"""Tuesday (weekday=1) is NOT an alarm day."""
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.datetime",
|
|
) as mock_dt:
|
|
mock_now = MagicMock()
|
|
mock_now.weekday.return_value = 1 # Tuesday
|
|
mock_dt.now.return_value = mock_now
|
|
assert _is_alarm_day() is False
|
|
|
|
def test_friday_is_alarm_day(self) -> None:
|
|
"""Friday (weekday=4) is an alarm day."""
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.datetime",
|
|
) as mock_dt:
|
|
mock_now = MagicMock()
|
|
mock_now.weekday.return_value = 4 # Friday
|
|
mock_dt.now.return_value = mock_now
|
|
assert _is_alarm_day() is True
|
|
|
|
def test_saturday_is_alarm_day(self) -> None:
|
|
"""Saturday (weekday=5) is an alarm day."""
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.datetime",
|
|
) as mock_dt:
|
|
mock_now = MagicMock()
|
|
mock_now.weekday.return_value = 5
|
|
mock_dt.now.return_value = mock_now
|
|
assert _is_alarm_day() is True
|
|
|
|
def test_sunday_is_alarm_day(self) -> None:
|
|
"""Sunday (weekday=6) is an alarm day."""
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.datetime",
|
|
) as mock_dt:
|
|
mock_now = MagicMock()
|
|
mock_now.weekday.return_value = 6
|
|
mock_dt.now.return_value = mock_now
|
|
assert _is_alarm_day() is True
|
|
|
|
def test_wednesday_is_not_alarm_day(self) -> None:
|
|
"""Wednesday (weekday=2) is NOT an alarm day."""
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.datetime",
|
|
) as mock_dt:
|
|
mock_now = MagicMock()
|
|
mock_now.weekday.return_value = 2
|
|
mock_dt.now.return_value = mock_now
|
|
assert _is_alarm_day() is False
|
|
|
|
|
|
class TestSpeakerTestPath:
|
|
"""Tests for _speaker_test_path."""
|
|
|
|
def test_returns_path_when_found(self) -> None:
|
|
"""Return full path when speaker-test is available."""
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.shutil.which",
|
|
return_value="/usr/bin/speaker-test",
|
|
):
|
|
assert _speaker_test_path() == "/usr/bin/speaker-test"
|
|
|
|
def test_raises_when_not_found(self) -> None:
|
|
"""Raise FileNotFoundError when speaker-test is missing."""
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm.shutil.which",
|
|
return_value=None,
|
|
),
|
|
pytest.raises(FileNotFoundError, match="speaker-test not found"),
|
|
):
|
|
_speaker_test_path()
|
|
|
|
|
|
class TestBeepFunctions:
|
|
"""Tests for beep helper functions."""
|
|
|
|
def test_beep_soft_writes_bell(self) -> None:
|
|
"""_beep_soft writes terminal bell character."""
|
|
with patch("python_pkg.wake_alarm._alarm.sys") as mock_sys:
|
|
mock_sys.stdout = MagicMock()
|
|
_beep_soft()
|
|
mock_sys.stdout.write.assert_called_once_with("\a")
|
|
mock_sys.stdout.flush.assert_called_once()
|
|
|
|
def test_beep_medium_calls_speaker_test(self) -> None:
|
|
"""_beep_medium runs speaker-test subprocess."""
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._speaker_test_path",
|
|
return_value="/usr/bin/speaker-test",
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm.subprocess.run",
|
|
) as mock_run,
|
|
):
|
|
_beep_medium(frequency=800)
|
|
mock_run.assert_called_once()
|
|
args = mock_run.call_args[0][0]
|
|
assert "/usr/bin/speaker-test" in args
|
|
assert "800" in args
|
|
|
|
def test_beep_medium_falls_back_on_error(self) -> None:
|
|
"""_beep_medium falls back to soft beep on OSError."""
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._speaker_test_path",
|
|
return_value="/usr/bin/speaker-test",
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm.subprocess.run",
|
|
side_effect=OSError("no speaker-test"),
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._beep_soft",
|
|
) as mock_soft,
|
|
):
|
|
_beep_medium()
|
|
mock_soft.assert_called_once()
|
|
|
|
def test_beep_medium_falls_back_on_timeout(self) -> None:
|
|
"""_beep_medium falls back on TimeoutExpired."""
|
|
from subprocess import TimeoutExpired
|
|
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._speaker_test_path",
|
|
return_value="/usr/bin/speaker-test",
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm.subprocess.run",
|
|
side_effect=TimeoutExpired("cmd", 3),
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._beep_soft",
|
|
) as mock_soft,
|
|
):
|
|
_beep_medium()
|
|
mock_soft.assert_called_once()
|
|
|
|
def test_beep_medium_falls_back_on_missing_binary(self) -> None:
|
|
"""_beep_medium falls back when speaker-test binary not found."""
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._speaker_test_path",
|
|
side_effect=FileNotFoundError("not found"),
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._beep_soft",
|
|
) as mock_soft,
|
|
):
|
|
_beep_medium()
|
|
mock_soft.assert_called_once()
|
|
|
|
def test_beep_loud_calls_speaker_test(self) -> None:
|
|
"""_beep_loud runs speaker-test subprocess."""
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._speaker_test_path",
|
|
return_value="/usr/bin/speaker-test",
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm.subprocess.run",
|
|
) as mock_run,
|
|
):
|
|
_beep_loud(frequency=1200)
|
|
mock_run.assert_called_once()
|
|
args = mock_run.call_args[0][0]
|
|
assert "1200" in args
|
|
|
|
def test_beep_loud_falls_back_on_error(self) -> None:
|
|
"""_beep_loud falls back to soft beep on OSError."""
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._speaker_test_path",
|
|
return_value="/usr/bin/speaker-test",
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm.subprocess.run",
|
|
side_effect=OSError("fail"),
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._beep_soft",
|
|
) as mock_soft,
|
|
):
|
|
_beep_loud()
|
|
mock_soft.assert_called_once()
|
|
|
|
def test_beep_loud_falls_back_on_missing_binary(self) -> None:
|
|
"""_beep_loud falls back when speaker-test binary not found."""
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._speaker_test_path",
|
|
side_effect=FileNotFoundError("not found"),
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._beep_soft",
|
|
) as mock_soft,
|
|
):
|
|
_beep_loud()
|
|
mock_soft.assert_called_once()
|
|
|
|
|
|
class TestShouldRunAlarm:
|
|
"""Tests for _should_run_alarm."""
|
|
|
|
def test_returns_false_on_non_alarm_day(self) -> None:
|
|
"""Return False when today is not an alarm day."""
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm._is_alarm_day",
|
|
return_value=False,
|
|
):
|
|
assert _should_run_alarm() is False
|
|
|
|
def test_returns_false_when_already_dismissed(self) -> None:
|
|
"""Return False when alarm was already dismissed today."""
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._is_alarm_day",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm.was_alarm_dismissed_today",
|
|
return_value=True,
|
|
),
|
|
):
|
|
assert _should_run_alarm() is False
|
|
|
|
def test_returns_true_when_alarm_day_and_not_dismissed(self) -> None:
|
|
"""Return True when today is alarm day and not yet dismissed."""
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._is_alarm_day",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm.was_alarm_dismissed_today",
|
|
return_value=False,
|
|
),
|
|
):
|
|
assert _should_run_alarm() is True
|
|
|
|
|
|
class TestWakeAlarmInit:
|
|
"""Tests for WakeAlarm initialization."""
|
|
|
|
def test_demo_mode_sets_smaller_window(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Demo mode creates a smaller window."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
assert alarm.demo_mode is True
|
|
assert alarm.dismissed is False
|
|
alarm._stop_beep.set() # Stop beep thread
|
|
|
|
def test_production_mode_fullscreen(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Production mode activates fullscreen."""
|
|
alarm = WakeAlarm(demo_mode=False)
|
|
assert alarm.demo_mode is False
|
|
mock_root = mock_tk_module.Tk.return_value
|
|
mock_root.overrideredirect.assert_called_once()
|
|
alarm._stop_beep.set()
|
|
|
|
|
|
class TestWakeAlarmDismiss:
|
|
"""Tests for alarm dismiss logic."""
|
|
|
|
def test_correct_code_dismisses(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Entering the correct code dismisses the alarm."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
code = alarm._current_code
|
|
mock_entry = mock_tk_module.Entry.return_value
|
|
mock_entry.get.return_value = code
|
|
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.save_wake_state",
|
|
) as mock_save:
|
|
alarm._on_submit()
|
|
|
|
assert alarm.dismissed is True
|
|
mock_save.assert_called_once()
|
|
call_kwargs = mock_save.call_args[1]
|
|
assert call_kwargs["skip_workout"] is True
|
|
alarm._stop_beep.set()
|
|
|
|
def test_wrong_code_does_not_dismiss(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Entering the wrong code shows error without dismissing."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
mock_entry = mock_tk_module.Entry.return_value
|
|
mock_entry.get.return_value = "000000"
|
|
# Ensure current code is different
|
|
alarm._current_code = "123456"
|
|
|
|
alarm._on_submit()
|
|
|
|
assert alarm.dismissed is False
|
|
alarm._stop_beep.set()
|
|
|
|
def test_dismiss_window_expired(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Window expiry saves state with no skip."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.save_wake_state",
|
|
) as mock_save:
|
|
alarm._on_dismiss_window_expired()
|
|
|
|
assert alarm.dismissed is False
|
|
mock_save.assert_called_once_with(
|
|
dismissed_at=None,
|
|
skip_workout=False,
|
|
)
|
|
alarm._stop_beep.set()
|
|
|
|
def test_dismiss_window_expired_noop_if_already_dismissed(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Expiry is a no-op if already dismissed."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
alarm.dismissed = True
|
|
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.save_wake_state",
|
|
) as mock_save:
|
|
alarm._on_dismiss_window_expired()
|
|
|
|
mock_save.assert_not_called()
|
|
alarm._stop_beep.set()
|
|
|
|
|
|
class TestMain:
|
|
"""Tests for the main() entry point."""
|
|
|
|
def test_exits_when_not_alarm_day(self) -> None:
|
|
"""main() returns early when not an alarm day."""
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm._should_run_alarm",
|
|
return_value=False,
|
|
):
|
|
main() # Should just return without error
|
|
|
|
def test_creates_alarm_when_should_run(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""main() creates a WakeAlarm when conditions are met."""
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._should_run_alarm",
|
|
return_value=True,
|
|
),
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm.sys",
|
|
) as mock_sys,
|
|
patch.object(WakeAlarm, "run") as mock_run,
|
|
patch.object(WakeAlarm, "__init__", return_value=None),
|
|
):
|
|
mock_sys.argv = []
|
|
main()
|
|
mock_run.assert_called_once()
|
|
|
|
|
|
class TestCodeRefreshAndTimer:
|
|
"""Tests for code refresh and timer update methods."""
|
|
|
|
def test_code_refresh_changes_code(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Code refresh generates a new code."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
# Call refresh many times — at least one should differ
|
|
codes = set()
|
|
for _ in range(50):
|
|
alarm._schedule_code_refresh()
|
|
codes.add(alarm._current_code)
|
|
assert len(codes) > 1
|
|
alarm._stop_beep.set()
|
|
|
|
def test_code_refresh_noop_when_dismissed(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Code refresh is a no-op after dismissal."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
alarm.dismissed = True
|
|
old_code = alarm._current_code
|
|
alarm._schedule_code_refresh()
|
|
# Code doesn't change because dismissed=True causes early return
|
|
assert alarm._current_code == old_code
|
|
alarm._stop_beep.set()
|
|
|
|
def test_update_timer_noop_when_dismissed(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Timer update is a no-op after dismissal."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
alarm.dismissed = True
|
|
alarm._update_timer() # Should not raise
|
|
alarm._stop_beep.set()
|
|
|
|
|
|
class TestBeepLoop:
|
|
"""Tests for the beep loop thread."""
|
|
|
|
def test_beep_loop_stops_on_event(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Beep loop exits when stop event is set."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
alarm._stop_beep.set()
|
|
# Loop should exit immediately
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm._beep_soft",
|
|
):
|
|
alarm._beep_loop()
|
|
alarm._stop_beep.set()
|
|
|
|
|
|
class TestCloseAndFallback:
|
|
"""Tests for close and fallback scheduling."""
|
|
|
|
def test_close_stops_beep_and_destroys(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""_close sets stop event and destroys root."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
alarm._close()
|
|
assert alarm._stop_beep.is_set()
|
|
alarm.root.destroy.assert_called()
|
|
|
|
def test_close_and_schedule_fallback(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""_close_and_schedule_fallback destroys root."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
alarm._close_and_schedule_fallback()
|
|
alarm.root.destroy.assert_called()
|
|
alarm._stop_beep.set()
|
|
|
|
|
|
class TestDismissWithoutSkip:
|
|
"""Tests for alarm dismiss without earning skip."""
|
|
|
|
def test_dismiss_without_skip_shows_no_skip_message(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Dismissing with earned_skip=False shows appropriate message."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
# Simulate existing child widgets
|
|
mock_widget = MagicMock()
|
|
alarm._container.winfo_children.return_value = [mock_widget]
|
|
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.save_wake_state",
|
|
) as mock_save:
|
|
alarm._dismiss_alarm(earned_skip=False)
|
|
|
|
assert alarm.dismissed is True
|
|
mock_save.assert_called_once()
|
|
call_kwargs = mock_save.call_args[1]
|
|
assert call_kwargs["skip_workout"] is False
|
|
mock_widget.destroy.assert_called_once()
|
|
alarm._stop_beep.set()
|
|
|
|
|
|
class TestDismissWindowExpiredWidgets:
|
|
"""Tests for widget cleanup during dismiss window expiry."""
|
|
|
|
def test_expired_creates_label(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Expiry creates a 'Too late' label and destroys children."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
mock_widget = MagicMock()
|
|
alarm._container.winfo_children.return_value = [mock_widget]
|
|
|
|
with patch(
|
|
"python_pkg.wake_alarm._alarm.save_wake_state",
|
|
):
|
|
alarm._on_dismiss_window_expired()
|
|
|
|
mock_widget.destroy.assert_called_once()
|
|
mock_tk_module.Label.assert_called()
|
|
alarm._stop_beep.set()
|
|
|
|
|
|
class TestBeepLoopPhases:
|
|
"""Tests for different beep loop escalation phases."""
|
|
|
|
def test_medium_phase(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Beep loop enters medium phase after PHASE_SOFT_END minutes."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
# Set alarm start to make elapsed > PHASE_SOFT_END minutes
|
|
import time as time_mod
|
|
|
|
alarm._alarm_start = time_mod.monotonic() - (PHASE_SOFT_END + 1) * 60
|
|
|
|
call_count = 0
|
|
|
|
def stop_after_one(*_args: object, **_kwargs: object) -> None:
|
|
nonlocal call_count
|
|
call_count += 1
|
|
if call_count >= 1:
|
|
alarm._stop_beep.set()
|
|
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._beep_medium",
|
|
side_effect=stop_after_one,
|
|
) as mock_beep,
|
|
):
|
|
alarm._beep_loop()
|
|
|
|
mock_beep.assert_called()
|
|
alarm._stop_beep.set()
|
|
|
|
def test_loud_phase(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Beep loop enters loud phase after PHASE_MEDIUM_END minutes."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
import time as time_mod
|
|
|
|
alarm._alarm_start = time_mod.monotonic() - (PHASE_MEDIUM_END + 1) * 60
|
|
|
|
call_count = 0
|
|
|
|
def stop_after_one(*_args: object, **_kwargs: object) -> None:
|
|
nonlocal call_count
|
|
call_count += 1
|
|
if call_count >= 1:
|
|
alarm._stop_beep.set()
|
|
|
|
with (
|
|
patch(
|
|
"python_pkg.wake_alarm._alarm._beep_loud",
|
|
side_effect=stop_after_one,
|
|
) as mock_beep,
|
|
):
|
|
alarm._beep_loop()
|
|
|
|
mock_beep.assert_called()
|
|
alarm._stop_beep.set()
|
|
|
|
|
|
class TestRunMethod:
|
|
"""Tests for the run() method."""
|
|
|
|
def test_run_calls_mainloop(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""run() calls root.mainloop()."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
alarm.run()
|
|
alarm.root.mainloop.assert_called_once()
|
|
alarm._stop_beep.set()
|
|
|
|
|
|
class TestUpdateTimerActive:
|
|
"""Tests for timer update when alarm is active."""
|
|
|
|
def test_update_timer_shows_remaining(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Timer update shows remaining time when not dismissed."""
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
alarm._update_timer()
|
|
alarm._timer_label.configure.assert_called()
|
|
alarm._stop_beep.set()
|
|
|
|
def test_update_timer_stops_at_zero(
|
|
self,
|
|
mock_tk_module: MagicMock,
|
|
) -> None:
|
|
"""Timer stops scheduling when remaining time reaches zero."""
|
|
import time as time_mod
|
|
|
|
alarm = WakeAlarm(demo_mode=True)
|
|
# Set alarm start far in the past so remaining = 0
|
|
alarm._alarm_start = time_mod.monotonic() - 60 * 60
|
|
alarm._update_timer()
|
|
# root.after should NOT be called for re-scheduling
|
|
# (configure is still called to show 00:00)
|
|
alarm._timer_label.configure.assert_called()
|
|
alarm._stop_beep.set()
|