735 lines
21 KiB
Python
735 lines
21 KiB
Python
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import threading
|
|
|
|
import pytest
|
|
|
|
from src.bootstrap.application import (
|
|
ApplicationComposition,
|
|
run_application,
|
|
)
|
|
from src.market_data.acquisition.runtime.trade_stream_production_runtime import (
|
|
TradeStreamProductionRuntimeState,
|
|
)
|
|
|
|
|
|
class FakeBotSession:
|
|
def __init__(
|
|
self,
|
|
*,
|
|
close_error: BaseException | None = None,
|
|
) -> None:
|
|
self.close_calls = 0
|
|
self.close_error = close_error
|
|
|
|
async def close(self) -> None:
|
|
self.close_calls += 1
|
|
|
|
if self.close_error is not None:
|
|
raise self.close_error
|
|
|
|
|
|
class FakeBot:
|
|
def __init__(
|
|
self,
|
|
*,
|
|
close_error: BaseException | None = None,
|
|
) -> None:
|
|
self.session = FakeBotSession(
|
|
close_error=close_error,
|
|
)
|
|
|
|
|
|
class FakeDispatcher:
|
|
def __init__(
|
|
self,
|
|
*,
|
|
return_immediately: bool = False,
|
|
error: BaseException | None = None,
|
|
calls: list[str] | None = None,
|
|
) -> None:
|
|
self.started = asyncio.Event()
|
|
self.release = asyncio.Event()
|
|
self.cancelled = asyncio.Event()
|
|
self.return_immediately = return_immediately
|
|
self.error = error
|
|
self.calls = calls
|
|
self.close_bot_session_values: list[bool] = []
|
|
|
|
async def start_polling(
|
|
self,
|
|
bot: FakeBot,
|
|
*,
|
|
close_bot_session: bool,
|
|
) -> None:
|
|
del bot
|
|
if self.calls is not None:
|
|
self.calls.append("polling.start")
|
|
self.close_bot_session_values.append(close_bot_session)
|
|
self.started.set()
|
|
|
|
try:
|
|
if not self.return_immediately:
|
|
await self.release.wait()
|
|
except asyncio.CancelledError:
|
|
self.cancelled.set()
|
|
raise
|
|
|
|
if self.error is not None:
|
|
raise self.error
|
|
|
|
|
|
class FakeRuntime:
|
|
def __init__(
|
|
self,
|
|
*,
|
|
return_immediately: bool = False,
|
|
error: BaseException | None = None,
|
|
stop_error: BaseException | None = None,
|
|
calls: list[str] | None = None,
|
|
) -> None:
|
|
self.started = asyncio.Event()
|
|
self.release = asyncio.Event()
|
|
self.stopped = asyncio.Event()
|
|
self.return_immediately = return_immediately
|
|
self.error = error
|
|
self.stop_error = stop_error
|
|
self.calls = calls
|
|
self.stop_calls = 0
|
|
|
|
@property
|
|
def state(self) -> TradeStreamProductionRuntimeState:
|
|
return (
|
|
TradeStreamProductionRuntimeState.RUNNING
|
|
if self.started.is_set() and not self.stopped.is_set()
|
|
else TradeStreamProductionRuntimeState.STOPPED
|
|
)
|
|
|
|
@property
|
|
def running(self) -> bool:
|
|
return self.state is TradeStreamProductionRuntimeState.RUNNING
|
|
|
|
async def run(self) -> None:
|
|
if self.calls is not None:
|
|
self.calls.append("runtime.run")
|
|
self.started.set()
|
|
|
|
if not self.return_immediately:
|
|
await self.release.wait()
|
|
|
|
if self.error is not None:
|
|
raise self.error
|
|
|
|
async def stop(self) -> None:
|
|
self.stop_calls += 1
|
|
if self.calls is not None:
|
|
self.calls.append("runtime.stop")
|
|
self.release.set()
|
|
self.stopped.set()
|
|
|
|
if self.stop_error is not None:
|
|
raise self.stop_error
|
|
|
|
|
|
class BlockingStopRuntime(FakeRuntime):
|
|
def __init__(self) -> None:
|
|
super().__init__()
|
|
|
|
self.stop_entered = asyncio.Event()
|
|
self.stop_release = asyncio.Event()
|
|
|
|
async def stop(self) -> None:
|
|
self.stop_calls += 1
|
|
self.stop_entered.set()
|
|
await self.stop_release.wait()
|
|
self.release.set()
|
|
self.stopped.set()
|
|
|
|
|
|
class FakeStorageLifecycle:
|
|
def __init__(
|
|
self,
|
|
*,
|
|
calls: list[str] | None = None,
|
|
start_error: BaseException | None = None,
|
|
stop_error: BaseException | None = None,
|
|
start_release: threading.Event | None = None,
|
|
stop_release: threading.Event | None = None,
|
|
) -> None:
|
|
self.calls = calls
|
|
self.start_error = start_error
|
|
self.stop_error = stop_error
|
|
self.start_release = start_release
|
|
self.stop_release = stop_release
|
|
self.start_entered = threading.Event()
|
|
self.stop_entered = threading.Event()
|
|
self.start_calls = 0
|
|
self.stop_calls = 0
|
|
self.started = False
|
|
|
|
def start(self) -> None:
|
|
self.start_calls += 1
|
|
if self.calls is not None:
|
|
self.calls.append("storage.start")
|
|
self.start_entered.set()
|
|
|
|
if self.start_release is not None:
|
|
if not self.start_release.wait(timeout=2.0):
|
|
raise TimeoutError("storage startup was not released")
|
|
|
|
if self.start_error is not None:
|
|
raise self.start_error
|
|
|
|
self.started = True
|
|
|
|
def stop(self) -> None:
|
|
self.stop_calls += 1
|
|
if self.calls is not None:
|
|
self.calls.append("storage.stop")
|
|
self.started = False
|
|
self.stop_entered.set()
|
|
|
|
if self.stop_release is not None:
|
|
if not self.stop_release.wait(timeout=2.0):
|
|
raise TimeoutError("storage shutdown was not released")
|
|
|
|
if self.stop_error is not None:
|
|
raise self.stop_error
|
|
|
|
|
|
def make_application(
|
|
*,
|
|
dispatcher: FakeDispatcher,
|
|
runtime: FakeRuntime | None,
|
|
bot: FakeBot | None = None,
|
|
storage_lifecycle: FakeStorageLifecycle | None = None,
|
|
) -> ApplicationComposition:
|
|
return ApplicationComposition(
|
|
bot=bot or FakeBot(), # type: ignore[arg-type]
|
|
dispatcher=dispatcher, # type: ignore[arg-type]
|
|
trade_stream_runtime=runtime,
|
|
market_data_storage_lifecycle=storage_lifecycle,
|
|
)
|
|
|
|
|
|
def test_storage_lifecycle_wraps_root_runtime_tasks() -> None:
|
|
async def scenario() -> None:
|
|
calls: list[str] = []
|
|
storage = FakeStorageLifecycle(calls=calls)
|
|
dispatcher = FakeDispatcher(
|
|
return_immediately=True,
|
|
calls=calls,
|
|
)
|
|
runtime = FakeRuntime(calls=calls)
|
|
|
|
await run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
storage_lifecycle=storage,
|
|
)
|
|
)
|
|
|
|
assert storage.start_calls == 1
|
|
assert storage.stop_calls == 1
|
|
assert calls.index("storage.start") < calls.index(
|
|
"polling.start"
|
|
)
|
|
assert calls.index("storage.start") < calls.index(
|
|
"runtime.run"
|
|
)
|
|
assert calls.index("runtime.stop") < calls.index(
|
|
"storage.stop"
|
|
)
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_storage_startup_failure_prevents_root_task_start() -> None:
|
|
async def scenario() -> None:
|
|
expected = RuntimeError("storage startup failed")
|
|
storage = FakeStorageLifecycle(start_error=expected)
|
|
dispatcher = FakeDispatcher()
|
|
runtime = FakeRuntime()
|
|
bot = FakeBot()
|
|
|
|
with pytest.raises(RuntimeError) as error_info:
|
|
await run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
bot=bot,
|
|
storage_lifecycle=storage,
|
|
)
|
|
)
|
|
|
|
assert error_info.value is expected
|
|
assert dispatcher.started.is_set() is False
|
|
assert runtime.started.is_set() is False
|
|
assert runtime.stop_calls == 1
|
|
assert storage.stop_calls == 1
|
|
assert bot.session.close_calls == 1
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_cancellation_waits_for_storage_startup_before_cleanup() -> None:
|
|
async def scenario() -> None:
|
|
start_release = threading.Event()
|
|
storage = FakeStorageLifecycle(
|
|
start_release=start_release,
|
|
)
|
|
dispatcher = FakeDispatcher()
|
|
runtime = FakeRuntime()
|
|
bot = FakeBot()
|
|
task = asyncio.create_task(
|
|
run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
bot=bot,
|
|
storage_lifecycle=storage,
|
|
)
|
|
)
|
|
)
|
|
|
|
entered = await asyncio.to_thread(
|
|
storage.start_entered.wait,
|
|
1.0,
|
|
)
|
|
assert entered is True
|
|
task.cancel()
|
|
|
|
try:
|
|
await asyncio.sleep(0)
|
|
await asyncio.sleep(0)
|
|
assert task.done() is False
|
|
finally:
|
|
start_release.set()
|
|
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await task
|
|
|
|
assert dispatcher.started.is_set() is False
|
|
assert runtime.started.is_set() is False
|
|
assert storage.stop_calls == 1
|
|
assert bot.session.close_calls == 1
|
|
await asyncio.sleep(0)
|
|
assert not {
|
|
child.get_name()
|
|
for child in asyncio.all_tasks()
|
|
if child is not asyncio.current_task()
|
|
and not child.done()
|
|
and child.get_name()
|
|
in {
|
|
"application-shutdown",
|
|
"market-data-storage-shutdown",
|
|
"market-data-storage-startup",
|
|
"telegram-polling",
|
|
"trade-stream-runtime",
|
|
}
|
|
}
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_storage_shutdown_error_is_reported_and_bot_still_closes() -> None:
|
|
async def scenario() -> None:
|
|
expected = RuntimeError("storage close failed")
|
|
storage = FakeStorageLifecycle(stop_error=expected)
|
|
dispatcher = FakeDispatcher(return_immediately=True)
|
|
bot = FakeBot()
|
|
|
|
with pytest.raises(RuntimeError) as error_info:
|
|
await run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=None,
|
|
bot=bot,
|
|
storage_lifecycle=storage,
|
|
)
|
|
)
|
|
|
|
assert error_info.value is expected
|
|
assert storage.stop_calls == 1
|
|
assert bot.session.close_calls == 1
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_storage_shutdown_error_does_not_replace_runtime_error() -> None:
|
|
async def scenario() -> None:
|
|
runtime_error = RuntimeError("runtime failed")
|
|
storage_error = RuntimeError("storage close failed")
|
|
storage = FakeStorageLifecycle(stop_error=storage_error)
|
|
dispatcher = FakeDispatcher()
|
|
runtime = FakeRuntime(
|
|
return_immediately=True,
|
|
error=runtime_error,
|
|
)
|
|
|
|
with pytest.raises(RuntimeError) as error_info:
|
|
await run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
storage_lifecycle=storage,
|
|
)
|
|
)
|
|
|
|
assert error_info.value is runtime_error
|
|
assert any(
|
|
"cleanup also failed" in note
|
|
for note in getattr(runtime_error, "__notes__", ())
|
|
)
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_repeated_cancellation_does_not_interrupt_storage_shutdown(
|
|
) -> None:
|
|
async def scenario() -> None:
|
|
stop_release = threading.Event()
|
|
storage = FakeStorageLifecycle(
|
|
stop_release=stop_release,
|
|
)
|
|
dispatcher = FakeDispatcher(return_immediately=True)
|
|
bot = FakeBot()
|
|
task = asyncio.create_task(
|
|
run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=None,
|
|
bot=bot,
|
|
storage_lifecycle=storage,
|
|
)
|
|
)
|
|
)
|
|
|
|
entered = await asyncio.to_thread(
|
|
storage.stop_entered.wait,
|
|
1.0,
|
|
)
|
|
assert entered is True
|
|
task.cancel()
|
|
task.cancel()
|
|
|
|
try:
|
|
await asyncio.sleep(0)
|
|
assert task.done() is False
|
|
finally:
|
|
stop_release.set()
|
|
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await task
|
|
|
|
assert storage.stop_calls == 1
|
|
assert bot.session.close_calls == 1
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_disabled_runtime_runs_only_polling_and_closes_bot() -> None:
|
|
async def scenario() -> None:
|
|
dispatcher = FakeDispatcher(return_immediately=True)
|
|
bot = FakeBot()
|
|
|
|
await run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=None,
|
|
bot=bot,
|
|
)
|
|
)
|
|
|
|
assert dispatcher.close_bot_session_values == [False]
|
|
assert bot.session.close_calls == 1
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_polling_completion_stops_and_awaits_runtime() -> None:
|
|
async def scenario() -> None:
|
|
dispatcher = FakeDispatcher(return_immediately=True)
|
|
runtime = FakeRuntime()
|
|
bot = FakeBot()
|
|
|
|
await run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
bot=bot,
|
|
)
|
|
)
|
|
|
|
assert runtime.started.is_set()
|
|
assert runtime.stop_calls == 1
|
|
assert runtime.stopped.is_set()
|
|
assert bot.session.close_calls == 1
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_runtime_error_is_fatal_and_stops_polling() -> None:
|
|
async def scenario() -> None:
|
|
expected = RuntimeError("trade stream failed")
|
|
dispatcher = FakeDispatcher()
|
|
runtime = FakeRuntime(
|
|
return_immediately=True,
|
|
error=expected,
|
|
)
|
|
bot = FakeBot()
|
|
|
|
with pytest.raises(RuntimeError) as exc_info:
|
|
await run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
bot=bot,
|
|
)
|
|
)
|
|
|
|
assert exc_info.value is expected
|
|
assert dispatcher.cancelled.is_set()
|
|
assert runtime.stop_calls == 1
|
|
assert bot.session.close_calls == 1
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_normal_runtime_completion_is_fatal() -> None:
|
|
async def scenario() -> None:
|
|
dispatcher = FakeDispatcher()
|
|
runtime = FakeRuntime(return_immediately=True)
|
|
|
|
with pytest.raises(
|
|
RuntimeError,
|
|
match="terminated unexpectedly",
|
|
):
|
|
await run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
)
|
|
)
|
|
|
|
assert dispatcher.cancelled.is_set()
|
|
assert runtime.stop_calls == 1
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_application_cancellation_performs_full_cleanup() -> None:
|
|
async def scenario() -> None:
|
|
dispatcher = FakeDispatcher()
|
|
runtime = FakeRuntime()
|
|
bot = FakeBot()
|
|
task = asyncio.create_task(
|
|
run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
bot=bot,
|
|
)
|
|
)
|
|
)
|
|
|
|
await dispatcher.started.wait()
|
|
await runtime.started.wait()
|
|
task.cancel()
|
|
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await task
|
|
|
|
assert dispatcher.cancelled.is_set()
|
|
assert runtime.stop_calls == 1
|
|
assert runtime.stopped.is_set()
|
|
assert bot.session.close_calls == 1
|
|
await asyncio.sleep(0)
|
|
assert not {
|
|
child.get_name()
|
|
for child in asyncio.all_tasks()
|
|
if child is not asyncio.current_task()
|
|
and not child.done()
|
|
and child.get_name()
|
|
in {
|
|
"telegram-polling",
|
|
"trade-stream-runtime",
|
|
"application-shutdown",
|
|
"market-data-storage-startup",
|
|
"market-data-storage-shutdown",
|
|
}
|
|
}
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_polling_error_stops_runtime_and_preserves_error() -> None:
|
|
async def scenario() -> None:
|
|
expected = RuntimeError("polling failed")
|
|
dispatcher = FakeDispatcher(
|
|
return_immediately=True,
|
|
error=expected,
|
|
)
|
|
runtime = FakeRuntime()
|
|
bot = FakeBot()
|
|
|
|
with pytest.raises(RuntimeError) as exc_info:
|
|
await run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
bot=bot,
|
|
)
|
|
)
|
|
|
|
assert exc_info.value is expected
|
|
assert runtime.stop_calls == 1
|
|
assert runtime.stopped.is_set()
|
|
assert bot.session.close_calls == 1
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_simultaneous_root_failures_are_awaited_deterministically() -> None:
|
|
async def scenario() -> None:
|
|
polling_error = RuntimeError("polling failed")
|
|
runtime_error = ValueError("trade stream failed")
|
|
dispatcher = FakeDispatcher(
|
|
error=polling_error,
|
|
)
|
|
runtime = FakeRuntime(
|
|
error=runtime_error,
|
|
)
|
|
bot = FakeBot()
|
|
task = asyncio.create_task(
|
|
run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
bot=bot,
|
|
)
|
|
)
|
|
)
|
|
|
|
await dispatcher.started.wait()
|
|
await runtime.started.wait()
|
|
dispatcher.release.set()
|
|
runtime.release.set()
|
|
|
|
with pytest.raises(ValueError) as exc_info:
|
|
await task
|
|
|
|
assert exc_info.value is runtime_error
|
|
assert runtime.stop_calls == 1
|
|
assert bot.session.close_calls == 1
|
|
assert any(
|
|
"cleanup also failed" in note
|
|
for note in getattr(runtime_error, "__notes__", ())
|
|
)
|
|
await asyncio.sleep(0)
|
|
assert not {
|
|
child.get_name()
|
|
for child in asyncio.all_tasks()
|
|
if child is not asyncio.current_task()
|
|
and not child.done()
|
|
and child.get_name()
|
|
in {
|
|
"telegram-polling",
|
|
"trade-stream-runtime",
|
|
"application-shutdown",
|
|
"market-data-storage-startup",
|
|
"market-data-storage-shutdown",
|
|
}
|
|
}
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_repeated_cancellation_does_not_interrupt_cleanup() -> None:
|
|
async def scenario() -> None:
|
|
dispatcher = FakeDispatcher()
|
|
runtime = BlockingStopRuntime()
|
|
storage = FakeStorageLifecycle()
|
|
bot = FakeBot()
|
|
task = asyncio.create_task(
|
|
run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
bot=bot,
|
|
storage_lifecycle=storage,
|
|
)
|
|
)
|
|
)
|
|
|
|
await dispatcher.started.wait()
|
|
await runtime.started.wait()
|
|
task.cancel()
|
|
await runtime.stop_entered.wait()
|
|
|
|
task.cancel()
|
|
await asyncio.sleep(0)
|
|
assert storage.stop_calls == 0
|
|
runtime.stop_release.set()
|
|
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await task
|
|
|
|
assert task.cancelled() is True
|
|
assert dispatcher.cancelled.is_set()
|
|
assert runtime.stop_calls == 1
|
|
assert runtime.stopped.is_set()
|
|
assert storage.stop_calls == 1
|
|
assert bot.session.close_calls == 1
|
|
await asyncio.sleep(0)
|
|
assert not {
|
|
child.get_name()
|
|
for child in asyncio.all_tasks()
|
|
if child is not asyncio.current_task()
|
|
and not child.done()
|
|
and child.get_name()
|
|
in {
|
|
"telegram-polling",
|
|
"trade-stream-runtime",
|
|
"application-shutdown",
|
|
"market-data-storage-startup",
|
|
"market-data-storage-shutdown",
|
|
}
|
|
}
|
|
|
|
asyncio.run(scenario())
|
|
|
|
|
|
def test_cleanup_error_does_not_replace_runtime_error() -> None:
|
|
async def scenario() -> None:
|
|
expected = RuntimeError("trade stream failed")
|
|
dispatcher = FakeDispatcher()
|
|
runtime = FakeRuntime(
|
|
return_immediately=True,
|
|
error=expected,
|
|
stop_error=RuntimeError("stop failed"),
|
|
)
|
|
bot = FakeBot(
|
|
close_error=RuntimeError("close failed"),
|
|
)
|
|
|
|
with pytest.raises(RuntimeError) as exc_info:
|
|
await run_application(
|
|
make_application(
|
|
dispatcher=dispatcher,
|
|
runtime=runtime,
|
|
bot=bot,
|
|
)
|
|
)
|
|
|
|
assert exc_info.value is expected
|
|
assert bot.session.close_calls == 1
|
|
assert any(
|
|
"cleanup also failed" in note
|
|
for note in getattr(expected, "__notes__", ())
|
|
)
|
|
|
|
asyncio.run(scenario())
|