153 lines
5.1 KiB
Python
153 lines
5.1 KiB
Python
"""Bounded background reads, cooperative cancellation and GUI callback identity."""
|
|
import os
|
|
os.environ.setdefault('QT_QPA_PLATFORM', 'offscreen')
|
|
from threading import Event, get_ident
|
|
from time import monotonic
|
|
|
|
import pytest
|
|
from PySide6.QtCore import QCoreApplication, QEvent, QThreadPool
|
|
|
|
from dx_productivity.trial_task_center.read_control import QueryCancelled, QueryControl
|
|
from dx_productivity.trial_task_center.ui.queries import LatestQuery
|
|
|
|
|
|
def test_control_cancellation_and_deadline():
|
|
control = QueryControl()
|
|
control.checkpoint()
|
|
control.cancel()
|
|
assert control.cancelled
|
|
with pytest.raises(QueryCancelled):
|
|
control.checkpoint()
|
|
with pytest.raises(QueryCancelled):
|
|
QueryControl(deadline=monotonic() - 1).checkpoint()
|
|
|
|
|
|
def test_new_selection_finishes_while_old_system_call_is_blocked(qtbot):
|
|
query = LatestQuery()
|
|
entered, release = Event(), Event()
|
|
results, failures, threads = [], [], []
|
|
def old(control):
|
|
entered.set()
|
|
assert release.wait(5)
|
|
control.checkpoint()
|
|
return 'old'
|
|
def received(value):
|
|
results.append(value)
|
|
threads.append(get_ident())
|
|
try:
|
|
query.request(old, received, failures.append, cancellable=True)
|
|
qtbot.waitUntil(entered.is_set)
|
|
query.request(lambda control: 'new', received, failures.append, cancellable=True)
|
|
qtbot.waitUntil(lambda: results == ['new'])
|
|
assert threads == [get_ident()]
|
|
assert not release.is_set()
|
|
finally:
|
|
release.set()
|
|
qtbot.waitUntil(lambda: not query.busy)
|
|
query.close()
|
|
assert results == ['new'] and failures == []
|
|
|
|
|
|
def test_switches_coalesce_pending_reads_and_never_exceed_two_slots(qtbot):
|
|
query = LatestQuery()
|
|
releases = [Event(), Event()]
|
|
entered = [Event(), Event()]
|
|
calls, results, errors = [], [], []
|
|
def blocked(index):
|
|
def action(control):
|
|
calls.append(index)
|
|
entered[index].set()
|
|
assert releases[index].wait(5)
|
|
# Simulate a stale failure from an uninterruptible I/O call.
|
|
raise OSError('stale')
|
|
return action
|
|
try:
|
|
query.request(blocked(0), results.append, errors.append, cancellable=True)
|
|
qtbot.waitUntil(entered[0].is_set)
|
|
query.request(blocked(1), results.append, errors.append, cancellable=True)
|
|
qtbot.waitUntil(entered[1].is_set)
|
|
for value in range(100):
|
|
query.request(lambda control, value=value: calls.append(value) or value,
|
|
results.append, errors.append, cancellable=True)
|
|
assert len(query._active) == 2
|
|
assert calls == [0, 1]
|
|
releases[1].set()
|
|
qtbot.waitUntil(lambda: results == [99])
|
|
assert calls == [0, 1, 99]
|
|
finally:
|
|
for release in releases:
|
|
release.set()
|
|
qtbot.waitUntil(lambda: not query.busy)
|
|
query.close()
|
|
assert errors == []
|
|
|
|
|
|
def test_close_cancels_active_and_drops_pending_callbacks(qtbot):
|
|
query = LatestQuery()
|
|
entered, release = Event(), Event()
|
|
controls, callbacks = [], []
|
|
def blocked(control):
|
|
controls.append(control)
|
|
entered.set()
|
|
assert release.wait(5)
|
|
return 'old'
|
|
try:
|
|
query.request(blocked, callbacks.append, callbacks.append, cancellable=True)
|
|
qtbot.waitUntil(entered.is_set)
|
|
query.close()
|
|
assert controls[0].cancelled
|
|
query.request(lambda: 'never', callbacks.append, callbacks.append)
|
|
finally:
|
|
release.set()
|
|
qtbot.waitUntil(lambda: not query.busy)
|
|
assert callbacks == []
|
|
|
|
|
|
def test_checkpoint_stops_cancelled_work_before_next_segment(qtbot):
|
|
query = LatestQuery()
|
|
entered, release, cancelled = Event(), Event(), Event()
|
|
results = []
|
|
def segmented(control):
|
|
entered.set()
|
|
assert release.wait(5)
|
|
try:
|
|
control.checkpoint()
|
|
except QueryCancelled:
|
|
cancelled.set()
|
|
raise
|
|
pytest.fail('cancelled read reached its next segment')
|
|
try:
|
|
query.request(segmented, results.append, results.append, cancellable=True)
|
|
qtbot.waitUntil(entered.is_set)
|
|
query.request(lambda: 'new', results.append, results.append)
|
|
release.set()
|
|
qtbot.waitUntil(cancelled.is_set)
|
|
qtbot.waitUntil(lambda: not query.busy)
|
|
finally:
|
|
release.set()
|
|
query.close()
|
|
assert results == ['new']
|
|
|
|
|
|
def test_deleted_receiver_does_not_receive_worker_completion(qtbot):
|
|
from shiboken6 import isValid
|
|
query = LatestQuery()
|
|
entered, release = Event(), Event()
|
|
callbacks = []
|
|
def blocked():
|
|
entered.set()
|
|
assert release.wait(5)
|
|
return 'discarded'
|
|
try:
|
|
query.request(blocked, callbacks.append, callbacks.append)
|
|
qtbot.waitUntil(entered.is_set)
|
|
query.close()
|
|
query.deleteLater()
|
|
QCoreApplication.sendPostedEvents(query, QEvent.Type.DeferredDelete)
|
|
assert not isValid(query)
|
|
finally:
|
|
release.set()
|
|
assert QThreadPool.globalInstance().waitForDone(5000)
|
|
QCoreApplication.processEvents()
|
|
assert callbacks == []
|