import hashlib import ctypes import json import os from pathlib import Path import subprocess import sys import tempfile import unittest from unittest.mock import Mock, patch HERE = Path(__file__).resolve().parent sys.path.insert(0, str(HERE)) import repair_windows_update_check as fix class UpdateCheckRepairTest(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory(prefix='quality firstaid repair ') self.addCleanup(self.temp.cleanup) self.root = Path(self.temp.name) / '中文 QualityCenter & files' self.root.mkdir() self.old_manager = b'known old updater fixture\n' self.old_control = b'known old controller fixture\n' self.old_manager_sha = hashlib.sha256(self.old_manager).hexdigest() self.old_control_sha = hashlib.sha256(self.old_control).hexdigest() self.reviewed_manager_hashes = fix.OLD_MANAGER_SHA256 self.reviewed_control_hashes = fix.OLD_CONTROL_SHA256 self.manager_guard = patch.object(fix, 'OLD_MANAGER_SHA256', frozenset({self.old_manager_sha})) self.control_guard = patch.object(fix, 'OLD_CONTROL_SHA256', frozenset({self.old_control_sha})) self.manager_guard.start() self.control_guard.start() self.addCleanup(self.manager_guard.stop) self.addCleanup(self.control_guard.stop) self.manager_payload, self.control_payload = fix.read_hardened_sources() for name, value in { fix.MANAGER: self.old_manager, fix.CONTROL: self.old_control, 'deploy/bootstrap/windows-start.ps1': b'original bootstrap', 'migration/database.sql.gz': b'existing migration payload', '.runtime/deployment.json': b'original private configuration', 'runtimedata/mysql/retained-database': b'imported database data', }.items(): target = self.root / name target.parent.mkdir(parents=True, exist_ok=True) target.write_bytes(value) self.manifest = { 'platform': 'windows', 'updateVersion': '2026.11.04.1', 'updateSequence': 1, 'runtimeFingerprint': 'unchanged', 'otherMetadata': {'keep': True}, 'files': [ {'path': fix.MANAGER, 'sha256': self.old_manager_sha}, {'path': fix.CONTROL, 'sha256': self.old_control_sha}, {'path': 'deploy/bootstrap/windows-start.ps1', 'sha256': 'unchanged'}, ], } self.manifest_path = self.root / 'manifest.json' self.manifest_path.write_text(json.dumps(self.manifest), encoding='utf-8') def test_backups_both_programs_and_manifest_and_preserves_private_data(self): private = {name: (self.root / name).read_bytes() for name in ['migration/database.sql.gz', '.runtime/deployment.json', 'runtimedata/mysql/retained-database']} result = fix.repair(self.root, self.manager_payload, self.control_payload) self.assertTrue(result['updateCheckRepaired']) self.assertTrue(result['controlRecoveryRepaired']) self.assertEqual(result['changedFiles'], 3) self.assertEqual((self.root / fix.MANAGER).read_bytes(), self.manager_payload) self.assertEqual((self.root / fix.CONTROL).read_bytes(), self.control_payload) expected = json.loads(json.dumps(self.manifest)) expected['files'][0]['sha256'] = hashlib.sha256(self.manager_payload).hexdigest() expected['files'][1]['sha256'] = hashlib.sha256(self.control_payload).hexdigest() self.assertEqual(json.loads(self.manifest_path.read_text()), expected) backup = self.root / result['backup'] self.assertEqual((backup / 'update_manager.py').read_bytes(), self.old_manager) self.assertEqual((backup / 'control.py').read_bytes(), self.old_control) self.assertEqual(json.loads((backup / 'manifest.json').read_text()), self.manifest) for name, value in private.items(): self.assertEqual((self.root / name).read_bytes(), value) self.assertTrue(fix.repair(self.root, self.manager_payload, self.control_payload)['alreadyRepaired']) def test_unknown_program_or_manifest_digest_is_never_overwritten(self): original_manifest = self.manifest_path.read_bytes() (self.root / fix.MANAGER).write_bytes(b'unrecognized updater') with self.assertRaisesRegex(RuntimeError, '版本'): fix.repair(self.root, self.manager_payload, self.control_payload) self.assertEqual(self.manifest_path.read_bytes(), original_manifest) (self.root / fix.MANAGER).write_bytes(self.old_manager) value = json.loads(original_manifest) value['files'][0]['sha256'] = '0' * 64 self.manifest_path.write_text(json.dumps(value), encoding='utf-8') with self.assertRaisesRegex(RuntimeError, '版本'): fix.repair(self.root, self.manager_payload, self.control_payload) self.assertEqual((self.root / fix.MANAGER).read_bytes(), self.old_manager) def test_failed_manifest_write_rolls_back_both_programs_and_manifest(self): before = {fix.MANAGER: (self.root / fix.MANAGER).read_bytes(), fix.CONTROL: (self.root / fix.CONTROL).read_bytes(), 'manifest.json': self.manifest_path.read_bytes()} original_atomic = fix.atomic calls = [] def failing(path, data): calls.append(path) if len(calls) == 3: raise OSError('simulated manifest write failure') original_atomic(path, data) with patch.object(fix, 'atomic', side_effect=failing), self.assertRaises(OSError): fix.repair(self.root, self.manager_payload, self.control_payload) self.assertEqual((self.root / fix.MANAGER).read_bytes(), before[fix.MANAGER]) self.assertEqual((self.root / fix.CONTROL).read_bytes(), before[fix.CONTROL]) self.assertEqual(self.manifest_path.read_bytes(), before['manifest.json']) self.assertEqual(len(list((self.root / '.runtime/update-check-repair-backups').iterdir())), 1) def test_retry_completes_old_new_mix_and_accepts_rolled_back_journal(self): (self.root / fix.MANAGER).write_bytes(self.manager_payload) journal = self.root / '.runtime/update/journal.json' journal.parent.mkdir(parents=True) journal.write_text(json.dumps({'phase': 'rolledBack'}), encoding='utf-8') result = fix.repair(self.root, self.manager_payload, self.control_payload) self.assertTrue(result['updateCheckRepaired']) self.assertEqual((self.root / fix.CONTROL).read_bytes(), self.control_payload) manifest = json.loads(self.manifest_path.read_text()) self.assertEqual(manifest['files'][0]['sha256'], hashlib.sha256(self.manager_payload).hexdigest()) self.assertEqual(manifest['files'][1]['sha256'], hashlib.sha256(self.control_payload).hexdigest()) def test_active_worker_and_unknown_or_unfinished_journal_block_repair(self): worker = self.root / '.runtime/update/worker.json' worker.parent.mkdir(parents=True) worker.write_text(json.dumps({'pid': __import__('os').getpid()}), encoding='utf-8') with self.assertRaisesRegex(RuntimeError, '进程'): fix.repair(self.root, self.manager_payload, self.control_payload) worker.unlink() journal = worker.parent / 'journal.json' for value in ({'phase': 'installing'}, {'phase': 'futurePhase'}, {'unknown': True}): journal.write_text(json.dumps(value), encoding='utf-8') with self.assertRaises(RuntimeError): fix.repair(self.root, self.manager_payload, self.control_payload) self.assertEqual((self.root / fix.MANAGER).read_bytes(), self.old_manager) journal.unlink() def test_windows_worker_probe_is_read_only_for_missing_and_live_pids(self): worker = self.root / '.runtime/update/worker.json' worker.parent.mkdir(parents=True) worker.write_text(json.dumps({'pid': 424242}), encoding='utf-8') missing_kernel = Mock() missing_kernel.OpenProcess = Mock(return_value=None) missing_kernel.GetExitCodeProcess = Mock() missing_kernel.CloseHandle = Mock() with (patch.object(fix.os, 'name', 'nt'), patch.object(fix.os, 'kill', side_effect=AssertionError('os.kill must not run')) as kill, patch('ctypes.WinDLL', return_value=missing_kernel, create=True), patch('ctypes.get_last_error', return_value=87, create=True)): self.assertFalse(fix.worker_active(self.root.resolve())) kill.assert_not_called() missing_kernel.GetExitCodeProcess.assert_not_called() missing_kernel.CloseHandle.assert_not_called() missing_kernel.TerminateProcess.assert_not_called() missing_kernel.OpenProcess.assert_called_once_with(0x1000, False, 424242) denied_kernel = Mock() denied_kernel.OpenProcess = Mock(return_value=None) denied_kernel.GetExitCodeProcess = Mock() denied_kernel.CloseHandle = Mock() with (patch.object(fix.os, 'name', 'nt'), patch.object(fix.os, 'kill', side_effect=AssertionError('os.kill must not run')) as kill, patch('ctypes.WinDLL', return_value=denied_kernel, create=True), patch('ctypes.get_last_error', return_value=5, create=True)): with self.assertRaisesRegex(RuntimeError, '无法只读确认'): fix.worker_active(self.root.resolve()) kill.assert_not_called() denied_kernel.TerminateProcess.assert_not_called() live_kernel = Mock() live_kernel.OpenProcess = Mock(return_value=123) live_kernel.CloseHandle = Mock(return_value=1) def set_still_active(_handle, output): ctypes.cast(output, ctypes.POINTER(ctypes.c_ulong)).contents.value = 259 return 1 live_kernel.GetExitCodeProcess = Mock(side_effect=set_still_active) with (patch.object(fix.os, 'name', 'nt'), patch.object(fix.os, 'kill', side_effect=AssertionError('os.kill must not run')) as kill, patch('ctypes.WinDLL', return_value=live_kernel, create=True)): self.assertTrue(fix.worker_active(self.root.resolve())) kill.assert_not_called() live_kernel.CloseHandle.assert_called_once_with(123) live_kernel.TerminateProcess.assert_not_called() def test_stale_worker_pid_allows_repair_and_live_reused_pid_fails_closed(self): worker = self.root / '.runtime/update/worker.json' worker.parent.mkdir(parents=True) worker.write_text(json.dumps({'pid': 424242}), encoding='utf-8') with patch.object(fix.os, 'kill', side_effect=ProcessLookupError): self.assertTrue(fix.repair(self.root, self.manager_payload, self.control_payload)['updateCheckRepaired']) # A live process with a stale/reused PID is treated as active; no identity match is required. (self.root / fix.MANAGER).write_bytes(self.old_manager) (self.root / fix.CONTROL).write_bytes(self.old_control) self.manifest_path.write_text(json.dumps(self.manifest), encoding='utf-8') with patch.object(fix.os, 'kill', return_value=None): with self.assertRaisesRegex(RuntimeError, '仍在运行'): fix.repair(self.root, self.manager_payload, self.control_payload) def test_update_lock_blocks_firstaid(self): with fix.update_lock(self.root), self.assertRaisesRegex(RuntimeError, '仍在运行'): fix.repair(self.root, self.manager_payload, self.control_payload) def test_self_contained_cmd_uses_bundled_python_and_latest_source_bytes(self): manager, control = fix.read_hardened_sources() # This models a crash after source replacement but before manifest update. (self.root / fix.MANAGER).write_bytes(manager) (self.root / fix.CONTROL).write_bytes(control) value = json.loads(self.manifest_path.read_text()) value['files'][0]['sha256'] = '29512f15a9ee329bc7c7777454bdd79aa7ffd11c3cffa9400b8a4585bdabf35b' value['files'][1]['sha256'] = 'd98fa24d17e9bdd90ff37f9886df280451eceabac0df35d2eeecf4fe615bc6f1' self.manifest_path.write_text(json.dumps(value), encoding='utf-8') command = self.root / '兼容旧安装修复.cmd' body = fix.command_file() command.write_bytes(body) module, payload = body.rsplit(fix.MODULE_MARKER, 1)[1].rsplit(fix.PAYLOAD_MARKER, 1) embedded = {} exec(compile(payload.decode('ascii'), str(command), 'exec'), embedded) self.assertEqual(embedded['PATCHED_MANAGER'], manager) self.assertEqual(embedded['PATCHED_CONTROL'], control) code = body.decode('utf-8').split(' -c "', 1)[1].split('" "%~f0"', 1)[0] result = subprocess.run([sys.executable, '-I', '-S', '-B', '-X', 'utf8', '-c', code, str(command)], capture_output=True, text=True) self.assertEqual(result.returncode, 0, result.stderr) self.assertEqual((self.root / fix.MANAGER).read_bytes(), manager) self.assertEqual((self.root / fix.CONTROL).read_bytes(), control) manifest = json.loads(self.manifest_path.read_text()) self.assertEqual(manifest['files'][0]['sha256'], hashlib.sha256(manager).hexdigest()) self.assertEqual(manifest['files'][1]['sha256'], hashlib.sha256(control).hexdigest()) command_header = body.split(fix.MODULE_MARKER, 1)[0].decode('utf-8') self.assertNotIn('powershell.exe', command_header) self.assertNotIn('windows-start.ps1', command_header) self.assertIn(' -I -S -B ', command_header) def test_historical_allowlist_matches_known_release_inputs(self): self.assertEqual(self.reviewed_manager_hashes, frozenset({ '29512f15a9ee329bc7c7777454bdd79aa7ffd11c3cffa9400b8a4585bdabf35b', 'b91cb7fec10e183d2904d86f032ff0ffcf7f19f7cb27aecd2d803d3448685482', 'a4bd05789f559fede0bed083ce61123307d6b5cf52fa638b6bde1fa112a0348a', })) self.assertEqual(self.reviewed_control_hashes, frozenset({ 'd98fa24d17e9bdd90ff37f9886df280451eceabac0df35d2eeecf4fe615bc6f1', })) if __name__ == '__main__': unittest.main()