224 lines
9.7 KiB
Python
224 lines
9.7 KiB
Python
"""All execution tests use a fake terminal. Never connect to or trade a live account."""
|
|
from datetime import datetime
|
|
import io
|
|
import json
|
|
from pathlib import Path
|
|
from tempfile import TemporaryDirectory
|
|
from types import SimpleNamespace as NS
|
|
import unittest
|
|
from unittest.mock import Mock
|
|
|
|
from mt5_app.app import handler_for
|
|
from mt5_app.broker import Broker
|
|
from mt5_app.config import ROOT, Settings, TZ
|
|
from mt5_app.service import make_plan
|
|
from mt5_app.store import Store
|
|
from mt5_app.market import Market
|
|
|
|
|
|
FAKE_NOW = datetime(2026, 10, 19, 10, 10, tzinfo=TZ)
|
|
|
|
|
|
class FakeAPI:
|
|
TRADE_ACTION_PENDING = 5
|
|
TRADE_ACTION_REMOVE = 8
|
|
ORDER_TYPE_BUY_LIMIT = 2
|
|
ORDER_TYPE_SELL_LIMIT = 3
|
|
ORDER_TYPE_SELL_STOP = 5
|
|
POSITION_TYPE_BUY = 0
|
|
ORDER_TIME_DAY = 1
|
|
ORDER_FILLING_RETURN = 2
|
|
SYMBOL_TRADE_MODE_DISABLED = 0
|
|
SYMBOL_TRADE_MODE_SHORTONLY = 2
|
|
SYMBOL_TRADE_MODE_CLOSEONLY = 3
|
|
TRADE_RETCODE_DONE = 10009
|
|
TRADE_RETCODE_PLACED = 10008
|
|
TRADE_RETCODE_DONE_PARTIAL = 10010
|
|
|
|
def __init__(self, path):
|
|
self.path = path
|
|
self.cash = 10_000
|
|
self.position_volume = 100
|
|
self.orders = []
|
|
self.sent = []
|
|
self.fail_send = False
|
|
self.login = 123
|
|
|
|
def terminal_info(self):
|
|
return NS(data_path=str(self.path), connected=True, trade_allowed=True, tradeapi_disabled=False)
|
|
|
|
def account_info(self):
|
|
return NS(login=self.login, server='TEST', balance=self.cash, margin_free=self.cash,
|
|
trade_allowed=True, trade_expert=True)
|
|
|
|
def symbol_info(self, name):
|
|
return NS(path='SET\\Common Stock\\' + name, trade_contract_size=1, volume_max=1e6, trade_mode=1,
|
|
bid=10., ask=10., last=10., time=int(FAKE_NOW.timestamp()), volume_step=100, volume_min=1)
|
|
|
|
def symbol_info_tick(self, name):
|
|
return NS(time=int(FAKE_NOW.timestamp()))
|
|
|
|
def orders_get(self, **kwargs):
|
|
return self.orders
|
|
|
|
def positions_get(self, **kwargs):
|
|
return [NS(type=0, volume=self.position_volume)]
|
|
|
|
def order_check(self, request):
|
|
return NS(retcode=0, comment='Test passed')
|
|
|
|
def order_send(self, request):
|
|
self.sent.append(request)
|
|
if self.fail_send:
|
|
return None
|
|
return NS(retcode=10008, _asdict=lambda: {'retcode': 10008, 'comment': 'Placed', 'order': 456})
|
|
|
|
def last_error(self):
|
|
return (-1, 'fake lost connection')
|
|
|
|
|
|
class DeskTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = TemporaryDirectory(prefix='test_', dir=ROOT / 'data')
|
|
self.directory = Path(self.tmp.name)
|
|
self.settings = Settings(data_path=self.directory, live_orders=True, state_dir=self.directory)
|
|
self.store = Store(self.directory)
|
|
self.api = FakeAPI(self.directory)
|
|
self.broker = Broker(self.settings, self.store, api=self.api, market=Market(clock=lambda: FAKE_NOW))
|
|
self.signals = [{'symbol': 'AAA', 'reference_close': 10, 'stale_sessions': 0}]
|
|
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
|
|
def test_account_change_is_blocked(self):
|
|
self.broker.connect()
|
|
self.api.login = 999
|
|
with self.assertRaisesRegex(RuntimeError, 'บัญชี MT5 เปลี่ยน'):
|
|
self.broker.connect()
|
|
self.assertFalse(self.api.sent)
|
|
|
|
def test_wrong_terminal_folder_is_blocked(self):
|
|
self.api.path = self.directory / 'other'
|
|
with self.assertRaisesRegex(RuntimeError, 'folder'):
|
|
self.broker.connect()
|
|
|
|
def test_preview_never_sends_and_submit_is_single_use(self):
|
|
preview = self.broker.preview('AAA', 'BUY', 100, 10, self.signals)
|
|
self.assertFalse(self.api.sent)
|
|
result = self.broker.submit(preview['id'])
|
|
self.assertEqual(result['status'], 'accepted')
|
|
with self.assertRaises(ValueError):
|
|
self.broker.submit(preview['id'])
|
|
self.assertEqual(len(self.api.sent), 1)
|
|
|
|
def test_send_uncertainty_cannot_be_retried(self):
|
|
preview = self.broker.preview('AAA', 'BUY', 100, 10, self.signals)
|
|
self.api.fail_send = True
|
|
with self.assertRaises(RuntimeError):
|
|
self.broker.submit(preview['id'])
|
|
self.assertEqual(self.store.intents()[0]['status'], 'unknown')
|
|
with self.assertRaises(ValueError):
|
|
self.broker.submit(preview['id'])
|
|
self.assertEqual(len(self.api.sent), 1)
|
|
with self.assertRaisesRegex(ValueError, 'ไม่ทราบผล'):
|
|
self.broker.preview('AAA', 'BUY', 100, 10, self.signals)
|
|
|
|
def test_reconciliation_resolves_uncertain_send_from_broker_fill(self):
|
|
preview = self.broker.preview('AAA', 'BUY', 100, 10, self.signals)
|
|
self.api.fail_send = True
|
|
with self.assertRaises(RuntimeError):
|
|
self.broker.submit(preview['id'])
|
|
request = preview['request']
|
|
self.store.reconcile({'deals': [{'magic': self.settings.magic, 'comment': request['comment'],
|
|
'volume': 100, 'type': 0}], 'orders': []}, self.settings.magic)
|
|
self.assertEqual(self.store.intents()[0]['status'], 'filled')
|
|
self.assertEqual(len(self.api.sent), 1)
|
|
|
|
def test_live_off_blocks_send(self):
|
|
broker = Broker(Settings(data_path=self.directory, state_dir=self.directory), self.store, self.api)
|
|
preview = broker.preview('AAA', 'BUY', 100, 10, self.signals)
|
|
with self.assertRaisesRegex(ValueError, 'ปิดอยู่'):
|
|
broker.submit(preview['id'])
|
|
self.assertFalse(self.api.sent)
|
|
|
|
def test_bad_lots_prices_and_chasing_are_blocked(self):
|
|
for quantity, price in [(1, 10), (150, 10), (100, float('nan')), (100, 10.01), (100, 11)]:
|
|
with self.subTest(quantity=quantity, price=price), self.assertRaises(ValueError):
|
|
self.broker.preview('AAA', 'BUY', quantity, price, self.signals)
|
|
self.assertFalse(self.api.sent)
|
|
|
|
def test_sell_cannot_open_short_or_sell_reserved_shares(self):
|
|
with self.assertRaises(ValueError):
|
|
self.broker.preview('AAA', 'SELL', 200, 10, [])
|
|
self.api.orders = [NS(symbol='AAA', type=3, volume_current=100)]
|
|
with self.assertRaises(ValueError):
|
|
self.broker.preview('AAA', 'SELL', 100, 10, [])
|
|
|
|
def test_cash_is_checked_again_after_preview(self):
|
|
preview = self.broker.preview('AAA', 'BUY', 100, 10, self.signals)
|
|
self.api.cash = 100
|
|
with self.assertRaises(ValueError):
|
|
self.broker.submit(preview['id'])
|
|
self.assertFalse(self.api.sent)
|
|
|
|
def test_foreign_pending_order_cannot_be_cancelled(self):
|
|
self.api.orders = [NS(magic=539141)]
|
|
with self.assertRaises(ValueError):
|
|
self.broker.manage_pending(123)
|
|
self.assertFalse(self.api.sent)
|
|
|
|
def test_skip_reallocates_cash_but_never_changes_the_portfolio(self):
|
|
snapshot = {'account': {'balance': 10_000, 'margin_free': 10_000, 'equity': 10_000,
|
|
'equity_from_positions': 10_000}, 'positions': [], 'orders': []}
|
|
research = {'signal_as_of': '2026-10-15', 'signals': [
|
|
{'symbol': 'AAA', 'target_weight': .5, 'reference_close': 80,
|
|
'stale_sessions': 0, 'allocation_score': 1, 'model_agreement': 2},
|
|
{'symbol': 'BBB', 'target_weight': .5, 'reference_close': 30,
|
|
'stale_sessions': 0, 'allocation_score': .5, 'model_agreement': 1},
|
|
]}
|
|
initial = {r['symbol']: r for r in make_plan(snapshot, research, set(), self.settings)['rows']}
|
|
after = {r['symbol']: r for r in make_plan(snapshot, research, {'AAA'}, self.settings)['rows']}
|
|
self.assertEqual(initial['AAA']['action'], 'BUY')
|
|
self.assertEqual(initial['BBB']['action'], 'BUDGET')
|
|
self.assertEqual(after['AAA']['action'], 'SKIPPED')
|
|
self.assertEqual(after['BBB']['action'], 'BUY')
|
|
self.assertEqual(after['BBB']['quantity'], 100)
|
|
self.assertEqual(snapshot['account']['balance'], 10_000)
|
|
self.store.skip('AAA', '2026-10-15')
|
|
self.assertEqual(self.store.skipped('2026-10-16'), set())
|
|
|
|
def test_first_loading_state_never_generates_sell_signals(self):
|
|
snapshot = {'account': {'balance': 100, 'margin_free': 100},
|
|
'positions': [{'symbol': 'AAA', 'volume': 100, 'price_current': 10}], 'orders': []}
|
|
plan = make_plan(snapshot, {}, set(), self.settings)
|
|
self.assertEqual(plan['rows'][0]['action'], 'WAIT')
|
|
self.assertEqual(plan['rows'][0]['quantity'], 0)
|
|
|
|
def test_unclosed_daily_bar_cutoff(self):
|
|
self.assertEqual(self.settings.closed_through(datetime(2026, 10, 15, 15, 0, tzinfo=TZ)), '2026-10-14')
|
|
self.assertEqual(self.settings.closed_through(datetime(2026, 10, 15, 21, 0, tzinfo=TZ)), '2026-10-15')
|
|
|
|
|
|
class LocalHTTPTests(unittest.TestCase):
|
|
def handler(self, host, origin, token):
|
|
desk = Mock()
|
|
handler = handler_for(desk, 'secret', 18901).__new__(handler_for(desk, 'secret', 18901))
|
|
handler.path = '/api/submit'
|
|
handler.headers = {'Host': host, 'Origin': origin, 'X-App-Token': token, 'Content-Length': '2'}
|
|
handler.rfile = io.BytesIO(b'{}')
|
|
handler.respond = Mock()
|
|
return handler, desk
|
|
|
|
def test_remote_host_origin_or_missing_token_cannot_submit(self):
|
|
for host, origin, token in [('evil.test:18901', 'http://evil.test:18901', 'secret'),
|
|
('127.0.0.1:18901', 'http://evil.test', 'secret'),
|
|
('127.0.0.1:18901', 'http://127.0.0.1:18901', '')]:
|
|
handler, desk = self.handler(host, origin, token)
|
|
handler.do_POST()
|
|
self.assertEqual(handler.respond.call_args.args[0], 403)
|
|
desk.submit.assert_not_called()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|