388 lines
21 KiB
Python
388 lines
21 KiB
Python
"""Explicit maintenance for preexisting advertisements; native writes forbidden."""
|
|
from dataclasses import replace
|
|
from contextlib import contextmanager
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def no_native_launch(monkeypatch):
|
|
import subprocess, win32process, win32com.client
|
|
import cbb_refresh_verify.desktop_worker as desktop
|
|
def forbidden(*a, **k): raise AssertionError('No native launch allowed in maintenance tests')
|
|
monkeypatch.setattr(subprocess, 'Popen', forbidden)
|
|
monkeypatch.setattr(win32process, 'CreateProcess', forbidden)
|
|
monkeypatch.setattr(win32com.client, 'Dispatch', forbidden)
|
|
monkeypatch.setattr(win32com.client, 'DispatchEx', forbidden)
|
|
monkeypatch.setattr(desktop, 'DesktopWorker', forbidden)
|
|
|
|
|
|
@pytest.fixture
|
|
def case(tmp_path, monkeypatch):
|
|
from cbb_refresh_verify.verify_runner import VerifyRequest
|
|
import cbb_refresh_verify.maintenance_entry as entry
|
|
library = tmp_path/'library/mentor.lmc'; library.parent.mkdir(); library.write_bytes(b'library')
|
|
work = library.parent/'ReusableBlocksLP/IP101GR/Work'
|
|
(work/'database/cdbsvr').mkdir(parents=True)
|
|
(work/'database/icdb.dat').write_bytes(b'schematic')
|
|
address = work/'database/cdbsvr/sAddress.adr'; address.write_bytes(b'old server address - preserved')
|
|
(work/'PCB/Layout').mkdir(parents=True)
|
|
(work/'PCB/Layout/LayoutDB.lyt').write_bytes(b'layout')
|
|
project = work/'IP101GR.prj'
|
|
project.write_text('KEY iCDBDir ".\\database"\nKEY PCBDesignPath "PCB/IP101GR.pcb"\n')
|
|
(work/'PCB/IP101GR.pcb').write_text('KEY ProjectFile "../IP101GR.prj"\n')
|
|
(work/'PCB/pcb.prj').write_text('KEY CentralLibrary "old.lmc"\n')
|
|
monkeypatch.setattr(entry, 'assert_native_idle', lambda: None)
|
|
request = VerifyRequest(library, 'IP101GR', tmp_path/'evidence', maintenance=True)
|
|
yield request, project, address
|
|
import cbb_refresh_verify.library_lock as locks
|
|
key = locks.LibraryLock(library).key
|
|
with locks._guard:
|
|
owner = locks._owners.pop(key, None)
|
|
if owner: owner['handle'].Close()
|
|
|
|
|
|
@pytest.mark.parametrize('pcb_config', ['standard', 'legacy_template'])
|
|
@pytest.mark.parametrize('advertisement', ['present', 'absent'])
|
|
def test_explicit_maintenance_enters_official_repair_once_without_lostsession_fabrication(case, monkeypatch, pcb_config, advertisement):
|
|
from cbb_refresh_verify import verify_runner as runner, native_repair
|
|
from test_native_repair import complete_native_success
|
|
request, project, address = case
|
|
if advertisement == 'absent':
|
|
address.unlink()
|
|
if pcb_config == 'legacy_template':
|
|
(project.parent/'PCB/pcb.prj').rename(project.parent/'PCB/template.prj')
|
|
calls = []
|
|
def repair(target, root, **kwargs):
|
|
calls.append('repair')
|
|
if advertisement == 'present':
|
|
assert address.read_bytes() == b'old server address - preserved'
|
|
assert kwargs['maintenance_context']['addresses'][str(address.resolve())]['sha256']
|
|
address.unlink() # Simulated native release, never a production cleanup.
|
|
else:
|
|
assert kwargs['maintenance_context']['addresses'] == {}
|
|
assert target.project == project
|
|
return complete_native_success(target)
|
|
monkeypatch.setattr(native_repair, 'run_native_repair', repair)
|
|
monkeypatch.setattr(native_repair, 'repair_release_state', lambda *a:
|
|
{'safe_to_continue': True, 'native_exited': True, 'addresses': []})
|
|
def verify(req, **kwargs):
|
|
calls.append('verify')
|
|
from cbb_refresh_verify.post_repair_consent import PostRepairProof
|
|
assert isinstance(req.post_repair_proof, PostRepairProof)
|
|
assert not req.maintenance and not req.auto_repair
|
|
assert req.lmc_file == request.lmc_file and req.block_name == request.block_name
|
|
return runner.VerifyResult('PASS', library_flag='GREEN')
|
|
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
|
|
result = runner.run_verify(request)
|
|
assert calls == ['repair', 'verify'] and result.status == 'PASS'
|
|
assert result.recovery_attempts[0]['validation_passed'] is True
|
|
record = json.loads(result.evidence_path.read_text(encoding='utf-8'))
|
|
assert record['operation'] == 'explicit_project_maintenance'
|
|
assert 'session' not in record['maintenance_context']
|
|
|
|
|
|
def test_addressless_target_binds_unique_project_and_rejects_new_address(case):
|
|
from cbb_refresh_verify.maintenance_entry import maintenance_target_guard
|
|
request, project, address = case
|
|
address.unlink()
|
|
with maintenance_target_guard(request) as checked:
|
|
context = checked['context']
|
|
assert checked['target'].project == project and context['addresses'] == {}
|
|
address.write_bytes(b'owner appeared after preflight')
|
|
with pytest.raises(ValueError, match='MAINTENANCE_SOURCE_CHANGED'):
|
|
with maintenance_target_guard(request, context): pass
|
|
|
|
|
|
@pytest.mark.parametrize('reference', ['', 'KEY ProjectFile "../Other.prj"\n',
|
|
'KEY ProjectFile "../IP101GR.prj"\nKEY ProjectFile "../IP101GR.prj"\n'])
|
|
def test_addressless_target_requires_exact_pcb_back_reference(case, reference):
|
|
from cbb_refresh_verify.maintenance_entry import select_maintenance_target
|
|
request, project, address = case
|
|
address.unlink()
|
|
(project.parent/'PCB/IP101GR.pcb').write_text(reference)
|
|
with pytest.raises(ValueError, match='PCB.*ProjectFile'):
|
|
select_maintenance_target(request)
|
|
|
|
|
|
def test_addressless_multiple_project_databases_are_not_guessed(case):
|
|
from cbb_refresh_verify.maintenance_entry import select_maintenance_target
|
|
request, project, address = case
|
|
address.unlink()
|
|
(project.parent/'PCB/pcb.prj').write_text('KEY iCDBDir "database"\n')
|
|
database = project.parent/'PCB/database'; database.mkdir()
|
|
(database/'icdb.dat').write_bytes(b'another native database')
|
|
with pytest.raises(ValueError, match='多个工程数据库'):
|
|
select_maintenance_target(request)
|
|
|
|
|
|
@pytest.mark.parametrize('back_reference', ['', 'KEY ProjectFile "../other.prj"\n',
|
|
'KEY ProjectFile "../IP101GR.prj"\nKEY ProjectFile "../IP101GR.prj"\n'])
|
|
def test_legacy_maintenance_requires_unambiguous_pcb_back_reference(case, back_reference):
|
|
from cbb_refresh_verify.maintenance_entry import select_maintenance_target
|
|
request, project, _ = case
|
|
(project.parent/'PCB/pcb.prj').rename(project.parent/'PCB/template.prj')
|
|
(project.parent/'PCB/IP101GR.pcb').write_text(back_reference)
|
|
with pytest.raises(ValueError, match='MAINTENANCE_TARGET_UNCONFIRMED'):
|
|
select_maintenance_target(request)
|
|
|
|
|
|
def test_legacy_target_does_not_guess_template_for_physical_address(case):
|
|
from cbb_refresh_verify.maintenance_entry import select_maintenance_target
|
|
request, project, address = case
|
|
(project.parent/'PCB/pcb.prj').rename(project.parent/'PCB/template.prj')
|
|
address.unlink()
|
|
physical = project.parent/'PCB/database/cdbsvr/sAddress.adr'
|
|
physical.parent.mkdir(parents=True); physical.write_bytes(b'physical owner')
|
|
with pytest.raises(ValueError, match='SHARED_DATABASE_REPAIR_UNSUPPORTED'):
|
|
select_maintenance_target(request)
|
|
|
|
|
|
def test_optional_pcb_project_appearance_invalidates_maintenance_proof(case):
|
|
from cbb_refresh_verify.maintenance_entry import maintenance_target_guard
|
|
request, project, _ = case
|
|
config = project.parent/'PCB/pcb.prj'
|
|
config.rename(config.with_name('template.prj'))
|
|
with maintenance_target_guard(request) as proof:
|
|
before = proof['context']
|
|
config.write_text('KEY CentralLibrary "different.lmc"\n')
|
|
with pytest.raises(ValueError, match='MAINTENANCE_SOURCE_CHANGED'):
|
|
with maintenance_target_guard(request, before): pass
|
|
|
|
|
|
def test_ordinary_verify_still_blocks_existing_address_without_repair(case, monkeypatch):
|
|
from cbb_refresh_verify import verify_runner as runner, native_repair
|
|
request, _, address = case
|
|
monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **k: pytest.fail('ordinary verify must not repair'))
|
|
result = runner.run_verify(replace(request, maintenance=False))
|
|
assert result.status == 'BLOCKED' and not result.safe_to_continue
|
|
assert address.read_bytes() == b'old server address - preserved'
|
|
|
|
|
|
@pytest.mark.parametrize('obstacle', ['active_owner', 'exclusive', 'shared_address', 'ambiguous', 'address_mutation'])
|
|
def test_maintenance_guard_blocks_before_native(case, monkeypatch, obstacle):
|
|
from cbb_refresh_verify import maintenance_entry as entry, native_repair, verify_runner as runner
|
|
import win32file, win32con
|
|
request, project, address = case
|
|
handle = None
|
|
if obstacle == 'active_owner':
|
|
monkeypatch.setattr(entry, 'assert_native_idle', lambda: (_ for _ in ()).throw(ValueError('native owner')))
|
|
if obstacle == 'exclusive':
|
|
handle = win32file.CreateFile(str(project.parent/'database/icdb.dat'), win32con.GENERIC_READ,
|
|
0, None, win32con.OPEN_EXISTING, 0, None)
|
|
if obstacle == 'shared_address':
|
|
shared = request.lmc_file.parent/'SymbolLibs/__ReusableBlocksSymb/cdbsvr/sAddress.adr'
|
|
shared.parent.mkdir(parents=True); shared.write_bytes(b'shared owner')
|
|
if obstacle == 'ambiguous': project.write_text(project.read_text() + 'KEY iCDBDir "other"\n')
|
|
if obstacle == 'address_mutation':
|
|
original = entry.address_snapshot
|
|
def mutate(paths):
|
|
result = original(paths)
|
|
address.write_bytes(b'changed after snapshot')
|
|
return result
|
|
monkeypatch.setattr(entry, 'address_snapshot', mutate)
|
|
monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **k: pytest.fail('guard bypass'))
|
|
try:
|
|
result = runner.run_verify(request)
|
|
assert result.status == 'BLOCKED' and not result.safe_to_continue
|
|
assert result.error_stage == 'preflight'
|
|
finally:
|
|
if handle: handle.Close()
|
|
|
|
|
|
@pytest.mark.parametrize('change', ['dead', 'same_process', 'live_foreign', 'malformed', 'foreign_library', 'guard_failure'])
|
|
def test_takeover_preserves_old_checkpoint_until_every_guard_passes(case, monkeypatch, change):
|
|
from cbb_refresh_verify import library_lock as locks, maintenance_entry as entry
|
|
request, _, address = case
|
|
library = request.lmc_file
|
|
with locks.LibraryLock(library, safe_to_release=lambda: False): pass
|
|
marker = locks.blocker_path(library)
|
|
record = json.loads(marker.read_text(encoding='utf-8'))
|
|
if change != 'same_process':
|
|
with locks._guard: locks._owners.pop(locks.LibraryLock(library).key)['handle'].Close()
|
|
record['pid'] = 789123
|
|
if change == 'foreign_library': record['library'] = str(library.parent.parent/'foreign/mentor.lmc')
|
|
marker.write_text('broken json' if change == 'malformed' else json.dumps(record), encoding='utf-8')
|
|
old = marker.read_bytes()
|
|
monkeypatch.setattr(locks, '_supervisor_alive', lambda pid: change == 'live_foreign')
|
|
if change == 'guard_failure':
|
|
monkeypatch.setattr(entry, 'assert_native_idle', lambda: (_ for _ in ()).throw(ValueError('guard failed')))
|
|
archive = request.evidence_dir/'takeover'
|
|
guard = lambda: entry.maintenance_target_guard(request)
|
|
if change in ('dead', 'same_process'):
|
|
lease = locks.LibraryLock.for_maintenance(library, archive, guard, safe_to_release=lambda: True)
|
|
with lease:
|
|
assert (archive/'previous-checkpoint.json').read_bytes() == old
|
|
assert address.exists()
|
|
import win32file, win32con
|
|
with pytest.raises(Exception):
|
|
win32file.CreateFile(str(lease.path), win32con.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, 0, None)
|
|
assert lease.path.exists() and not marker.exists()
|
|
else:
|
|
with pytest.raises((ValueError, OSError)):
|
|
with locks.LibraryLock.for_maintenance(library, archive, guard): pass
|
|
assert marker.read_bytes() == old
|
|
|
|
|
|
@pytest.mark.parametrize('status', ['MISSING_HEALTHY_BACKUP', 'RESTORED_REVIEW_REQUIRED', 'DATABASE_BUSY', 'TIMEOUT_UNRELEASED'])
|
|
def test_nonrepair_outcomes_never_verify_or_count_success(case, monkeypatch, status):
|
|
from cbb_refresh_verify import native_repair, verify_runner as runner
|
|
request, _, _ = case
|
|
monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **k: {
|
|
'status': status, 'release': {'safe_to_continue': False}, 'detail': 'native result'})
|
|
monkeypatch.setattr(native_repair, 'repair_release_state', lambda *a: {'safe_to_continue': False})
|
|
monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **k: pytest.fail('unsafe or nonrepair outcome reopened'))
|
|
result = runner.run_verify(request)
|
|
assert result.status != 'PASS' and not result.safe_to_continue
|
|
assert result.recovery_attempts[0]['status'] == status
|
|
|
|
|
|
def test_native_success_cannot_bypass_remaining_address(case, monkeypatch):
|
|
from cbb_refresh_verify import native_repair, verify_runner as runner
|
|
from test_native_repair import complete_native_success
|
|
request, _, _ = case
|
|
monkeypatch.setattr(native_repair, 'run_native_repair', lambda target, *a, **k: complete_native_success(target))
|
|
monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **k: pytest.fail('retained address reopened'))
|
|
# Native release queries remain mocked, actual address/exclusive checks stay real.
|
|
monkeypatch.setattr('cbb_refresh_verify.mentor_adapter.pcb_processes', lambda: [])
|
|
monkeypatch.setattr('cbb_refresh_verify.mentor_adapter._process_details', lambda name: [])
|
|
result = runner.run_verify(request)
|
|
assert result.status != 'PASS' and not result.safe_to_continue
|
|
|
|
|
|
@pytest.mark.parametrize('output', ['', 'Checking if project is in use.',
|
|
"Project is not in use. Full iCDB Project Backup's functionality is available.",
|
|
"Project is not in use. Full iCDB Project Backup's functionality is available.\nProject is in use."])
|
|
def test_explicit_worker_requires_positive_native_idle_before_repair(tmp_path, monkeypatch, output):
|
|
import win32con
|
|
from test_native_repair import repair_worker_fixture
|
|
import cbb_refresh_verify.maintenance_entry as entry
|
|
from cbb_refresh_verify.native_repair import RepairTarget
|
|
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'active')
|
|
values = json.loads(job.read_text())
|
|
values['maintenance_context'] = {'library': str(tmp_path/'lib.lmc'), 'block': 'CBB1'}
|
|
job.write_text(json.dumps(values))
|
|
@contextmanager
|
|
def guard(*args):
|
|
yield {'target': RepairTarget(Path(values['project']), Path(values['database']))}
|
|
monkeypatch.setattr(entry, 'maintenance_target_guard', guard)
|
|
monkeypatch.setattr(ui, '_native_output', lambda windows: output)
|
|
ui.repair_worker_main(job)
|
|
expected = output == "Project is not in use. Full iCDB Project Backup's functionality is available."
|
|
assert any(message == win32con.WM_COMMAND for _, message in actions) is expected
|
|
|
|
|
|
def test_worker_rechecks_address_after_complete_backup_before_native_launch(tmp_path, monkeypatch):
|
|
from test_native_repair import repair_worker_fixture
|
|
import cbb_refresh_verify.maintenance_entry as entry
|
|
from cbb_refresh_verify.native_repair import RepairTarget
|
|
ui, root, job, _ = repair_worker_fixture(tmp_path, monkeypatch, 'active')
|
|
values = json.loads(job.read_text()); values['maintenance_context'] = {'library': str(tmp_path/'lib.lmc'), 'block': 'CBB1'}
|
|
job.write_text(json.dumps(values))
|
|
calls = []
|
|
@contextmanager
|
|
def guard(*args):
|
|
calls.append('guard')
|
|
if len(calls) == 2: raise ValueError('address changed during complete backup')
|
|
yield {'target': RepairTarget(Path(values['project']), Path(values['database']))}
|
|
monkeypatch.setattr(entry, 'maintenance_target_guard', guard)
|
|
monkeypatch.setattr(ui.subprocess, 'Popen', lambda *a, **k: pytest.fail('mutation must stop native launch'))
|
|
ui.repair_worker_main(job)
|
|
assert calls == ['guard', 'guard']
|
|
assert 'address changed' in json.loads((root/'repair-result.json').read_text())['detail']
|
|
|
|
|
|
def test_guard_failure_keeps_takeover_checkpoint_byte_exact_when_address_changes(case, monkeypatch):
|
|
from cbb_refresh_verify import library_lock as locks, maintenance_entry as entry
|
|
request, _, address = case
|
|
with locks.LibraryLock(request.lmc_file, safe_to_release=lambda: False): pass
|
|
marker = locks.blocker_path(request.lmc_file); old = marker.read_bytes()
|
|
snapshot = entry.address_snapshot
|
|
def mutate(paths):
|
|
result = snapshot(paths); address.write_bytes(b'changed'); return result
|
|
monkeypatch.setattr(entry, 'address_snapshot', mutate)
|
|
with pytest.raises(ValueError):
|
|
with locks.LibraryLock.for_maintenance(request.lmc_file, request.evidence_dir/'takeover',
|
|
lambda: entry.maintenance_target_guard(request)): pass
|
|
assert marker.read_bytes() == old
|
|
|
|
|
|
def test_independent_cbb_address_does_not_select_or_block_current_project(case):
|
|
from cbb_refresh_verify.maintenance_entry import maintenance_target_guard
|
|
request, project, address = case
|
|
other = request.lmc_file.parent/'ReusableBlocksLP/1GPHY_8212/Work/database/cdbsvr/sAddress.adr'
|
|
other.parent.mkdir(parents=True); other.write_bytes(b'independent CBB original address')
|
|
with maintenance_target_guard(request) as checked:
|
|
assert checked['target'].project == project
|
|
assert set(checked['context']['addresses']) == {str(address.resolve())}
|
|
assert other.read_bytes() == b'independent CBB original address'
|
|
assert other.read_bytes() == b'independent CBB original address'
|
|
|
|
|
|
@pytest.mark.parametrize('status,complete,expected_safe', [
|
|
('RESTORED_REVIEW_REQUIRED', True, False), ('DATABASE_BUSY', True, False),
|
|
('UNKNOWN_DIALOG', True, False), ('UNCONFIRMED', True, False),
|
|
('MISSING_HEALTHY_BACKUP', False, False), ('NATIVE_REPAIR_FAILED', False, False),
|
|
('MISSING_HEALTHY_BACKUP', True, True), ('NATIVE_REPAIR_FAILED', True, True)])
|
|
def test_physical_release_alone_does_not_authorize_queue(case, monkeypatch, status, complete, expected_safe):
|
|
from cbb_refresh_verify import native_repair, verify_runner as runner, library_lock
|
|
from test_native_repair import complete_native_success
|
|
request, _, address = case
|
|
def repair(target, *args, **kwargs):
|
|
address.unlink() # Simulate official process releasing its test-only advertisement.
|
|
result = complete_native_success(target)
|
|
result.update(status=status, detail='native completed')
|
|
result['evidence']['failure_complete'] = complete
|
|
return result
|
|
monkeypatch.setattr(native_repair, 'run_native_repair', repair)
|
|
monkeypatch.setattr(native_repair, 'repair_release_state', lambda req, target, result: result['release'])
|
|
monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **k: pytest.fail('nonrepair outcome reopened'))
|
|
result = runner.run_verify(request)
|
|
assert result.status != 'PASS'
|
|
assert result.safe_to_continue is expected_safe
|
|
assert result.recovery_attempts[0]['status'] == status
|
|
assert library_lock.has_blocker(request.lmc_file) is not expected_safe
|
|
|
|
|
|
def test_successful_icdb_repair_then_version_choice_reports_partial_completion(case, monkeypatch):
|
|
from cbb_refresh_verify import native_repair, verify_runner as runner
|
|
from test_native_repair import complete_native_success
|
|
request, _, address = case
|
|
def repair(target, *a, **k):
|
|
address.unlink()
|
|
return complete_native_success(target)
|
|
monkeypatch.setattr(native_repair, 'run_native_repair', repair)
|
|
monkeypatch.setattr(native_repair, 'repair_release_state', lambda req, target, result: result['release'])
|
|
monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **k: runner.VerifyResult('FAIL',
|
|
error_category='PCB_VERSION_CHOICE_REQUIRED', stderr='PCB版本待选:最后用户保存/自动保存 2026/9/24 23:06',
|
|
safe_to_continue=False, evidence_path=request.evidence_dir/'verify/result.json'))
|
|
result = runner.run_verify(request)
|
|
assert result.status == 'FAIL' and not result.safe_to_continue
|
|
assert 'ICDB原生修复已完成' in result.stderr and '尚未校验通过' in result.stderr
|
|
assert result.recovery_attempts[0]['native_status'] == 'REPAIRED'
|
|
assert result.recovery_attempts[0]['status'] == 'PCB_VERSION_CHOICE_REQUIRED'
|
|
assert result.recovery_attempts[0]['validation_passed'] is False
|
|
|
|
|
|
def test_user_chosen_pcb_history_is_not_reported_as_lossless_repair(case, monkeypatch):
|
|
from cbb_refresh_verify import native_repair, verify_runner as runner
|
|
from test_native_repair import complete_native_success
|
|
request, project, address = case
|
|
address.unlink()
|
|
monkeypatch.setattr(native_repair, 'run_native_repair', lambda target, *a, **k: complete_native_success(target))
|
|
monkeypatch.setattr(native_repair, 'repair_release_state', lambda req, target, result: result['release'])
|
|
def verify(*a, **k):
|
|
root = request.evidence_dir/'verify'; root.mkdir(exist_ok=True)
|
|
(root/'pcb-version-restoration.json').write_text(json.dumps({'project': str(project),
|
|
'choice': 'last_user_saved', 'date': '2026/9/24 23:06', 'confirm_sent': True, 'historical_restore': True}))
|
|
return runner.VerifyResult('PASS', library_flag='GREEN', evidence_path=root/'result.json')
|
|
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
|
|
result = runner.run_verify(request)
|
|
assert result.status == 'PASS'
|
|
assert result.recovery_attempts[0]['status'] == 'RESTORED_REVIEW_REQUIRED'
|
|
assert result.recovery_attempts[0]['pcb_version']['choice'] == 'last_user_saved'
|