Files
quality_analyse/deploy/offline/test_windows_update_check_repair.py
T

255 lines
14 KiB
Python

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