"""Project Backup is reached only after a current, released PCB startup fault.""" from dataclasses import replace import json import pytest from test_maintenance_entry import case, no_native_launch, run_legacy_maintenance def fault_text(database): return ("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 install_probe(monkeypatch, result, calls): from cbb_refresh_verify import verify_runner as runner def probe(request, **kwargs): assert request.diagnostic_only and not request.maintenance and not request.auto_repair assert not request.native_lm_verify and request.post_repair_proof is None calls.append('open') return result monkeypatch.setattr(runner, '_run_verify_serialized', probe) def forbid_backup(monkeypatch): from cbb_refresh_verify import native_repair monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **k: pytest.fail('Project Backup launched without a current matching startup fault')) def test_healthy_startup_skips_project_backup_even_with_old_address(case, monkeypatch): from cbb_refresh_verify import verify_runner as runner request, _, address = case calls = [] install_probe(monkeypatch, runner.VerifyResult('PASS', safe_to_continue=True), calls) forbid_backup(monkeypatch) result = run_legacy_maintenance(replace(request, native_lm_verify=True)) assert calls == ['open'] assert result.status == 'CHECKED' and result.library_flag == 'UNKNOWN' assert result.recovery_attempts == () and result.safe_to_continue assert address.read_bytes() == b'old server address - preserved' @pytest.mark.parametrize('message', ['License unavailable', 'Could not run server', 'COM 已连接,尚无目标文档', 'ICDB_REPAIR_REQUIRED', 'PCB 文件损坏', 'Lost connection to server']) def test_generic_startup_errors_remain_failures_without_backup(case, monkeypatch, message): from cbb_refresh_verify import verify_runner as runner request, _, _ = case calls = [] failed = runner.VerifyResult('FAIL', stderr=message, safe_to_continue=True) install_probe(monkeypatch, failed, calls) forbid_backup(monkeypatch) result = run_legacy_maintenance(request) assert calls == ['open'] and result == failed @pytest.mark.parametrize('reason', ['shared', 'other_project', 'no_session', 'unreleased', 'timeout', 'cancelled']) def test_unmatched_or_unreleased_icdb_fault_never_enters_backup(case, monkeypatch, reason): from cbb_refresh_verify import verify_runner as runner request, project, _ = case database = (project.parent/'database' if reason not in ('shared', 'other_project') else request.lmc_file.parent/('SymbolLibs/__ReusableBlocksSymb' if reason == 'shared' else 'ReusableBlocksLP/Other/Work/database')) if not database.exists(): database.mkdir(parents=True); (database/'icdb.dat').touch() text = fault_text(database) if reason == 'no_session': text = text.replace('session:[fixture-current-session]', '') failed = runner.VerifyResult('TIMEOUT' if reason == 'timeout' else 'CANCELLED' if reason == 'cancelled' else 'FAIL', stderr=text, error_category='ICDB_REPAIR_REQUIRED', safe_to_continue=reason != 'unreleased') calls = [] install_probe(monkeypatch, failed, calls) forbid_backup(monkeypatch) result = run_legacy_maintenance(request) assert calls == ['open'] and result.status == failed.status assert not result.recovery_attempts assert result.safe_to_continue is failed.safe_to_continue def test_only_current_matching_fault_enters_native_maintenance(case, monkeypatch): from cbb_refresh_verify import verify_runner as runner, maintenance_entry as entry request, project, _ = case calls = [] failed = runner.VerifyResult('FAIL', stderr=fault_text(project.parent/'database'), error_category='ICDB_REPAIR_REQUIRED', safe_to_continue=True) install_probe(monkeypatch, failed, calls) def maintain(req, *, diagnosed_target, startup_result, **kwargs): assert diagnosed_target.project == project and diagnosed_target.database == project.parent/'database' assert startup_result == failed calls.append('maintenance') return runner.VerifyResult('REPAIRED') monkeypatch.setattr(entry, 'run_existing_address_maintenance', maintain) result = run_legacy_maintenance(request) assert calls == ['open', 'maintenance'] and result.status == 'REPAIRED' def test_old_saved_diagnosis_does_not_turn_generic_startup_failure_into_repair(case, monkeypatch): from cbb_refresh_verify import verify_runner as runner request, project, _ = case root = request.evidence_dir/'old'; (root/'diagnostics').mkdir(parents=True) (root/'diagnostics/icdb-recovery.json').write_text(json.dumps({ 'error_code': 'ICDB_REPAIR_REQUIRED', 'native_message': fault_text(project.parent/'database')})) calls = [] failure = runner.VerifyResult('FAIL', stderr='License unavailable', evidence_path=root/'result.json') install_probe(monkeypatch, failure, calls) forbid_backup(monkeypatch) assert run_legacy_maintenance(request) == failure assert calls == ['open'] def test_native_admission_cannot_switch_the_diagnosed_database(case, monkeypatch): from cbb_refresh_verify import maintenance_entry as entry, native_repair from test_maintenance_entry import startup_failure request, project, _ = case forbid_backup(monkeypatch) result = entry.run_existing_address_maintenance(request, diagnosed_target=native_repair.RepairTarget(project, project.parent/'other'), startup_result=startup_failure(request)) assert result.status == 'FAIL' and result.safe_to_continue assert result.error_category == 'ICDB_TARGET_MISMATCH' def test_equivalent_diagnosed_path_keeps_the_native_launch_path(case, monkeypatch): from cbb_refresh_verify import maintenance_entry as entry, native_repair from test_maintenance_entry import startup_failure from test_maintenance_diagnosis import inspection request, project, _ = case seen = [] def inspect(target, *args, **kwargs): assert kwargs['inspection_only'] is True seen.append(target.project) return inspection(target) monkeypatch.setattr(native_repair, 'run_native_repair', inspect) alias = project.parent/'unused/..' result = entry.run_existing_address_maintenance(request, diagnosed_target=native_repair.RepairTarget(alias/project.name, alias/'database'), startup_result=startup_failure(request)) assert result.status == 'CHECKED' and result.safe_to_continue, result assert seen == [project] def test_unsafe_startup_success_is_not_reported_as_healthy(case, monkeypatch): from cbb_refresh_verify import verify_runner as runner request, _, _ = case install_probe(monkeypatch, runner.VerifyResult('PASS', safe_to_continue=False), []) forbid_backup(monkeypatch) result = run_legacy_maintenance(request) assert result.status == 'FAIL' and not result.safe_to_continue def test_report_write_failure_does_not_block_a_released_healthy_project(case, monkeypatch): from pathlib import Path from cbb_refresh_verify import verify_runner as runner request, _, _ = case evidence = request.evidence_dir/'result.json'; evidence.parent.mkdir(); evidence.write_text('{}') install_probe(monkeypatch, runner.VerifyResult('PASS', evidence_path=evidence), []) forbid_backup(monkeypatch) write = Path.write_text def unavailable(path, *args, **kwargs): if path.name == 'maintenance-result.json': raise PermissionError('report unavailable') return write(path, *args, **kwargs) monkeypatch.setattr(Path, 'write_text', unavailable) result = run_legacy_maintenance(request) assert result.status == 'CHECKED' and result.safe_to_continue assert result.evidence_path == evidence and evidence.read_text() == '{}' @pytest.mark.parametrize('before_open', [True, False]) def test_cancelled_startup_diagnosis_never_requests_repair(case, monkeypatch, before_open): from threading import Event from cbb_refresh_verify import verify_runner as runner from test_maintenance_entry import startup_failure request, _, _ = case stop = Event() if before_open: stop.set() calls = [] def probe(req, **kw): calls.append('open'); stop.set() return startup_failure(req) monkeypatch.setattr(runner, '_run_verify_serialized', probe) forbid_backup(monkeypatch) result = run_legacy_maintenance(request, stop=stop) assert result.status == 'CANCELLED' and result.safe_to_continue assert calls == ([] if before_open else ['open'])