Files
dxdesigner-part-replacement/tests/v1_1/test_ui_responsiveness.py
T

206 lines
7.6 KiB
Python

"""Exercise the event loop and task ownership while external I/O is delayed."""
import os
os.environ.setdefault('QT_QPA_PLATFORM', 'offscreen')
from threading import Event, get_ident
from time import perf_counter
import pytest
from PySide6.QtCore import QTimer
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.ui.main_window import TrialTaskCenterWindow
@pytest.fixture
def browser(qtbot, tmp_path):
root = tmp_path / 'projects'
root.mkdir()
for name in ('a', 'b'):
path = root / name / 'board.prj'
path.parent.mkdir()
path.write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
store = TaskStore(tmp_path / 'tasks.db')
service = TaskCenterService(store, configure_logging(tmp_path / 'data'))
tasks = service.create_project_tasks(root)
service.add_rule(tasks[0].task_id, 'OLD', 'NEW')
window = TrialTaskCenterWindow(service)
yield window, service, tasks
qtbot.waitUntil(lambda: not window._workers, timeout=5000)
qtbot.waitUntil(lambda: not window._context_query.busy and not window._task_query.busy
and not window._log_presenter.query.busy and not window._feedback_query.busy, timeout=5000)
window.close()
store.close()
def loaded(qtbot, window, task):
qtbot.waitUntil(lambda: window._context is not None and not window._loading
and window._context.task.task_id == task.task_id, timeout=3000)
def test_slow_task_read_is_background_and_stale_result_cannot_change_selection(browser, qtbot, monkeypatch):
window, service, (a, b) = browser
real = service.task_context
entered, release = Event(), Event()
threads = []
def delayed(task_id, **kwargs):
threads.append(get_ident())
if task_id == a.task_id:
entered.set()
assert release.wait(5)
return real(task_id, **kwargs)
monkeypatch.setattr(service, 'task_context', delayed)
try:
start = perf_counter()
window.open_task(a.task_id)
assert perf_counter() - start < 0.15
qtbot.waitUntil(entered.is_set)
tick = []
QTimer.singleShot(0, lambda: tick.append(True))
window.open_task(b.task_id)
qtbot.waitUntil(lambda: bool(tick))
assert window._task_id == b.task_id
loaded(qtbot, window, b)
assert not release.is_set()
finally:
release.set()
loaded(qtbot, window, b)
assert all(thread != get_ident() for thread in threads)
assert window.project_summary.path.text().endswith('b\\board.prj')
def test_execution_allows_read_only_browsing_and_completion_survives_task_switch(browser, qtbot):
window, _, (a, b) = browser
window.open_task(a.task_id)
loaded(qtbot, window, a)
release = Event()
finished = []
window._begin_run(a.task_id)
stop = window._batch_stop
def done(result):
finished.append(result)
window._finish_run()
try:
window._run_async(lambda: (release.wait(2), 'completed')[1], done, expected_task_id=a.task_id)
assert window.task_list.list.isEnabled()
window.open_task(b.task_id)
loaded(qtbot, window, b)
assert not window.add_mapping_button.isEnabled()
assert not window.run_panel.quick_run_button.isEnabled()
assert window.plan_panel.find_button.isEnabled()
window._pause_queue()
assert stop.is_set()
finally:
release.set()
qtbot.waitUntil(lambda: not window._workers)
assert finished == ['completed']
assert window._task_id == b.task_id and window._batch_stop is None
def test_slow_log_read_does_not_block_or_leak_previous_task(browser, qtbot, monkeypatch, tmp_path):
window, service, (a, b) = browser
for task, text in ((a, 'OLD_TASK_ONLY'), (b, 'CURRENT_TASK')):
path = tmp_path / 'data' / 'tasks' / task.task_id / 'events.jsonl'
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text + '\n')
real = service.read_task_log
entered, release = Event(), Event()
def delayed(task_id, **kwargs):
if task_id == a.task_id:
entered.set()
release.wait(0.4)
return real(task_id, **kwargs)
monkeypatch.setattr(service, 'read_task_log', delayed)
window.open_task(a.task_id)
loaded(qtbot, window, a)
try:
start = perf_counter()
window._show_task_log()
assert perf_counter() - start < 0.15
qtbot.waitUntil(entered.is_set)
window.open_task(b.task_id)
loaded(qtbot, window, b)
finally:
release.set()
qtbot.waitUntil(lambda: 'CURRENT_TASK' in window._log_presenter.log_text)
assert 'OLD_TASK_ONLY' not in window._log_presenter.log_text
def test_refresh_ticks_do_not_starve_initial_log_read(browser, qtbot, monkeypatch, tmp_path):
window, service, (a, _) = browser
path = tmp_path / 'data' / 'tasks' / a.task_id / 'events.jsonl'
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text('FIRST_PAGE\n')
real = service.read_task_log
entered, release = Event(), Event()
reads = []
def delayed(task_id, **kwargs):
reads.append(task_id)
entered.set()
release.wait(0.4)
return real(task_id, **kwargs)
monkeypatch.setattr(service, 'read_task_log', delayed)
window.open_task(a.task_id)
loaded(qtbot, window, a)
try:
window._show_task_log()
qtbot.waitUntil(entered.is_set)
for _ in range(5):
window._refresh_live_task_log()
finally:
release.set()
qtbot.waitUntil(lambda: not window._log_presenter.query.busy)
assert 'FIRST_PAGE' in window._log_presenter.log_text
assert reads == [a.task_id]
def test_completion_names_execution_owner_when_browsing_another_task(browser, qtbot):
from types import SimpleNamespace
window, _, (a, b) = browser
window.open_task(a.task_id)
loaded(qtbot, window, a)
window._begin_run(a.task_id)
window.open_task(b.task_id)
loaded(qtbot, window, b)
result = SimpleNamespace(paused=False, progress=SimpleNamespace(saved_items=3, failed_items=0, no_match_items=0))
window._show_batch_result(result)
assert a.name in window.run_panel.operator_band.text()
assert not window.run_panel.toggle_log_button.isChecked()
def test_completion_refresh_supersedes_a_pending_old_log_snapshot(browser, qtbot, monkeypatch, tmp_path):
from types import SimpleNamespace
window, service, (a, _) = browser
path = tmp_path / 'data' / 'tasks' / a.task_id / 'events.jsonl'
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text('BEFORE\n')
real = service.read_task_log
entered, release = Event(), Event()
first = True
def delayed(task_id, **kwargs):
nonlocal first
page = real(task_id, **kwargs)
if first:
first = False
entered.set()
release.wait(1)
return page
monkeypatch.setattr(service, 'read_task_log', delayed)
window.open_task(a.task_id)
loaded(qtbot, window, a)
window._begin_run(a.task_id)
try:
window._show_task_log()
qtbot.waitUntil(entered.is_set)
with path.open('a') as stream:
stream.write('AFTER_COMPLETION\n')
window._show_batch_result(SimpleNamespace(paused=False,
progress=SimpleNamespace(saved_items=1, failed_items=0, no_match_items=0)))
finally:
release.set()
window._finish_run()
qtbot.waitUntil(lambda: not window._log_presenter.query.busy)
assert 'AFTER_COMPLETION' in window._log_presenter.log_text