"""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, '_recorded_supervisor_alive', lambda record: 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()