One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""Synthetic Input controls: no task registration or UAC prompts."""
import ctypes
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import Mock, patch
from PySide6.QtWidgets import QApplication, QWidget, QVBoxLayout
import firewall_win
import input_injector
import kvm_bridge_win as kvm
import widgets
from input_blocker import ForegroundBlocker
class AdminControlTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = QApplication.instance() or QApplication([])
def make_control(self, enabled=False, reason=""):
import admin_mode
page = SimpleNamespace(
_set_admin_mode=Mock(),
_refresh_admin_mode=lambda: kvm.WindowsApplication._refresh_admin_mode(page),
)
host = QWidget()
self.addCleanup(host.deleteLater)
module = SimpleNamespace(body=QVBoxLayout(host))
with patch.object(admin_mode, "enabled", return_value=enabled), \
patch.object(admin_mode, "unavailable_reason", return_value=reason):
kvm.WindowsApplication._admin_control(page, module)
return page, host
def test_toggle_matches_existing_switch_and_defaults_off(self):
page, host = self.make_control()
self.assertIsInstance(page.admin_switch, widgets.Switch)
self.assertFalse(page.admin_switch.isChecked())
self.assertTrue(page.admin_switch.isEnabled())
self.assertEqual(page.admin_switch.text(), "Control administrator windows")
self.assertIn("this PC", page.admin_note.text())
host.resize(340, 200)
host.layout().activate()
self.assertLessEqual(page.admin_switch.geometry().right(), host.width())
def test_unavailable_account_or_portable_has_visible_reason(self):
for reason in ("Use an administrator account on this PC.", "Install Beamer to use this setting."):
page, _ = self.make_control(reason=reason)
self.assertFalse(page.admin_switch.isEnabled())
self.assertEqual(page.admin_note.text(), reason)
def test_cancelled_request_restores_toggle_without_quitting(self):
page, _ = self.make_control(enabled=False)
page.quit = Mock()
page.admin_switch.setChecked(True)
kvm.WindowsApplication._on_admin_mode_changed(page, OSError("Administrator permission was cancelled. Nothing changed."))
self.assertFalse(page.admin_switch.isChecked())
self.assertIn("cancelled", page.admin_note.text())
page.quit.assert_not_called()
def test_success_quits_only_after_helper_completes(self):
page, _ = self.make_control()
page.quit = Mock()
kvm.WindowsApplication._on_admin_mode_changed(page, None)
page.quit.assert_called_once_with()
def test_pending_request_keeps_old_state_and_passes_active_pairing_path(self):
import admin_mode
page, _ = self.make_control()
page.config_path = Path(r"C:\Synthetic Profile\settings.json")
page.bridge = SimpleNamespace(admin_changed=SimpleNamespace(emit=Mock()))
with patch.object(kvm.threading, "Thread") as thread, \
patch.object(admin_mode, "change", return_value=True) as change:
kvm.WindowsApplication._set_admin_mode(page, True)
self.assertFalse(page.admin_switch.isChecked())
self.assertFalse(page.admin_switch.isEnabled())
change.assert_not_called()
thread.call_args.kwargs["target"]()
change.assert_called_once_with(True, config_path=page.config_path)
page.bridge.admin_changed.emit.assert_called_once_with(None)
def test_no_change_does_not_quit_the_only_receiver(self):
page, _ = self.make_control()
page.quit = Mock()
page._refresh_admin_mode = Mock()
kvm.WindowsApplication._on_admin_mode_changed(page, False)
page.quit.assert_not_called()
page._refresh_admin_mode.assert_called_once_with()
class ElevatedDiagnosticTests(unittest.TestCase):
def test_elevated_receiver_does_not_blame_equal_integrity_target(self):
blocker = ForegroundBlocker(process_name="admin.exe", elevated=True, integrity=0x3000)
notices = []
with patch.object(input_injector, "is_elevated", return_value=True, create=True), \
patch.object(input_injector, "on_problem", notices.append), \
patch.object(input_injector, "_problem_at", float("-inf")), \
patch.object(input_injector, "_problem_notified", set()):
input_injector.report_input_problem(blocker)
self.assertEqual(len(notices), 1)
self.assertNotIn("running as administrator", notices[0])
self.assertIn("admin.exe", notices[0])
def test_elevated_firewall_denial_does_not_ask_for_permission_it_has(self):
status = firewall_win.FirewallStatus(24820, False, False, (), (), False, (), True,
error="permission-denied")
self.assertNotIn("without administrator permission", firewall_win.advise(status).sentence)
def test_medium_replacement_waits_for_high_instance_mutex(self):
kernel = SimpleNamespace(CreateMutexW=Mock(return_value=None))
with patch.object(kvm.sys, "platform", "win32"), \
patch.object(kvm, "_windows_kernel32", return_value=kernel), \
patch.object(ctypes, "get_last_error", return_value=5, create=True):
self.assertIsNone(kvm._claim_instance())
if __name__ == "__main__":
unittest.main()
class SignInHintTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = QApplication.instance() or QApplication([])
def hint(self, *, admin_on, enabled):
import admin_mode
import autostart_win
page = SimpleNamespace(_set_start_at_logon=Mock())
with patch.object(admin_mode, "enabled", return_value=admin_on), \
patch.object(autostart_win, "installed_exe", return_value=r"C:\Synthetic\Beamer.exe"), \
patch.object(autostart_win, "can_run_for_current_user", return_value=True), \
patch.object(autostart_win, "is_enabled", return_value=enabled):
module = kvm.WindowsApplication._sign_in_module(page)
return page.logon_hint.text()
def test_hint_says_administrator_only_when_the_task_runs_elevated(self):
for enabled in (True, False):
with self.subTest(enabled=enabled):
self.assertIn("as administrator", self.hint(admin_on=True, enabled=enabled))
self.assertNotIn("without an administrator prompt", self.hint(admin_on=True, enabled=enabled))
self.assertNotIn("as administrator", self.hint(admin_on=False, enabled=enabled))