242 lines
10 KiB
Python
242 lines
10 KiB
Python
"""Stale and repeated user actions around native queue admission."""
|
|
from threading import Event
|
|
from types import SimpleNamespace
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
from PySide6.QtCore import Qt
|
|
|
|
from cbb_refresh_verify import session_record as sessions
|
|
from cbb_refresh_verify.verify_runner import VerifyResult
|
|
from test_review326_queue_guidance import retain
|
|
from test_ui_filters import load_window
|
|
|
|
|
|
def test_verify_admission_hides_release_entry_before_action_finishes(qtbot, tmp_path, monkeypatch):
|
|
window = load_window(qtbot, tmp_path, monkeypatch)
|
|
window.show()
|
|
retain(monkeypatch, window.mentor_lmc_path)
|
|
started, finish = Event(), Event()
|
|
|
|
def action():
|
|
started.set()
|
|
assert finish.wait(5)
|
|
|
|
try:
|
|
# Hold admission until after the final waiting notification and proof.
|
|
# Neither _start's update nor a second waiting event can hide the bug.
|
|
with window.native_queue.condition:
|
|
window._start(action, lambda _: None)
|
|
window._progress(dict(stage='waiting_native_slot', library='test.lmc', retained=True))
|
|
assert window.queue_release_button.isVisible()
|
|
sessions._retained_libraries.clear()
|
|
qtbot.waitUntil(started.is_set)
|
|
qtbot.waitUntil(lambda: not window.queue_release_button.isVisible(), timeout=1000)
|
|
assert window.busy, 'The entry must disappear before the running task ends'
|
|
assert window._queue_wait_library is None
|
|
assert '排队' not in window.status_label.text()
|
|
finally:
|
|
finish.set()
|
|
sessions._retained_libraries.clear()
|
|
window.native_queue.wake()
|
|
qtbot.waitUntil(lambda: not window.busy)
|
|
|
|
|
|
@pytest.mark.parametrize('stale_library', [None, 'test.lmc'])
|
|
def test_delayed_queued_click_cannot_open_a_release_panel_after_proof(qtbot, tmp_path, monkeypatch, stale_library):
|
|
from cbb_refresh_verify import library_lock
|
|
window = load_window(qtbot, tmp_path, monkeypatch)
|
|
window.show()
|
|
monkeypatch.setattr(sessions, '_retained_libraries', {})
|
|
scans = []
|
|
monkeypatch.setattr(library_lock, 'inspect_residual_sessions', lambda library:
|
|
(scans.append(library) or dict(library=str(library), sessions=[])))
|
|
window.busy = True
|
|
window._queue_wait_library = stale_library
|
|
try:
|
|
for _ in range(5):
|
|
window.check_library_release(queued=True)
|
|
qtbot.wait(50)
|
|
assert getattr(window, 'release_dialog', None) is None
|
|
assert scans == [], 'A stale click must not trigger a new native session scan'
|
|
assert window.busy
|
|
assert not window.queue_release_button.isVisible()
|
|
finally:
|
|
dialog = getattr(window, 'release_dialog', None)
|
|
if dialog is not None:
|
|
qtbot.waitUntil(lambda: not dialog.busy)
|
|
dialog.close()
|
|
window.busy = False
|
|
|
|
|
|
def test_old_waiting_event_is_rechecked_against_current_release_state(qtbot, tmp_path, monkeypatch):
|
|
window = load_window(qtbot, tmp_path, monkeypatch)
|
|
window.show()
|
|
monkeypatch.setattr(sessions, '_retained_libraries', {})
|
|
window._progress(dict(stage='waiting_native_slot', library='test.lmc', retained=True))
|
|
assert not window.queue_release_button.isVisible()
|
|
assert window._queue_wait_library is None
|
|
|
|
|
|
def test_other_library_icdb_start_preserves_the_foreground_wait(qtbot, tmp_path, monkeypatch):
|
|
window = load_window(qtbot, tmp_path, monkeypatch)
|
|
window.show()
|
|
retain(monkeypatch, window.mentor_lmc_path)
|
|
window._start(lambda: None, lambda _: None)
|
|
try:
|
|
qtbot.waitUntil(lambda: window.queue_release_button.isVisible())
|
|
task = SimpleNamespace(requests=[SimpleNamespace(lmc_file='other.lmc')])
|
|
window._icdb_event(task, dict(stage='icdb_check_start', block='OtherCBB'))
|
|
assert window.queue_release_button.isVisible()
|
|
assert window._queue_wait_library == 'test.lmc'
|
|
finally:
|
|
sessions._retained_libraries.clear()
|
|
window.native_queue.wake()
|
|
qtbot.waitUntil(lambda: not window.busy)
|
|
|
|
|
|
@pytest.mark.parametrize('channel', ['verify', 'icdb'])
|
|
def test_another_library_wait_without_retention_cannot_erase_a_live_reason(qtbot, tmp_path, monkeypatch, channel):
|
|
window = load_window(qtbot, tmp_path, monkeypatch)
|
|
window.show()
|
|
retain(monkeypatch, window.mentor_lmc_path)
|
|
window._queue_wait_library = 'test.lmc'
|
|
window._update()
|
|
event = dict(stage='waiting_native_slot', library='other.lmc', retained=False)
|
|
if channel == 'verify':
|
|
window._progress(event)
|
|
else:
|
|
window._icdb_event(SimpleNamespace(), event)
|
|
assert window.queue_release_button.isVisible()
|
|
assert window._queue_wait_library == 'test.lmc'
|
|
|
|
|
|
@pytest.mark.parametrize('channel', ['verify', 'icdb'])
|
|
def test_delayed_other_library_retention_does_not_replace_a_live_reason(qtbot, tmp_path, monkeypatch, channel):
|
|
window = load_window(qtbot, tmp_path, monkeypatch)
|
|
window.show()
|
|
retain(monkeypatch, window.mentor_lmc_path)
|
|
window._queue_wait_library = 'test.lmc'
|
|
event = dict(stage='waiting_native_slot', library='already-released.lmc', retained=True)
|
|
if channel == 'verify':
|
|
window._progress(event)
|
|
else:
|
|
window._icdb_event(SimpleNamespace(), event)
|
|
assert window.queue_release_button.isVisible()
|
|
assert window._queue_wait_library == 'test.lmc'
|
|
|
|
|
|
def test_repeated_click_and_close_reuse_one_panel_without_unlocking_the_task(qtbot, tmp_path, monkeypatch):
|
|
from cbb_refresh_verify import library_lock
|
|
window = load_window(qtbot, tmp_path, monkeypatch)
|
|
window.show()
|
|
retain(monkeypatch, window.mentor_lmc_path)
|
|
monkeypatch.setattr(library_lock, 'inspect_residual_sessions',
|
|
lambda library: dict(library=str(library), sessions=[]))
|
|
window._start(lambda: None, lambda _: None)
|
|
try:
|
|
qtbot.waitUntil(lambda: window.queue_release_button.isVisible())
|
|
qtbot.mouseClick(window.queue_release_button, Qt.LeftButton)
|
|
original = window.release_dialog
|
|
for _ in range(5):
|
|
qtbot.mouseClick(window.queue_release_button, Qt.LeftButton)
|
|
assert window.release_dialog is original
|
|
qtbot.waitUntil(lambda: not original.busy)
|
|
original.reject()
|
|
assert window.busy, 'Closing a panel must not mark the queued task finished'
|
|
qtbot.mouseClick(window.queue_release_button, Qt.LeftButton)
|
|
reopened = window.release_dialog
|
|
qtbot.waitUntil(lambda: not reopened.busy)
|
|
reopened.close()
|
|
assert window.busy
|
|
finally:
|
|
sessions._retained_libraries.clear()
|
|
window.native_queue.wake()
|
|
qtbot.waitUntil(lambda: not window.busy)
|
|
|
|
|
|
def test_repeat_verify_then_stop_then_delayed_release_click_never_starts_work(qtbot, tmp_path, monkeypatch):
|
|
calls = []
|
|
window = load_window(qtbot, tmp_path, monkeypatch, verifier=lambda request: calls.append(request.block_name))
|
|
window.show()
|
|
retain(monkeypatch, window.mentor_lmc_path)
|
|
window.search_edit.setText('Beta')
|
|
window.verify_all()
|
|
try:
|
|
qtbot.waitUntil(lambda: window.queue_release_button.isVisible())
|
|
for _ in range(5):
|
|
qtbot.mouseClick(window.batch_button, Qt.LeftButton)
|
|
window.verify_all()
|
|
assert len(window.native_queue.pending) == 1
|
|
qtbot.mouseClick(window.stop_button, Qt.LeftButton)
|
|
qtbot.waitUntil(lambda: not window.busy)
|
|
for _ in range(5):
|
|
window.check_library_release(queued=True)
|
|
assert calls == []
|
|
assert not window.native_queue.pending
|
|
assert getattr(window, 'release_dialog', None) is None
|
|
finally:
|
|
window.stop.set()
|
|
sessions._retained_libraries.clear()
|
|
window.native_queue.wake()
|
|
qtbot.waitUntil(lambda: not window.busy)
|
|
|
|
|
|
@pytest.mark.parametrize('foreground_finishes_first', [True, False])
|
|
def test_foreground_completion_and_background_cancel_keep_only_live_waits(qtbot, tmp_path, monkeypatch,
|
|
foreground_finishes_first):
|
|
window = load_window(qtbot, tmp_path, monkeypatch,
|
|
verifier=lambda _: pytest.fail('A retained library must not start a native check'))
|
|
window.show()
|
|
retain(monkeypatch, window.mentor_lmc_path)
|
|
window._run(['Beta'], maintenance=True)
|
|
qtbot.waitUntil(lambda: window.queue_release_button.isVisible())
|
|
window.mentor_lmc_path = Path('other.lmc')
|
|
window.lmc_edit.setText('other.lmc')
|
|
started, finish = Event(), Event()
|
|
|
|
def foreground():
|
|
started.set()
|
|
assert finish.wait(5)
|
|
return VerifyResult('PASS')
|
|
|
|
window._start(foreground, lambda _: None)
|
|
try:
|
|
qtbot.waitUntil(started.is_set)
|
|
if foreground_finishes_first:
|
|
finish.set()
|
|
qtbot.waitUntil(lambda: not window.busy)
|
|
assert window.icdb_task.active
|
|
assert window.queue_release_button.isVisible()
|
|
assert window._queue_wait_library == 'test.lmc'
|
|
window.icdb_task.cancel()
|
|
qtbot.waitUntil(lambda: not window._icdb_active())
|
|
assert not window.queue_release_button.isVisible()
|
|
if not foreground_finishes_first:
|
|
assert window.busy
|
|
finally:
|
|
finish.set()
|
|
window.icdb_task.cancel()
|
|
sessions._retained_libraries.clear()
|
|
window.native_queue.wake()
|
|
qtbot.waitUntil(lambda: not window.busy and not window._icdb_active())
|
|
|
|
|
|
def test_delivered_click_during_window_close_does_not_open_a_panel(qtbot, tmp_path, monkeypatch):
|
|
from cbb_refresh_verify import library_lock
|
|
window = load_window(qtbot, tmp_path, monkeypatch)
|
|
retain(monkeypatch, window.mentor_lmc_path)
|
|
monkeypatch.setattr(library_lock, 'inspect_residual_sessions',
|
|
lambda library: dict(library=str(library), sessions=[]))
|
|
window._queue_wait_library = 'test.lmc'
|
|
window._closing = True
|
|
try:
|
|
window.check_library_release(queued=True)
|
|
assert getattr(window, 'release_dialog', None) is None
|
|
finally:
|
|
window._closing = False
|
|
dialog = getattr(window, 'release_dialog', None)
|
|
if dialog is not None:
|
|
qtbot.waitUntil(lambda: not dialog.busy)
|
|
dialog.close()
|