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

172 lines
7.7 KiB
Python

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