Some checks failed
Windows project source guards / test (push) Has been cancelled
Owner 2026-11-19: «send everything we possibly can automatically, even without the button» (a Hosonl failure on his screen never reached the panel: no core code, so classify() wrote nothing). A failed attempt is always written: one not about the server goes as local_*, which vpnbot keeps out of the verdict; a server of the user's own goes as foreign in full (address included). The button only sends at once. Also: the deleted-timer process test needs a sleep binary (absent on the Windows gate, which stopped 0.8.96). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
336 lines
12 KiB
Python
336 lines
12 KiB
Python
"""AC21/AC22: генераторные шаги переходов и TransitionRunner.
|
||
|
||
Проверяется контракт async_steps:
|
||
- полный проход генератора через TransitionRunner (run_in_worker + sleep_ms);
|
||
- отмена по устареванию generation посреди шага (finally выполняется,
|
||
оставшиеся шаги не выполняются);
|
||
- доставка исключения шага в генератор через throw() (существующие
|
||
try/except в операциях продолжают работать);
|
||
- wait_process_finished: по сигналу finished и по таймауту, без
|
||
waitForFinished/processEvents в продуктовом коде;
|
||
- синхронный драйвер run_steps_blocking (холодные совместимые пути).
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import shutil
|
||
import time
|
||
import unittest
|
||
|
||
from PyQt6.QtCore import QCoreApplication, QProcess
|
||
|
||
from xray_fluent.application.async_steps import (
|
||
TransitionRunner,
|
||
run_in_worker,
|
||
run_steps_blocking,
|
||
sleep_ms,
|
||
wait_process_finished,
|
||
wait_process_started,
|
||
)
|
||
|
||
_APP = QCoreApplication.instance() or QCoreApplication([])
|
||
|
||
|
||
def _drive_until(condition, timeout_ms: int = 5000) -> bool:
|
||
"""Прокачивает event loop теста, пока condition() не станет истинным."""
|
||
deadline = time.monotonic() + timeout_ms / 1000.0
|
||
while time.monotonic() < deadline:
|
||
if condition():
|
||
return True
|
||
_APP.processEvents()
|
||
time.sleep(0.002)
|
||
return condition()
|
||
|
||
|
||
def _boom() -> None:
|
||
raise ValueError("boom")
|
||
|
||
|
||
class TransitionRunnerTests(unittest.TestCase):
|
||
def test_full_pass_delivers_worker_result_and_sleeps(self) -> None:
|
||
events: list[object] = []
|
||
|
||
def gen():
|
||
value = yield run_in_worker(lambda: 21 * 2)
|
||
events.append(("worker", value))
|
||
yield sleep_ms(10)
|
||
events.append("slept")
|
||
return value + 1
|
||
|
||
runner = TransitionRunner(gen())
|
||
runner.start()
|
||
|
||
self.assertTrue(_drive_until(lambda: runner.done))
|
||
self.assertEqual(runner.result, 43)
|
||
self.assertIsNone(runner.error)
|
||
self.assertFalse(runner.cancelled)
|
||
self.assertEqual(events, [("worker", 42), "slept"])
|
||
|
||
def test_profile_names_each_step_by_its_innermost_origin(self) -> None:
|
||
def write_file() -> int:
|
||
return 1
|
||
|
||
def inner():
|
||
yield run_in_worker(write_file)
|
||
yield sleep_ms(20)
|
||
return True
|
||
|
||
def outer():
|
||
return (yield from inner())
|
||
|
||
runner = TransitionRunner(outer())
|
||
runner.start()
|
||
|
||
self.assertTrue(_drive_until(lambda: runner.done))
|
||
labels = [label for label, _ms in runner.profile.steps]
|
||
self.assertEqual(len(labels), 2)
|
||
self.assertTrue(labels[0].startswith("inner:"), labels)
|
||
self.assertTrue(labels[0].endswith("worker write_file"), labels)
|
||
self.assertTrue(labels[1].endswith("sleep 20"), labels)
|
||
self.assertGreaterEqual(runner.profile.steps[1][1], 15.0)
|
||
summary = runner.profile.summary()
|
||
self.assertIn("steps=2", summary)
|
||
self.assertIn("sleep 20=", summary)
|
||
|
||
def test_stale_generation_cancels_mid_step_and_runs_finally(self) -> None:
|
||
current = {"ok": True}
|
||
trace: list[str] = []
|
||
|
||
def gen():
|
||
try:
|
||
yield sleep_ms(10)
|
||
trace.append("after_step1")
|
||
yield sleep_ms(10)
|
||
trace.append("after_step2")
|
||
return True
|
||
finally:
|
||
trace.append("finally")
|
||
|
||
runner = TransitionRunner(gen(), is_current=lambda: current["ok"])
|
||
runner.start()
|
||
# Первый шаг уже запущен; новый "запрос перехода" делает текущий устаревшим.
|
||
current["ok"] = False
|
||
|
||
self.assertTrue(_drive_until(lambda: runner.done))
|
||
self.assertTrue(runner.cancelled)
|
||
self.assertIsNone(runner.result)
|
||
self.assertIsNone(runner.error)
|
||
# Генератор закрыт на первом yield: тело после шага не выполнялось,
|
||
# finally (cleanup/rollback операций) выполнен.
|
||
self.assertEqual(trace, ["finally"])
|
||
|
||
def test_step_error_is_delivered_into_generator_via_throw(self) -> None:
|
||
def gen():
|
||
try:
|
||
yield run_in_worker(_boom)
|
||
except ValueError as exc:
|
||
return f"caught:{exc}"
|
||
return "not raised"
|
||
|
||
runner = TransitionRunner(gen())
|
||
runner.start()
|
||
|
||
self.assertTrue(_drive_until(lambda: runner.done))
|
||
self.assertEqual(runner.result, "caught:boom")
|
||
self.assertIsNone(runner.error)
|
||
|
||
def test_uncaught_step_error_finishes_run_with_error(self) -> None:
|
||
def gen():
|
||
yield run_in_worker(_boom)
|
||
return "unreachable"
|
||
|
||
runner = TransitionRunner(gen())
|
||
runner.start()
|
||
|
||
self.assertTrue(_drive_until(lambda: runner.done))
|
||
self.assertIsInstance(runner.error, ValueError)
|
||
self.assertFalse(runner.cancelled)
|
||
self.assertIsNone(runner.result)
|
||
|
||
def test_run_in_worker_returns_result_to_generator_step(self) -> None:
|
||
def gen():
|
||
first = yield run_in_worker(lambda: "abc")
|
||
second = yield run_in_worker(lambda: first * 2)
|
||
return second
|
||
|
||
runner = TransitionRunner(gen())
|
||
runner.start()
|
||
|
||
self.assertTrue(_drive_until(lambda: runner.done))
|
||
self.assertEqual(runner.result, "abcabc")
|
||
|
||
def test_on_finished_callback_receives_runner(self) -> None:
|
||
seen: list[TransitionRunner] = []
|
||
|
||
def gen():
|
||
yield sleep_ms(1)
|
||
return 7
|
||
|
||
runner = TransitionRunner(gen(), on_finished=seen.append)
|
||
runner.start()
|
||
|
||
self.assertTrue(_drive_until(lambda: runner.done))
|
||
self.assertEqual(seen, [runner])
|
||
self.assertEqual(seen[0].result, 7)
|
||
|
||
|
||
@unittest.skipIf(shutil.which("sleep") is None, "требуется бинарь sleep")
|
||
class WaitProcessFinishedTests(unittest.TestCase):
|
||
def test_resolves_true_when_process_finishes(self) -> None:
|
||
process = QProcess()
|
||
process.start("sleep", ["0.15"])
|
||
|
||
def gen():
|
||
return (yield wait_process_finished(process, 5000))
|
||
|
||
runner = TransitionRunner(gen())
|
||
began = time.monotonic()
|
||
runner.start()
|
||
|
||
self.assertTrue(_drive_until(lambda: runner.done, timeout_ms=8000))
|
||
self.assertIs(runner.result, True)
|
||
# Резюм пришёл по сигналу finished, а не по 5-секундному таймауту.
|
||
self.assertLess(time.monotonic() - began, 4.0)
|
||
|
||
def test_resolves_false_on_timeout(self) -> None:
|
||
process = QProcess()
|
||
process.start("sleep", ["5"])
|
||
|
||
def gen():
|
||
return (yield wait_process_finished(process, 150))
|
||
|
||
runner = TransitionRunner(gen())
|
||
runner.start()
|
||
try:
|
||
self.assertTrue(_drive_until(lambda: runner.done, timeout_ms=8000))
|
||
self.assertIs(runner.result, False)
|
||
finally:
|
||
process.kill()
|
||
process.waitForFinished(2000)
|
||
|
||
def test_resolves_immediately_for_not_running_process(self) -> None:
|
||
process = QProcess()
|
||
|
||
def gen():
|
||
return (yield wait_process_finished(process, 5000))
|
||
|
||
runner = TransitionRunner(gen())
|
||
runner.start()
|
||
|
||
self.assertTrue(_drive_until(lambda: runner.done))
|
||
self.assertIs(runner.result, True)
|
||
|
||
def test_wait_process_started_resolves_true(self) -> None:
|
||
process = QProcess()
|
||
process.start("sleep", ["0.15"])
|
||
|
||
def gen():
|
||
started = yield wait_process_started(process, 5000)
|
||
finished = yield wait_process_finished(process, 5000)
|
||
return started, finished
|
||
|
||
runner = TransitionRunner(gen())
|
||
runner.start()
|
||
|
||
self.assertTrue(_drive_until(lambda: runner.done, timeout_ms=8000))
|
||
self.assertEqual(runner.result, (True, True))
|
||
|
||
|
||
class DeletedTimerAtExitTests(unittest.TestCase):
|
||
"""startup.log 2026-11-19: at every update exit since 0.8.89 the core process's ``finished`` fired after Qt had
|
||
deleted the race timer, and «wrapped C/C++ object of type QTimer has been deleted» showed «не удалось запустить»."""
|
||
|
||
@unittest.skipIf(shutil.which("sleep") is None, "требуется бинарь sleep")
|
||
def test_process_finishing_after_its_timer_was_deleted_still_resolves(self) -> None:
|
||
from PyQt6 import sip
|
||
|
||
process = QProcess()
|
||
process.start("sleep", ["0.15"])
|
||
|
||
def gen():
|
||
return (yield wait_process_finished(process, 5000))
|
||
|
||
runner = TransitionRunner(gen())
|
||
runner.start()
|
||
sip.delete(runner._current_step._timer) # what Qt does to it at interpreter exit
|
||
self.assertTrue(_drive_until(lambda: runner.done, timeout_ms=8000))
|
||
self.assertIs(runner.result, True)
|
||
|
||
def test_cancel_and_sleep_tolerate_a_deleted_timer(self) -> None:
|
||
from PyQt6 import sip
|
||
from xray_fluent.application.async_steps import SleepStep
|
||
|
||
step = SleepStep(10_000)
|
||
step.start(lambda *_args: None)
|
||
sip.delete(step._timer)
|
||
step.cancel() # must not raise
|
||
|
||
|
||
|
||
class RunStepsBlockingTests(unittest.TestCase):
|
||
def test_executes_steps_synchronously_and_returns_value(self) -> None:
|
||
def gen():
|
||
value = yield run_in_worker(lambda: 5)
|
||
yield sleep_ms(1)
|
||
return value * 2
|
||
|
||
self.assertEqual(run_steps_blocking(gen()), 10)
|
||
|
||
def test_delivers_step_error_via_throw(self) -> None:
|
||
def gen():
|
||
try:
|
||
yield run_in_worker(_boom)
|
||
except ValueError:
|
||
return "handled"
|
||
return "not raised"
|
||
|
||
self.assertEqual(run_steps_blocking(gen()), "handled")
|
||
|
||
|
||
class WorkerDeadlineTimerTests(unittest.TestCase):
|
||
"""Windows e2e 2026-11-16: python.exe died with an access violation in ``_on_deadline``. A finished worker step
|
||
left its 60 s deadline QTimer active inside a step <-> timer <-> closure cycle; the cyclic collector ran on a
|
||
worker thread, deleted the active timer off its thread, and the GUI loop fired the dangling timer."""
|
||
|
||
def test_a_finished_worker_step_leaves_no_active_timer(self) -> None:
|
||
step = run_in_worker(lambda: 1, deadline_ms=60_000)
|
||
|
||
def gen():
|
||
value = yield step
|
||
return value
|
||
|
||
runner = TransitionRunner(gen())
|
||
runner.start()
|
||
self.assertTrue(_drive_until(lambda: runner.done))
|
||
self.assertEqual(runner.result, 1)
|
||
self.assertIsNone(step._timer) # noqa: SLF001
|
||
self.assertIsNone(step._future) # noqa: SLF001
|
||
|
||
def test_collector_on_a_worker_thread_does_not_crash_the_gui_loop(self) -> None:
|
||
import gc
|
||
import threading
|
||
|
||
enabled = gc.isenabled()
|
||
gc.disable()
|
||
try:
|
||
for _ in range(30):
|
||
runners = []
|
||
for _ in range(10):
|
||
def gen():
|
||
return (yield run_in_worker(lambda: 1, deadline_ms=40))
|
||
|
||
runner = TransitionRunner(gen())
|
||
runner.start()
|
||
runners.append(runner)
|
||
self.assertTrue(_drive_until(lambda: all(r.done for r in runners)))
|
||
del runners
|
||
collector = threading.Thread(target=gc.collect)
|
||
collector.start()
|
||
collector.join()
|
||
_drive_until(lambda: False, timeout_ms=60) # past every deadline: a dangling timer would fire now
|
||
finally:
|
||
if enabled:
|
||
gc.enable()
|
||
|
||
if __name__ == "__main__":
|
||
unittest.main()
|