Files
cbb-refresh-verify-795/tests/test_maintenance_startup_gate.py
T

186 lines
8.8 KiB
Python

"""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'])