feat(offload): auto-pause apps + idle keep-alive model unload (#592)
* feat(auto-pause): unload speech model while selected apps run Add Settings toggle + process list so Vocalinux frees CPU/GPU/RAM while configured games/apps are running, then reloads the model when they exit. Closes the process-list half of #445 (window-focus pause is separate). * test(auto-pause): isolate tray wiring to avoid stale GLib mocks Move TrayIndicator auto-pause tests into test_suspend_handler so test_auto_pause_monitor never imports tray_indicator under a collection-time gi MagicMock. That import pinned GLib.SOURCE_REMOVE and broke resume tests later in the suite (CI on #517). * test(auto-pause): raise patch coverage for codecov target Cover process snapshot I/O, GLib poll scheduling, config coercion, unload edge cases, and tray fallback paths so codecov/patch clears 80%. * feat(keepalive): idle model offload for GPU/battery saving Add opt-in keep-alive that unloads the speech model after inactivity so hybrid-GPU laptops can release VRAM/Vulkan. Next dictation lazy-reloads. Shares unload_model with auto-pause (#445) using distinct reasons so app-pause still blocks dictation while idle unload does not. Fixes #591 (with #445 via shared offload infrastructure). * test(keepalive): mock gi.repository.GLib via sys.modules Match the auto-pause GLib test pattern so CI on Python 3.9/3.10 sees the late `from gi.repository import GLib` import. * test(keepalive): drop post-fire source_remove assertion After the GLib timeout callback runs, _timeout_id is already cleared, so shutdown does not call source_remove. * fix(settings): hide auto-pause empty-state label when apps are listed The dialog-wide show_all() after _load_and_apply_settings() re-showed the 'No apps listed yet' row that _refresh_auto_pause_list had hidden. Mark the row no_show_all and manage visibility explicitly. Co-authored-by: Jatin K Malik <jatinkrmalik@users.noreply.github.com> * feat(settings): move auto-pause and idle unload to dedicated Power tab - New Power tab between Shortcuts and General so resource management features are easy to find; General returns to app-behavior toggles only - Rename 'Model Keep-Alive (Battery)' to 'Unload When Idle' — the old name read as the opposite of what the feature does - Clearer copy throughout: row titles, descriptions, tooltips, 'From running…' becomes 'Choose Running App…', empty-state hint - Gray out app-list and idle-timeout controls while their feature toggle is off Co-authored-by: Jatin K Malik <jatinkrmalik@users.noreply.github.com> * fix(settings): show which notebook tab is selected The tab CSS targeted :selected, but GTK3 marks the active notebook tab with :checked, so no selected styling ever applied — all tabs rendered identically. Use :checked and add an accent underline + bold label. Co-authored-by: Jatin K Malik <jatinkrmalik@users.noreply.github.com> --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com> Co-authored-by: Jatin K Malik <jatinkrmalik@users.noreply.github.com>
This commit is contained in:
Jatin K Malik
co-authored by
Jatin K Malik
Cursor Agent
Jatin K Malik
Cursor Agent
parent
b945137d60
commit
4c070ded46
@@ -0,0 +1,696 @@
|
||||
"""
|
||||
Tests for auto-pause process matching, monitor pause/resume, and model unload.
|
||||
|
||||
Exercises the shipped matching helpers and AutoPauseMonitor against real
|
||||
callbacks — not a parallel reimplementation of the match logic.
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
# Heavy deps used transitively when importing recognition manager
|
||||
mock_pywhispercpp = MagicMock()
|
||||
mock_pywhispercpp.model = MagicMock()
|
||||
mock_pywhispercpp.model.Model = MagicMock()
|
||||
|
||||
sys.modules.setdefault("vosk", MagicMock())
|
||||
sys.modules.setdefault("whisper", MagicMock())
|
||||
sys.modules.setdefault("pywhispercpp", mock_pywhispercpp)
|
||||
sys.modules.setdefault("pywhispercpp.model", mock_pywhispercpp.model)
|
||||
sys.modules.setdefault("requests", MagicMock())
|
||||
sys.modules.setdefault("pyaudio", MagicMock())
|
||||
sys.modules.setdefault("wave", MagicMock())
|
||||
sys.modules.setdefault("tqdm", MagicMock())
|
||||
sys.modules.setdefault("numpy", MagicMock())
|
||||
sys.modules.setdefault("torch", MagicMock())
|
||||
sys.modules.setdefault("psutil", MagicMock())
|
||||
|
||||
from vocalinux.auto_pause_monitor import ( # noqa: E402
|
||||
AutoPauseMonitor,
|
||||
any_configured_process_running,
|
||||
configured_names_set,
|
||||
normalize_process_name,
|
||||
)
|
||||
from vocalinux.common_types import RecognitionState # noqa: E402
|
||||
from vocalinux.ui.config_manager import DEFAULT_CONFIG # noqa: E402
|
||||
|
||||
|
||||
class TestNormalizeAndMatch(unittest.TestCase):
|
||||
"""Pure matching helpers (no I/O)."""
|
||||
|
||||
def test_normalize_basename_and_case(self):
|
||||
self.assertEqual(normalize_process_name("Overwatch"), "overwatch")
|
||||
self.assertEqual(normalize_process_name("/usr/bin/Steam"), "steam")
|
||||
self.assertEqual(normalize_process_name("game.EXE"), "game")
|
||||
self.assertEqual(normalize_process_name(" chrome "), "chrome")
|
||||
self.assertEqual(normalize_process_name(""), "")
|
||||
|
||||
def test_configured_names_set_drops_empty(self):
|
||||
self.assertEqual(
|
||||
configured_names_set(["Overwatch", "", " ", "steam"]),
|
||||
{"overwatch", "steam"},
|
||||
)
|
||||
|
||||
def test_match_when_process_running(self):
|
||||
self.assertTrue(
|
||||
any_configured_process_running(
|
||||
["overwatch", "steam"],
|
||||
["bash", "Overwatch.exe", "Xorg"],
|
||||
)
|
||||
)
|
||||
|
||||
def test_no_match_when_absent(self):
|
||||
self.assertFalse(
|
||||
any_configured_process_running(
|
||||
["overwatch"],
|
||||
["bash", "chrome", "Xorg"],
|
||||
)
|
||||
)
|
||||
|
||||
def test_empty_config_never_matches(self):
|
||||
self.assertFalse(any_configured_process_running([], ["overwatch", "steam"]))
|
||||
self.assertFalse(any_configured_process_running(["", " "], ["overwatch"]))
|
||||
|
||||
def test_match_via_exe_basename_path(self):
|
||||
self.assertTrue(
|
||||
any_configured_process_running(
|
||||
["firefox"],
|
||||
["/usr/lib/firefox/firefox"],
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class TestAutoPauseMonitor(unittest.TestCase):
|
||||
"""Poller state machine: pause once, resume once, no double-fire."""
|
||||
|
||||
def _make_monitor(self, enabled=True, apps=None, snapshot=None):
|
||||
apps = apps if apps is not None else ["overwatch"]
|
||||
config = {"enabled": enabled, "apps": list(apps), "interval": 5.0}
|
||||
pause_cb = MagicMock()
|
||||
resume_cb = MagicMock()
|
||||
running = snapshot if snapshot is not None else (lambda: set())
|
||||
|
||||
def get_config():
|
||||
return config["enabled"], config["apps"], config["interval"]
|
||||
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=get_config,
|
||||
on_pause=pause_cb,
|
||||
on_resume=resume_cb,
|
||||
process_snapshot=running if callable(running) else (lambda: running),
|
||||
use_glib=False,
|
||||
)
|
||||
return monitor, pause_cb, resume_cb, config
|
||||
|
||||
def test_pause_when_match_appears(self):
|
||||
running = {"bash", "overwatch"}
|
||||
monitor, pause_cb, resume_cb, _ = self._make_monitor(
|
||||
snapshot=lambda: running,
|
||||
)
|
||||
|
||||
matched = monitor.check_once()
|
||||
|
||||
self.assertTrue(matched)
|
||||
self.assertTrue(monitor.paused)
|
||||
pause_cb.assert_called_once()
|
||||
resume_cb.assert_not_called()
|
||||
|
||||
def test_no_pause_when_disabled(self):
|
||||
monitor, pause_cb, resume_cb, _ = self._make_monitor(
|
||||
enabled=False,
|
||||
snapshot=lambda: {"overwatch"},
|
||||
)
|
||||
|
||||
matched = monitor.check_once()
|
||||
|
||||
self.assertFalse(matched)
|
||||
self.assertFalse(monitor.paused)
|
||||
pause_cb.assert_not_called()
|
||||
resume_cb.assert_not_called()
|
||||
|
||||
def test_no_pause_when_no_match(self):
|
||||
monitor, pause_cb, resume_cb, _ = self._make_monitor(
|
||||
snapshot=lambda: {"bash", "chrome"},
|
||||
)
|
||||
|
||||
matched = monitor.check_once()
|
||||
|
||||
self.assertFalse(matched)
|
||||
pause_cb.assert_not_called()
|
||||
|
||||
def test_resume_when_match_clears(self):
|
||||
state = {"running": {"overwatch"}}
|
||||
monitor, pause_cb, resume_cb, _ = self._make_monitor(
|
||||
snapshot=lambda: state["running"],
|
||||
)
|
||||
|
||||
monitor.check_once()
|
||||
pause_cb.assert_called_once()
|
||||
|
||||
state["running"] = {"bash"}
|
||||
matched = monitor.check_once()
|
||||
|
||||
self.assertFalse(matched)
|
||||
self.assertFalse(monitor.paused)
|
||||
resume_cb.assert_called_once()
|
||||
|
||||
def test_no_double_pause(self):
|
||||
monitor, pause_cb, resume_cb, _ = self._make_monitor(
|
||||
snapshot=lambda: {"overwatch"},
|
||||
)
|
||||
|
||||
monitor.check_once()
|
||||
monitor.check_once()
|
||||
|
||||
pause_cb.assert_called_once()
|
||||
resume_cb.assert_not_called()
|
||||
|
||||
def test_no_double_resume(self):
|
||||
state = {"running": {"overwatch"}}
|
||||
monitor, pause_cb, resume_cb, _ = self._make_monitor(
|
||||
snapshot=lambda: state["running"],
|
||||
)
|
||||
monitor.check_once()
|
||||
state["running"] = set()
|
||||
monitor.check_once()
|
||||
monitor.check_once()
|
||||
|
||||
resume_cb.assert_called_once()
|
||||
|
||||
def test_disabling_while_paused_resumes(self):
|
||||
state = {"enabled": True, "running": {"overwatch"}}
|
||||
pause_cb = MagicMock()
|
||||
resume_cb = MagicMock()
|
||||
|
||||
def get_config():
|
||||
return state["enabled"], ["overwatch"], 5.0
|
||||
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=get_config,
|
||||
on_pause=pause_cb,
|
||||
on_resume=resume_cb,
|
||||
process_snapshot=lambda: state["running"],
|
||||
use_glib=False,
|
||||
)
|
||||
monitor.check_once()
|
||||
pause_cb.assert_called_once()
|
||||
|
||||
state["enabled"] = False
|
||||
monitor.check_once()
|
||||
resume_cb.assert_called_once()
|
||||
self.assertFalse(monitor.paused)
|
||||
|
||||
def test_pause_callback_exception_does_not_raise(self):
|
||||
pause_cb = MagicMock(side_effect=RuntimeError("boom"))
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=lambda: (True, ["x"], 5.0),
|
||||
on_pause=pause_cb,
|
||||
process_snapshot=lambda: {"x"},
|
||||
use_glib=False,
|
||||
)
|
||||
# Should not raise
|
||||
monitor.check_once()
|
||||
self.assertTrue(monitor.paused)
|
||||
|
||||
def test_start_stop_without_glib(self):
|
||||
monitor, _, _, _ = self._make_monitor()
|
||||
monitor.start()
|
||||
self.assertTrue(monitor.active)
|
||||
monitor.stop()
|
||||
self.assertFalse(monitor.active)
|
||||
monitor.shutdown()
|
||||
self.assertFalse(monitor.active)
|
||||
|
||||
def test_start_is_idempotent(self):
|
||||
monitor, _, _, _ = self._make_monitor()
|
||||
monitor.start()
|
||||
monitor.start()
|
||||
self.assertTrue(monitor.active)
|
||||
monitor.stop()
|
||||
|
||||
def test_resume_callback_exception_does_not_raise(self):
|
||||
state = {"running": {"x"}}
|
||||
resume_cb = MagicMock(side_effect=RuntimeError("resume boom"))
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=lambda: (True, ["x"], 5.0),
|
||||
on_pause=MagicMock(),
|
||||
on_resume=resume_cb,
|
||||
process_snapshot=lambda: state["running"],
|
||||
use_glib=False,
|
||||
)
|
||||
monitor.check_once()
|
||||
state["running"] = set()
|
||||
monitor.check_once() # should not raise
|
||||
resume_cb.assert_called_once()
|
||||
self.assertFalse(monitor.paused)
|
||||
|
||||
def test_read_config_handles_get_config_failure(self):
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=MagicMock(side_effect=RuntimeError("config broken")),
|
||||
use_glib=False,
|
||||
)
|
||||
matched = monitor.check_once()
|
||||
self.assertFalse(matched)
|
||||
self.assertFalse(monitor.paused)
|
||||
|
||||
def test_read_config_coerces_invalid_apps_and_interval(self):
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=lambda: (True, "not-a-list", "bad"),
|
||||
process_snapshot=lambda: {"overwatch"},
|
||||
use_glib=False,
|
||||
)
|
||||
# invalid apps → treated as empty → no match even if overwatch runs
|
||||
self.assertFalse(monitor.check_once())
|
||||
|
||||
monitor2 = AutoPauseMonitor(
|
||||
get_config=lambda: (True, ["overwatch"], 999), # clamps to max 60
|
||||
process_snapshot=lambda: {"overwatch"},
|
||||
use_glib=False,
|
||||
)
|
||||
enabled, apps, interval = monitor2._read_config()
|
||||
self.assertTrue(enabled)
|
||||
self.assertEqual(list(apps), ["overwatch"])
|
||||
self.assertEqual(interval, 60.0)
|
||||
|
||||
monitor3 = AutoPauseMonitor(
|
||||
get_config=lambda: (True, ["x"], 0), # clamps to min 1
|
||||
use_glib=False,
|
||||
)
|
||||
_, _, interval3 = monitor3._read_config()
|
||||
self.assertEqual(interval3, 1.0)
|
||||
|
||||
@patch("vocalinux.auto_pause_monitor.GLib", create=True)
|
||||
def test_start_with_glib_schedules_idle_then_timeout(self, _unused):
|
||||
"""Drive real GLib scheduling helpers via mocked gi.repository.GLib."""
|
||||
mock_glib = MagicMock()
|
||||
mock_glib.idle_add.return_value = 11
|
||||
mock_glib.timeout_add_seconds.return_value = 22
|
||||
|
||||
with patch.dict(
|
||||
"sys.modules",
|
||||
{"gi": MagicMock(), "gi.repository": MagicMock(GLib=mock_glib)},
|
||||
):
|
||||
# Force re-import path used inside methods
|
||||
import vocalinux.auto_pause_monitor as apm
|
||||
|
||||
monitor = apm.AutoPauseMonitor(
|
||||
get_config=lambda: (False, [], 5.0),
|
||||
process_snapshot=lambda: set(),
|
||||
use_glib=True,
|
||||
)
|
||||
monitor.start()
|
||||
self.assertTrue(monitor.active)
|
||||
mock_glib.idle_add.assert_called()
|
||||
# Simulate the idle callback (immediate first poll)
|
||||
result = monitor._glib_poll()
|
||||
self.assertFalse(result) # always SOURCE_REMOVE style
|
||||
mock_glib.timeout_add_seconds.assert_called()
|
||||
monitor.stop()
|
||||
mock_glib.source_remove.assert_called()
|
||||
|
||||
def test_glib_poll_when_stopped_returns_false(self):
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=lambda: (False, [], 5.0),
|
||||
use_glib=False,
|
||||
)
|
||||
monitor._running = False
|
||||
self.assertFalse(monitor._glib_poll())
|
||||
|
||||
def test_glib_poll_swallows_check_once_errors(self):
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=lambda: (True, ["x"], 5.0),
|
||||
process_snapshot=MagicMock(side_effect=RuntimeError("psutil down")),
|
||||
use_glib=False,
|
||||
)
|
||||
monitor._running = True
|
||||
# use_glib False so reschedule is a no-op after poll
|
||||
self.assertFalse(monitor._glib_poll())
|
||||
|
||||
def test_cancel_timeout_noop_when_none(self):
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=lambda: (False, [], 5.0),
|
||||
use_glib=False,
|
||||
)
|
||||
monitor._timeout_id = None
|
||||
monitor._cancel_timeout() # no raise
|
||||
self.assertIsNone(monitor._timeout_id)
|
||||
|
||||
def test_cancel_timeout_handles_source_remove_failure(self):
|
||||
mock_glib = MagicMock()
|
||||
mock_glib.source_remove.side_effect = RuntimeError("bad id")
|
||||
with patch.dict(
|
||||
"sys.modules",
|
||||
{"gi": MagicMock(), "gi.repository": MagicMock(GLib=mock_glib)},
|
||||
):
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=lambda: (False, [], 5.0),
|
||||
use_glib=False,
|
||||
)
|
||||
monitor._timeout_id = 99
|
||||
monitor._cancel_timeout()
|
||||
self.assertIsNone(monitor._timeout_id)
|
||||
|
||||
def test_schedule_skipped_when_not_running(self):
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=lambda: (False, [], 5.0),
|
||||
use_glib=True,
|
||||
)
|
||||
monitor._running = False
|
||||
monitor._schedule_next_poll(immediate=True)
|
||||
self.assertIsNone(monitor._timeout_id)
|
||||
|
||||
def test_schedule_handles_glib_import_failure(self):
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=lambda: (False, [], 5.0),
|
||||
use_glib=True,
|
||||
)
|
||||
monitor._running = True
|
||||
real_import = __import__
|
||||
|
||||
def fake_import(name, globals=None, locals=None, fromlist=(), level=0):
|
||||
if name == "gi" or name.startswith("gi."):
|
||||
raise ImportError("no gi")
|
||||
return real_import(name, globals, locals, fromlist, level)
|
||||
|
||||
with patch("builtins.__import__", side_effect=fake_import):
|
||||
monitor._schedule_next_poll(immediate=False)
|
||||
self.assertIsNone(monitor._timeout_id)
|
||||
|
||||
|
||||
class TestCollectRunningProcessNames(unittest.TestCase):
|
||||
"""collect_running_process_names uses real helper with mocked psutil."""
|
||||
|
||||
def _psutil_mock(self):
|
||||
mock_psutil = MagicMock()
|
||||
mock_psutil.NoSuchProcess = type("NoSuchProcess", (Exception,), {})
|
||||
mock_psutil.AccessDenied = type("AccessDenied", (Exception,), {})
|
||||
mock_psutil.ZombieProcess = type("ZombieProcess", (Exception,), {})
|
||||
return mock_psutil
|
||||
|
||||
def test_collects_name_and_exe_basename(self):
|
||||
import vocalinux.auto_pause_monitor as apm
|
||||
|
||||
mock_psutil = self._psutil_mock()
|
||||
proc_ok = MagicMock()
|
||||
proc_ok.info = {"name": "steam", "exe": "/usr/bin/steam"}
|
||||
proc_no_name = MagicMock()
|
||||
proc_no_name.info = {"name": None, "exe": "/opt/game/Game.exe"}
|
||||
|
||||
class Denied:
|
||||
@property
|
||||
def info(self):
|
||||
raise mock_psutil.AccessDenied()
|
||||
|
||||
mock_psutil.process_iter.return_value = [proc_ok, Denied(), proc_no_name]
|
||||
|
||||
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
||||
names = apm.collect_running_process_names()
|
||||
|
||||
self.assertIn("steam", names)
|
||||
self.assertIn("Game.exe", names)
|
||||
|
||||
def test_collect_skips_empty_entries(self):
|
||||
import vocalinux.auto_pause_monitor as apm
|
||||
|
||||
mock_psutil = self._psutil_mock()
|
||||
proc = MagicMock()
|
||||
proc.info = {"name": "", "exe": None}
|
||||
mock_psutil.process_iter.return_value = [proc]
|
||||
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
||||
names = apm.collect_running_process_names()
|
||||
self.assertEqual(names, set())
|
||||
|
||||
def test_collect_swallows_basename_errors(self):
|
||||
import vocalinux.auto_pause_monitor as apm
|
||||
|
||||
mock_psutil = self._psutil_mock()
|
||||
proc = MagicMock()
|
||||
# os.path.basename on non-path-like may raise; helper must continue
|
||||
bad_exe = MagicMock()
|
||||
bad_exe.__fspath__ = MagicMock(side_effect=TypeError("nope"))
|
||||
proc.info = {"name": "ok", "exe": bad_exe}
|
||||
mock_psutil.process_iter.return_value = [proc]
|
||||
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
||||
with patch("os.path.basename", side_effect=TypeError("bad")):
|
||||
names = apm.collect_running_process_names()
|
||||
self.assertIn("ok", names)
|
||||
|
||||
|
||||
class TestUnloadModelAndAutoPauseBlock(unittest.TestCase):
|
||||
"""SpeechRecognitionManager.unload_model and start_recognition guard."""
|
||||
|
||||
def _make_manager(self):
|
||||
from vocalinux.speech_recognition.recognition_manager import SpeechRecognitionManager
|
||||
|
||||
with patch.object(SpeechRecognitionManager, "__init__", lambda self: None):
|
||||
mgr = SpeechRecognitionManager()
|
||||
|
||||
mgr.engine = "vosk"
|
||||
mgr.state = RecognitionState.IDLE
|
||||
mgr.model = MagicMock(name="model")
|
||||
mgr.recognizer = MagicMock(name="recognizer")
|
||||
mgr._model_initialized = True
|
||||
mgr._auto_paused = False
|
||||
mgr._idle_unloaded = False
|
||||
mgr._model_lock = MagicMock()
|
||||
mgr._model_lock.__enter__ = MagicMock(return_value=None)
|
||||
mgr._model_lock.__exit__ = MagicMock(return_value=False)
|
||||
mgr._http_session = None
|
||||
mgr._reconnection_attempts = 0
|
||||
mgr._update_state = MagicMock()
|
||||
mgr._init_vosk = MagicMock()
|
||||
mgr._init_whisper = MagicMock()
|
||||
mgr._init_whispercpp = MagicMock()
|
||||
mgr._init_remote_api = MagicMock()
|
||||
mgr.stop_recognition = MagicMock()
|
||||
return mgr
|
||||
|
||||
def test_unload_model_clears_resources_and_sets_flag(self):
|
||||
mgr = self._make_manager()
|
||||
|
||||
mgr.unload_model()
|
||||
|
||||
self.assertIsNone(mgr.model)
|
||||
self.assertIsNone(mgr.recognizer)
|
||||
self.assertFalse(mgr._model_initialized)
|
||||
self.assertTrue(mgr.is_auto_paused)
|
||||
mgr.stop_recognition.assert_not_called() # already IDLE
|
||||
|
||||
def test_unload_stops_active_recognition_first(self):
|
||||
mgr = self._make_manager()
|
||||
mgr.state = RecognitionState.LISTENING
|
||||
|
||||
mgr.unload_model()
|
||||
|
||||
mgr.stop_recognition.assert_called_once()
|
||||
self.assertTrue(mgr.is_auto_paused)
|
||||
|
||||
def test_unload_closes_http_session(self):
|
||||
mgr = self._make_manager()
|
||||
session = MagicMock()
|
||||
mgr._http_session = session
|
||||
|
||||
mgr.unload_model()
|
||||
|
||||
session.close.assert_called_once()
|
||||
self.assertIsNone(mgr._http_session)
|
||||
|
||||
def test_unload_http_session_close_error_is_swallowed(self):
|
||||
mgr = self._make_manager()
|
||||
session = MagicMock()
|
||||
session.close.side_effect = RuntimeError("already closed")
|
||||
mgr._http_session = session
|
||||
|
||||
mgr.unload_model()
|
||||
|
||||
self.assertIsNone(mgr._http_session)
|
||||
self.assertTrue(mgr.is_auto_paused)
|
||||
|
||||
def test_unload_continues_if_gc_raises(self):
|
||||
mgr = self._make_manager()
|
||||
with patch("gc.collect", side_effect=RuntimeError("gc failed")):
|
||||
mgr.unload_model()
|
||||
self.assertTrue(mgr.is_auto_paused)
|
||||
self.assertIsNone(mgr.model)
|
||||
|
||||
def test_start_recognition_blocked_when_auto_paused(self):
|
||||
mgr = self._make_manager()
|
||||
mgr._auto_paused = True
|
||||
# model not ready either; auto-pause should win first
|
||||
with (
|
||||
patch("vocalinux.speech_recognition.recognition_manager.play_error_sound"),
|
||||
patch("vocalinux.speech_recognition.recognition_manager._show_notification"),
|
||||
):
|
||||
mgr.start_recognition()
|
||||
|
||||
self.assertEqual(mgr.state, RecognitionState.IDLE)
|
||||
# Should not have transitioned to listening
|
||||
mgr._update_state.assert_not_called()
|
||||
|
||||
def test_unload_idle_keepalive_sets_idle_flag_not_auto_pause(self):
|
||||
mgr = self._make_manager()
|
||||
mgr.unload_model(reason="idle_keepalive")
|
||||
self.assertFalse(mgr.is_auto_paused)
|
||||
self.assertTrue(mgr.is_idle_unloaded)
|
||||
self.assertIsNone(mgr.model)
|
||||
|
||||
def test_ensure_model_loaded_reloads_after_idle_unload(self):
|
||||
mgr = self._make_manager()
|
||||
mgr.unload_model(reason="idle_keepalive")
|
||||
|
||||
def init_vosk():
|
||||
mgr.model = MagicMock()
|
||||
mgr._model_initialized = True
|
||||
|
||||
mgr._init_vosk.side_effect = init_vosk
|
||||
self.assertTrue(mgr.ensure_model_loaded())
|
||||
self.assertFalse(mgr.is_idle_unloaded)
|
||||
self.assertTrue(mgr.model_ready)
|
||||
|
||||
def test_ensure_model_loaded_blocked_when_auto_paused(self):
|
||||
mgr = self._make_manager()
|
||||
mgr.unload_model(reason="auto_pause")
|
||||
self.assertFalse(mgr.ensure_model_loaded())
|
||||
mgr._init_vosk.assert_not_called()
|
||||
|
||||
def test_start_recognition_lazy_reloads_after_idle_unload(self):
|
||||
mgr = self._make_manager()
|
||||
mgr.unload_model(reason="idle_keepalive")
|
||||
|
||||
def init_vosk():
|
||||
mgr.model = MagicMock()
|
||||
mgr._model_initialized = True
|
||||
|
||||
mgr._init_vosk.side_effect = init_vosk
|
||||
mgr.should_record = False
|
||||
mgr._recognition_mode = "toggle"
|
||||
mgr.audio_buffer = []
|
||||
mgr._segment_queue = None
|
||||
mgr.audio_thread = None
|
||||
mgr.recognition_thread = None
|
||||
|
||||
with (
|
||||
patch("vocalinux.speech_recognition.recognition_manager.play_start_sound"),
|
||||
patch(
|
||||
"vocalinux.speech_recognition.recognition_manager.threading.Thread"
|
||||
) as mock_thread,
|
||||
):
|
||||
mock_thread.return_value = MagicMock()
|
||||
mgr.start_recognition()
|
||||
|
||||
self.assertFalse(mgr.is_idle_unloaded)
|
||||
mgr._update_state.assert_called()
|
||||
|
||||
def test_reinitialize_clears_auto_pause_and_reloads(self):
|
||||
mgr = self._make_manager()
|
||||
mgr._auto_paused = True
|
||||
mgr.model = None
|
||||
mgr._model_initialized = False
|
||||
|
||||
# Simulate successful reinit setting model ready
|
||||
def init_vosk():
|
||||
mgr.model = MagicMock()
|
||||
mgr._model_initialized = True
|
||||
|
||||
mgr._init_vosk.side_effect = init_vosk
|
||||
|
||||
mgr.reinitialize_after_resume()
|
||||
|
||||
mgr._init_vosk.assert_called_once()
|
||||
self.assertFalse(mgr.is_auto_paused)
|
||||
self.assertIsNotNone(mgr.model)
|
||||
|
||||
def test_pause_then_resume_via_monitor_and_engine(self):
|
||||
"""End-to-end of the shipped path: match → unload → clear → reinit."""
|
||||
mgr = self._make_manager()
|
||||
state = {"running": {"overwatch"}}
|
||||
|
||||
def on_pause():
|
||||
mgr.unload_model()
|
||||
|
||||
def on_resume():
|
||||
def init_vosk():
|
||||
mgr.model = MagicMock()
|
||||
mgr._model_initialized = True
|
||||
|
||||
mgr._init_vosk.side_effect = init_vosk
|
||||
mgr.reinitialize_after_resume()
|
||||
|
||||
monitor = AutoPauseMonitor(
|
||||
get_config=lambda: (True, ["overwatch"], 5.0),
|
||||
on_pause=on_pause,
|
||||
on_resume=on_resume,
|
||||
process_snapshot=lambda: state["running"],
|
||||
use_glib=False,
|
||||
)
|
||||
|
||||
monitor.check_once()
|
||||
self.assertTrue(mgr.is_auto_paused)
|
||||
self.assertIsNone(mgr.model)
|
||||
|
||||
state["running"] = set()
|
||||
monitor.check_once()
|
||||
self.assertFalse(mgr.is_auto_paused)
|
||||
self.assertIsNotNone(mgr.model)
|
||||
self.assertTrue(mgr._model_initialized)
|
||||
|
||||
|
||||
class TestAutoPauseConfigDefaults(unittest.TestCase):
|
||||
"""DEFAULT_CONFIG schema for auto_pause section."""
|
||||
|
||||
def test_default_config_has_auto_pause_section(self):
|
||||
self.assertIn("auto_pause", DEFAULT_CONFIG)
|
||||
section = DEFAULT_CONFIG["auto_pause"]
|
||||
self.assertFalse(section["enabled"])
|
||||
self.assertEqual(section["apps"], [])
|
||||
self.assertIn("poll_interval_seconds", section)
|
||||
|
||||
def test_default_config_has_model_keepalive_section(self):
|
||||
self.assertIn("model_keepalive", DEFAULT_CONFIG)
|
||||
section = DEFAULT_CONFIG["model_keepalive"]
|
||||
self.assertFalse(section["enabled"])
|
||||
self.assertEqual(section["idle_timeout_seconds"], 300)
|
||||
|
||||
def test_config_manager_round_trip_auto_pause(self):
|
||||
import json
|
||||
import tempfile
|
||||
from unittest.mock import patch
|
||||
|
||||
from vocalinux.ui.config_manager import ConfigManager
|
||||
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
config_dir = os.path.join(tmp, "vocalinux")
|
||||
config_file = os.path.join(config_dir, "config.json")
|
||||
os.makedirs(config_dir, exist_ok=True)
|
||||
|
||||
with (
|
||||
patch("vocalinux.ui.config_manager.CONFIG_DIR", config_dir),
|
||||
patch("vocalinux.ui.config_manager.CONFIG_FILE", config_file),
|
||||
):
|
||||
cm = ConfigManager()
|
||||
self.assertFalse(cm.get_bool("auto_pause", "enabled", True))
|
||||
self.assertEqual(cm.get("auto_pause", "apps", None), [])
|
||||
|
||||
cm.set("auto_pause", "enabled", True)
|
||||
cm.set("auto_pause", "apps", ["Overwatch", "steam"])
|
||||
self.assertTrue(cm.save_config())
|
||||
|
||||
cm2 = ConfigManager()
|
||||
self.assertTrue(cm2.get_bool("auto_pause", "enabled", False))
|
||||
self.assertEqual(cm2.get("auto_pause", "apps"), ["Overwatch", "steam"])
|
||||
|
||||
with open(config_file) as f:
|
||||
raw = json.load(f)
|
||||
self.assertIn("auto_pause", raw)
|
||||
self.assertEqual(raw["auto_pause"]["apps"], ["Overwatch", "steam"])
|
||||
|
||||
|
||||
# Tray wiring tests live in test_suspend_handler.py (TestTrayAutoPauseWiring)
|
||||
# so this module never imports tray_indicator and cannot pin a stale gi/GLib
|
||||
# mock for later suite files.
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,156 @@
|
||||
"""Tests for model keep-alive idle unload helper."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
from vocalinux.model_keepalive import (
|
||||
DEFAULT_IDLE_TIMEOUT_SECONDS,
|
||||
ModelKeepAlive,
|
||||
clamp_idle_timeout,
|
||||
)
|
||||
from vocalinux.ui.config_manager import DEFAULT_CONFIG
|
||||
|
||||
|
||||
class TestClampIdleTimeout(unittest.TestCase):
|
||||
def test_clamps_low_and_high(self):
|
||||
self.assertEqual(clamp_idle_timeout(10), 60)
|
||||
self.assertEqual(clamp_idle_timeout(99999), 3600)
|
||||
self.assertEqual(clamp_idle_timeout(300), 300)
|
||||
|
||||
def test_invalid_falls_back_to_default(self):
|
||||
self.assertEqual(clamp_idle_timeout("nope"), float(DEFAULT_IDLE_TIMEOUT_SECONDS))
|
||||
self.assertEqual(clamp_idle_timeout(None), float(DEFAULT_IDLE_TIMEOUT_SECONDS))
|
||||
|
||||
|
||||
class TestModelKeepAlive(unittest.TestCase):
|
||||
def test_bump_when_disabled_cancels(self):
|
||||
fired = []
|
||||
ka = ModelKeepAlive(
|
||||
get_config=lambda: (False, 300),
|
||||
on_idle_unload=lambda: fired.append(1),
|
||||
use_glib=False,
|
||||
)
|
||||
ka.start()
|
||||
ka.bump()
|
||||
self.assertFalse(ka.armed)
|
||||
self.assertFalse(ka.fire_if_due())
|
||||
self.assertEqual(fired, [])
|
||||
|
||||
def test_bump_arms_and_fire_unloads(self):
|
||||
fired = []
|
||||
ka = ModelKeepAlive(
|
||||
get_config=lambda: (True, 300),
|
||||
on_idle_unload=lambda: fired.append(1),
|
||||
is_safe_to_unload=lambda: True,
|
||||
use_glib=False,
|
||||
)
|
||||
ka.start()
|
||||
ka.bump()
|
||||
self.assertTrue(ka.armed)
|
||||
self.assertTrue(ka.fire_if_due())
|
||||
self.assertEqual(fired, [1])
|
||||
self.assertFalse(ka.armed)
|
||||
# Second fire without re-arm is a no-op
|
||||
self.assertFalse(ka.fire_if_due())
|
||||
|
||||
def test_cancel_prevents_fire(self):
|
||||
fired = []
|
||||
ka = ModelKeepAlive(
|
||||
get_config=lambda: (True, 120),
|
||||
on_idle_unload=lambda: fired.append(1),
|
||||
use_glib=False,
|
||||
)
|
||||
ka.start()
|
||||
ka.bump()
|
||||
ka.cancel()
|
||||
self.assertFalse(ka.armed)
|
||||
self.assertFalse(ka.fire_if_due())
|
||||
self.assertEqual(fired, [])
|
||||
|
||||
def test_unsafe_predicate_skips_unload(self):
|
||||
fired = []
|
||||
ka = ModelKeepAlive(
|
||||
get_config=lambda: (True, 120),
|
||||
on_idle_unload=lambda: fired.append(1),
|
||||
is_safe_to_unload=lambda: False,
|
||||
use_glib=False,
|
||||
)
|
||||
ka.start()
|
||||
ka.bump()
|
||||
self.assertFalse(ka.fire_if_due())
|
||||
self.assertEqual(fired, [])
|
||||
|
||||
def test_callback_error_is_swallowed(self):
|
||||
def boom():
|
||||
raise RuntimeError("unload failed")
|
||||
|
||||
ka = ModelKeepAlive(
|
||||
get_config=lambda: (True, 120),
|
||||
on_idle_unload=boom,
|
||||
is_safe_to_unload=lambda: True,
|
||||
use_glib=False,
|
||||
)
|
||||
ka.start()
|
||||
ka.bump()
|
||||
self.assertFalse(ka.fire_if_due())
|
||||
|
||||
def test_config_error_disables(self):
|
||||
def bad_config():
|
||||
raise RuntimeError("config boom")
|
||||
|
||||
ka = ModelKeepAlive(get_config=bad_config, use_glib=False)
|
||||
ka.start()
|
||||
ka.bump()
|
||||
self.assertFalse(ka.armed)
|
||||
|
||||
def test_stop_and_shutdown(self):
|
||||
ka = ModelKeepAlive(get_config=lambda: (True, 120), use_glib=False)
|
||||
ka.start()
|
||||
ka.bump()
|
||||
ka.shutdown()
|
||||
self.assertFalse(ka.active)
|
||||
self.assertFalse(ka.armed)
|
||||
|
||||
def test_start_idempotent(self):
|
||||
ka = ModelKeepAlive(get_config=lambda: (True, 120), use_glib=False)
|
||||
ka.start()
|
||||
ka.start()
|
||||
self.assertTrue(ka.active)
|
||||
|
||||
def test_glib_schedule_and_timeout(self):
|
||||
"""Drive GLib scheduling via mocked gi.repository (same pattern as auto-pause)."""
|
||||
mock_glib = MagicMock()
|
||||
mock_glib.timeout_add_seconds.return_value = 42
|
||||
fired = []
|
||||
|
||||
with patch.dict(
|
||||
"sys.modules",
|
||||
{"gi": MagicMock(), "gi.repository": MagicMock(GLib=mock_glib)},
|
||||
):
|
||||
ka = ModelKeepAlive(
|
||||
get_config=lambda: (True, 90),
|
||||
on_idle_unload=lambda: fired.append(1),
|
||||
is_safe_to_unload=lambda: True,
|
||||
use_glib=True,
|
||||
)
|
||||
ka.start()
|
||||
ka.bump()
|
||||
mock_glib.timeout_add_seconds.assert_called()
|
||||
# Invoke the scheduled callback
|
||||
cb = mock_glib.timeout_add_seconds.call_args[0][1]
|
||||
self.assertFalse(cb())
|
||||
self.assertEqual(fired, [1])
|
||||
# Callback clears _timeout_id; shutdown should be a no-op cancel
|
||||
ka.shutdown()
|
||||
self.assertFalse(ka.active)
|
||||
self.assertFalse(ka.armed)
|
||||
|
||||
def test_default_config_section(self):
|
||||
self.assertIn("model_keepalive", DEFAULT_CONFIG)
|
||||
self.assertFalse(DEFAULT_CONFIG["model_keepalive"]["enabled"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -457,5 +457,191 @@ class TestTrayIndicatorResumeFlow(unittest.TestCase):
|
||||
mock_glib.source_remove.assert_not_called()
|
||||
|
||||
|
||||
class TestTrayAutoPauseWiring(unittest.TestCase):
|
||||
"""TrayIndicator auto-pause config + pause/resume handlers.
|
||||
|
||||
Kept here (not in test_auto_pause_monitor) so tray_indicator is only
|
||||
imported from this module's existing tray tests, avoiding early import
|
||||
under a collection-time gi MagicMock that would pin a stale GLib on the
|
||||
module and break SOURCE_REMOVE comparisons later in the suite.
|
||||
"""
|
||||
|
||||
def _make_tray_indicator(self):
|
||||
from vocalinux.ui.tray_indicator import TrayIndicator
|
||||
|
||||
with patch.object(TrayIndicator, "__init__", lambda self: None):
|
||||
indicator = TrayIndicator.__new__(TrayIndicator)
|
||||
|
||||
indicator.speech_engine = MagicMock()
|
||||
indicator.speech_engine.state = RecognitionState.IDLE
|
||||
indicator.speech_engine.unload_model = MagicMock()
|
||||
indicator.speech_engine.reinitialize_after_resume = MagicMock()
|
||||
indicator.speech_engine.is_auto_paused = False
|
||||
indicator.config_manager = MagicMock()
|
||||
indicator._setup_keyboard_shortcuts = MagicMock()
|
||||
indicator._input_monitor = None
|
||||
indicator._settle_timer_id = None
|
||||
indicator._monitor_timeout_id = None
|
||||
indicator._model_keepalive = MagicMock()
|
||||
indicator._auto_pause_monitor = MagicMock()
|
||||
indicator._auto_pause_monitor.paused = False
|
||||
return indicator
|
||||
|
||||
def test_get_auto_pause_config(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator.config_manager.get_bool.return_value = True
|
||||
indicator.config_manager.get.return_value = ["steam"]
|
||||
indicator.config_manager.get_float.return_value = 7.0
|
||||
|
||||
enabled, apps, interval = indicator._get_auto_pause_config()
|
||||
|
||||
assert enabled is True
|
||||
assert apps == ["steam"]
|
||||
assert interval == 7.0
|
||||
indicator.config_manager.get_bool.assert_called_with("auto_pause", "enabled", False)
|
||||
indicator.config_manager.get.assert_called_with("auto_pause", "apps", [])
|
||||
|
||||
def test_on_auto_pause_calls_unload(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator._on_auto_pause()
|
||||
indicator.speech_engine.unload_model.assert_called_once_with(reason="auto_pause")
|
||||
indicator._model_keepalive.cancel.assert_called_once()
|
||||
|
||||
def test_on_auto_resume_calls_reinit(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator._on_auto_resume()
|
||||
indicator.speech_engine.reinitialize_after_resume.assert_called_once()
|
||||
indicator._model_keepalive.bump.assert_called_once()
|
||||
|
||||
def test_get_model_keepalive_config(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator.config_manager.get_bool.return_value = True
|
||||
indicator.config_manager.get_float.return_value = 600.0
|
||||
|
||||
enabled, timeout = indicator._get_model_keepalive_config()
|
||||
|
||||
assert enabled is True
|
||||
assert timeout == 600.0
|
||||
indicator.config_manager.get_bool.assert_called_with("model_keepalive", "enabled", False)
|
||||
|
||||
def test_on_keepalive_idle_unload(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator._on_keepalive_idle_unload()
|
||||
indicator.speech_engine.unload_model.assert_called_once_with(reason="idle_keepalive")
|
||||
|
||||
def test_is_safe_for_keepalive_unload(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator.speech_engine.state = RecognitionState.IDLE
|
||||
indicator.speech_engine.is_auto_paused = False
|
||||
assert indicator._is_safe_for_keepalive_unload() is True
|
||||
|
||||
indicator.speech_engine.state = RecognitionState.LISTENING
|
||||
assert indicator._is_safe_for_keepalive_unload() is False
|
||||
|
||||
indicator.speech_engine.state = RecognitionState.IDLE
|
||||
indicator.speech_engine.is_auto_paused = True
|
||||
assert indicator._is_safe_for_keepalive_unload() is False
|
||||
|
||||
@patch("vocalinux.ui.tray_indicator.GLib")
|
||||
def test_system_resume_skips_reinit_when_auto_paused(self, mock_glib):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator.speech_engine.is_auto_paused = True
|
||||
indicator._start_input_device_monitor = MagicMock()
|
||||
|
||||
indicator._on_system_resume()
|
||||
|
||||
assert mock_glib.timeout_add_seconds.call_count == 1
|
||||
assert (
|
||||
mock_glib.timeout_add_seconds.call_args[0][1] == indicator._start_input_device_monitor
|
||||
)
|
||||
|
||||
@patch("vocalinux.ui.tray_indicator.GLib")
|
||||
def test_system_resume_reinits_when_not_auto_paused(self, mock_glib):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator.speech_engine.is_auto_paused = False
|
||||
indicator._reinit_speech_after_resume = MagicMock()
|
||||
indicator._start_input_device_monitor = MagicMock()
|
||||
|
||||
indicator._on_system_resume()
|
||||
|
||||
assert mock_glib.timeout_add_seconds.call_count == 2
|
||||
|
||||
def test_get_auto_pause_config_coerces_non_list_apps(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator.config_manager.get_bool.return_value = True
|
||||
indicator.config_manager.get.return_value = "steam" # not a list
|
||||
indicator.config_manager.get_float.return_value = 5.0
|
||||
|
||||
enabled, apps, interval = indicator._get_auto_pause_config()
|
||||
|
||||
assert enabled is True
|
||||
assert apps == []
|
||||
assert interval == 5.0
|
||||
|
||||
def test_get_auto_pause_config_treats_none_apps_as_empty(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator.config_manager.get_bool.return_value = False
|
||||
indicator.config_manager.get.return_value = None
|
||||
indicator.config_manager.get_float.return_value = 5.0
|
||||
|
||||
enabled, apps, _interval = indicator._get_auto_pause_config()
|
||||
|
||||
assert enabled is False
|
||||
assert apps == []
|
||||
|
||||
def test_on_auto_pause_fallback_stops_when_no_unload(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
# Non-callable attribute so getattr finds it but callable() is False
|
||||
indicator.speech_engine.unload_model = None
|
||||
indicator.speech_engine.state = RecognitionState.LISTENING
|
||||
indicator.speech_engine.stop_recognition = MagicMock()
|
||||
|
||||
indicator._on_auto_pause()
|
||||
|
||||
indicator.speech_engine.stop_recognition.assert_called_once()
|
||||
|
||||
def test_on_auto_pause_fallback_idle_is_noop(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator.speech_engine.unload_model = None
|
||||
indicator.speech_engine.state = RecognitionState.IDLE
|
||||
indicator.speech_engine.stop_recognition = MagicMock()
|
||||
|
||||
indicator._on_auto_pause()
|
||||
|
||||
indicator.speech_engine.stop_recognition.assert_not_called()
|
||||
|
||||
def test_on_auto_resume_swallows_reinit_errors(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator.speech_engine.reinitialize_after_resume.side_effect = RuntimeError("boom")
|
||||
|
||||
indicator._on_auto_resume() # must not raise
|
||||
|
||||
indicator.speech_engine.reinitialize_after_resume.assert_called_once()
|
||||
|
||||
def test_on_auto_resume_without_reinit_method(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
indicator.speech_engine.reinitialize_after_resume = None
|
||||
|
||||
indicator._on_auto_resume() # no-op path
|
||||
indicator._model_keepalive.bump.assert_called_once()
|
||||
|
||||
def test_quit_shuts_down_keepalive(self):
|
||||
indicator = self._make_tray_indicator()
|
||||
monitor = MagicMock()
|
||||
indicator._auto_pause_monitor = monitor
|
||||
indicator._suspend_handler = MagicMock()
|
||||
indicator._cleanup_input_monitor = MagicMock()
|
||||
indicator.shortcut_manager = MagicMock()
|
||||
indicator.text_injector = None
|
||||
|
||||
with patch("vocalinux.ui.tray_indicator.Gtk") as mock_gtk:
|
||||
indicator._quit()
|
||||
|
||||
monitor.shutdown.assert_called_once()
|
||||
indicator._model_keepalive.shutdown.assert_called_once()
|
||||
indicator._suspend_handler.shutdown.assert_called_once()
|
||||
mock_gtk.main_quit.assert_called_once()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
Reference in New Issue
Block a user