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

237 lines
10 KiB
Python

"""Regression cases for the PCB/iCDB emergency shutdown defects.
Native Mentor boundaries are replaced; no production library is opened.
"""
from pathlib import Path
from types import SimpleNamespace
import pytest
from cbb_refresh_verify import mentor_adapter as adapter
from cbb_refresh_verify.verify_runner import VerifyResult, run_batch
from test_verify_worker_stability import exercise_worker
from test_dialog_rules import prompt, ASSETS
from cbb_refresh_verify.dialog_rules import decide, load_rules
def test_network_timeout_cannot_remove_database_advertisement(tmp_path, monkeypatch):
address = tmp_path / 'database/cdbsvr/sAddress.adr'
address.parent.mkdir(parents=True)
original = b'guid\n192.168.1.10\n10062\n1094\n'
address.write_bytes(original)
monkeypatch.setattr(adapter, 'probe_icdb_server', lambda *a: (False, 'timeout'))
result = adapter.prepare_icdb_address(tmp_path / 'database', tmp_path / 'evidence')
assert address.exists(), 'A timeout is not proof the database owner is dead'
assert address.read_bytes() == original
assert result['status'] == 'UNREACHABLE'
@pytest.mark.parametrize('state', ['LIVE', 'UNREACHABLE', 'INVALID'])
def test_existing_database_owner_blocks_before_pcb_launch(tmp_path, monkeypatch, state):
job, events, execute = exercise_worker(tmp_path, monkeypatch)
monkeypatch.setattr(adapter, 'prepare_icdb_address', lambda *a, **k: {'status': state})
with pytest.raises(RuntimeError, match='ICDB_SESSION_UNCONFIRMED'):
execute()
assert not any(e['stage'] == 'pcb_launch' for e in events)
@pytest.mark.parametrize('text', [
'Continue to open the design with read/write access permission?',
'Confirm that no other users have the design open',
'Database restoration: last user saved database',
])
def test_database_recovery_requires_manual_review_without_click(text):
decision = decide(prompt(text), load_rules(ASSETS / 'dialog_rules.v1.json'))
assert decision.error_code == 'DATABASE_RECOVERY_REQUIRED'
assert not decision.action
def test_unsafe_result_stops_batch_even_when_reported_pass():
calls = []
def verify(item):
calls.append(item)
return VerifyResult('PASS', safe_to_continue=False)
results = run_batch(['A', 'B'], verifier=verify)
assert calls == ['A']
assert results[1].status == 'SKIPPED'
def test_cleanup_does_not_force_terminate_native_database_owner(monkeypatch):
killed = []
monkeypatch.setattr(adapter, '_terminate_pid', lambda pid, **k: killed.append(pid))
monkeypatch.setattr(adapter, '_process_details', lambda name:
[(22, 'ExpeditionPCB.exe', 'pcb', 11)] if name == 'ExpeditionPCB.exe' else [])
events = []
result = adapter.cleanup_verify_processes(None, 22, 11, emit=lambda **e: events.append(e))
assert killed == []
assert result['safe_to_continue'] is False
assert result['remaining_pids'] == [22]
assert any(e['stage'] == 'process_retained' for e in events)
def test_cleanup_enumeration_failure_cannot_confirm_release(monkeypatch):
def fail(name):
raise OSError('access denied')
monkeypatch.setattr(adapter, '_process_details', fail)
result = adapter.cleanup_verify_processes(None, 22)
assert result['safe_to_continue'] is False
def test_python_com_references_are_released_before_save_helper(tmp_path, monkeypatch):
import weakref
job, events, execute = exercise_worker(tmp_path, monkeypatch)
references = []
class ComObject:
pass
def attach(*a, **k):
objects = tuple(ComObject() for _ in range(3))
references.extend(weakref.ref(obj) for obj in objects)
return objects
monkeypatch.setattr('cbb_refresh_verify.pcb_bridge.wait_for_target_document', attach)
original = adapter.subprocess.Popen
def helper(*a, **k):
assert all(ref() is None for ref in references), 'Python still owns PCB COM references'
return original(*a, **k)
monkeypatch.setattr(adapter.subprocess, 'Popen', helper)
assert execute()['status'] == 'PASS'
def test_desktop_abort_does_not_kill_native_process_tree(monkeypatch):
from cbb_refresh_verify import desktop_worker as desktop
worker = desktop.DesktopWorker.__new__(desktop.DesktopWorker)
worker.job_bound = True
worker.job = object()
worker.handle = object()
worker.pid = 101
worker.companions = []
terminated = []
job_kills = []
monkeypatch.setattr(desktop.win32job, 'TerminateJobObject', lambda *a: job_kills.append(a))
monkeypatch.setattr(desktop.win32process, 'TerminateProcess', lambda h, code: terminated.append(h))
monkeypatch.setattr(adapter, '_process_details', lambda name: [])
worker.kill()
assert job_kills == [], 'Terminating the job interrupts PCB and cdbsvr writes'
assert worker.handle in terminated
def test_saved_pcb_with_retained_icdb_address_cannot_pass(tmp_path, monkeypatch):
job, events, execute = exercise_worker(tmp_path, monkeypatch)
original = adapter.subprocess.Popen
def helper(*a, **k):
address = Path(job['project']).parent / 'database/cdbsvr/sAddress.adr'
address.parent.mkdir(parents=True)
address.write_text('still owned', encoding='ascii')
return original(*a, **k)
monkeypatch.setattr(adapter.subprocess, 'Popen', helper)
with pytest.raises(RuntimeError, match='ICDB_RELEASE_UNCONFIRMED'):
execute()
assert not any(e['stage'] == 'complete' for e in events)
def test_retained_pcb_after_close_cannot_pass_or_be_killed(tmp_path, monkeypatch):
from itertools import count
job, events, execute = exercise_worker(tmp_path, monkeypatch)
calls = count()
monkeypatch.setattr(adapter, 'pcb_processes', lambda:
() if next(calls) == 0 else ((2, 'ExpeditionPCB.exe', 'pcb'),))
clock = count(step=40)
monkeypatch.setattr(adapter.time, 'monotonic', lambda: next(clock))
with pytest.raises(RuntimeError, match='PCB_RELEASE_UNCONFIRMED'):
execute()
assert not any(e['stage'] == 'complete' for e in events)
def test_library_manager_close_does_not_force_kill_database_owner():
from cbb_refresh_verify.library_manager_verify import LibraryVerifySession
killed = []
def wait(**kw):
import subprocess
raise subprocess.TimeoutExpired('LibraryManager', 5)
process = SimpleNamespace(poll=lambda: None, wait=wait,
terminate=lambda: killed.append('terminate'),
kill=lambda: killed.append('kill'))
session = LibraryVerifySession(SimpleNamespace(close=lambda: None), process, 1, Path('lib.lmc'), 'CBB')
session.close()
assert killed == []
def test_supervisor_rejects_pass_when_native_release_is_unconfirmed(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)
class Worker:
desktop = None
returncode = 0
def __init__(self, command, *_a, **_k):
root = Path(command[-1]).parent
(root / 'outcome.json').write_text('{"status":"PASS"}', encoding='utf-8')
(root / 'backup/CBB').mkdir(parents=True)
(root / 'backup/CBB/original.bin').write_bytes(b'original')
def poll(self): return 0
def close(self): pass
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker', Worker)
monkeypatch.setattr('cbb_refresh_verify.verify_runner._cleanup_session_processes',
lambda *a, **k: {'safe_to_continue': False, 'remaining_pids': [42]})
monkeypatch.setattr('cbb_refresh_verify.verify_diagnostics.capture_failure_logs_with_timeout', lambda *a: None)
bridge_calls = []
result = run_verify(request(tmp_path), port_check=PORTS_OK,
flag_reader=lambda *a: bridge_calls.append(a))
assert result.status == 'FAIL'
assert not result.safe_to_continue
assert bridge_calls == []
root = result.evidence_path.parent
assert (root / 'backup/CBB/original.bin').read_bytes() == b'original'
recovery = json.loads((root / 'recovery-required.json').read_text(encoding='utf-8'))
assert recovery['release']['remaining_pids'] == [42]
assert recovery['desktop'].startswith('CbbVerify_')
def test_existing_pcb_session_blocks_before_mutating_project(tmp_path, monkeypatch):
job, events, execute = exercise_worker(tmp_path, monkeypatch)
monkeypatch.setattr(adapter, 'pcb_processes', lambda: ((20, 'ExpeditionPCB.exe', 'user design'),))
with pytest.raises(RuntimeError, match='PCB_SESSION_ACTIVE'):
execute()
assert not events
def test_real_windows_job_abort_preserves_native_like_child(tmp_path):
"""Exercise real Win32 job/handle semantics using harmless Python processes."""
import sys
import time
import uuid
import win32api
import win32con
import win32process
from cbb_refresh_verify.desktop_worker import DesktopWorker
script = tmp_path / 'parent.py'
pid_path = tmp_path / 'child.pid'
script.write_text(
'import subprocess, sys, time\nfrom pathlib import Path\n'
'child = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(30)"])\n'
f'Path({str(pid_path)!r}).write_text(str(child.pid))\n'
'time.sleep(30)\n', encoding='utf-8')
worker = DesktopWorker([sys.executable, str(script)], 'CbbSafetyTest_' + uuid.uuid4().hex[:8])
child_handle = None
closed = False
try:
deadline = time.monotonic() + 10
while not pid_path.exists() and time.monotonic() < deadline:
time.sleep(.05)
assert pid_path.exists(), 'Harmless child process failed to start'
child_handle = win32api.OpenProcess(
win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_TERMINATE, False,
int(pid_path.read_text()))
worker.kill()
worker.wait()
worker.close()
closed = True
assert win32process.GetExitCodeProcess(child_handle) == 259
finally:
if not closed:
worker.kill()
worker.close()
if child_handle is not None:
win32process.TerminateProcess(child_handle, 0)
child_handle.Close()