added adaptive quickshell

This commit is contained in:
wt committed 2026-11-17 18:15:16 +07:00
1 parent 6eb56d2065
commit 5b33a73fd8
189 files changed
+8678 -15

No files matched your search

+164
View File
@@ -0,0 +1,164 @@
"""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()