wake-alarm/wake_alarm/tests/test_alarm_part3.py

"""Tests for WakeAlarm — beep loop phases, run, update timer, and flash challenge."""

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 wake_alarm._alarm import (
    WakeAlarm,
)


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("wake_alarm._alarm.tk", mock),
        patch("wake_alarm._dismiss_view.tk", mock),
        patch("wake_alarm._alarm_view.tk", mock),
        patch(
            "wake_alarm._alarm.GateRoot",
            return_value=mock.Tk.return_value,
        ),
    ):
        yield mock


@pytest.fixture(autouse=True)
def _block_extra_devices() -> Generator[MagicMock]:
    """Prevent real subprocess calls for extra ALSA devices and hardware."""
    with (
        patch("wake_alarm._beep_loop._play_on_all_sinks") as mock,
        patch("wake_alarm._startup._set_max_brightness"),
        patch("wake_alarm._startup._wake_display"),
        patch("wake_alarm._alarm._restore_display"),
        patch("wake_alarm._startup._warn_if_no_real_sink"),
        patch("wake_alarm._alarm._activate_all_outputs", return_value=None),
        patch("wake_alarm._alarm._restore_audio_state"),
        patch("wake_alarm._startup.turn_on_plug"),
        patch("wake_alarm._alarm.turn_off_plug"),
    ):
        yield mock


@pytest.fixture
def mock_tk_module() -> Generator[MagicMock]:
    """Provide explicit access to the mocked tk module."""
    mock = _make_mock_tk()
    with (
        patch("wake_alarm._alarm.tk", mock),
        patch("wake_alarm._dismiss_view.tk", mock),
        patch("wake_alarm._alarm_view.tk", mock),
        patch(
            "wake_alarm._alarm.GateRoot",
            return_value=mock.Tk.return_value,
        ),
    ):
        yield mock


class TestRunMethod:
    """Tests for the run() method."""

    def test_run_delegates_to_lock(
        self,
        mock_tk_module: MagicMock,
    ) -> None:
        """run() hands off to the owned LockWindow.

        Asserts delegation rather than calling the real LockWindow.run(),
        which installs real SIGTERM/SIGINT handlers in the test process.
        """
        del mock_tk_module
        alarm = WakeAlarm(demo_mode=True)
        with patch.object(alarm._lock, "run") as mock_run:
            alarm.run()
        mock_run.assert_called_once_with()
        alarm._stop_beep.set()


class TestUpdateTimerActive:
    """Tests for timer update when alarm is active."""

    def test_update_timer_shows_skip_window(
        self,
        mock_tk_module: MagicMock,
    ) -> None:
        """While the skip is earnable, the timer shows the skip-window count."""
        del mock_tk_module
        alarm = WakeAlarm(demo_mode=True)
        alarm._update_timer()
        text = alarm._view._views[0].labels.timer.configure.call_args[1]["text"]
        assert text.startswith("Skip window:")
        alarm._stop_beep.set()

    def test_update_timer_shows_prompt_after_window(
        self,
        mock_tk_module: MagicMock,
    ) -> None:
        """After the window the timer shows the silence prompt and keeps going."""
        import time as time_mod

        alarm = WakeAlarm(demo_mode=True)
        # Far in the past so remaining == 0 -> the else branch.
        alarm._progress.started_at = time_mod.monotonic() - 60 * 60
        alarm.root.after.reset_mock()
        alarm._update_timer()
        text = alarm._view._views[0].labels.timer.configure.call_args[1]["text"]
        assert "type the code" in text
        # The alarm keeps nagging: it always reschedules while active.
        alarm.root.after.assert_called_once()
        alarm._stop_beep.set()

    def test_update_timer_noop_when_not_active(
        self,
        mock_tk_module: MagicMock,
    ) -> None:
        """Timer update is a no-op once the alarm is no longer active."""
        del mock_tk_module
        alarm = WakeAlarm(demo_mode=True)
        alarm._active = False
        alarm._view._views[0].labels.timer.configure.reset_mock()
        alarm._update_timer()
        alarm._view._views[0].labels.timer.configure.assert_not_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."""
        del mock_tk_module
        alarm = WakeAlarm(demo_mode=True)
        mock_widget = MagicMock()
        alarm._view._views[0].container.winfo_children.return_value = [mock_widget]

        with patch(
            "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()
        assert mock_save.call_args[1]["skip_workout"] is False
        mock_widget.destroy.assert_called_once()
        alarm._stop_beep.set()


class TestSkipWindowExpiredMessage:
    """Tests for the on-screen message when the skip window expires."""

    def test_expired_updates_status_label(
        self,
        mock_tk_module: MagicMock,
    ) -> None:
        """Expiry updates the status label instead of closing the alarm."""
        del mock_tk_module
        alarm = WakeAlarm(demo_mode=True)

        alarm._on_skip_window_expired()

        alarm._view._views[0].labels.status.configure.assert_called_with(
            text="No workout skip today.",
        )
        alarm._stop_beep.set()