186 lines
8.8 KiB
Python
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'])
|