Files
cbb-refresh-verify-795/tests/test_backup_recovery.py

448 lines
22 KiB
Python

import pytest
from pathlib import Path
from cbb_refresh_verify.verify_runner import VerifyRequest, VerifyResult
def project(work, name, data):
(work/'database').mkdir(parents=True)
(work/'database/icdb.dat').write_bytes(data)
(work/'PCB/Layout').mkdir(parents=True)
(work/'PCB/Layout/LayoutDB.lyt').write_bytes(data)
(work/'PCB'/f'{name}.pcb').write_text(f'SECTION Integration\nKEY ProjectFile "..\\{name}.prj"\nENDSECTION\n')
(work/'PCB/pcb.prj').write_text('SECTION Project\nKEY CentralLibrary "old.lmc"\nENDSECTION\n')
path = work/f'{name}.prj'
path.write_text(f'SECTION Board1\nKEY RootBlock "{name}"\nKEY PCBDesignPath "PCB\\{name}.pcb"\nENDSECTION\n'
'SECTION DesignInfo\nKEY CentralLibrary "old.lmc"\nENDSECTION\n'
'SECTION iCDB\nKEY iCDBDir ".\\database"\nENDSECTION\n')
return path
@pytest.fixture
def recovery_files(tmp_path, monkeypatch):
monkeypatch.setattr(Path, 'home', lambda: tmp_path/'profile')
library = tmp_path/'target/target.lmc'
original = project(library.parent/'ReusableBlocksLP/A/Work', 'A', b'damaged')
library.write_bytes(b'library')
source = project(tmp_path/'backup/Work', 'A', b'healthy')
return VerifyRequest(library, 'A', tmp_path/'evidence'), original, source
def test_restore_checks_source_in_library_copy_then_opens_actual_target(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
pcb_project = source.parent/'PCB/pcb.prj'
pcb_project.write_text(pcb_project.read_text() +
'SECTION SecondNativeConfiguration\nKEY CentralLibrary "old.lmc"\nENDSECTION\n')
before = source.read_bytes()
calls = []
def verify(req, **kwargs):
work = req.lmc_file.parent/'ReusableBlocksLP/A/Work'
assert (work/'database/icdb.dat').read_bytes() == b'healthy'
if calls:
assert req.lmc_file == request.lmc_file
else:
assert req.lmc_file != request.lmc_file
assert not req.lmc_file.is_relative_to(request.evidence_dir)
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
calls.append(req)
assert not req.auto_repair
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'PASS'
assert len(calls) == 2
assert source.read_bytes() == before
assert (original.parent/'database/icdb.dat').read_bytes() == b'healthy'
retained = list(original.parent.parent.glob('Work.before-restore-*'))
assert len(retained) == 1
assert (retained[0]/'database/icdb.dat').read_bytes() == b'damaged'
assert not list(request.evidence_dir.rglob('library-before'))
assert not list(request.evidence_dir.rglob('source-before'))
def test_invalid_source_does_not_touch_target(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
source.write_text(source.read_text().replace('RootBlock "A"', 'RootBlock "OTHER"'))
result = recover_from_backup(request, source, verifier=lambda *_: pytest.fail('must not verify'),
idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert '同名' in result.stderr
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
@pytest.mark.parametrize('linked_to_target', [True, False])
def test_legacy_backup_without_auxiliary_pcb_project(recovery_files, linked_to_target):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
(source.parent/'PCB/pcb.prj').unlink()
if not linked_to_target:
pcb = source.parent/'PCB/A.pcb'
pcb.write_text(pcb.read_text().replace('A.prj', 'OTHER.prj'))
calls = []
def verify(req, **kwargs):
work = req.lmc_file.parent/'ReusableBlocksLP/A/Work'
assert not (work/'PCB/pcb.prj').exists()
calls.append(req)
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
if linked_to_target:
assert result.status == 'PASS', result.stderr
assert len(calls) == 2
assert (original.parent/'database/icdb.dat').read_bytes() == b'healthy'
else:
assert result.status == 'BLOCKED'
assert not calls
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
def test_unusable_backup_never_replaces_target(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
result = recover_from_backup(request, source, verifier=lambda *a, **k:
VerifyResult('FAIL', stderr='ICDB cannot load'), idle_check=lambda *_: None)
assert result.status == 'FAIL'
assert '目标未更改' in result.stderr
assert not list(original.parent.parent.glob('Work.before-restore-*'))
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
def test_final_open_failure_preserves_original_and_does_not_report_pass(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
calls = []
def verify(req, **kwargs):
calls.append(req)
return (VerifyResult('PASS', library_flag='GREEN') if len(calls) == 1 else
VerifyResult('FAIL', stderr='共享符号库不可用', safe_to_continue=False))
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'FAIL'
assert not result.safe_to_continue
assert '共享符号库不可用' in result.stderr
assert list(original.parent.parent.glob('Work.before-restore-*'))
def test_source_verify_must_confirm_green_and_release(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
result = recover_from_backup(request, source, verifier=lambda *a, **k:
VerifyResult('PASS', library_flag='UNKNOWN'), idle_check=lambda *_: None)
assert result.status != 'PASS'
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
def test_external_changes_during_validation_stop_install(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
def verify(*args, **kwargs):
(original.parent/'database/icdb.dat').write_bytes(b'another-user')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status != 'PASS'
assert '变化' in result.stderr
assert (original.parent/'database/icdb.dat').read_bytes() == b'another-user'
@pytest.mark.parametrize('field', ['ProjectFile', 'iCDBDir'])
def test_absolute_source_references_are_rejected_before_native_open(recovery_files, field):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
if field == 'ProjectFile':
path = source.parent/'PCB/A.pcb'
path.write_text(f'SECTION Integration\nKEY ProjectFile "{source}"\nENDSECTION\n')
else:
source.write_text(source.read_text().replace('".\\database"', f'"{source.parent / "database"}"'))
result = recover_from_backup(request, source, verifier=lambda *a, **k:
pytest.fail('must not launch native against source'), idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert '相对' in result.stderr
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
def test_idle_guard_queries_supported_native_process_names(recovery_files, monkeypatch):
import win32com.client
from cbb_refresh_verify.backup_recovery import _idle_check
request, original, source = recovery_files
queries = []
class EmptyProcesses:
def ExecQuery(self, query):
queries.append(query)
return []
monkeypatch.setattr(win32com.client, 'GetObject', lambda _: EmptyProcesses())
from cbb_refresh_verify import owner_probe
import subprocess
monkeypatch.setattr(owner_probe.subprocess, 'run', lambda command, **kw:
subprocess.CompletedProcess(command, owner_probe.owner_probe_main(command[-1])))
_idle_check(request.lmc_file, original, original.parent/'PCB/A.pcb')
assert any("Name='viewdraw.exe'" in query for query in queries)
def test_idle_guard_ignores_unrelated_project_and_prefix_sibling(recovery_files, monkeypatch):
from cbb_refresh_verify.backup_recovery import _idle_check
from cbb_refresh_verify import mentor_adapter
request, original, _ = recovery_files
unrelated = original.parent.with_name(original.parent.name+'Old')/'PCB/A.pcb'
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [(123, '', str(unrelated))])
monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda names:[
dict(pid=123,name='ExpeditionPCB.exe',executable='ExpeditionPCB.exe',
command=f'ExpeditionPCB.exe "{unrelated}" -ReusableCircuit',parent=0)])
_idle_check(request.lmc_file, original, original.parent/'PCB/A.pcb')
def test_idle_guard_rejects_exact_target_process(recovery_files, monkeypatch):
from cbb_refresh_verify.backup_recovery import _idle_check
from cbb_refresh_verify import mentor_adapter
request, original, _ = recovery_files
target = original.parent/'PCB/A.pcb'
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [])
monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda names:[
dict(pid=123,name='ExpeditionPCB.exe',executable='ExpeditionPCB.exe',
command=f'ExpeditionPCB.exe "{target}" -ReusableCircuit',parent=0)])
with pytest.raises(ValueError, match='TARGET_NATIVE_OWNER_ACTIVE'):
_idle_check(request.lmc_file, original, target)
@pytest.mark.parametrize('target_state', ['idle', 'open_file', 'address'])
def test_pathless_external_client_requires_resource_proof_and_confirmation(recovery_files, monkeypatch, target_state):
import pywintypes
import win32con
import win32file
from cbb_refresh_verify import mentor_adapter
from cbb_refresh_verify.backup_recovery import _idle_check
request, original, _ = recovery_files
monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners', lambda names:[
dict(pid=123,name='viewdraw.exe',executable='viewdraw.exe',command='viewdraw.exe',parent=0)])
address = original.parent/'database/cdbsvr/sAddress.adr'
handle = None
try:
if target_state == 'open_file':
handle = win32file.CreateFile(str(request.lmc_file), win32con.GENERIC_READ,
win32con.FILE_SHARE_READ, None, win32con.OPEN_EXISTING, 0, None)
with pytest.raises(pywintypes.error) as error:
_idle_check(request.lmc_file, original, original.parent/'PCB/A.pcb')
assert error.value.winerror == 32
elif target_state == 'address':
address.parent.mkdir(parents=True, exist_ok=True)
address.write_bytes(b'live or unconfirmed native address')
with pytest.raises(ValueError, match='TARGET_DATABASE_ADDRESS_UNCONFIRMED'):
_idle_check(request.lmc_file, original, original.parent/'PCB/A.pcb')
assert address.read_bytes() == b'live or unconfirmed native address'
else:
with pytest.raises(ValueError,match='TARGET_NATIVE_OWNER_UNCONFIRMED'):
_idle_check(request.lmc_file, original, original.parent/'PCB/A.pcb')
finally:
if handle is not None: handle.Close()
def test_prelaunch_recovery_rejection_has_no_unreleased_session(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, _, source = recovery_files
def reject(*args): raise ValueError('target unavailable before launch')
result = recover_from_backup(request, source, idle_check=reject,
verifier=lambda *a, **k: pytest.fail('prelaunch rejection must not start native'))
assert result.status == 'BLOCKED'
assert result.safe_to_continue
def test_report_write_failure_does_not_lose_prelaunch_release_fact(recovery_files, monkeypatch):
from cbb_refresh_verify.backup_recovery import recover_from_backup
import win32event
from uuid import uuid4
create_mutex = win32event.CreateMutex
monkeypatch.setattr(win32event, 'CreateMutex', lambda security, owned, name:
create_mutex(security, owned, name+'-test-'+uuid4().hex))
request, _, source = recovery_files
original_write = Path.write_text
def write(path, *args, **kwargs):
if path.name == 'recovery-result.json': raise OSError('report disk unavailable')
return original_write(path, *args, **kwargs)
monkeypatch.setattr(Path, 'write_text', write)
def reject(*args): raise ValueError('prelaunch unavailable')
result = recover_from_backup(request, source, idle_check=reject)
assert result.status == 'BLOCKED' and result.safe_to_continue
assert 'report disk unavailable' in result.stderr
def test_copy_refuses_directory_junction_before_copying(tmp_path):
import subprocess
from cbb_refresh_verify.backup_recovery import _copy_verified
source = tmp_path/'source'; source.mkdir()
outside = tmp_path/'outside'; outside.mkdir()
(outside/'sentinel').write_bytes(b'do not copy or modify')
linked = source/'linked'
result = subprocess.run(['cmd', '/c', 'mklink', '/J', str(linked), str(outside)], capture_output=True)
assert result.returncode == 0
with pytest.raises(ValueError, match='链接'):
_copy_verified(source, tmp_path/'destination')
assert not (tmp_path/'destination').exists()
assert (outside/'sentinel').read_bytes() == b'do not copy or modify'
def test_target_native_verification_keeps_selected_library_alias(recovery_files):
import subprocess
from dataclasses import replace
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
alias = request.lmc_file.parent.with_name('selected-library')
made = subprocess.run(['cmd', '/c', 'mklink', '/J', str(alias), str(request.lmc_file.parent)], capture_output=True)
assert made.returncode == 0
selected = alias/request.lmc_file.name
calls = []
def verify(req, **kwargs):
calls.append(req.lmc_file)
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(replace(request, lmc_file=selected), source,
verifier=verify, idle_check=lambda *_: None)
assert result.status == 'PASS'
assert calls[-1] == selected
def test_equivalent_library_reference_preserves_native_project_bytes_and_date(recovery_files):
from cbb_refresh_verify.backup_recovery import _align_library
request, original, source = recovery_files
original.write_text(original.read_text().replace('old.lmc', '../../../target.lmc'))
before = original.read_bytes(), original.stat().st_mtime_ns
_align_library(original, original.parent/'PCB/A.pcb', request.lmc_file)
assert (original.read_bytes(), original.stat().st_mtime_ns) == before
def test_logs_and_unrelated_cbb_changes_after_snapshot_do_not_block_install(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
(source.parent/'session.log').write_bytes(b'snapshot log')
other = project(request.lmc_file.parent/'ReusableBlocksLP/B/Work', 'B', b'unrelated')
calls = []
def verify(req, **kwargs):
calls.append(req)
if len(calls) == 1:
(source.parent/'session.log').write_bytes(b'updated source log')
(original.parent/'new.log').write_bytes(b'new target log')
(other.parent/'database/icdb.dat').write_bytes(b'unrelated update')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'PASS'
assert len(calls) == 2
assert (original.parent/'database/icdb.dat').read_bytes() == b'healthy'
assert (other.parent/'database/icdb.dat').read_bytes() == b'unrelated update'
staged = calls[0].lmc_file.parent/'ReusableBlocksLP/A/Work'
assert (staged/'session.log').read_bytes() == b'snapshot log'
@pytest.mark.parametrize('location,change', [
('source', 'edit'), ('source', 'delete'), ('source', 'add'),
('target', 'delete'), ('target', 'add'), ('cert', 'edit'), ('shared', 'edit'),
])
def test_primary_conflicts_preserve_target_and_validation_evidence(recovery_files, location, change):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
if location == 'source':
conflict = source.parent/'database/icdb.dat'
elif location == 'target':
conflict = original.parent/'PCB/Layout/LayoutDB.lyt'
elif location == 'cert':
conflict = original.parent.parent/'Cert/A.prj'
else:
conflict = request.lmc_file.parent/'SymbolLibs/__ReusableBlocksSymb/icdb.dat'
conflict.parent.mkdir(parents=True, exist_ok=True)
if location in ('cert', 'shared'):
conflict.write_bytes(b'before')
calls = []
def verify(*args, **kwargs):
calls.append(args)
if change == 'delete':
conflict.unlink()
elif change == 'add':
(conflict.parent/'new-engineering.bin').write_bytes(b'new')
else:
conflict.write_bytes(b'concurrent edit')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert len(calls) == 1
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
assert not list(original.parent.parent.glob('Work.before-restore-*'))
assert list(request.evidence_dir.rglob('library-baseline-manifest.json'))
assert list(request.evidence_dir.rglob('source-manifest.json'))
assert calls[0][0].lmc_file.is_file()
assert not list(request.evidence_dir.rglob('library-before'))
def test_source_conflict_while_preparing_incoming_work_blocks_install(recovery_files, monkeypatch):
from cbb_refresh_verify import backup_recovery as recovery
request, original, source = recovery_files
copy = recovery._copy_verified
def copy_then_change_source(src, dst, **kwargs):
result = copy(src, dst, **kwargs)
if dst.name.startswith('Work.restore-'):
(source.parent/'database/icdb.dat').write_bytes(b'late concurrent change')
return result
monkeypatch.setattr(recovery, '_copy_verified', copy_then_change_source)
result = recovery.recover_from_backup(request, source,
verifier=lambda *a, **k: VerifyResult('PASS', library_flag='GREEN'), idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
def test_source_address_record_is_rechecked_after_validation(recovery_files):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
address = source.parent/'database/cdbsvr/sAddress.adr'
def idle(library, project, pcb):
if project == source and address.exists():
raise ValueError('Source database ownership is still active')
def verify(*args, **kwargs):
address.parent.mkdir(parents=True, exist_ok=True)
address.write_bytes(b'live owner')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=idle)
assert result.status == 'BLOCKED'
assert 'ownership' in result.stderr
assert address.read_bytes() == b'live owner'
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
@pytest.mark.parametrize('name', ['Logs', 'tEmP', 'bAcKuP', 'Output'])
@pytest.mark.parametrize('role', ['Work', 'Cert'])
def test_cbb_names_matching_runtime_labels_do_not_hide_target_conflicts(tmp_path, monkeypatch, name, role):
from cbb_refresh_verify.backup_recovery import recover_from_backup
monkeypatch.setattr(Path, 'home', lambda: tmp_path/'profile')
library = tmp_path/'target/target.lmc'
original = project(library.parent/f'ReusableBlocksLP/{name}/Work', name, b'damaged')
library.write_bytes(b'library')
source = project(tmp_path/'backup/Work', name, b'healthy')
request = VerifyRequest(library, name, tmp_path/'evidence')
conflict = original.parent.parent/role/'database/icdb.dat'
conflict.parent.mkdir(parents=True, exist_ok=True)
if role == 'Cert':
conflict.write_bytes(b'cert before')
calls = []
def verify(*args, **kwargs):
calls.append(args)
conflict.write_bytes(b'concurrent target edit')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert len(calls) == 1
assert conflict.read_bytes() == b'concurrent target edit'
assert not list(original.parent.parent.glob('Work.before-restore-*'))
@pytest.mark.parametrize('relative', ['SymbolLibs/temp/icdb.dat', 'SymbolLibs/Temp_a/device.sym',
'SharedDependency/hdl/Logs/design.v'])
def test_shared_partition_engineering_conflicts_block_install(recovery_files, relative):
from cbb_refresh_verify.backup_recovery import recover_from_backup
request, original, source = recovery_files
conflict = request.lmc_file.parent/relative
conflict.parent.mkdir(parents=True, exist_ok=True)
conflict.write_bytes(b'shared before')
calls = []
def verify(*args, **kwargs):
calls.append(args)
conflict.write_bytes(b'concurrent shared edit')
return VerifyResult('PASS', library_flag='GREEN')
result = recover_from_backup(request, source, verifier=verify, idle_check=lambda *_: None)
assert result.status == 'BLOCKED'
assert len(calls) == 1
assert (original.parent/'database/icdb.dat').read_bytes() == b'damaged'
assert conflict.read_bytes() == b'concurrent shared edit'