"""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()