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

465 lines
25 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)
monkeypatch.setattr('cbb_refresh_verify.verify_runner.runtime_fingerprint', lambda *_: {})
@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)
monkeypatch.setattr('cbb_refresh_verify.verify_runner._run_verify_serialized',
lambda req, **kw: startup_failure(req))
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()
def startup_failure(request):
"""Stub the PCB process boundary with a complete current native failure."""
from cbb_refresh_verify.verify_runner import VerifyResult
database = request.lmc_file.parent/'ReusableBlocksLP'/request.block_name/'Work/database'
return VerifyResult('FAIL', safe_to_continue=True, error_category='ICDB_REPAIR_REQUIRED',
stderr=("The last server session on different server machine lost the connection to the database. "
"Please use iCDB Project Backup 'Repair project' functionality to fix this issue. "
f"Machine:[fixture-server] Path:[{database}] session:[fixture-current-session]"))
def run_legacy_maintenance(request, **kwargs):
"""Keep explicit recovery helper coverage separate from the batch-check API."""
from cbb_refresh_verify import verify_runner as runner, maintenance_entry as entry
if not request.maintenance:
return runner.run_verify(request, **kwargs)
return entry.run_diagnosed_maintenance(request,
diagnose=lambda probe: runner.run_verify(probe, **kwargs),
progress=kwargs.get('progress'), stop=kwargs.get('stop'))
def patch_verification_after_fault(monkeypatch, runner, verify):
"""Inject only native process boundaries; production interprets the Output."""
from cbb_refresh_verify import native_repair
from test_native_occupancy import output
repair = native_repair.run_native_repair
def native(target, root, **kw):
if not kw.get('inspection_only'):
return repair(target, root, **kw)
return {'inspection_only': True, 'repair_requested': False, 'native_pid': 777,
'native_exit_code': 0, 'project': str(target.project), 'database': str(target.database),
'output': output(target.project, target.database, fault=True),
'status': 'NOT_IN_USE', 'repair_required': True, 'release': {'native_exited': True}}
monkeypatch.setattr(native_repair, 'run_native_repair', native)
monkeypatch.setattr(runner, '_run_verify_serialized',
lambda req, **kw: startup_failure(req) if req.diagnostic_only else verify(req, **kw))
@pytest.mark.parametrize('pcb_config', ['standard', 'legacy_template'])
@pytest.mark.parametrize('advertisement', ['present', 'absent'])
def test_diagnosed_maintenance_enters_official_repair_once(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')
patch_verification_after_fault(monkeypatch, runner, verify)
result = run_legacy_maintenance(request)
assert calls == ['repair'] and result.status == 'REPAIRED'
assert result.recovery_attempts[0]['validation_passed'] is False
assert result.library_flag == 'UNKNOWN'
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
def test_guard_reuses_full_tree_scan_but_still_refreshes_before_yield(case, monkeypatch):
from cbb_refresh_verify.maintenance_entry import maintenance_target_guard
import cbb_refresh_verify.scoped_manifest as manifests
request, project, _ = case
scans = []
original = manifests.scan_tree
def scan(root, **kwargs):
scans.append(Path(root))
return original(root, **kwargs)
monkeypatch.setattr(manifests, 'scan_tree', scan)
with maintenance_target_guard(request): pass
assert request.lmc_file.parent not in scans
assert scans.count(project.parent) == 2
def test_guard_rejects_new_native_database_appearing_during_checks(case, monkeypatch):
import cbb_refresh_verify.maintenance_entry as entry
request, _, _ = case
calls = []
def idle():
calls.append(1)
if len(calls) == 2:
(request.lmc_file.parent/'new.lmc').write_bytes(b'new native store')
monkeypatch.setattr(entry, 'assert_native_idle', idle)
with pytest.raises(ValueError, match='MAINTENANCE_SOURCE_CHANGED'):
with entry.maintenance_target_guard(request): 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_calls_native_verifier_despite_existing_address(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'))
calls = []
monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **k:
(calls.append('verify') or runner.VerifyResult('FAIL', stderr='native ICDB problem')))
result = run_legacy_maintenance(replace(request, maintenance=False))
assert calls == ['verify'] and result.status == 'FAIL' and 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 = run_legacy_maintenance(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})
patch_verification_after_fault(monkeypatch, runner, lambda *a, **k: pytest.fail('unsafe or nonrepair outcome reopened'))
result = run_legacy_maintenance(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))
patch_verification_after_fault(monkeypatch, runner, 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 = run_legacy_maintenance(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, stop=None):
assert stop is not None
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_access_probe_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 = []
monkeypatch.setattr('cbb_refresh_verify.native_repair.check_repair_access',
lambda *_: calls.append('access'))
@contextmanager
def guard(*args, stop=None):
assert stop is not None
calls.append('guard')
assert calls == ['access', 'guard']
raise ValueError('address changed after access probe')
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 == ['access', '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, True), ('DATABASE_BUSY', True, True),
('UNKNOWN_DIALOG', True, True), ('UNCONFIRMED', True, True),
('MISSING_HEALTHY_BACKUP', False, True), ('NATIVE_REPAIR_FAILED', False, True),
('MISSING_HEALTHY_BACKUP', True, True), ('NATIVE_REPAIR_FAILED', True, True)])
def test_failed_content_does_not_block_other_items_after_actual_release(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'])
patch_verification_after_fault(monkeypatch, runner, lambda *a, **k: pytest.fail('nonrepair outcome reopened'))
result = run_legacy_maintenance(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'])
patch_verification_after_fault(monkeypatch, runner, 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 = run_legacy_maintenance(request)
assert result.status == 'REPAIRED' and result.safe_to_continue
assert '待单独校验' in result.stdout
assert result.recovery_attempts[0]['native_status'] == 'REPAIRED'
assert result.recovery_attempts[0]['status'] == 'REPAIRED_UNVERIFIED'
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')
patch_verification_after_fault(monkeypatch, runner, verify)
result = run_legacy_maintenance(request)
assert result.status == 'REPAIRED' and result.library_flag == 'UNKNOWN'
assert result.recovery_attempts[0]['status'] == 'REPAIRED_UNVERIFIED'
assert not (request.evidence_dir/'verify').exists()