165 lines
7.7 KiB
Python
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()
|