459 lines
15 KiB
Python
459 lines
15 KiB
Python
# piker: trading gear for hackers
|
|
# Copyright (C) Tyler Goodlet (in stewardship for pikers)
|
|
|
|
# This program is free software: you can redistribute it and/or
|
|
# modify it under the terms of the GNU Affero General Public
|
|
# License as published by the Free Software Foundation, either
|
|
# version 3 of the License, or (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Affero General Public
|
|
# License along with this program. If not, see
|
|
# <https://www.gnu.org/licenses/>.
|
|
|
|
'''
|
|
Real local-actor qualification of clearing's directional contracts.
|
|
|
|
No market-data service, credentials, or persistent account is opened.
|
|
|
|
'''
|
|
|
|
from decimal import Decimal
|
|
|
|
import pytest
|
|
import tractor
|
|
from tractor.trionics import collapse_eg
|
|
import trio
|
|
|
|
from piker.clearing._codec import ProtocolError, validate
|
|
from piker.clearing._protocol import (
|
|
BrokerdPhase,
|
|
Stream,
|
|
open_stream,
|
|
)
|
|
from piker.clearing._schema import (
|
|
BrokerdEvent,
|
|
BrokerdFill,
|
|
BrokerdOpenOrder,
|
|
BrokerdOpenOrdersComplete,
|
|
BrokerdOrder,
|
|
BrokerdOrderAck,
|
|
BrokerdPayload,
|
|
BrokerdRequest,
|
|
BrokerdStartup,
|
|
Order,
|
|
validate_startup,
|
|
BrokerdStatus,
|
|
Cancel,
|
|
EmsEvent,
|
|
EmsPayload,
|
|
EmsRequest,
|
|
EmsStartup,
|
|
Status,
|
|
validate_ems_startup,
|
|
)
|
|
from piker.clearing._state import Effects, OrderState
|
|
|
|
|
|
@tractor.context(pld_spec=BrokerdPayload)
|
|
async def fake_broker(
|
|
ctx: tractor.Context,
|
|
fault: str,
|
|
empty: bool,
|
|
) -> None:
|
|
'''
|
|
Exchange typed broker traffic or inject a selected wire fault.
|
|
|
|
``fault`` selects a provider exception, wrong direction, wrong
|
|
phase, or malformed execution. ``empty`` omits the existing order
|
|
while retaining the explicit completion barrier.
|
|
|
|
'''
|
|
startup: BrokerdStartup = BrokerdStartup(
|
|
broker='fixture',
|
|
mode='paper',
|
|
accounts=('paper',),
|
|
)
|
|
await ctx.started(validate_startup(startup))
|
|
stream: Stream[BrokerdRequest, BrokerdEvent]
|
|
async with open_stream(
|
|
ctx,
|
|
BrokerdRequest,
|
|
BrokerdEvent,
|
|
) as stream:
|
|
if not empty:
|
|
await stream.send(
|
|
BrokerdOpenOrder(
|
|
broker='fixture',
|
|
reqid='existing-1',
|
|
time_ns=1,
|
|
order=Order(
|
|
oid='fixture:paper:existing-1',
|
|
account='paper',
|
|
symbol='btc.spot.fixture',
|
|
price=Decimal('12.25'),
|
|
size=1.0,
|
|
action='buy',
|
|
exec_mode='live',
|
|
),
|
|
)
|
|
)
|
|
await stream.send(
|
|
BrokerdOpenOrdersComplete(
|
|
broker='fixture',
|
|
)
|
|
)
|
|
request: BrokerdOrder = await stream.receive()
|
|
if fault == 'peer_error':
|
|
raise RuntimeError('fixture provider failed')
|
|
if fault == 'wrong_direction':
|
|
# Deliberately bypass the local send guard to prove that
|
|
# the other actor's scoped wire decoder rejects this.
|
|
await stream.raw.send(request)
|
|
elif fault == 'wrong_phase':
|
|
await stream.raw.send(startup)
|
|
elif fault == 'malformed':
|
|
await stream.raw.send(
|
|
{
|
|
'type': 'broker_fill',
|
|
'time_ns': 1,
|
|
'broker_time': 1.0,
|
|
'reqid': 1,
|
|
'account': 'paper',
|
|
'broker': 'fixture',
|
|
'action': 'buy',
|
|
'size': 1.0,
|
|
'price': 12.25,
|
|
}
|
|
)
|
|
else:
|
|
await stream.send(
|
|
BrokerdOrderAck(
|
|
oid=request.oid,
|
|
reqid=1,
|
|
account='paper',
|
|
)
|
|
)
|
|
await stream.send(
|
|
BrokerdFill(
|
|
time_ns=1,
|
|
broker_time=1.0,
|
|
reqid=1,
|
|
account='paper',
|
|
broker='fixture',
|
|
fill_id='fill-1',
|
|
action='buy',
|
|
size=1.0,
|
|
price=12.25,
|
|
)
|
|
)
|
|
# A malicious peer must not hold teardown open after its
|
|
# receiver rejects a payload. The parent cancels this sleep.
|
|
await trio.sleep_forever()
|
|
|
|
|
|
async def exercise(fault: str = '', empty: bool = False) -> None:
|
|
'''
|
|
Own the fake broker actor tree through exchange and teardown.
|
|
|
|
``fault`` and ``empty`` select ``fake_broker`` behavior. A Trio
|
|
deadline encloses all actor scopes; the test runner adds an
|
|
independent process timeout.
|
|
|
|
'''
|
|
# The deadline encloses the entire actor tree, including
|
|
# teardown.
|
|
# An outer process timeout remains necessary for shielded runtime
|
|
# failures; the run-tests harness supplies that second bound.
|
|
with trio.fail_after(15):
|
|
nursery: tractor.ActorNursery
|
|
async with (
|
|
collapse_eg(),
|
|
tractor.open_root_actor(
|
|
name='clearing-schema-test',
|
|
tpt_bind_addrs=[('127.0.0.1', 0)],
|
|
),
|
|
tractor.open_nursery() as nursery,
|
|
):
|
|
portal: tractor.Portal = await nursery.start_actor(
|
|
'fake-broker',
|
|
enable_modules=[__name__],
|
|
)
|
|
ctx: tractor.Context
|
|
startup: BrokerdStartup
|
|
async with portal.open_context(
|
|
fake_broker,
|
|
fault=fault,
|
|
empty=empty,
|
|
) as (ctx, startup):
|
|
phase: BrokerdPhase = BrokerdPhase(startup)
|
|
stream: Stream[BrokerdEvent, BrokerdRequest]
|
|
async with open_stream(
|
|
ctx,
|
|
BrokerdEvent,
|
|
BrokerdRequest,
|
|
) as stream:
|
|
if not empty:
|
|
existing: BrokerdEvent = phase.receive(
|
|
await stream.receive(),
|
|
)
|
|
assert isinstance(existing, BrokerdOpenOrder)
|
|
assert isinstance(existing.order, Order)
|
|
assert existing.order.price == Decimal(
|
|
'12.25',
|
|
)
|
|
phase.receive(await stream.receive())
|
|
assert phase.complete
|
|
request: BrokerdOrder = BrokerdOrder(
|
|
oid='client-1',
|
|
account='paper',
|
|
time_ns=1,
|
|
symbol='btc.spot',
|
|
price=Decimal('12.25'),
|
|
size=1.0,
|
|
action='buy',
|
|
)
|
|
await stream.send(phase.request(request))
|
|
ack: BrokerdEvent = phase.receive(
|
|
await stream.receive()
|
|
)
|
|
assert type(ack) is BrokerdOrderAck
|
|
fill: BrokerdEvent = phase.receive(
|
|
await stream.receive()
|
|
)
|
|
assert type(fill) is BrokerdFill
|
|
assert fill.fill_id == 'fill-1'
|
|
await ctx.cancel()
|
|
await nursery.cancel()
|
|
|
|
|
|
@pytest.mark.parametrize('empty', [True, False])
|
|
def test_typed_startup_and_stream(empty: bool) -> None:
|
|
'''
|
|
Typed startup must precede an explicit completion barrier, even
|
|
with no existing orders. Exercise both snapshots through a real
|
|
child process and exchange a request, ack and identified fill.
|
|
Nested Order and Decimal types must survive actor serialization.
|
|
|
|
'''
|
|
trio.run(exercise, '', empty)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
'fault',
|
|
[
|
|
'wrong_direction',
|
|
'wrong_phase',
|
|
'malformed',
|
|
],
|
|
)
|
|
def test_wire_rejection_and_bounded_teardown(fault: str) -> None:
|
|
'''
|
|
A peer bypassing outbound checks must still fail at wire decode.
|
|
Send a request in the event direction, a startup in the stream,
|
|
or a fill without its execution ID. Require MsgTypeError and let
|
|
exercise's deadline cover cancellation of the sleeping producer.
|
|
|
|
'''
|
|
with pytest.raises(tractor.MsgTypeError):
|
|
trio.run(exercise, fault)
|
|
|
|
|
|
def test_provider_failure_is_not_swallowed() -> None:
|
|
'''
|
|
Provider failure while a client waits for an ack must abort that
|
|
receive and terminate the actor tree. Raise inside the fake
|
|
broker and require its remote RuntimeError within the teardown
|
|
deadline.
|
|
|
|
'''
|
|
error: pytest.ExceptionInfo[tractor.RemoteActorError]
|
|
with pytest.raises(tractor.RemoteActorError) as error:
|
|
trio.run(exercise, 'peer_error')
|
|
assert error.value.boxed_type is RuntimeError
|
|
|
|
|
|
@tractor.context(pld_spec=BrokerdPayload)
|
|
async def wrong_final_result(
|
|
ctx: tractor.Context,
|
|
) -> BrokerdStartup:
|
|
'''
|
|
Return a wire-valid startup in the forbidden final phase.
|
|
|
|
'''
|
|
startup: BrokerdStartup = BrokerdStartup(
|
|
broker='fixture',
|
|
mode='paper',
|
|
accounts=('paper',),
|
|
)
|
|
await ctx.started(startup)
|
|
return startup
|
|
|
|
|
|
def test_final_result_has_its_own_phase() -> None:
|
|
'''
|
|
A lifecycle union permits startup objects but a finished broker
|
|
context returns only None. Receive a wire-valid wrong Return and
|
|
prove the phase validator rejects it after the child terminates.
|
|
|
|
'''
|
|
|
|
async def main() -> None:
|
|
'''
|
|
Receive a completed child result and reject its startup
|
|
payload.
|
|
|
|
'''
|
|
with trio.fail_after(15):
|
|
nursery: tractor.ActorNursery
|
|
async with (
|
|
collapse_eg(),
|
|
tractor.open_root_actor(
|
|
tpt_bind_addrs=[('127.0.0.1', 0)],
|
|
),
|
|
tractor.open_nursery() as nursery,
|
|
):
|
|
portal: tractor.Portal = await nursery.start_actor(
|
|
'wrong-return',
|
|
enable_modules=[__name__],
|
|
)
|
|
ctx: tractor.Context
|
|
_: BrokerdStartup
|
|
async with portal.open_context(
|
|
wrong_final_result,
|
|
) as (ctx, _):
|
|
result: BrokerdPayload = (
|
|
await ctx.wait_for_result()
|
|
)
|
|
with pytest.raises(ProtocolError):
|
|
validate(result, type(None))
|
|
await nursery.cancel()
|
|
|
|
trio.run(main)
|
|
|
|
|
|
@tractor.context(pld_spec=EmsPayload)
|
|
async def fake_ems(ctx: tractor.Context) -> None:
|
|
'''
|
|
Apply client cancellation before publishing the provider ack.
|
|
|
|
The receive order fixes the interleaving: ``OrderState.cancel()``
|
|
runs before ``OrderState.accept()`` handles the ack. Assert one
|
|
deferred cancellation and publish its terminal response.
|
|
|
|
'''
|
|
await ctx.started(
|
|
EmsStartup(
|
|
broker='fixture',
|
|
positions=(),
|
|
accounts=('paper',),
|
|
dialogs=(),
|
|
)
|
|
)
|
|
state: OrderState = OrderState()
|
|
stream: Stream[EmsRequest, EmsEvent]
|
|
async with open_stream(ctx, EmsRequest, EmsEvent) as stream:
|
|
order: Order = await stream.receive()
|
|
state.register(order)
|
|
cancel: Cancel = await stream.receive()
|
|
assert cancel.oid == order.oid
|
|
assert not state.cancel(cancel.oid).broker
|
|
effects: Effects = state.accept(
|
|
BrokerdOrderAck(
|
|
oid=order.oid,
|
|
account=order.account,
|
|
reqid=1,
|
|
)
|
|
)
|
|
assert len(effects.broker) == 1
|
|
assert effects.broker[0].oid == order.oid
|
|
effects = state.accept(
|
|
BrokerdStatus(
|
|
time_ns=1,
|
|
account=order.account,
|
|
broker='fixture',
|
|
reqid=1,
|
|
status='canceled',
|
|
)
|
|
)
|
|
await stream.send(effects.clients[0])
|
|
await trio.sleep_forever()
|
|
|
|
|
|
def test_ems_cancel_before_ack_over_ipc() -> None:
|
|
'''
|
|
Client Order and Cancel must arrive as typed requests and produce
|
|
an immutable nested Status. Hold the fake provider ack until the
|
|
cancel reaches the remote EMS reducer, then require one deferred
|
|
broker cancel and a terminal client response through real IPC.
|
|
|
|
'''
|
|
|
|
async def main() -> None:
|
|
'''
|
|
Send ordered client intent and require a typed canceled
|
|
snapshot.
|
|
|
|
'''
|
|
with trio.fail_after(15):
|
|
nursery: tractor.ActorNursery
|
|
async with (
|
|
collapse_eg(),
|
|
tractor.open_root_actor(
|
|
tpt_bind_addrs=[('127.0.0.1', 0)],
|
|
),
|
|
tractor.open_nursery() as nursery,
|
|
):
|
|
portal: tractor.Portal = await nursery.start_actor(
|
|
'fake-ems',
|
|
enable_modules=[__name__],
|
|
)
|
|
ctx: tractor.Context
|
|
startup: EmsStartup
|
|
async with portal.open_context(
|
|
fake_ems,
|
|
) as (ctx, startup):
|
|
startup = validate_ems_startup(
|
|
startup
|
|
)
|
|
assert startup.dialogs == ()
|
|
stream: Stream[EmsEvent, EmsRequest]
|
|
async with open_stream(
|
|
ctx,
|
|
EmsEvent,
|
|
EmsRequest,
|
|
) as stream:
|
|
order: Order = Order(
|
|
oid='client-1',
|
|
account='paper',
|
|
symbol='btc.spot.fixture',
|
|
price=Decimal('12.25'),
|
|
size=1.0,
|
|
action='buy',
|
|
exec_mode='live',
|
|
)
|
|
await stream.send(order)
|
|
await stream.send(
|
|
Cancel(
|
|
oid=order.oid,
|
|
symbol=order.symbol,
|
|
)
|
|
)
|
|
status: EmsEvent = await stream.receive()
|
|
assert isinstance(status, Status)
|
|
assert status.req == order
|
|
assert status.resp == 'canceled'
|
|
assert status.cancel_called
|
|
assert isinstance(
|
|
status.brokerd_event,
|
|
BrokerdStatus,
|
|
)
|
|
await ctx.cancel()
|
|
await nursery.cancel()
|
|
|
|
trio.run(main)
|