329 lines
16 KiB
Python
329 lines
16 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 list(request.evidence_dir.rglob('library-before/target.lmc'))
|
|
|
|
|
|
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'
|
|
|
|
|
|
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())
|
|
_idle_check(request.lmc_file, original, original.parent/'PCB/A.pcb')
|
|
assert any("Name='viewdraw.exe'" in query for query in queries)
|
|
|
|
|
|
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'
|
|
assert list(request.evidence_dir.rglob('source-before/session.log'))[0].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_complete_recovery_copies(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-before/target.lmc'))
|
|
assert list(request.evidence_dir.rglob('source-before/database/icdb.dat'))
|
|
|
|
|
|
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'
|