160 lines
6.4 KiB
Python
160 lines
6.4 KiB
Python
import asyncio
|
|
import logging
|
|
import unittest
|
|
from datetime import datetime, timedelta
|
|
from unittest.mock import AsyncMock, MagicMock, patch
|
|
|
|
from app.danmu_queue import SystemScheduler
|
|
|
|
|
|
class _FakeConfig:
|
|
def __init__(self, system_cfg):
|
|
self.system_cfg = system_cfg
|
|
|
|
|
|
class RebootAfterStopTests(unittest.IsolatedAsyncioTestCase):
|
|
def setUp(self):
|
|
self.logger = logging.getLogger("test-system-scheduler")
|
|
self.scheduler = SystemScheduler(
|
|
_FakeConfig({
|
|
"reboot_after_stop_enabled": True,
|
|
"reboot_after_stop_delay_sec": 60,
|
|
}),
|
|
self.logger,
|
|
)
|
|
|
|
@patch("app.danmu_queue.os.name", "nt")
|
|
@patch("app.danmu_queue.subprocess.Popen")
|
|
def test_schedules_one_minute_reboot_only_once(self, popen):
|
|
stopped_at = datetime(2026, 7, 23, 23, 0)
|
|
|
|
self.assertTrue(self.scheduler._schedule_reboot_after_stop(stopped_at))
|
|
self.assertFalse(self.scheduler._schedule_reboot_after_stop(stopped_at))
|
|
|
|
popen.assert_called_once()
|
|
command = popen.call_args.args[0]
|
|
self.assertEqual(command[:5], ["shutdown", "/r", "/t", "60", "/c"])
|
|
|
|
async def test_failed_stop_still_schedules_reboot(self):
|
|
self.scheduler._live_occurrences = MagicMock(
|
|
return_value=[("stop", datetime.now().replace(second=0, microsecond=0))]
|
|
)
|
|
self.scheduler.stop_bilibili_live = AsyncMock(return_value=False)
|
|
self.scheduler._schedule_reboot_after_stop = MagicMock()
|
|
self.scheduler._end_live_statistics = MagicMock()
|
|
|
|
async def stop_after_first_sleep(_seconds):
|
|
self.scheduler._stop = True
|
|
|
|
with patch("app.danmu_queue.asyncio.sleep", side_effect=stop_after_first_sleep):
|
|
await self.scheduler.run()
|
|
|
|
self.scheduler._schedule_reboot_after_stop.assert_called_once()
|
|
|
|
async def test_stop_exception_still_schedules_reboot(self):
|
|
self.scheduler._live_occurrences = MagicMock(
|
|
return_value=[("stop", datetime.now().replace(second=0, microsecond=0))]
|
|
)
|
|
self.scheduler.stop_bilibili_live = AsyncMock(side_effect=RuntimeError("click failed"))
|
|
self.scheduler._schedule_reboot_after_stop = MagicMock()
|
|
self.scheduler._end_live_statistics = MagicMock()
|
|
|
|
async def stop_after_first_sleep(_seconds):
|
|
self.scheduler._stop = True
|
|
|
|
with patch("app.danmu_queue.asyncio.sleep", side_effect=stop_after_first_sleep):
|
|
await self.scheduler.run()
|
|
|
|
self.scheduler._schedule_reboot_after_stop.assert_called_once()
|
|
|
|
|
|
class StartupLiveCompensationTests(unittest.IsolatedAsyncioTestCase):
|
|
def setUp(self):
|
|
self.logger = logging.getLogger("test-startup-live-compensation")
|
|
self.scheduler = SystemScheduler(
|
|
_FakeConfig({
|
|
"live_start_time": "09:00",
|
|
"live_end_time": "23:00",
|
|
"launch_bilibili_live_enabled": True,
|
|
"launch_genshin_enabled": True,
|
|
"bilibili_push_enabled": True,
|
|
}),
|
|
self.logger,
|
|
)
|
|
self.start_at = datetime.now() - timedelta(hours=1)
|
|
self.end_at = datetime.now() + timedelta(hours=1)
|
|
self.scheduler._startup_window_active = MagicMock(return_value=True)
|
|
self.scheduler._is_exe_running = MagicMock(return_value=False)
|
|
self.scheduler._launch_exe = AsyncMock(side_effect=[True, True])
|
|
self.scheduler.push_bilibili_live = AsyncMock(return_value=True)
|
|
|
|
async def test_launches_apps_after_one_minute_then_pushes_after_another(self):
|
|
with patch("app.danmu_queue.asyncio.sleep", new_callable=AsyncMock) as sleep:
|
|
await self.scheduler._run_startup_live_compensation(self.start_at, self.end_at)
|
|
|
|
self.assertEqual(
|
|
[call.args[0] for call in sleep.await_args_list],
|
|
[60, 60],
|
|
)
|
|
self.assertEqual(
|
|
[call.args for call in self.scheduler._launch_exe.await_args_list],
|
|
[("B站直播姬", "bilibili_live_exe"), ("原神", "genshin_exe")],
|
|
)
|
|
self.scheduler.push_bilibili_live.assert_awaited_once()
|
|
|
|
async def test_skips_push_when_livehime_was_already_running(self):
|
|
self.scheduler._is_exe_running = MagicMock(return_value=True)
|
|
self.scheduler._launch_exe = AsyncMock(side_effect=[False, False])
|
|
|
|
with patch("app.danmu_queue.asyncio.sleep", new_callable=AsyncMock):
|
|
await self.scheduler._run_startup_live_compensation(self.start_at, self.end_at)
|
|
|
|
self.scheduler.push_bilibili_live.assert_not_awaited()
|
|
|
|
async def test_cancels_before_push_when_live_window_ends(self):
|
|
self.scheduler._startup_window_active = MagicMock(side_effect=[True, False])
|
|
|
|
with patch("app.danmu_queue.asyncio.sleep", new_callable=AsyncMock):
|
|
await self.scheduler._run_startup_live_compensation(self.start_at, self.end_at)
|
|
|
|
self.scheduler.push_bilibili_live.assert_not_awaited()
|
|
|
|
async def test_scheduling_marks_prepare_and_start_to_avoid_duplicate_clicks(self):
|
|
with patch.object(self.scheduler, "_run_startup_live_compensation", new_callable=AsyncMock):
|
|
scheduled = self.scheduler._schedule_startup_live_compensation(self.start_at, self.end_at)
|
|
await asyncio.sleep(0)
|
|
|
|
if self.scheduler._startup_compensation_task:
|
|
await self.scheduler._startup_compensation_task
|
|
|
|
self.assertTrue(scheduled)
|
|
self.assertFalse(self.scheduler._schedule_startup_live_compensation(self.start_at, self.end_at))
|
|
self.assertIn(
|
|
self.scheduler._event_key("prepare_tts", self.start_at - timedelta(minutes=15)),
|
|
self.scheduler._triggered_events,
|
|
)
|
|
self.assertIn(
|
|
self.scheduler._event_key("prepare", self.start_at - timedelta(minutes=10)),
|
|
self.scheduler._triggered_events,
|
|
)
|
|
self.assertIn(
|
|
self.scheduler._event_key("start", self.start_at),
|
|
self.scheduler._triggered_events,
|
|
)
|
|
|
|
def test_current_live_window_supports_cross_midnight_schedule(self):
|
|
self.scheduler.config.system_cfg["live_start_time"] = "23:00"
|
|
self.scheduler.config.system_cfg["live_end_time"] = "02:00"
|
|
current = datetime(2026, 7, 31, 1, 0)
|
|
|
|
window = self.scheduler._current_live_window(current)
|
|
|
|
self.assertEqual(
|
|
window,
|
|
(datetime(2026, 7, 30, 23, 0), datetime(2026, 7, 31, 2, 0)),
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|