309 lines
16 KiB
Python
309 lines
16 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()
|
|
|
|
|
|
def test_release_check_clears_only_its_own_management_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, library_b = tmp_path/'a.lmc', tmp_path/'b.lmc'
|
|
for library in (library_a, library_b):
|
|
window._management_unsafe = True
|
|
window._management_unsafe_library = library
|
|
window._update()
|
|
monkeypatch.setattr('cbb_refresh_verify.library_lock.release_retained_library',
|
|
lambda *_: {'status': 'RELEASE_CONFIRMED', 'library': str(library_a),
|
|
'evidence_path': str(tmp_path/'release.json')})
|
|
window.lmc_edit.setText(str(library_a))
|
|
window.load_library()
|
|
qtbot.waitUntil(lambda: not window.busy)
|
|
window._complete_library_release(library_a, {'status': 'RELEASE_CONFIRMED',
|
|
'library': str(library_a), 'evidence_path': str(tmp_path/'release.json')})
|
|
qtbot.waitUntil(lambda: not window.busy)
|
|
assert not window._management_block_reason('add')
|
|
window.lmc_edit.setText(str(library_b))
|
|
window.load_library()
|
|
qtbot.waitUntil(lambda: not window.busy)
|
|
assert window._management_library_unsafe(library_b)
|
|
assert not window._management_block_reason('add')
|
|
|
|
|
|
@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
|
|
|
|
|
|
@pytest.mark.parametrize('proof_kind', ['valid', 'foreign', 'invalid', 'lease_error'])
|
|
def test_release_check_restores_current_mapping_only_after_matching_proof(qtbot, tmp_path, monkeypatch, proof_kind):
|
|
from test_ui_filters import load_window
|
|
from cbb_refresh_verify import network_path
|
|
window = load_window(qtbot, tmp_path, monkeypatch)
|
|
library = Path('test.lmc').absolute()
|
|
current = network_path.LibraryPathLease(library, library)
|
|
current.retain_for_recovery()
|
|
window.library_lease = current
|
|
window.mentor_lmc_path = library
|
|
window._management_unsafe = True
|
|
window._management_unsafe_library = library
|
|
session = SimpleNamespace(library=library, path_lease=current, process=SimpleNamespace(poll=lambda: 0))
|
|
window._native_backup_session = session
|
|
proof = {'status': 'UNCONFIRMED' if proof_kind == 'invalid' else 'RELEASE_CONFIRMED',
|
|
'library': str(tmp_path/'foreign.lmc') if proof_kind == 'foreign' else str(library),
|
|
'evidence_path': str(tmp_path/'release.json')}
|
|
monkeypatch.setattr('cbb_refresh_verify.library_lock.release_retained_library', lambda *_: proof)
|
|
if proof_kind == 'lease_error':
|
|
def failed_release(*_a, **_k):
|
|
raise network_path.NetworkPathError('mapping release failed')
|
|
monkeypatch.setattr(network_path, 'release_retained_path_leases', failed_release)
|
|
try:
|
|
window._complete_library_release(library, proof)
|
|
qtbot.waitUntil(lambda: window._mapping_busy == 0)
|
|
qtbot.waitUntil(lambda: window._lease_pending == 0)
|
|
assert current._retained_for_recovery is (proof_kind != 'valid')
|
|
assert not current._closed
|
|
assert window._management_unsafe is (proof_kind != 'valid')
|
|
assert (window._native_backup_session is session) is (proof_kind != 'valid')
|
|
finally:
|
|
window._native_backup_session = None
|
|
network_path._retained_path_leases.pop(id(current), 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()
|