wake-alarm/wake_alarm/tests/test_escape_integration.py

"""Tests wiring the escape hatch into the running alarm.

Split from ``test_escape_flow`` for the 250-line cap: that module covers the
hatch in isolation, this one covers it mounted on a real two-monitor alarm.
"""

from __future__ import annotations

import tkinter as tk
from typing import TYPE_CHECKING
from unittest.mock import MagicMock, patch

from gatelock import EscapePolicy, EscapeTracker
import pytest

from wake_alarm._alarm import WakeAlarm
from wake_alarm._constants import ESCAPE_OFFER_AFTER_SECONDS
from wake_alarm.tests.conftest import TWO_OUTPUTS

if TYPE_CHECKING:
    from collections.abc import Generator
    from pathlib import Path

TODAY = "2026-07-25"


@pytest.fixture
def tracker(tmp_path: Path) -> EscapeTracker:
    """A tracker over a throwaway history and key."""
    key = tmp_path / "hmac.key"
    key.write_bytes(b"0" * 32)
    return EscapeTracker(
        EscapePolicy(name="cant-wake", label="Can't-wake"),
        tmp_path / "escape.json",
        key_file=key,
    )


# ---------------------------------------------------------------------------
# Tk stand-ins (duplicated from the part files so this one is self-contained;
# they are autouse there, and hoisting them into conftest would silently
# neuter the audio and sync suites)
# ---------------------------------------------------------------------------


def _make_mock_tk() -> MagicMock:
    """Build a MagicMock that stands in for the tkinter module.

    ``Button`` gets a ``side_effect`` rather than a single ``return_value``:
    every surface must end up with its *own* button, otherwise
    ``escape_buttons`` is N references to one mock and "packed on every
    monitor" cannot be told apart from "packed once".
    """
    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.side_effect = lambda *_args, **_kwargs: MagicMock()
    mock.Label.return_value = MagicMock()
    mock.Entry.return_value = MagicMock()
    mock.Button.side_effect = lambda *_args, **_kwargs: 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.Popen calls for extra ALSA devices."""
    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.mark.usefixtures("dual_output")
class TestAlarmIntegration:
    """The hatch as the alarm actually uses it, on a two-monitor desk."""

    def test_every_output_gets_its_own_button(self) -> None:
        """The premise the rest of this class rests on: two distinct buttons."""
        alarm = WakeAlarm(demo_mode=True)

        buttons = alarm._view.escape_buttons
        assert len(buttons) == len(TWO_OUTPUTS)
        assert len({id(button) for button in buttons}) == len(TWO_OUTPUTS)
        alarm._stop_beep.set()

    def test_button_hidden_until_earned(self) -> None:
        """Straight after the alarm starts, the hatch is not offered."""
        alarm = WakeAlarm(demo_mode=True)
        for button in alarm._view.escape_buttons:
            button.pack.reset_mock()

        alarm._update_timer()

        for button in alarm._view.escape_buttons:
            button.pack.assert_not_called()
        alarm._stop_beep.set()

    def test_button_revealed_once_earned(self) -> None:
        """After the threshold the button appears on every monitor.

        Driven through ``_update_timer`` rather than the hatch directly, so
        the per-second tick is on the hook for ever offering the hatch at all.
        """
        alarm = WakeAlarm(demo_mode=True)
        alarm._progress.started_at -= ESCAPE_OFFER_AFTER_SECONDS + 10
        for button in alarm._view.escape_buttons:
            button.pack.reset_mock()

        alarm._update_timer()

        for button in alarm._view.escape_buttons:
            button.pack.assert_called()
        alarm._stop_beep.set()

    def test_not_reoffered_while_open(self) -> None:
        """With the form already up, the button is not re-packed."""
        alarm = WakeAlarm(demo_mode=True)
        alarm._progress.started_at -= ESCAPE_OFFER_AFTER_SECONDS + 10
        alarm._escape.is_open = True
        for button in alarm._view.escape_buttons:
            button.pack.reset_mock()

        alarm._update_timer()

        for button in alarm._view.escape_buttons:
            button.pack.assert_not_called()
        alarm._stop_beep.set()

    def test_open_swaps_every_surface(self) -> None:
        """Opening the form hides the challenge and builds a form per monitor."""
        alarm = WakeAlarm(demo_mode=True)
        surfaces = alarm._view.surfaces
        assert len(surfaces) == len(TWO_OUTPUTS)

        with patch("wake_alarm._escape_flow.EscapeDialog") as dialog_cls:
            alarm._escape.open()

        assert alarm._escape.is_open is True
        assert dialog_cls.call_count == len(surfaces)
        # One dialog *per* container, not two against the same parent.
        parents = [call.args[0] for call in dialog_cls.call_args_list]
        assert {id(parent) for parent in parents} == {
            id(view.container) for view in surfaces
        }
        for view in surfaces:
            view.challenge_frame.pack_forget.assert_called_once_with()
        alarm._stop_beep.set()

    def test_a_dead_surface_does_not_block_the_others(self) -> None:
        """A monitor that has gone away raises TclError; the rest still swap."""
        alarm = WakeAlarm(demo_mode=True)
        dead, live = alarm._view.surfaces
        dead.challenge_frame.pack_forget.side_effect = tk.TclError("bad path name")

        with patch("wake_alarm._escape_flow.EscapeDialog") as dialog_cls:
            alarm._escape.open()

        assert dialog_cls.call_count == 1
        assert dialog_cls.call_args.args[0] is live.container
        alarm._stop_beep.set()

    def test_cancel_puts_the_challenge_back(self) -> None:
        """Backing out destroys every form and re-packs every challenge.

        The bool alone is not the property that matters: ``open`` took the
        challenge off the screen, so a cancel that only flips a flag leaves
        the alarm showing a dead form on both monitors.
        """
        alarm = WakeAlarm(demo_mode=True)
        surfaces = alarm._view.surfaces
        dialogs: list[MagicMock] = []

        def make_dialog(*_args: object, **_kwargs: object) -> MagicMock:
            dialog = MagicMock()
            dialogs.append(dialog)
            return dialog

        with patch("wake_alarm._escape_flow.EscapeDialog", side_effect=make_dialog):
            alarm._escape.open()
        # The frame was packed once when the view was built; only the re-pack
        # that close() owes us should count.
        for view in surfaces:
            view.challenge_frame.pack.reset_mock()

        alarm._escape.close()

        assert alarm._escape.is_open is False
        assert alarm.dismissed is False
        assert len(dialogs) == len(TWO_OUTPUTS)
        for dialog in dialogs:
            dialog.frame.destroy.assert_called_once_with()
        for view in surfaces:
            view.challenge_frame.pack.assert_called_once_with()
        alarm._stop_beep.set()

    def test_granted_dismisses_without_a_skip(self) -> None:
        """Using the hatch silences the alarm but earns no workout skip."""
        alarm = WakeAlarm(demo_mode=True)

        with patch.object(alarm, "_dismiss_alarm") as dismiss:
            alarm._on_escape_granted()

        dismiss.assert_called_once_with(earned_skip=False)
        alarm._stop_beep.set()