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

814 lines
44 KiB
Python

import json
from pathlib import Path
import pytest
def target_fixture(tmp_path):
from test_verify_runner import fixture, request
from cbb_refresh_verify.native_repair import select_repair_target
work = fixture(tmp_path)
database = work/'database'
database.mkdir()
(database/'icdb.dat').write_bytes(b'original damaged database')
diagnosis = {'error_code': 'ICDB_REPAIR_REQUIRED', 'machine': 'OLD-PC',
'database_path': str(database), 'session': '2026-10-24 08.22.29-10308', 'scope': 'project'}
return request(tmp_path), diagnosis, select_repair_target(request(tmp_path), diagnosis)
def complete_native_success(target):
"""A complete successful worker result, with no contradictory native state."""
return {'status': 'REPAIRED', 'project': str(target.project), 'database': str(target.database),
'native_pid': 777,
'release': {'native_exited': True, 'safe_to_continue': True, 'addresses': []},
'evidence': {'confirmed': True, 'native_backup': True, 'outcome': 'UNCONFIRMED',
'failure_complete': False, 'restore_complete': False, 'restored_from_backup': '',
'diagnostic_tail': 'Diagnostic: START\nDiagnostic: FINISH',
'database_tail': f'{target.database}\niCDBProjectBackupRepair\nIC: Closing project',
'restore_tail': '', 'output_tail': '', 'backup_log_tail': '',
'log_paths': []}}
def test_repair_target_matches_actual_database_not_guessed_cbb_name(tmp_path):
request, record, target = target_fixture(tmp_path)
assert target.project.name == 'CBB1.prj'
assert target.database == target.project.parent/'database'
@pytest.mark.parametrize('change', ['foreign', 'shared', 'missing_session', 'unknown_scope'])
def test_repair_target_rejects_unresolved_or_shared_database(tmp_path, change):
from cbb_refresh_verify.native_repair import select_repair_target
request, record, target = target_fixture(tmp_path)
if change == 'foreign': record['database_path'] = str(tmp_path/'foreign/database')
if change == 'shared':
record.update(scope='central_library', database_path=str(tmp_path/'SymbolLibs/__ReusableBlocksSymb'))
if change == 'missing_session': record['session'] = ''
if change == 'unknown_scope': record['scope'] = 'unknown'
with pytest.raises(ValueError):
select_repair_target(request, record)
def test_repair_backup_contains_database_locks_backups_and_original_files(tmp_path):
from cbb_refresh_verify.native_repair import backup_project
request, record, target = target_fixture(tmp_path)
for relative in ('database/cdbsvr/sAddress.adr', 'ProjectBackup/backups/old.zip',
'PCB/copy.lock', 'Log Files/ProjectBackupLog.txt'):
path = target.project.parent/relative
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(b'original '+relative.encode())
destination = tmp_path/'repair-backup'
manifest = backup_project(target, destination)
assert manifest['complete'] is True
assert (destination/'database/icdb.dat').read_bytes() == b'original damaged database'
assert (destination/'database/cdbsvr/sAddress.adr').read_bytes().startswith(b'original')
assert (destination/'ProjectBackup/backups/old.zip').is_file()
assert (destination/'PCB/copy.lock').is_file()
def test_repair_backup_refuses_database_open_by_another_client(tmp_path):
import win32file, win32con
from cbb_refresh_verify.native_repair import backup_project
request, record, target = target_fixture(tmp_path)
handle = win32file.CreateFile(str(target.database/'icdb.dat'), win32con.GENERIC_READ,
win32con.FILE_SHARE_READ, None, win32con.OPEN_EXISTING, 0, None)
try:
with pytest.raises(OSError):
backup_project(target, tmp_path/'backup')
finally:
handle.Close()
assert not (tmp_path/'backup/backup-manifest.json').exists()
def test_repair_backup_rejects_reparse_directory(tmp_path):
import _winapi
from cbb_refresh_verify.native_repair import backup_project
request, record, target = target_fixture(tmp_path)
outside = tmp_path/'outside'
outside.mkdir()
_winapi.CreateJunction(str(outside), str(target.project.parent/'linked'))
with pytest.raises(ValueError):
backup_project(target, tmp_path/'backup')
def test_native_confirmation_requires_exact_target_and_known_repair_prompt():
from cbb_refresh_verify.native_repair_ui import confirmation_allowed
assert confirmation_allowed('iCDB Project Backup - C:\\exact.prj', r'C:\exact.prj',
'The project content will be validated and repaired if necessary.\n'
'A project backup will be created before any action take place.\n'
'You will be able to revert all changes using that backup.')
assert not confirmation_allowed('iCDB Project Backup - C:\\OTHER.prj', r'C:\exact.prj',
'The project content will be validated and repaired if necessary.')
assert not confirmation_allowed('iCDB Project Backup - C:\\exact.prj', r'C:\exact.prj',
'Confirm no other clients are connected. Continue anyway?')
def test_native_diagnostics_finish_alone_does_not_prove_repair_success():
from cbb_refresh_verify.native_repair_ui import repair_completed
assert not repair_completed('Diagnostic: FINISH', 'IC: Closing project', native_backup=False)
assert not repair_completed('ERROR: invalid database\nDiagnostic: FINISH',
'iCDBProjectBackupRepair\nIC: Closing project', native_backup=True)
assert repair_completed('Diagnostic: START\nDiagnostic: FINISH',
'iCDBProjectBackupRepair\nIC: Closing project', native_backup=True)
def test_native_restore_of_old_backup_requires_review_even_when_diagnostics_finish(tmp_path):
from cbb_refresh_verify.native_repair_ui import _native_evidence
from cbb_refresh_verify.icdb_recovery import snapshot_log
project = tmp_path/'project.prj'
database = tmp_path/'database'
project.touch()
log = tmp_path/'Log Files/ProjectBackupLog.txt'
log.parent.mkdir()
baseline = snapshot_log(log)
for folder, text in (
('dbcheck', 'Diagnostic: START\nDiagnostic: FINISH'),
('dbrestore', f'iCDB database restored from backup: {tmp_path}/old.zip\n[0] DONE')):
path = database/'cdbsvr'/folder/'new-1234/log.txt'
path.parent.mkdir(parents=True)
path.write_text(text)
evidence = _native_evidence(project, database, 1234, 0, baseline)
assert evidence['restored_from_backup'] == f'{tmp_path}/old.zip'
assert evidence['restore_complete'] is True
assert evidence['confirmed'] is False
def test_automatic_repair_retries_only_once_and_preserves_original_failure(tmp_path, monkeypatch):
from dataclasses import replace
from cbb_refresh_verify import verify_runner as runner
from cbb_refresh_verify import native_repair
request, record, target = target_fixture(tmp_path)
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(record))
original = runner.VerifyResult('FAIL', stderr='native lost session',
safe_to_continue=False, error_category='ICDB_REPAIR_REQUIRED', evidence_path=evidence)
calls = []
def verify(req, **kwargs):
calls.append(req)
return original
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: complete_native_success(target))
outcome = runner.run_verify(request)
assert len(calls) == 2
assert outcome.status == 'FAIL'
assert outcome.stderr == 'native lost session'
assert outcome.recovery_attempts[0]['original_error'] == 'native lost session'
assert outcome.recovery_attempts[0]['status'] == 'REPAIR_VALIDATION_FAILED'
assert outcome.recovery_attempts[0]['native_status'] == 'REPAIRED'
@pytest.mark.parametrize('text,expected,terminal', [
('There is no backup of iCDB.\nRepair project error [Cannot repair the project - there is no backup of missing iCDB].',
'MISSING_HEALTHY_BACKUP', True),
('Repair project error [Database validation failed].', 'NATIVE_REPAIR_FAILED', True),
('Project is in use. Full functionality is unavailable.', 'DATABASE_BUSY', False),
('Repairing the project. Diagnostic: START', 'UNCONFIRMED', False),
])
def test_current_native_output_classifies_failure_and_terminal_evidence(text, expected, terminal):
from cbb_refresh_verify.native_repair_ui import classify_repair_evidence
result = classify_repair_evidence('', '', '', text)
assert result['outcome'] == expected
assert result['failure_complete'] is terminal
def test_historical_no_backup_output_replay_is_conclusive_failure():
from cbb_refresh_verify.native_repair_ui import classify_repair_evidence
# Sanitized actual native Output from the 2026-10-28 no-history fixture.
text = ('Repairing the project [<project>/CBB.prj].\n'
'Repair backup [repair.zip] created successfully.\n'
'The iCDB database is corrupted.\nThere is no backup of iCDB.\n'
'Repair project error [Cannot repair the project - there is no backup of missing iCDB].\n'
'The project is probably in inconsistent state. Please restore the project from one of previous backups.')
result = classify_repair_evidence('', '', '', text)
assert result == {'outcome': 'MISSING_HEALTHY_BACKUP', 'failure_complete': True}
@pytest.mark.parametrize('repair_status', ['BLOCKED', 'RESTORED_REVIEW_REQUIRED'])
def test_automatic_repair_does_not_retry_busy_or_unsupported_target(tmp_path, monkeypatch, repair_status):
from cbb_refresh_verify import verify_runner as runner
from cbb_refresh_verify import native_repair
request, record, target = target_fixture(tmp_path)
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(record))
calls = []
def verify(req, **kwargs):
calls.append(req)
return runner.VerifyResult('FAIL', stderr='native lost session',
error_category='ICDB_REPAIR_REQUIRED', safe_to_continue=False, evidence_path=evidence)
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: {'status':repair_status})
outcome = runner.run_verify(request)
assert len(calls) == 1
assert outcome.safe_to_continue is False
assert outcome.recovery_attempts[0]['status'] == repair_status
def test_timeout_never_enters_automatic_repair(tmp_path, monkeypatch):
from cbb_refresh_verify import verify_runner as runner, native_repair
request, record, target = target_fixture(tmp_path)
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(record))
monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **kw:
runner.VerifyResult('TIMEOUT', error_category='ICDB_REPAIR_REQUIRED',
safe_to_continue=False, evidence_path=evidence))
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw:
pytest.fail('A timed-out native owner must not be repaired'))
assert runner.run_verify(request).status == 'TIMEOUT'
def test_retained_importer_blocks_repair_even_without_an_open_database_handle(tmp_path, monkeypatch):
from cbb_refresh_verify import native_repair
request, record, target = target_fixture(tmp_path)
evidence = tmp_path/'original'
evidence.mkdir()
(evidence/'content-check-process.json').write_text(json.dumps({'status':'RETAINED','pid':123}))
monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **kw:
pytest.fail('Do not repair between importer transactions'))
outcome = native_repair.attempt_recovery(request, record, evidence)
assert outcome['status'] == 'BLOCKED'
assert 'IMPORTER_RELEASE_UNCONFIRMED' in outcome['detail']
def test_repair_cancellation_during_backup_prevents_native_launch(tmp_path, monkeypatch):
from cbb_refresh_verify import native_repair_ui as ui, native_repair, mentor_adapter
request, record, target = target_fixture(tmp_path)
root = tmp_path/'worker'
root.mkdir()
cancel = root/'cancel.signal'
job = root/'request.json'
job.write_text(json.dumps({'project':str(target.project),'database':str(target.database),
'root':str(root),'cancel_signal':str(cancel),'timeout':1,
'supervisor_pid':123,'desktop':'CbbRepair_test'}))
calls = []
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.start_supervisor_watchdog',
lambda *a, **kw: calls.append('watchdog'))
monkeypatch.setattr(ui, '_current_desktop_name', lambda: 'CbbRepair_test', raising=False)
monkeypatch.setattr(ui, '_repair_command', lambda *_: 32924)
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [])
monkeypatch.setattr(mentor_adapter, '_process_details', lambda *_: [])
def backup(*a):
assert calls == ['watchdog'], 'Watch supervisor before the potentially long backup'
cancel.touch()
calls.append('backup')
monkeypatch.setattr(native_repair, 'backup_project', backup)
monkeypatch.setattr(ui.subprocess, 'Popen', lambda *a, **kw: pytest.fail('Repair must not start'))
assert ui.repair_worker_main(job) == 1
outcome = json.loads((root/'repair-result.json').read_text('utf-8'))
assert 'REPAIR_CANCELLED_AFTER_BACKUP' in outcome['detail']
def test_repair_worker_refuses_the_input_desktop_before_backup(tmp_path, monkeypatch):
from cbb_refresh_verify import native_repair_ui as ui, native_repair
request, record, target = target_fixture(tmp_path)
root = tmp_path/'worker'
root.mkdir()
job = root/'request.json'
job.write_text(json.dumps({'project':str(target.project),'database':str(target.database),
'root':str(root),'cancel_signal':str(root/'cancel.signal'),'timeout':1,
'supervisor_pid':123,'desktop':'CbbRepair_test'}))
monkeypatch.setattr(ui, '_current_desktop_name', lambda: 'Default', raising=False)
monkeypatch.setattr(native_repair, 'backup_project', lambda *a: pytest.fail('Input desktop repair forbidden'))
assert ui.repair_worker_main(job) == 1
assert 'REPAIR_PRIVATE_DESKTOP_REQUIRED' in json.loads((root/'repair-result.json').read_text('utf-8'))['detail']
def test_repair_worker_job_binds_supervisor_and_private_desktop(tmp_path, monkeypatch):
from cbb_refresh_verify.native_repair import run_native_repair
request, record, target = target_fixture(tmp_path)
class Worker:
returncode = 0
def __init__(self, command, desktop):
job = json.loads(Path(command[-1]).read_text('utf-8'))
assert job['supervisor_pid'] > 0
assert job['desktop'] == desktop
assert desktop.startswith('CbbRepair_')
(Path(job['root'])/'repair-result.json').write_text('{"status":"BLOCKED"}')
def poll(self): return 0
def bind_cancellation(self, path): pass
def close(self): pass
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker', Worker)
assert run_native_repair(target, tmp_path/'native')['status'] == 'BLOCKED'
def test_backup_detects_a_file_added_during_the_copy(tmp_path, monkeypatch):
from cbb_refresh_verify import native_repair
request, record, target = target_fixture(tmp_path)
original = native_repair.shutil.copy2
def changed(source, destination):
result = original(source, destination)
(target.project.parent/'new-file.txt').write_bytes(b'concurrent writer')
return result
monkeypatch.setattr(native_repair.shutil, 'copy2', changed)
with pytest.raises(OSError, match='REPAIR_BACKUP_CHANGED'):
native_repair.backup_project(target, tmp_path/'backup')
def repair_worker_fixture(tmp_path, monkeypatch, scenario):
"""Replay native window/log transitions without launching a native client."""
from types import SimpleNamespace
import win32con, win32gui
from cbb_refresh_verify import native_repair_ui as ui, native_repair, mentor_adapter
request, diagnosis, target = target_fixture(tmp_path)
root = tmp_path/'worker'
root.mkdir()
job = root/'request.json'
job.write_text(json.dumps({'project': str(target.project), 'database': str(target.database),
'root': str(root), 'cancel_signal': str(root/'cancel.signal'), 'timeout': 1,
'supervisor_pid': 123, 'desktop': 'CbbRepair_test'}))
ticks = [0.0]
state = {'requested': False, 'confirmed': False, 'closed': False}
actions = []
monkeypatch.setattr(ui, 'time', SimpleNamespace(monotonic=lambda: ticks[0], time_ns=lambda: 0,
sleep=lambda seconds: ticks.__setitem__(0, ticks[0]+seconds)))
monkeypatch.setattr(ui, '_current_desktop_name', lambda: 'CbbRepair_test')
monkeypatch.setattr(ui, '_repair_command', lambda *_: 32924)
monkeypatch.setattr(ui, 'discover_sdd_home', lambda *_: tmp_path, raising=False)
monkeypatch.setattr('cbb_refresh_verify.mentor_paths.discover_sdd_home', lambda *_: tmp_path)
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.start_supervisor_watchdog', lambda *a, **kw: None)
monkeypatch.setattr(native_repair, 'backup_project', lambda *a: {})
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [])
monkeypatch.setattr(mentor_adapter, '_process_details', lambda *_: [])
monkeypatch.setattr(ui.subprocess, 'Popen', lambda *a, **kw: SimpleNamespace(
pid=777, poll=lambda: 0 if state['closed'] and ticks[0] >= .6 else None))
terminal = 'Repair project error [Cannot repair the project - there is no backup of missing iCDB].'
def output(_):
if scenario == 'busy_before': return 'Project is in use. Full functionality is unavailable.'
if scenario == 'stale': return terminal
if not state['confirmed']: return ''
if scenario == 'busy': return 'Repair project error [Project is in use].'
if scenario == 'active': return 'Repairing the project. Please wait.'
if scenario in {'success', 'restore'}: return 'Repair project finished.'
return terminal
monkeypatch.setattr(ui, '_native_output', output, raising=False)
def windows(_):
main = {'hwnd': 100, 'class': 'Afx:main', 'title': 'iCDB Project Backup - '+str(target.project),
'enabled': True, 'children': []}
if state['confirmed'] and scenario in {'unknown', 'custom_prompt'}:
return [main, {'hwnd': 300, 'class': 'CustomDialog' if scenario == 'custom_prompt' else '#32770', 'title': 'Unexpected',
'enabled': True, 'children': [{'text': 'Overwrite design?', 'class': 'Button',
'id': 1, 'hwnd': 301, 'enabled': True}]}]
if state['requested'] and not state['confirmed']:
return [main, {'hwnd': 200, 'class': '#32770', 'title': '', 'enabled': True,
'children': [{'hwnd': 201, 'class': 'Button', 'id': 1, 'enabled': True,
'text': 'The project content will be validated and repaired if necessary.\n'
'A project backup will be created before any action take place.\n'
'You will be able to revert all changes using that backup.'}]}]
return [main]
monkeypatch.setattr(ui, '_windows', windows)
def post(hwnd, message, *args):
actions.append((hwnd, message))
if message == win32con.WM_COMMAND: state['requested'] = True
if message == win32con.BM_CLICK:
state['confirmed'] = True
if scenario in {'success', 'restore'}:
import zipfile
log = target.project.parent/'Log Files/ProjectBackupLog.txt'
log.parent.mkdir(parents=True)
log.write_text('Successfully created [Project Repair] backup [repair.zip]')
archive = target.project.parent/'ProjectBackup/backups/repair.zip'
archive.parent.mkdir(parents=True)
with zipfile.ZipFile(archive, 'w') as zipped: zipped.writestr('database/icdb.dat', b'backup')
logs = {'dbcheck': 'Diagnostic: START\nDiagnostic: FINISH',
'log': f'{target.database}\niCDBProjectBackupRepair\nIC: Closing project'}
if scenario == 'restore':
logs['dbrestore'] = 'iCDB database restored from backup: old.zip\n[0] DONE'
for folder, text in logs.items():
path = target.database/'cdbsvr'/folder/'new-777/log.txt'
path.parent.mkdir(parents=True)
path.write_text(text)
if scenario == 'address':
address = target.database/'cdbsvr/sAddress.adr'
address.parent.mkdir(parents=True)
address.write_text('owner')
if message == win32con.WM_CLOSE: state['closed'] = True
monkeypatch.setattr(win32gui, 'PostMessage', post)
return ui, root, job, actions
@pytest.mark.parametrize('scenario,expected,closed', [
('failed', 'MISSING_HEALTHY_BACKUP', True), ('busy', 'DATABASE_BUSY', False),
('unknown', 'UNKNOWN_DIALOG', False), ('custom_prompt', 'UNKNOWN_DIALOG', False),
('active', 'TIMEOUT_UNRELEASED', False),
('stale', 'TIMEOUT_UNRELEASED', False), ('address', 'MISSING_HEALTHY_BACKUP', False),
])
def test_native_worker_closes_only_conclusively_failed_idle_tool(tmp_path, monkeypatch, scenario, expected, closed):
import win32con
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, scenario)
assert ui.repair_worker_main(job) == 1
result = json.loads((root/'repair-result.json').read_text('utf-8'))
assert result['status'] == expected
assert result['release']['safe_to_continue'] is closed
assert ((100, win32con.WM_CLOSE) in actions) is closed
assert actions[:2] == [(100, win32con.WM_COMMAND), (201, win32con.BM_CLICK)]
assert bool(result['evidence']['output_tail']) is (scenario != 'stale')
if scenario == 'unknown': assert result['unknown_dialogs'][0]['title'] == 'Unexpected'
@pytest.mark.parametrize('scenario,expected', [('success', 'REPAIRED'), ('restore', 'RESTORED_REVIEW_REQUIRED')])
def test_native_worker_preserves_success_and_historical_restore_distinction(tmp_path, monkeypatch, scenario, expected):
from cbb_refresh_verify.native_repair import RepairTarget, native_success_confirmed
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, scenario)
assert ui.repair_worker_main(job) == (0 if scenario == 'success' else 1)
result = json.loads((root/'repair-result.json').read_text('utf-8'))
assert result['status'] == expected
assert result['release']['safe_to_continue'] is True
assert result['evidence']['native_backup'] is True
assert result['evidence']['confirmed'] is (scenario == 'success')
assert (root/'native-logs/dbcheck/new-777/log.txt').exists()
request = json.loads(job.read_text('utf-8'))
target = RepairTarget(Path(request['project']), Path(request['database']))
assert native_success_confirmed(target, result) is (scenario == 'success')
def test_native_busy_project_on_load_never_invokes_repair(tmp_path, monkeypatch):
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'busy_before')
assert ui.repair_worker_main(job) == 1
result = json.loads((root/'repair-result.json').read_text('utf-8'))
assert result['status'] == 'DATABASE_BUSY'
assert actions == []
assert not result['release']['safe_to_continue']
@pytest.mark.parametrize('readback', ['missing', 'timeout', 'truncated'])
def test_unavailable_initial_output_never_requests_or_confirms_repair(tmp_path, monkeypatch, readback):
from types import SimpleNamespace
from cbb_refresh_verify import native_repair_ui as module
actual_read = module._native_output
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'active')
windows = ui._windows
def observe(pid):
result = windows(pid)
if readback != 'missing':
result[0]['children'].append({'hwnd': 400, 'class': 'RichEdit20A'})
return result
monkeypatch.setattr(ui, '_windows', observe)
class Readback:
def __call__(self, hwnd, message, length, buffer, flags, timeout, copied):
if readback == 'timeout': return 0
copied._obj.value = length-1
return 1
monkeypatch.setattr(ui.ctypes, 'WinDLL', lambda *a, **kw: SimpleNamespace(SendMessageTimeoutW=Readback()))
monkeypatch.setattr(ui, '_native_output', actual_read)
assert ui.repair_worker_main(job) == 1
result = json.loads((root/'repair-result.json').read_text('utf-8'))
assert actions == []
assert result['status'] == 'TIMEOUT_UNRELEASED'
assert result['release']['safe_to_continue'] is False
assert json.loads((root/'native-output.json').read_text('utf-8'))['baseline'] is None
def test_initial_output_waits_until_readable_and_accepts_empty_baseline(tmp_path, monkeypatch):
import win32con
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'active')
reads = []
def output(_):
reads.append(len(reads))
if len(reads) <= 2:
assert not actions
return None
return ''
monkeypatch.setattr(ui, '_native_output', output)
assert ui.repair_worker_main(job) == 1
assert actions == [(100, win32con.WM_COMMAND), (201, win32con.BM_CLICK)]
assert json.loads((root/'native-output.json').read_text('utf-8'))['baseline'] == ''
def test_invoked_busy_native_result_never_reopens_or_continues_queue(tmp_path, monkeypatch):
import win32con
from test_verify_runner import request
from cbb_refresh_verify import verify_runner as runner, native_repair
ui, root, job, actions = repair_worker_fixture(tmp_path, monkeypatch, 'busy')
assert ui.repair_worker_main(job) == 1
busy = json.loads((root/'repair-result.json').read_text('utf-8'))
assert (100, win32con.WM_CLOSE) not in actions
assert busy['status'] == 'DATABASE_BUSY' and busy['release']['native_exited'] is False
req = request(tmp_path)
target = json.loads(job.read_text('utf-8'))
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps({
'error_code': 'ICDB_REPAIR_REQUIRED', 'scope': 'project',
'session': 'original-session', 'database_path': target['database']}))
opens = []
def verify(*a, **kw):
opens.append('open')
return runner.VerifyResult('FAIL', error_category='ICDB_REPAIR_REQUIRED',
safe_to_continue=False, evidence_path=evidence)
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: busy)
results = runner.run_batch([req, req], verifier=runner.run_verify)
assert opens == ['open']
assert results[0].recovery_attempts[0]['status'] == 'DATABASE_BUSY'
assert results[0].safe_to_continue is False and results[1].status == 'SKIPPED'
@pytest.mark.parametrize('status,released,scope,expected', [
('MISSING_HEALTHY_BACKUP', True, 'project', True),
('NATIVE_REPAIR_FAILED', True, 'project', True),
('MISSING_HEALTHY_BACKUP', False, 'project', False),
('MISSING_HEALTHY_BACKUP', True, 'central_library', False),
('MISSING_HEALTHY_BACKUP', True, 'unknown', False),
('UNKNOWN_DIALOG', True, 'project', False), ('TIMEOUT_UNRELEASED', True, 'project', False),
('DATABASE_BUSY', True, 'project', False),
])
def test_failed_repair_continues_only_released_project_local_items(
tmp_path, monkeypatch, status, released, scope, expected):
from cbb_refresh_verify import verify_runner as runner, native_repair
request, diagnosis, target = target_fixture(tmp_path)
diagnosis['scope'] = scope
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(diagnosis))
original = runner.VerifyResult('FAIL', stderr='original session lost', safe_to_continue=False,
error_category='ICDB_REPAIR_REQUIRED', error_stage='PCB_STARTING', evidence_path=evidence)
monkeypatch.setattr(runner, '_run_verify_serialized', lambda *a, **kw: original)
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: {
'status': status, 'release': {'safe_to_continue': released},
'evidence': {'failure_complete': True}, 'project': str(target.project),
'database': str(target.database)})
result = runner.run_verify(request)
assert result.safe_to_continue is expected
assert result.status == 'FAIL'
assert result.error_stage == 'PCB_STARTING'
assert result.stderr.startswith('original session lost')
assert status in result.stderr
assert result.recovery_attempts[0]['original_stage'] == 'PCB_STARTING'
@pytest.mark.parametrize('validation_status,flag,expected', [
('PASS', 'GREEN', True), ('PASS', 'UNKNOWN', False), ('FAIL', 'GREEN', False),
])
def test_maintenance_counts_require_native_success_then_verify_green(
tmp_path, monkeypatch, validation_status, flag, expected):
from cbb_refresh_verify import verify_runner as runner, native_repair
from cbb_refresh_verify.icdb_maintenance import maintenance_counts
request, diagnosis, target = target_fixture(tmp_path)
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(diagnosis))
original = runner.VerifyResult('FAIL', stderr='original lost session', safe_to_continue=False,
error_category='ICDB_REPAIR_REQUIRED', evidence_path=evidence)
evidence.write_text(json.dumps({'stderr': original.stderr}))
validated = runner.VerifyResult(validation_status, library_flag=flag,
evidence_path=tmp_path/'second.json', safe_to_continue=True)
calls = []
def verify(req, **kwargs):
calls.append(req)
return original if len(calls) == 1 else validated
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: complete_native_success(target))
result = runner.run_verify(request)
assert len(calls) == 2 and calls[1].auto_repair is False
assert result.recovery_attempts[0]['validation_passed'] is expected
assert maintenance_counts([result])['repaired'] == int(expected)
assert original.evidence_path.exists(), 'Original result evidence must remain available'
assert json.loads(original.evidence_path.read_text('utf-8'))['stderr'] == 'original lost session'
def test_native_success_without_release_does_not_reopen(tmp_path, monkeypatch):
from cbb_refresh_verify import verify_runner as runner, native_repair
request, diagnosis, target = target_fixture(tmp_path)
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(diagnosis))
calls = []
def verify(*args, **kwargs):
calls.append('open')
return runner.VerifyResult('FAIL', error_category='ICDB_REPAIR_REQUIRED',
safe_to_continue=False, evidence_path=evidence)
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: {'status': 'REPAIRED'})
result = runner.run_verify(request)
assert calls == ['open']
assert not result.safe_to_continue
assert result.recovery_attempts[0]['status'] == 'UNCONFIRMED'
@pytest.mark.parametrize('obstacle', ['none', 'launcher', 'repair_tool', 'importer', 'address', 'handle', 'shared_handle', 'probe'])
def test_repair_release_requires_process_address_and_database_handle_release(tmp_path, monkeypatch, obstacle):
import win32con, win32file
from cbb_refresh_verify import native_repair, mentor_adapter
request, diagnosis, target = target_fixture(tmp_path)
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda:
[(123, 'ExpeditionPCB.exe', 'launcher')] if obstacle == 'launcher' else [])
def processes(name):
if obstacle == 'probe': raise OSError('process observation unavailable')
if ((obstacle == 'repair_tool' and name == 'iCDBProjectBackup.exe')
or (obstacle == 'importer' and name == 'ReuseBlockImporter.exe')):
return [(456, name, 'unconfirmed owner', 0)]
return []
monkeypatch.setattr(mentor_adapter, '_process_details', processes)
if obstacle == 'address':
address = target.database/'cdbsvr/sAddress.adr'
address.parent.mkdir(parents=True)
address.touch()
handle = None
try:
if obstacle in {'handle', 'shared_handle'}:
database_file = target.database/'icdb.dat'
if obstacle == 'shared_handle':
database_file = request.lmc_file.parent/'SymbolLibs/__ReusableBlocksSymb/icdb.dat'
database_file.parent.mkdir(parents=True)
database_file.touch()
handle = win32file.CreateFile(str(database_file), win32con.GENERIC_READ,
0, None, win32con.OPEN_EXISTING, 0, None)
result = native_repair.repair_release_state(request, target, complete_native_success(target))
assert result['safe_to_continue'] is (obstacle == 'none')
finally:
if handle: handle.Close()
def test_attempt_persists_distinct_native_failure_and_release_result(tmp_path, monkeypatch):
from cbb_refresh_verify import native_repair, mentor_adapter
request, diagnosis, target = target_fixture(tmp_path)
evidence = tmp_path/'evidence'
evidence.mkdir()
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [])
monkeypatch.setattr(mentor_adapter, '_process_details', lambda *_: [])
monkeypatch.setattr(native_repair, 'run_native_repair', lambda *a, **kw: {
'status': 'MISSING_HEALTHY_BACKUP', 'project': str(target.project),
'database': str(target.database), 'native_pid': 777,
'release': {'safe_to_continue': True, 'native_exited': True, 'addresses': []},
'evidence': {'failure_complete': True, 'output_tail': 'no backup'}})
result = native_repair.attempt_recovery(request, diagnosis, evidence)
assert result['status'] == 'MISSING_HEALTHY_BACKUP'
assert result['release']['database_exclusive'] is True
assert result['release']['safe_to_continue'] is True
assert isinstance(result['evidence'], dict)
assert result['evidence_path'] == str(evidence/'native-repair')
assert json.loads((evidence/'native-repair/attempt.json').read_text('utf-8')) == result
def test_retry_exception_keeps_original_error_and_native_repair_evidence(tmp_path, monkeypatch):
from cbb_refresh_verify import verify_runner as runner, native_repair
request, diagnosis, target = target_fixture(tmp_path)
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(diagnosis))
calls = []
def verify(*a, **kw):
calls.append('open')
if len(calls) > 1: raise OSError('retry infrastructure failure')
return runner.VerifyResult('FAIL', stderr='original native error', safe_to_continue=False,
error_category='ICDB_REPAIR_REQUIRED', evidence_path=evidence)
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
native_result = complete_native_success(target)
native_result['evidence']['diagnostic_tail'] += '\noriginal repair evidence'
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw: native_result)
result = runner.run_verify(request)
assert not result.safe_to_continue
assert 'original native error' in result.stderr
assert 'retry infrastructure failure' in result.stderr
assert 'original repair evidence' in result.recovery_attempts[0]['evidence']['diagnostic_tail']
assert result.recovery_attempts[0]['status'] == 'REPAIR_VALIDATION_FAILED'
assert json.loads(evidence.read_text('utf-8'))['recovery_attempts']
def test_sanitized_field_open_failure_replay_closes_launcher_then_repairs_once(tmp_path, monkeypatch):
from types import SimpleNamespace
from dataclasses import replace
from test_failed_startup import startup_fixture
from cbb_refresh_verify import verify_runner as runner, native_repair, failed_session, mentor_adapter
from cbb_refresh_verify.pcb_bridge import wait_for_target_document, PcbBridgeError
replay = json.loads((Path(__file__).parent/'fixtures/issue2-lost-session-sanitized.json').read_text('utf-8'))
request, diagnosis, target = target_fixture(tmp_path)
# Retain a different PRJ name: the field CBB name never authorizes guessing it.
block_root = target.project.parent.parent
block_root.rename(block_root.with_name(replay['block']))
request = replace(request, block_name=replay['block'])
project, pcb = runner.preflight(request)
diagnosis['database_path'] = str(project.parent/'database')
target = native_repair.select_repair_target(request, diagnosis)
job, records, messages = startup_fixture(tmp_path, monkeypatch)
job.update(project=str(project), pcb=str(pcb), lmc_file=str(request.lmc_file))
records[0] = (12, records[0][1], f'ExpeditionPCB.exe "{pcb}" -ReusableCircuit', 11)
diagnosis.update(session=replay['diagnosis']['session'], machine='FIELD-PC')
(tmp_path/'diagnostics/icdb-recovery.json').write_text(json.dumps(diagnosis))
(tmp_path/'dialogs.jsonl').write_text(json.dumps(replay['dialog'])+'\n')
ticks = [0.0]
monkeypatch.setattr(failed_session, 'time', SimpleNamespace(monotonic=lambda: ticks[0],
sleep=lambda seconds: ticks.__setitem__(0, ticks[0]+seconds)))
launcher = SimpleNamespace(pid=11, poll=lambda: 0 if ticks[0] >= .4 else None)
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [])
trace = []
evidence = tmp_path/'result.json'
original = runner.VerifyResult('FAIL', stderr=replay['native_error'], safe_to_continue=False,
error_category=replay['original_result']['error_category'],
error_stage=replay['original_result']['error_stage'], evidence_path=evidence)
assert runner.classify_failure_category(original.stderr) == original.error_category
assert runner.phase_for_event(replay['observed_events'][2]).value == original.error_stage
opens = []
def verify(req, **kwargs):
opens.append(req)
trace.append('open')
if len(opens) == 1:
errors = iter(('', replay['native_error']))
with pytest.raises(PcbBridgeError, match='Repair project'):
wait_for_target_document(job, lambda: SimpleNamespace(ActiveDocument=None),
process_alive=lambda: True, error_reader=lambda: next(errors),
emit=lambda **e: trace.append(e['stage']), sleep=lambda _: None)
closed = failed_session.close_failed_startup(job, 12, launcher_process=launcher,
emit=lambda **e: trace.append(e['stage']), timeout_seconds=1)
assert closed['status'] == 'CLOSED'
trace.append('launcher_exited')
return original # Repeated field error after one repair must not loop.
def repair(actual, root, **kwargs):
assert actual == target
assert trace[-1] == 'launcher_exited'
assert not records and launcher.poll() == 0
trace.append('native_repair')
return complete_native_success(actual)
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
monkeypatch.setattr(native_repair, 'run_native_repair', repair)
result = runner.run_verify(request)
assert trace == ['open', 'pcb_document_wait', 'startup_close_requested', 'startup_close_result',
'launcher_exited', 'native_repair', 'open']
assert len(opens) == 2 and opens[1].auto_repair is False
assert result.error_stage == 'PCB_STARTING'
assert result.recovery_attempts[0]['status'] == 'REPAIR_VALIDATION_FAILED'
assert result.recovery_attempts[0]['original_error'] == replay['native_error']
assert json.loads((tmp_path/'pre-repair-result.json').read_text('utf-8'))['stderr'] == replay['native_error']
MALFORMED_SUCCESS = [
('minimal', None),
('native_pid', None), ('native_pid', True),
('project', None), ('project', '<other>/CBB.prj'), ('project', []),
('database', None), ('database', '<other>/database'),
('release', []), ('release', 'released'),
('release.native_exited', None), ('release.native_exited', False),
('release.native_exited', 1), ('release.native_exited', 'true'),
('release.safe_to_continue', 1), ('release.addresses', ['owner']), ('release.addresses', ''),
('evidence', None), ('evidence', []), ('evidence', 'confirmed'),
('evidence.confirmed', None), ('evidence.confirmed', False),
('evidence.confirmed', 1), ('evidence.confirmed', 'true'),
('evidence.native_backup', False), ('evidence.failure_complete', True),
('evidence.outcome', 'DATABASE_BUSY'), ('evidence.restore_complete', True),
('evidence.restored_from_backup', 'old.zip'), ('unknown_dialogs', [{'title': 'Unknown'}]),
]
def malformed_native_success(target, key, value):
result = complete_native_success(target)
if key == 'minimal': return {'status': 'REPAIRED', 'release': {'safe_to_continue': True}}
if key in {'project', 'database'} and isinstance(value, str) and value.startswith('<other>'):
other = target.project.parent.parent.parent/'other-target'
other.mkdir(exist_ok=True)
if key == 'project':
other = other/'other.prj'
other.touch()
value = str(other.resolve())
if '.' in key:
parent, field = key.split('.')
result[parent][field] = value
else:
result[key] = value
return result
@pytest.mark.parametrize('key,value', MALFORMED_SUCCESS)
def test_malformed_native_success_never_authorizes_release(tmp_path, monkeypatch, key, value):
from cbb_refresh_verify import native_repair, mentor_adapter
request, diagnosis, target = target_fixture(tmp_path)
monkeypatch.setattr(mentor_adapter, 'pcb_processes', lambda: [])
monkeypatch.setattr(mentor_adapter, '_process_details', lambda *_: [])
result = native_repair.repair_release_state(request, target, malformed_native_success(target, key, value))
assert result['safe_to_continue'] is False
@pytest.mark.parametrize('key,value', MALFORMED_SUCCESS)
def test_malformed_native_success_never_reopens_or_counts_repaired(tmp_path, monkeypatch, key, value):
from cbb_refresh_verify import verify_runner as runner, native_repair
from cbb_refresh_verify.icdb_maintenance import maintenance_counts
request, diagnosis, target = target_fixture(tmp_path)
evidence = tmp_path/'first/result.json'
evidence.parent.mkdir()
(evidence.parent/'diagnostics').mkdir()
(evidence.parent/'diagnostics/icdb-recovery.json').write_text(json.dumps(diagnosis))
calls = []
def verify(*a, **kw):
calls.append('open')
if len(calls) == 1:
return runner.VerifyResult('FAIL', stderr='original error', error_category='ICDB_REPAIR_REQUIRED',
safe_to_continue=False, evidence_path=evidence)
return runner.VerifyResult('PASS', library_flag='GREEN', evidence_path=evidence)
monkeypatch.setattr(runner, '_run_verify_serialized', verify)
monkeypatch.setattr(native_repair, 'attempt_recovery', lambda *a, **kw:
malformed_native_success(target, key, value))
result = runner.run_verify(request)
assert calls == ['open']
assert result.status == 'FAIL' and result.safe_to_continue is False
assert result.recovery_attempts[0]['status'] == 'UNCONFIRMED'
assert result.recovery_attempts[0]['release']['safe_to_continue'] is False
assert maintenance_counts([result])['repaired'] == 0