Files
nix-config/home/linux/gui/base/hypridle/test_activity_monitor.py
T
2026-10-21 16:17:59 +08:00

295 lines
13 KiB
Python

"""Regression tests for the hypridle activity policy and device lifecycle."""
import argparse
import json
import os
import sys
import time
from pathlib import Path
import subprocess
import tempfile
from types import SimpleNamespace
import unittest
from unittest.mock import Mock, patch
import activity_monitor as monitor
class StateTests(unittest.TestCase):
def test_activity_threshold_and_heartbeat_boundary(self):
state = {"heartbeat": 100, "last_activity": 80}
self.assertTrue(monitor.blocked(state, 21, 100))
self.assertFalse(monitor.blocked(state, 20, 100))
self.assertTrue(monitor.blocked(state, 100, 129.999))
self.assertFalse(monitor.blocked(state, 100, 130))
def test_invalid_and_future_state_never_blocks(self):
for state in [
None, [], {}, {"heartbeat": 100, "last_activity": None},
{"heartbeat": 101, "last_activity": 90},
{"heartbeat": 99, "last_activity": 100},
{"heartbeat": 100, "last_activity": -1},
{"heartbeat": True, "last_activity": 0},
{"heartbeat": 100, "last_activity": float("nan")},
{"heartbeat": float("inf"), "last_activity": 99},
{"heartbeat": "100", "last_activity": 99},
]:
with self.subTest(state=state):
self.assertFalse(monitor.blocked(state, 1200, 100))
def test_state_publication_and_missing_corrupt_recovery(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "activity" / "state.json"
with self.assertLogs(monitor.LOG, level="WARNING"):
self.assertEqual(monitor.check(path, 20, 100), 0)
monitor.write_state(path, None, 100)
self.assertEqual(monitor.check(path, 20, 100), 0)
monitor.write_state(path, 90, 100)
self.assertEqual(monitor.check(path, 20, 100), 1)
self.assertEqual(list(path.parent.iterdir()), [path])
self.assertEqual(path.stat().st_mode & 0o777, 0o600)
path.write_text("{broken")
with self.assertLogs(monitor.LOG, level="WARNING"):
self.assertEqual(monitor.check(path, 20, 100), 0)
monitor.write_state(path, 100, 100)
self.assertEqual(json.loads(path.read_text())["heartbeat"], 100)
def test_cli_exit_statuses(self):
with tempfile.TemporaryDirectory() as runtime:
path = Path(runtime) / "hypridle-activity" / "state.json"
command = [sys.executable, "-B", monitor.__file__, "check", "--timeout", "1200"]
env = dict(os.environ, XDG_RUNTIME_DIR=runtime)
now = time.monotonic()
for activity, heartbeat, expected in [
(now, now, 1), (now - 1201, now, 0),
(now, now - 31, 0), (None, now, 0),
]:
monitor.write_state(path, activity, heartbeat)
result = subprocess.run(command, env=env, capture_output=True, timeout=5)
self.assertEqual(result.returncode, expected, result.stderr)
def test_daemon_startup_has_no_fake_activity(self):
selector = Mock()
selector.select.side_effect = KeyboardInterrupt
manager = Mock()
manager.__enter__ = Mock(return_value=selector)
manager.__exit__ = Mock(return_value=False)
with tempfile.TemporaryDirectory() as runtime:
path = Path(runtime) / "state.json"
with (
patch.dict(sys.modules, {"evdev": Mock(), "pyudev": Mock()}),
patch.object(monitor.selectors, "DefaultSelector", return_value=manager),
patch.object(monitor, "Joysticks"),
patch.object(monitor, "media_active", return_value=False),
patch.object(monitor.signal, "signal"),
self.assertRaises(KeyboardInterrupt),
):
monitor.daemon(path)
self.assertIsNone(json.loads(path.read_text())["last_activity"])
def test_first_gamepad_event_is_published_before_next_poll(self):
selector = Mock()
selector.select.side_effect = [[(SimpleNamespace(data="pad"), 1)], KeyboardInterrupt]
manager = Mock()
manager.__enter__ = Mock(return_value=selector)
manager.__exit__ = Mock(return_value=False)
with tempfile.TemporaryDirectory() as runtime:
path = Path(runtime) / "state.json"
with (
patch.dict(sys.modules, {"evdev": Mock(), "pyudev": Mock()}),
patch.object(monitor.selectors, "DefaultSelector", return_value=manager),
patch.object(monitor, "Joysticks") as joysticks,
patch.object(monitor, "media_active", return_value=False),
patch.object(monitor.time, "monotonic", return_value=100),
patch.object(monitor.signal, "signal"),
self.assertRaises(KeyboardInterrupt),
):
joysticks.return_value.read.return_value = True
monitor.daemon(path)
self.assertEqual(json.loads(path.read_text())["last_activity"], 100)
def test_media_interval_preserves_heartbeat_and_input(self):
now = 0.0
media_times = []
selector = Mock()
def select(timeout):
nonlocal now
now += timeout
if now >= 20:
raise KeyboardInterrupt
return [(SimpleNamespace(data="pad"), 1)] if now == 5 else []
def media():
media_times.append(now)
return False
selector.select.side_effect = select
manager = Mock()
manager.__enter__ = Mock(return_value=selector)
manager.__exit__ = Mock(return_value=False)
with (
patch.dict(sys.modules, {"evdev": Mock(), "pyudev": Mock()}),
patch.object(monitor.selectors, "DefaultSelector", return_value=manager),
patch.object(monitor, "Joysticks") as joysticks,
patch.object(monitor, "media_active", side_effect=media),
patch.object(monitor, "publish") as publish,
patch.object(monitor.time, "monotonic", side_effect=lambda: now),
patch.object(monitor.signal, "signal"),
self.assertRaises(KeyboardInterrupt),
):
joysticks.return_value.read.return_value = True
monitor.daemon(Path("unused"))
self.assertEqual(media_times, [0, 15])
self.assertEqual([call.args[2] for call in publish.call_args_list], [0, 5, 5, 10, 15])
self.assertEqual(publish.call_args_list[-1].args[1], 5)
def test_timeout_validation(self):
for value in ["0", "-1", "nan", "inf"]:
with self.subTest(value=value), self.assertRaises(argparse.ArgumentTypeError):
monitor.positive_seconds(value)
self.assertEqual(monitor.positive_seconds("20"), 20)
class AudioTests(unittest.TestCase):
def setUp(self):
monitor._FAILURES.clear()
def test_error_log_deduplication_and_recovery(self):
with self.assertLogs(monitor.LOG, level="WARNING") as logs:
monitor.report_failure("audio", "unavailable")
monitor.report_failure("audio", "unavailable")
self.assertEqual(len(logs.output), 1)
monitor.recovered("audio")
with self.assertLogs(monitor.LOG, level="WARNING"):
monitor.report_failure("audio", "unavailable")
def test_silent_running_firefox_output_does_not_block(self):
pulse = Mock()
pulse.sink_list.return_value = [
SimpleNamespace(state="running", mute=False, monitor_source=42)
]
pulse.get_peak_sample.return_value = 0.0
self.assertFalse(monitor.audio_active(monitor.output_peak(pulse)))
pulse.get_peak_sample.assert_called_once_with(42, 0.25)
pulse.get_peak_sample.return_value = 0.01
self.assertTrue(monitor.audio_active(monitor.output_peak(pulse)))
def test_peak_threshold_and_invalid_values(self):
self.assertTrue(monitor.audio_active(0.001))
for value in [0, 0.00001, monitor.AUDIO_THRESHOLD, -1, None, True,
float("nan"), float("inf"), "0.1"]:
with self.subTest(value=value):
self.assertFalse(monitor.audio_active(value))
def test_only_valid_running_output_monitors_are_sampled(self):
pulse = Mock()
pulse.sink_list.return_value = [
SimpleNamespace(state="suspended", mute=False, monitor_source=10),
SimpleNamespace(state="running", mute=True, monitor_source=11),
SimpleNamespace(state="running", mute=False, monitor_source=0xFFFFFFFF),
SimpleNamespace(state="running", mute=False, monitor_source=None),
]
self.assertEqual(monitor.output_peak(pulse), 0)
pulse.get_peak_sample.assert_not_called()
pulse.source_list.assert_not_called()
def test_multiple_outputs_and_total_sampling_budget(self):
pulse = Mock()
pulse.sink_list.return_value = [
SimpleNamespace(state="running", mute=False, monitor_source=i)
for i in range(6)
]
pulse.get_peak_sample.return_value = 0
with patch.object(monitor.time, "monotonic", side_effect=[0, 0, 0.8, 1.1]):
self.assertEqual(monitor.output_peak(pulse), 0)
self.assertEqual(pulse.get_peak_sample.call_count, 2)
self.assertLessEqual(sum(c.args[1] for c in pulse.get_peak_sample.call_args_list), 1)
def test_mpris_requires_exact_playing_status(self):
self.assertTrue(monitor.playing("Paused\nPlaying\n"))
self.assertFalse(monitor.playing("Not Playing\nPaused\nStopped\n"))
@patch.object(monitor.subprocess, "run")
def test_timeout_does_not_hide_other_media_source(self, run):
run.side_effect = [
subprocess.TimeoutExpired("audio-peak", 2),
SimpleNamespace(returncode=0, stdout="Playing\n"),
]
with self.assertLogs(monitor.LOG, level="WARNING"):
self.assertTrue(monitor.media_active())
for call in run.call_args_list:
self.assertEqual(call.kwargs["timeout"], monitor.COMMAND_TIMEOUT)
@patch.object(monitor.subprocess, "run")
def test_failed_probe_can_recover_next_poll(self, run):
run.side_effect = [
FileNotFoundError("python"), SimpleNamespace(returncode=1, stdout=""),
SimpleNamespace(stdout='0.01'),
SimpleNamespace(returncode=1, stdout=""),
]
with self.assertLogs(monitor.LOG, level="WARNING"):
self.assertFalse(monitor.media_active())
self.assertTrue(monitor.media_active())
class GamepadTests(unittest.TestCase):
def active(self, kind, code, value, minimum=-32768, maximum=32767, flat=0):
return monitor.gamepad_active(
SimpleNamespace(type=kind, code=code, value=value),
lambda _: SimpleNamespace(min=minimum, max=maximum, flat=flat),
)
def test_buttons_syn_and_unrelated_events(self):
self.assertTrue(self.active(1, 304, 1))
self.assertTrue(self.active(1, 304, 2))
self.assertFalse(self.active(1, 304, 0))
self.assertFalse(self.active(0, 0, 1))
self.assertFalse(self.active(4, 0, 1))
self.assertFalse(self.active(3, 40, 100))
def test_center_drift_and_unsigned_sticks(self):
self.assertFalse(self.active(3, 0, 1000))
self.assertTrue(self.active(3, 0, -20000))
self.assertTrue(self.active(3, 4, 20000))
self.assertFalse(self.active(3, 0, 128, 0, 255))
self.assertTrue(self.active(3, 0, 220, 0, 255))
self.assertFalse(self.active(3, 0, 15000, flat=20000))
def test_hat_trigger_and_invalid_axis(self):
self.assertFalse(self.active(3, 16, 0))
self.assertTrue(self.active(3, 16, -1))
self.assertFalse(self.active(3, 2, 2, 0, 255))
self.assertTrue(self.active(3, 2, 100, 0, 255))
self.assertFalse(self.active(3, 0, 1, 0, 0))
def test_reconcile_unplug_and_reconnect_without_grabbing(self):
context, selector, device = Mock(), Mock(), Mock()
node = Mock(device_node="/dev/input/event7")
node.get.return_value = "1"
context.list_devices.return_value = [node]
device.fd = 7
factory = Mock(return_value=device)
joysticks = monitor.Joysticks(context, factory, selector)
joysticks.reconcile()
device.grab.assert_not_called()
joysticks.reconcile()
factory.assert_called_once_with("/dev/input/event7")
device.read.return_value = [SimpleNamespace(type=0, code=0, value=0)]
self.assertFalse(joysticks.read(node.device_node))
device.read.return_value = [SimpleNamespace(type=1, code=304, value=1)]
self.assertTrue(joysticks.read(node.device_node))
device.read.side_effect = OSError("unplugged")
self.assertFalse(joysticks.read(node.device_node))
self.assertEqual(joysticks.devices, {})
device.close.assert_called_once()
joysticks.reconcile()
self.assertEqual(factory.call_count, 2)
context.list_devices.return_value = []
joysticks.reconcile()
self.assertEqual(joysticks.devices, {})
if __name__ == "__main__":
unittest.main()