from cbb_refresh_verify.ui import timed_prompt from pathlib import Path from threading import Event from cbb_refresh_verify import session_record as sessions def retain(monkeypatch, library): key = 'controlled-session' monkeypatch.setattr(sessions, '_retained_libraries', {key: {sessions._library_key(library)}}) monkeypatch.setattr(sessions, '_retained_results', {key: dict(block='BlockedCBB', operation_id='test', library=str(library), status='UNCONFIRMED', detail='Close result unknown')}) def test_cached_wait_reason_names_retained_block_without_file_io(tmp_path, monkeypatch): library = tmp_path/'lib.lmc' retain(monkeypatch, library) monkeypatch.setattr(Path, 'resolve', lambda *a, **kw: (_ for _ in ()).throw(AssertionError('queue filesystem I/O'))) detail = sessions.library_wait_reason(library) assert 'BlockedCBB' in detail and '残留' in detail assert sessions.library_wait_reason(tmp_path/'other.lmc') == '' def test_queued_action_has_visible_release_entry_and_resumes_after_proof(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window from cbb_refresh_verify.verify_runner import VerifyResult window = load_window(qtbot, tmp_path, monkeypatch) window.show() library = window.mentor_lmc_path retain(monkeypatch, library) from test_review381_queue_release import hold_native_queue queue_release, queue_worker = hold_native_queue(window) finished = Event() window._start(lambda: VerifyResult('PASS'), lambda _: finished.set()) qtbot.waitUntil(lambda: 'BlockedCBB' in window.status_label.text()) assert window.queue_release_button.isVisible() and window.queue_release_button.isEnabled() opened = [] monkeypatch.setattr(window, 'check_library_release', lambda **kwargs: opened.append(kwargs)) window.queue_release_button.click() assert opened == [{'queued': True}] sessions._retained_libraries.clear() queue_release.set(); queue_worker.join(2) window.native_queue.wake() qtbot.waitUntil(finished.is_set) qtbot.waitUntil(lambda: not window.busy) assert not window.queue_release_button.isVisible() def test_release_entry_does_not_clear_the_busy_state_of_a_waiting_ticket(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window from cbb_refresh_verify import library_lock window = load_window(qtbot, tmp_path, monkeypatch) library = window.mentor_lmc_path retain(monkeypatch, library) monkeypatch.setattr(library_lock, 'inspect_residual_sessions', lambda _: dict(library=str(library), sessions=[])) window.busy = True window._queue_wait_library = str(library) window.check_library_release(queued=True) qtbot.waitUntil(lambda: not window.release_dialog.busy) window.release_dialog.close() qtbot.waitUntil(lambda: not window._queue_release_mode) assert window.busy window.busy = False def test_release_mapping_cleanup_finishes_before_waiting_ticket_resumes(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window from cbb_refresh_verify import library_lock window = load_window(qtbot, tmp_path, monkeypatch) cleaned, finished = Event(), Event() library = window.mentor_lmc_path retain(monkeypatch, library) monkeypatch.setattr(library_lock, 'inspect_residual_sessions', lambda _: dict(library=str(library), sessions=[])) entered, allow_release = Event(), Event() def backend_release(*a, **kw): entered.set(); assert allow_release.wait(5) sessions._retained_libraries.clear() return dict(status='RELEASE_CONFIRMED', sessions=[], proof=dict(status='RELEASE_CONFIRMED', library=str(library), evidence_path='controlled-proof.json')) monkeypatch.setattr(library_lock, 'release_residual_sessions', backend_release) def finalize(*a, **kw): assert window.native_queue.active, 'proof cleanup must complete inside serialized release' cleaned.set() monkeypatch.setattr('cbb_refresh_verify.network_path.release_retained_path_leases', finalize) def action(): assert cleaned.is_set(), 'new native operation began before old mapping release completed' finished.set() window._queue_wait_library = str(library) window.check_library_release(queued=True) qtbot.waitUntil(lambda: not window.release_dialog.busy) window.release_dialog.confirm_button.click() qtbot.waitUntil(entered.is_set) try: window._start(action, lambda _: None) allow_release.set() qtbot.waitUntil(finished.is_set) qtbot.waitUntil(lambda: not window.release_dialog.busy) qtbot.waitUntil(lambda: not window.busy) window.release_dialog.close() finally: allow_release.set() def test_wait_reason_updates_when_active_task_becomes_a_retained_session(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window window = load_window(qtbot, tmp_path, monkeypatch) library = window.mentor_lmc_path retain(monkeypatch, library) sessions._retained_libraries.clear() active = Event() release = Event() from threading import Thread first = Thread(target=lambda: window.native_queue.run(lambda: (active.set(), release.wait(5)))) first.start() qtbot.waitUntil(active.is_set) try: window._start(lambda: None, lambda _: None) qtbot.waitUntil(lambda: '已排队' in window.status_label.text()) assert window._queue_wait_library is None sessions._retained_libraries['controlled-session'] = {sessions._library_key(library)} qtbot.waitUntil(lambda: 'BlockedCBB' in window.status_label.text()) assert not window.queue_release_button.isHidden() finally: release.set(); first.join(3) sessions._retained_libraries.clear(); window.native_queue.wake() qtbot.waitUntil(lambda: not window.busy) def test_management_wait_shows_same_block_and_emits_release_target(qtbot, tmp_path, monkeypatch): from cbb_refresh_verify.ui.management_dialog import ManagementDialog from cbb_refresh_verify.management import ManagementRequest from cbb_refresh_verify.operation_queue import NativeQueue from PySide6.QtWidgets import QMessageBox library = tmp_path/'lib.lmc' retain(monkeypatch, library) monkeypatch.setattr(timed_prompt, 'question', lambda *a, **kw: QMessageBox.Yes) dialog = ManagementDialog([ManagementRequest('remove', library, 'A')], runner=lambda *a, **kw: []) dialog.native_queue = NativeQueue() qtbot.addWidget(dialog); dialog.show() targets = [] dialog.release_requested.connect(targets.append) from test_review381_queue_release import hold_native_queue queue_release, queue_worker = hold_native_queue(dialog) dialog.execute_button.click() qtbot.waitUntil(lambda: 'BlockedCBB' in dialog.status_label.text()) assert dialog.release_wait_button.isVisible() dialog.release_wait_button.click() assert targets == [library] dialog.stop.set() qtbot.waitUntil(lambda: not dialog.busy) queue_release.set(); queue_worker.join(2) def test_close_waits_for_independent_release_worker(qtbot, tmp_path, monkeypatch): from test_ui_filters import load_window from cbb_refresh_verify.ui.workers import ServiceWorker window = load_window(qtbot, tmp_path, monkeypatch) window.show() started, release = Event(), Event() worker = ServiceWorker(lambda: (started.set(), release.wait(5))) window.lifecycle_pool.start(worker) qtbot.waitUntil(started.is_set) try: window.close() qtbot.wait(40) assert window.isVisible(), 'window closed while independent release still owned callbacks' finally: release.set() qtbot.waitUntil(lambda: not window.isVisible())