"""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()