172 lines
8.4 KiB
Python
172 lines
8.4 KiB
Python
from pathlib import Path
|
|
import pytest
|
|
from PySide6.QtCore import Qt
|
|
|
|
|
|
def test_ready_rows_never_enter_maintenance_even_when_unchecked(qtbot, tmp_path, monkeypatch):
|
|
from test_ui_filters import load_window, MIXED
|
|
window = load_window(qtbot, tmp_path, monkeypatch, records=(MIXED[0],))
|
|
assert window._maintenance_names() == []
|
|
assert not window.icdb_repair_button.isEnabled()
|
|
assert not window.backup_restore_button.isEnabled()
|
|
window.select_visible_button.click()
|
|
assert window._maintenance_names() == []
|
|
|
|
|
|
def test_selected_ready_rows_are_ignored_in_mixed_maintenance(qtbot, tmp_path, monkeypatch):
|
|
from test_ui_filters import load_window
|
|
window = load_window(qtbot, tmp_path, monkeypatch)
|
|
window.select_visible_button.click()
|
|
assert window._maintenance_names() == ['Beta', 'Gamma', 'Delta']
|
|
window._apply_refreshed_records((('Beta', 'Gamma'), {'Beta': 'READY', 'Gamma': 'READY'}, {}, ''))
|
|
assert window._maintenance_names() == ['Delta']
|
|
assert window.icdb_repair_button.isEnabled()
|
|
|
|
|
|
def test_diagnostic_worker_closes_without_integration_save_or_config_edit(tmp_path, monkeypatch):
|
|
from test_verify_worker_stability import exercise_worker
|
|
from cbb_refresh_verify import mentor_adapter as adapter
|
|
job, events, execute = diagnostic_worker(tmp_path, monkeypatch)
|
|
job['diagnostic_only'] = True
|
|
def forbidden(*args, **kwargs):
|
|
pytest.fail('diagnosis attempted integration/save/config rewrite')
|
|
monkeypatch.setattr(adapter, 'ensure_pcb_central_library', forbidden)
|
|
monkeypatch.setattr(adapter, 'pcb_log_reports_integration_error', forbidden)
|
|
original_read = Path.read_bytes
|
|
def read_bytes(path):
|
|
if path.name in ('ForwardAnnotation.txt', 'MsgBoxResponse.log', 'PartPkg.log'):
|
|
pytest.fail('opening check read unrelated integration history')
|
|
return original_read(path)
|
|
monkeypatch.setattr(Path, 'read_bytes', read_bytes)
|
|
monkeypatch.setattr('cbb_refresh_verify.integration.refresh_integration', forbidden)
|
|
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.launch_save_helper', forbidden)
|
|
monkeypatch.setattr('cbb_refresh_verify.pcb_bridge.wait_for_target_document', forbidden)
|
|
monkeypatch.setattr('cbb_refresh_verify.failed_session.close_failed_document', forbidden)
|
|
closes = []
|
|
def check(job, pid, **kw):
|
|
assert pid == 2 and kw['launcher_process'].pid == 1
|
|
assert job['diagnostic_log_baseline']['started_ns']
|
|
closes.append(job)
|
|
kw['emit'](stage='diagnostic_wm_close')
|
|
return {'status': 'PASS', 'native_processes_exited': True}
|
|
monkeypatch.setattr('cbb_refresh_verify.diagnostic_open.check_target_window', check)
|
|
result = execute()
|
|
from cbb_refresh_verify.verify_runner import VerifyResult
|
|
assert VerifyResult(**result).status == 'PASS'
|
|
assert result['status'] == 'PASS'
|
|
assert len(closes) == 1
|
|
assert not any(e['stage'] in ('save_start', 'saved_and_closed') for e in events)
|
|
|
|
|
|
def test_diagnostic_close_failure_never_returns_healthy(tmp_path, monkeypatch):
|
|
from test_verify_worker_stability import exercise_worker
|
|
job, events, execute = diagnostic_worker(tmp_path, monkeypatch)
|
|
job['diagnostic_only'] = True
|
|
closes = []
|
|
def check(*a, **kw):
|
|
closes.append(a)
|
|
kw['emit'](stage='diagnostic_wm_close')
|
|
raise RuntimeError('DIAGNOSTIC_CLOSE_UNCONFIRMED')
|
|
monkeypatch.setattr('cbb_refresh_verify.diagnostic_open.check_target_window', check)
|
|
monkeypatch.setattr('cbb_refresh_verify.failed_session.close_failed_startup',
|
|
lambda *a, **kw: pytest.fail('must not send another close after WM_CLOSE'))
|
|
with pytest.raises(RuntimeError, match='DIAGNOSTIC_CLOSE_UNCONFIRMED'):
|
|
execute()
|
|
assert len(closes) == 1
|
|
|
|
|
|
@pytest.mark.parametrize('prefix', ['KEY CentralLibrary ', ' KEY CentralLibrary ', 'KEY\tCentralLibrary\t'])
|
|
def test_diagnosis_rejects_foreign_library_reference_before_native_launch(tmp_path, monkeypatch, prefix):
|
|
from test_verify_worker_stability import exercise_worker
|
|
from cbb_refresh_verify import mentor_adapter as adapter
|
|
job, events, execute = diagnostic_worker(tmp_path, monkeypatch)
|
|
job['diagnostic_only'] = True
|
|
project = Path(job['project'])
|
|
project.write_text(prefix + '"foreign.lmc"\n')
|
|
monkeypatch.setattr(adapter, 'launch_pcb_process', lambda *a: pytest.fail('foreign library opened'))
|
|
with pytest.raises(ValueError, match='DIAGNOSTIC_LIBRARY_MISMATCH'):
|
|
execute()
|
|
|
|
def diagnostic_worker(tmp_path, monkeypatch):
|
|
from test_verify_worker_stability import exercise_worker
|
|
job, events, execute = exercise_worker(tmp_path, monkeypatch)
|
|
(Path(job['pcb']).parent/'pcb.prj').write_text(
|
|
'KEY CentralLibrary "' + job['lmc_file'] + '"\n', encoding='utf-8')
|
|
monkeypatch.setattr('cbb_refresh_verify.diagnostic_open.check_target_window',
|
|
lambda *a, **kw: {'status': 'PASS', 'native_processes_exited': True})
|
|
return job, events, execute
|
|
|
|
|
|
def test_diagnostic_runner_skips_importer_and_ready_verification(tmp_path, monkeypatch):
|
|
import json
|
|
from test_verify_runner import fixture, request, PORTS_OK
|
|
from cbb_refresh_verify.verify_runner import run_verify
|
|
fixture(tmp_path)
|
|
captured = {}
|
|
class FinishedWorker:
|
|
desktop = None
|
|
returncode = 0
|
|
def __init__(self, command, name, **kwargs):
|
|
job = Path(command[-1])
|
|
captured.update(json.loads(job.read_text('utf-8')))
|
|
job.with_name('outcome.json').write_text('{"status":"PASS"}', encoding='utf-8')
|
|
def poll(self): return 0
|
|
def close(self): pass
|
|
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker', FinishedWorker)
|
|
def forbidden(*a, **kw): pytest.fail('diagnosis must not run importer or query READY')
|
|
result = run_verify(request(tmp_path, diagnostic_only=True, auto_repair=False,
|
|
libspec='configured', dms_login_config='configured'), port_check=PORTS_OK,
|
|
flag_reader=forbidden, process_runner=forbidden)
|
|
assert result.status == 'PASS' and result.library_flag == 'UNKNOWN'
|
|
assert captured['diagnostic_only'] is True
|
|
|
|
|
|
def test_diagnostic_cannot_pass_with_unconfirmed_process_exit(tmp_path, monkeypatch):
|
|
from cbb_refresh_verify import mentor_adapter as adapter
|
|
job, events, execute = diagnostic_worker(tmp_path, monkeypatch)
|
|
job['diagnostic_only'] = True
|
|
monkeypatch.setattr(adapter, 'cleanup_verify_processes',
|
|
lambda *a, **kw: {'safe_to_continue': False, 'remaining_pids': [2]})
|
|
with pytest.raises(RuntimeError, match='DIAGNOSTIC_CLOSE_UNCONFIRMED'):
|
|
execute()
|
|
|
|
|
|
@pytest.mark.parametrize('when', ['document_ready', 'closing'])
|
|
def test_diagnostic_checks_late_startup_errors_before_declaring_healthy(tmp_path, monkeypatch, when):
|
|
from cbb_refresh_verify import mentor_adapter as adapter
|
|
job, events, execute = diagnostic_worker(tmp_path, monkeypatch)
|
|
job['diagnostic_only'] = True
|
|
source = Path(job['pcb']).parent/'LogFiles/PCBLogFile.txt'
|
|
def late_fault():
|
|
source.parent.mkdir(exist_ok=True)
|
|
source.write_text("The last server session on different server machine lost the connection to the database. "
|
|
f"Machine:[fixture] Path:[{Path(job['project']).parent/'database'}] session:[current]", encoding='utf-8')
|
|
closes = []
|
|
def check(*a, **kw):
|
|
if when == 'document_ready':
|
|
late_fault()
|
|
raise RuntimeError(kw['error_reader']())
|
|
closes.append(True)
|
|
kw['emit'](stage='diagnostic_wm_close')
|
|
late_fault()
|
|
return {'status': 'PASS', 'native_processes_exited': True}
|
|
monkeypatch.setattr('cbb_refresh_verify.diagnostic_open.check_target_window', check)
|
|
monkeypatch.setattr('cbb_refresh_verify.failed_session.close_failed_startup',
|
|
lambda *a, **kw: {'status': 'CLOSED'})
|
|
with pytest.raises(RuntimeError, match='ICDB_REPAIR_REQUIRED'):
|
|
execute()
|
|
assert len(closes) == (1 if when == 'closing' else 0)
|
|
assert not any(e['stage'] == 'diagnostic_complete' for e in events)
|
|
|
|
|
|
def test_diagnostic_snapshot_is_before_launch(tmp_path, monkeypatch):
|
|
from cbb_refresh_verify import mentor_adapter as adapter
|
|
job, events, execute = diagnostic_worker(tmp_path, monkeypatch)
|
|
job['diagnostic_only'] = True
|
|
def launch(*a):
|
|
assert job.get('diagnostic_log_baseline', {}).get('started_ns')
|
|
from types import SimpleNamespace
|
|
return SimpleNamespace(pid=1)
|
|
monkeypatch.setattr(adapter, 'launch_pcb_process', launch)
|
|
assert execute()['status'] == 'PASS'
|