Files
dotfiles/quickshell/tests/test_power_backend.py
T
2026-11-17 18:15:16 +07:00

165 lines
7.7 KiB
Python

"""All mutation tests use injected objects. No real logind or Wayland calls."""
import importlib.util
from pathlib import Path
import subprocess
import unittest
import sys
from unittest.mock import Mock, patch
spec = importlib.util.spec_from_file_location('power_backend', Path(__file__).resolve().parents[1] / 'backend/power.py')
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'backend'))
backend = importlib.util.module_from_spec(spec)
spec.loader.exec_module(backend)
class PowerTests(unittest.TestCase):
def setUp(self):
self.events = []
self.logind = Mock()
self.logind.can.side_effect = lambda action: self.events.append('can:' + action) or 'yes'
self.logind.perform.side_effect = lambda action: self.events.append('perform:' + action)
self.observer = Mock()
self.observer.ensure_locked.side_effect = lambda: self.events.append('locked')
self.observer.close.side_effect = lambda: self.events.append('observer closed')
self.factory = Mock(return_value=self.logind)
self.observer_factory = Mock(return_value=self.observer)
def execute(self, action):
backend.execute(action, logind_factory=self.factory, observer_factory=self.observer_factory)
def test_authorization_is_not_interactive_after_lock(self):
logind = object.__new__(backend.Logind)
logind.call = Mock()
logind.perform('suspend')
logind.call.assert_called_with('Suspend', False)
logind.perform('reboot')
logind.call.assert_called_with('Reboot', True)
def test_suspend_waits_for_lock(self):
self.execute('suspend')
self.assertEqual(self.events, ['can:suspend', 'locked', 'perform:suspend', 'observer closed'])
def test_lock_failure_prevents_suspend(self):
self.observer.ensure_locked.side_effect = RuntimeError('no lock confirmation')
with self.assertRaisesRegex(RuntimeError, 'no lock confirmation'): self.execute('suspend')
self.logind.perform.assert_not_called()
self.observer.close.assert_called_once()
def test_unavailable_protocol_prevents_suspend(self):
self.observer_factory.side_effect = ImportError('no protocol')
with self.assertRaises(ImportError): self.execute('suspend')
self.logind.perform.assert_not_called()
def test_suspend_challenge_never_locks_or_sleeps(self):
self.logind.can.side_effect = None
self.logind.can.return_value = 'challenge'
with self.assertRaisesRegex(RuntimeError, 'before locking'): self.execute('suspend')
self.observer_factory.assert_not_called()
self.logind.perform.assert_not_called()
def test_reboot_challenge_uses_logind(self):
self.logind.can.side_effect = None
self.logind.can.return_value = 'challenge'
self.execute('reboot')
self.logind.perform.assert_called_once_with('reboot')
self.observer_factory.assert_not_called()
def test_denied_actions_never_execute(self):
for state in ['no', 'na', 'unknown']:
self.logind.can.side_effect = None
self.logind.can.return_value = state
with self.assertRaises(RuntimeError): self.execute('poweroff')
self.logind.perform.assert_not_called()
def test_lock_only_never_uses_logind(self):
self.execute('lock')
self.factory.assert_not_called()
self.observer.ensure_locked.assert_called_once()
self.observer.close.assert_called_once()
def test_unknown_action_never_executes(self):
with self.assertRaises(ValueError): self.execute('reboot; command')
self.factory.assert_not_called()
self.observer_factory.assert_not_called()
def test_logout_dispatch_is_fixed_and_session_scoped(self):
for provider, expected in [('lua', ['hyprctl', 'eval', 'hl.dispatch(hl.dsp.exit())']), ('conf', ['hyprctl', 'dispatch', 'exit'])]:
run = Mock()
backend.execute('logout', compositor_query=lambda: {'configProvider': provider}, run=run)
self.assertEqual(run.call_args.args[0], expected)
def test_logout_error_propagates(self):
run = Mock(side_effect=subprocess.TimeoutExpired('hyprctl', 5))
with self.assertRaises(subprocess.TimeoutExpired):
backend.execute('logout', compositor_query=lambda: {'configProvider': 'lua'}, run=run)
@patch.object(backend.shutil, 'which', return_value='/test/hyprlock')
def test_capabilities_are_real_states(self, which):
result = backend.capabilities(self.factory, self.observer_factory, lambda: {})
self.assertEqual(result['lock']['state'], 'yes')
self.assertEqual(result['suspend']['state'], 'yes')
self.logind.perform.assert_not_called()
self.observer.ensure_locked.assert_not_called()
def test_unavailable_backend_never_reports_yes(self):
fail = Mock(side_effect=RuntimeError('unavailable'))
result = backend.capabilities(fail, fail, fail)
self.assertFalse(any(action['state'] == 'yes' for action in result.values()))
from lock_observer import LockObserver
class LockObserverTests(unittest.TestCase):
def setUp(self):
self.observer = object.__new__(LockObserver)
self.observer.locked = False
self.observer.display = Mock()
self.child = Mock()
self.child.poll.return_value = None
def test_existing_lock_is_rechecked(self):
self.observer.locked = True
with patch('lock_observer.subprocess.Popen') as popen:
self.observer.ensure_locked()
self.observer.display.roundtrip.assert_called_once()
popen.assert_not_called()
def test_missing_locker_cannot_confirm_lock(self):
with patch('lock_observer.shutil.which', return_value=None):
with self.assertRaisesRegex(RuntimeError, 'not installed'): self.observer.ensure_locked()
@patch('lock_observer.shutil.which', return_value='/test/hyprlock')
def test_locker_exit_is_not_confirmation(self, which):
self.child.poll.return_value = 1
with patch('lock_observer.subprocess.Popen', return_value=self.child):
with self.assertRaisesRegex(RuntimeError, 'before the compositor'): self.observer.ensure_locked()
@patch('lock_observer.shutil.which', return_value='/test/hyprlock')
def test_lock_timeout_is_not_confirmation(self, which):
with patch('lock_observer.subprocess.Popen', return_value=self.child), patch('lock_observer.time.monotonic', side_effect=[0, 20]):
with self.assertRaisesRegex(RuntimeError, 'Timed out'): self.observer.ensure_locked()
self.child.terminate.assert_not_called()
@patch('lock_observer.shutil.which', return_value='/test/hyprlock')
def test_compositor_event_confirms_lock(self, which):
def ready(*args):
self.observer.locked = True
return ([1], [], [])
with patch('lock_observer.subprocess.Popen', return_value=self.child) as popen, patch('lock_observer.select.select', side_effect=ready):
self.observer.ensure_locked()
self.assertEqual(popen.call_args.args[0], ['/test/hyprlock', '--grace', '0'])
self.observer.display.roundtrip.assert_called_once()
@patch('lock_observer.shutil.which', return_value='/test/hyprlock')
def test_unlock_before_action_is_rejected(self, which):
def ready(*args):
self.observer.locked = True
return ([1], [], [])
self.observer.display.roundtrip.side_effect = lambda: setattr(self.observer, 'locked', False)
with patch('lock_observer.subprocess.Popen', return_value=self.child), patch('lock_observer.select.select', side_effect=ready):
with self.assertRaisesRegex(RuntimeError, 'unlocked'): self.observer.ensure_locked()
if __name__ == '__main__': unittest.main()