206 lines
7.6 KiB
Python
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
|