172 lines
7.7 KiB
Python
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())
|