Files
cbb-refresh-verify-795/tests/test_ui_batch_safety.py

248 lines
12 KiB
Python

"""No native applications or shared execution mutex are used by these regressions."""
import json
from dataclasses import replace
from pathlib import Path
from types import SimpleNamespace
import pytest
from cbb_refresh_verify import verify_runner as runner
from cbb_refresh_verify.status_bridge import BridgeResult
from test_verify_runner import fixture, request, PORTS_OK
@pytest.fixture
def isolated_verify(tmp_path, monkeypatch):
import win32event
fixture(tmp_path)
monkeypatch.setattr(win32event, 'CreateMutex', lambda *_: SimpleNamespace(Close=lambda: None))
monkeypatch.setattr(win32event, 'WaitForSingleObject', lambda *_: 0)
monkeypatch.setattr(win32event, 'ReleaseMutex', lambda *_: None)
monkeypatch.setattr(runner, '_cleanup_session_processes', lambda *a, **k:
{'safe_to_continue': True, 'remaining_pids': []})
monkeypatch.setattr('cbb_refresh_verify.verify_diagnostics.capture_failure_logs_with_timeout', lambda *_: None)
monkeypatch.setattr(runner, 'read_library_flag_if_available',
lambda *_: BridgeResult('READY', 'IsVerifiedReuseBlock', 1))
return request(tmp_path)
def test_invalid_proof_is_safe_before_worker_launch(isolated_verify, monkeypatch):
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker',
lambda *_: pytest.fail('invalid proof launched a worker'))
req = replace(isolated_verify, post_repair_proof=object())
results = runner.run_batch([req, req], verifier=lambda r: runner.run_verify(r, port_check=PORTS_OK))
assert [r.status for r in results] == ['BLOCKED', 'BLOCKED']
assert all(r.safe_to_continue for r in results)
@pytest.mark.parametrize('failure', ['directory', 'runtime', 'request', 'worker_log'])
def test_prelaunch_disk_failure_does_not_stop_independent_items(isolated_verify, monkeypatch, failure):
class FinishedWorker:
desktop = None
returncode = 0
def __init__(self, command, *_a, **_k):
Path(command[-1]).with_name('outcome.json').write_text('{"status":"PASS"}')
def poll(self): return 0
def close(self): pass
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker', FinishedWorker)
mkdir, write, open_file = Path.mkdir, Path.write_text, Path.open
def make(path, *a, **k):
if failure == 'directory' and path.name.startswith('verify-'):
raise OSError('evidence volume unavailable')
return mkdir(path, *a, **k)
def save(path, *a, **k):
if path.name == {'runtime': 'runtime.json', 'request': 'request.json'}.get(failure):
raise OSError('evidence volume unavailable')
return write(path, *a, **k)
def opening(path, *a, **k):
if failure == 'worker_log' and path.name == 'worker.log':
raise OSError('evidence volume unavailable')
return open_file(path, *a, **k)
monkeypatch.setattr(Path, 'mkdir', make)
monkeypatch.setattr(Path, 'write_text', save)
monkeypatch.setattr(Path, 'open', opening)
from cbb_refresh_verify import library_lock as locks
try:
results = runner.run_batch([isolated_verify, isolated_verify],
verifier=lambda r: runner.run_verify(r, port_check=PORTS_OK))
assert all(r.safe_to_continue for r in results)
assert [r.status for r in results] == (['PASS', 'PASS'] if failure == 'runtime' else ['FAIL', 'FAIL'])
assert locks.LibraryLock(isolated_verify.lmc_file).key not in locks._owners
finally:
owner = locks._owners.pop(locks.LibraryLock(isolated_verify.lmc_file).key, None)
if owner: owner['handle'].Close()
def test_coordination_permission_failure_does_not_manufacture_native_owner(isolated_verify, monkeypatch):
from cbb_refresh_verify.library_lock import LibraryLock
def denied(_): raise PermissionError('coordination directory is read-only')
monkeypatch.setattr(LibraryLock, '__enter__', denied)
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker',
lambda *_: pytest.fail('permission failure launched native work'))
results = runner.run_batch([isolated_verify, isolated_verify],
verifier=lambda r: runner.run_verify(r, port_check=PORTS_OK))
assert [r.status for r in results] == ['FAIL', 'FAIL']
assert all(r.safe_to_continue and r.error_category == 'LIBRARY_ACCESS_FAILED' for r in results)
@pytest.mark.parametrize('launch_state', ['never_created', 'unknown', 'partially_created'])
def test_constructor_release_evidence_controls_batch_continuation(isolated_verify, monkeypatch, launch_state):
proven_rollback = launch_state == 'never_created'
launches = []
def fail_launch(*_a, **_k):
launches.append(True)
error = RuntimeError('worker launch failed')
if launch_state != 'unknown':
error.worker_launch_release = {'safe_to_continue': True, 'worker_exited': True,
'remaining_pids': [], 'process_created': not proven_rollback}
raise error
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker', fail_launch)
from cbb_refresh_verify import library_lock as locks
try:
results = runner.run_batch([isolated_verify, isolated_verify],
verifier=lambda r: runner.run_verify(r, port_check=PORTS_OK))
assert len(launches) == (2 if proven_rollback else 1)
assert results[0].safe_to_continue is proven_rollback
if proven_rollback:
proof = json.loads(results[0].evidence_path.with_name('session-release.json').read_text('utf-8'))
assert proof['worker_exited'] and proof['safe_to_continue']
assert locks.LibraryLock(isolated_verify.lmc_file).key not in locks._owners
finally:
with locks._guard:
owner = locks._owners.pop(locks.LibraryLock(isolated_verify.lmc_file).key, None)
if owner:
owner['handle'].Close()
@pytest.mark.parametrize('filename', ['result.json', 'performance.json', 'bridge-status.json'])
def test_optional_evidence_write_failure_preserves_released_result(isolated_verify, monkeypatch, filename):
class FinishedWorker:
desktop = None
returncode = 0
def __init__(self, command, *_a, **_k):
Path(command[-1]).with_name('outcome.json').write_text('{"status":"PASS"}')
def poll(self): return 0
def close(self): pass
monkeypatch.setattr('cbb_refresh_verify.desktop_worker.DesktopWorker', FinishedWorker)
original = Path.write_text
def write(path, *a, **k):
if path.name == filename:
raise OSError('report disk unavailable')
return original(path, *a, **k)
monkeypatch.setattr(Path, 'write_text', write)
results = runner.run_batch([isolated_verify, isolated_verify],
verifier=lambda r: runner.run_verify(r, port_check=PORTS_OK))
assert [r.status for r in results] == ['PASS', 'PASS']
assert all(r.safe_to_continue for r in results)
def test_progress_failure_does_not_stop_safe_batch(isolated_verify):
def failed_progress(*_):
raise RuntimeError('view was closed')
results = runner.run_batch([isolated_verify, isolated_verify],
verifier=lambda _: runner.VerifyResult('FAIL', safe_to_continue=True), progress=failed_progress)
assert len(results) == 2 and all(r.safe_to_continue for r in results)
def test_performance_progress_failure_preserves_release(isolated_verify, monkeypatch):
root = isolated_verify.evidence_dir
root.mkdir()
result = runner.VerifyResult('FAIL', safe_to_continue=True, evidence_path=root/'result.json')
monkeypatch.setattr(runner, '_run_verify', lambda *a, **k: result)
def progress(event):
if event['stage'] == 'performance':
raise RuntimeError('view was closed')
actual = runner._run_verify_serialized(isolated_verify, progress=progress)
assert actual.safe_to_continue and actual.status == 'FAIL'
def test_performance_logger_failure_preserves_release(isolated_verify, monkeypatch):
def unavailable_log(*_a, **_k):
raise OSError('log destination unavailable')
req = replace(isolated_verify, logging_context=SimpleNamespace(logger=SimpleNamespace(info=unavailable_log)))
monkeypatch.setattr(runner, '_run_verify', lambda *a, **k: runner.VerifyResult('FAIL', safe_to_continue=True))
result = runner._run_verify_serialized(req)
assert result.safe_to_continue and result.status == 'FAIL'
def test_management_unsafe_survives_switching_back_to_library(qtbot, tmp_path, monkeypatch):
from test_ui_filters import load_window
from cbb_refresh_verify.management import Capability
adapter = SimpleNamespace(capabilities=lambda: {op: Capability(True, 'available')
for op in ('add', 'update', 'remove')})
window = load_window(qtbot, tmp_path, monkeypatch, management_adapter=adapter)
window.path_lease_factory = lambda path: SimpleNamespace(mentor_path=path, close=lambda: None,
retain_for_recovery=lambda: None)
library_a = tmp_path/'a.lmc'
library_b = tmp_path/'b.lmc'
window._management_unsafe = True
window._management_unsafe_library = library_a
for library, blocked in [(library_b, False), (library_a, True)]:
window.lmc_edit.setText(str(library))
window.load_library()
qtbot.waitUntil(lambda: not window.busy)
assert window._management_library_unsafe(library) is blocked
assert not window._management_block_reason('add')
assert window.batch_button.isEnabled()
@pytest.mark.parametrize('released', [True, False])
def test_batch_report_failure_preserves_ui_outcomes(qtbot, tmp_path, monkeypatch, released):
from test_ui_filters import load_window
import cbb_refresh_verify.ui.main_window as ui
window = load_window(qtbot, tmp_path, monkeypatch,
verifier=lambda _: runner.VerifyResult('FAIL', stderr='item failed', safe_to_continue=released),
status_refresher=lambda names, _: {name: 'PENDING' for name in names})
retained = []
window.library_lease.retain_for_recovery = lambda: retained.append(True)
monkeypatch.setattr(ui, 'write_batch_report', lambda *_: (_ for _ in ()).throw(OSError('report unavailable')))
window._run(['Beta', 'Gamma'])
qtbot.waitUntil(lambda: not window.busy)
assert bool(retained) is not released
assert 'report unavailable' in window.output.toPlainText()
assert 'item failed' in window.output.toPlainText()
assert window.batch_button.isEnabled()
@pytest.mark.parametrize('alias', ['absolute', 'mapped'])
def test_native_backup_session_matches_library_alias_without_network_resolution(qtbot, tmp_path, monkeypatch, alias):
from test_ui_filters import load_window
window = load_window(qtbot, tmp_path, monkeypatch)
if alias == 'absolute':
current = Path.cwd()/'test.lmc'
session_library = Path('test.lmc')
session_lease = None
else:
current = Path('T:/folder/lib.lmc')
session_library = Path('S:/folder/lib.lmc')
window.library_lease = SimpleNamespace(mentor_path=current, display_path=current,
drive='T:', remote_root=r'\\server\share', close=lambda: None)
session_lease = SimpleNamespace(mentor_path=session_library, display_path=session_library,
drive='S:', remote_root=r'\\server\share')
window.mentor_lmc_path = current
window._native_backup_session = SimpleNamespace(library=session_library, path_lease=session_lease)
try:
with monkeypatch.context() as context:
context.setattr(Path, 'resolve', lambda *_a, **_k: pytest.fail('UI touched network resolution'))
assert window._native_backup_same_library()
finally:
window._native_backup_session = None
def test_opening_evidence_failure_does_not_retain_library(qtbot, tmp_path, monkeypatch):
from test_ui_filters import load_window
window = load_window(qtbot, tmp_path, monkeypatch)
retained = []
window.library_lease.retain_for_recovery = lambda: retained.append(True)
window.recovery_path = tmp_path
def cannot_open(*_):
raise OSError('file viewer unavailable')
monkeypatch.setattr('os.startfile', cannot_open)
window.recover()
assert not retained
assert 'file viewer unavailable' in window.output.toPlainText()