def test_quote_processor(self):
config = SimConfig()
processor = QuoteProcessor()
order = NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5)
quote = Quote(bid=18, ask=19, bid_size=200, ask_size=500)
self.assertEqual(19, processor.get_price(order, quote, config))
self.assertEqual(500, processor.get_qty(order, quote, config))
order2 = NewOrderRequest(cl_id='test',
cl_ord_id=2,
inst_id=1,
action=OrdAction.SELL,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5)
self.assertEqual(18, processor.get_price(order2, quote, config))
self.assertEqual(200, processor.get_qty(order2, quote, config))
def test_stop_order_handler(self):
handler = StopOrderHandler(self.config)
bar1 = Bar(inst_id=1, open=20, high=21, low=19, close=20.5, vol=1000)
bar2 = Bar(inst_id=1, open=16, high=18, low=15, close=17, vol=1000)
# BUY
order1 = NewOrderRequest(cl_id='test', cl_ord_id=1, inst_id=1, action=OrdAction.BUY, type=OrdType.STOP,
qty=1000, stop_price=18.5)
fill_info = handler.process_w_price_qty(order1, 18, 1000)
self.assertFalse(handler.stop_limit_ready(order1.cl_id, order1.cl_ord_id))
self.assertEquals(None, fill_info)
fill_info = handler.process_w_price_qty(order1, 19, 1000)
self.assertTrue(handler.stop_limit_ready(order1.cl_id, order1.cl_ord_id))
self.assertEquals(19, fill_info.fill_price)
self.assertEquals(1000, fill_info.fill_qty)
# BUY with bar
order2 = NewOrderRequest(cl_id='test', cl_ord_id=2, inst_id=1, action=OrdAction.BUY, type=OrdType.STOP,
qty=1000, stop_price=18.5)
fill_info = handler.process(order2, bar2)
self.assertFalse(handler.stop_limit_ready(order2.cl_id, order2.cl_ord_id))
self.assertEquals(None, fill_info)
fill_info = handler.process(order2, bar1)
self.assertTrue(handler.stop_limit_ready(order2.cl_id, order2.cl_ord_id))
self.assertEquals(18.5, fill_info.fill_price)
self.assertEquals(1000, fill_info.fill_qty)
# SELL
order3 = NewOrderRequest(cl_id='test', cl_ord_id=3, inst_id=1, action=OrdAction.SELL, type=OrdType.STOP,
qty=1000, stop_price=18.5)
fill_info = handler.process_w_price_qty(order3, 19, 1000)
self.assertFalse(handler.stop_limit_ready(order3.cl_id, order3.cl_ord_id))
self.assertEquals(None, fill_info)
fill_info = handler.process_w_price_qty(order3, 18, 1000)
self.assertTrue(handler.stop_limit_ready(order3.cl_id, order3.cl_ord_id))
self.assertEquals(18, fill_info.fill_price)
self.assertEquals(1000, fill_info.fill_qty)
# SELL with bar
order4 = NewOrderRequest(cl_id='test', cl_ord_id=4, inst_id=1, action=OrdAction.SELL, type=OrdType.STOP,
qty=1000, stop_price=18.5)
fill_info = handler.process(order4, bar1)
self.assertFalse(handler.stop_limit_ready(order4.cl_id, order4.cl_ord_id))
self.assertEquals(None, fill_info)
fill_info = handler.process(order4, bar2)
self.assertTrue(handler.stop_limit_ready(order4.cl_id, order4.cl_ord_id))
self.assertEquals(18.5, fill_info.fill_price)
self.assertEquals(1000, fill_info.fill_qty)
def test_is_done(self):
order = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
self.assertFalse(order.is_done())
status_update1 = OrderStatusUpdate(cl_id='test',
cl_ord_id=1,
ord_id=1,
inst_id=1,
status=OrdStatus.REJECTED)
order.on_ord_upd(status_update1)
self.assertTrue(order.is_done())
order2 = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=2,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
status_update2 = OrderStatusUpdate(cl_id='test',
cl_ord_id=2,
ord_id=2,
inst_id=1,
status=OrdStatus.CANCELLED)
order2.on_ord_upd(status_update2)
self.assertTrue(order2.is_done())
order3 = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=3,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
status_update3 = OrderStatusUpdate(cl_id='test',
cl_ord_id=3,
ord_id=3,
inst_id=1,
status=OrdStatus.FILLED)
order3.on_ord_upd(status_update3)
self.assertTrue(order3.is_done())
def test_update_status_with_diff_ord_id(self):
order = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
self.assertEquals(OrdStatus.NEW, order.status)
status_update = OrderStatusUpdate(cl_id='test',
cl_ord_id=1,
ord_id=2,
inst_id=1,
status=OrdStatus.SUBMITTED)
order.on_ord_upd(status_update)
status_update = OrderStatusUpdate(cl_id='test',
cl_ord_id=1,
ord_id=3,
inst_id=1,
status=OrdStatus.SUBMITTED)
with self.assertRaises(Exception) as ex:
order.on_ord_upd(status_update)
def new_order(self,
inst_id=None,
action=None,
type=None,
qty=0,
limit_price=0,
stop_price=0,
tif=TIF.DAY,
oca_tag=None,
params=None):
req = NewOrderRequest(timestamp=self.clock.now(),
cl_id=self.stg_id,
cl_ord_id=self.__get_next_ord_id(),
portf_id=self.portfolio.portf_id,
broker_id=self.app_config.broker_id,
inst_id=inst_id,
action=action,
type=type,
qty=qty,
limit_price=limit_price,
stop_price=stop_price,
tif=tif,
oca_tag=oca_tag,
params=params)
self.ord_reqs[req.cl_ord_id] = req
order = self.portfolio.send_order(req)
self.orders[order.cl_ord_id] = order
self.get_position(order.inst_id).add_order(order)
return order
def test_leave_qty(self):
order = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
self.assertEqual(1000, order.leave_qty())
er1 = ExecutionReport(cl_id='test',
cl_ord_id=1,
ord_id=1,
er_id=1,
inst_id=1,
last_qty=800,
last_price=18.4,
status=OrdStatus.PARTIALLY_FILLED)
order.on_exec_report(er1)
self.assertEqual(200, order.leave_qty())
er2 = ExecutionReport(cl_id='test',
cl_ord_id=1,
ord_id=1,
er_id=2,
inst_id=1,
last_qty=200,
last_price=18.4,
status=OrdStatus.FILLED)
order.on_exec_report(er2)
self.assertEqual(0, order.leave_qty())
self.assertTrue(order.is_done())
self.assertEquals(OrdStatus.FILLED, order.status)
def test_on_limit_order_immediate_fill(self):
bar1 = Bar(inst_id=1, open=20, high=21, low=19, close=20.5, vol=1000)
bar2 = Bar(inst_id=1, open=16, high=18, low=15, close=17, vol=1000)
self.app_context.inst_data_mgr.on_bar(bar2)
orders = self.simulator._get_orders()
self.assertEqual(0, len(orders))
order1 = NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5)
self.simulator.on_new_ord_req(order1)
orders = self.simulator._get_orders()
self.assertEqual(1, len(orders))
self.assertEqual(1, len(orders[order1.inst_id]))
self.assertEqual(0, len(orders[order1.inst_id][order1.cl_id]))
self.assertEqual(2, len(self.exec_handler.exec_reports))
exec_report = self.exec_handler.exec_reports[0]
self.assert_exec_report(exec_report, order1.cl_id, order1.cl_ord_id, 0,
0, OrdStatus.SUBMITTED)
exec_report = self.exec_handler.exec_reports[1]
self.assert_exec_report(exec_report, order1.cl_id, order1.cl_ord_id,
1000, 18.5, OrdStatus.FILLED)
def test_position(self):
ord_req = NewOrderRequest(cl_id='test',
cl_ord_id=1,
portf_id="test",
broker_id="Dummy",
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5)
order1 = self.portfolio.send_order(ord_req)
er1 = ExecutionReport(cl_id='test',
cl_ord_id=1,
ord_id=1,
er_id=1,
inst_id=1,
last_qty=500,
last_price=18.4,
status=OrdStatus.PARTIALLY_FILLED)
self.app_context.order_mgr.on_exec_report(er1)
self.assertEqual(500, order1.last_qty)
self.assertEqual(18.4, order1.last_price)
self.assertEqual(500, order1.filled_qty)
self.assertEqual(18.4, order1.avg_price)
self.assertEqual(OrdStatus.PARTIALLY_FILLED, order1.status)
self.assertEquals(True,
self.portfolio.has_position(cl_id='test', inst_id=1))
self.assertEquals(False,
self.portfolio.has_position(cl_id='test', inst_id=2))
self.assertEquals(
False, self.portfolio.has_position(cl_id='dummy', inst_id=2))
def test_new_order_request(self, name, serializer):
item = NewOrderRequest(timestamp=datetime.datetime.now(), cl_id=1, cl_ord_id=2, portf_id=3, broker_id='IB',
inst_id=3,
action=OrdAction.BUY, type=OrdType.LIMIT,
qty=10, limit_price=16.01,
stop_price=17.5, tif=TIF.DAY, oca_tag="WTF", params=None)
SerializerTest.ser_deser(name, serializer, item)
def test_lmt_order_update_cancel(broker, inst_id=3, qty=1000, limit_price=100):
print "### testing limit order"
cl_ord_id = next_cl_ord_id()
order = NewOrderRequest(cl_id=1,
cl_ord_id=1,
inst_id=inst_id,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=qty,
limit_price=limit_price)
broker.on_new_ord_req(order)
time.sleep(5)
print "### testing order update"
order = OrderReplaceRequest(cl_id=1,
cl_ord_id=1,
type=OrdType.LIMIT,
qty=qty * 2,
limit_price=limit_price * 1.2)
broker.on_ord_replace_req(order)
time.sleep(5)
print "### testing order cancel"
broker.on_ord_cancel_req(order)
time.sleep(5)
def test_order(self, name, serializer):
nos = NewOrderRequest(timestamp=None, cl_id=None, cl_ord_id=None, portf_id=None, broker_id=None, inst_id=None,
action=None, type=None,
qty=0, limit_price=0,
stop_price=0, tif=TIF.DAY, oca_tag=None, params=None)
item = Order(nos=nos)
SerializerTest.ser_deser(name, serializer, item)
def test_mkt_order(broker, inst_id=3, action=OrdAction.BUY, qty=1000):
print "### testing market order"
cl_ord_id = next_cl_ord_id()
order = NewOrderRequest(cl_ord_id=cl_ord_id,
inst_id=inst_id,
action=action,
type=OrdType.MARKET,
qty=1000)
broker.on_new_ord_req(order)
time.sleep(10)
def test_add_order(self):
position = Position(1)
self.assertEquals(0, position.filled_qty())
self.assertEquals(0, len(position.all_orders()))
order1 = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
position.add_order(order1)
self.assertEquals(1000, position.ordered_qty())
self.assertEquals(1, len(position.all_orders()))
order2 = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=2,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
position.add_order(order2)
self.assertEquals(2000, position.ordered_qty())
self.assertEquals(2, len(position.all_orders()))
order3 = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=3,
inst_id=1,
action=OrdAction.SELL,
type=OrdType.LIMIT,
qty=1200,
limit_price=18.5))
position.add_order(order3)
self.assertEquals(800, position.ordered_qty())
self.assertEquals(3, len(position.all_orders()))
def test_is_active(self):
order = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
self.assertTrue(order.is_active())
def test_save_orders():
context = get_default_app_context()
store = context.provider_mgr.get(DataStore.Mongo)
store.start()
ord_mrg = context.order_mgr
ord_mrg.start()
order = ord_mrg.send_order(
NewOrderRequest(cl_id='test_stg',
cl_ord_id=1,
inst_id=1,
portf_id='test_porf',
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
order = ord_mrg.send_order(
NewOrderRequest(cl_id='test_stg',
cl_ord_id=2,
inst_id=1,
portf_id='test_porf',
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
before = ord_mrg.all_items()
ord_mrg.stop()
ord_mrg.start()
after = ord_mrg.all_items()
print before
print after
p1 = Portfolio(portf_id='test_porf', cash=1000, app_context=context)
p1.start()
print "all"
print p1.all_orders()
def test_limit_order_handler(self):
handler = LimitOrderHandler(self.config)
bar1 = Bar(inst_id=1, open=20, high=21, low=19, close=20.5, vol=1000)
bar2 = Bar(inst_id=1, open=16, high=18, low=15, close=17, vol=1000)
# BUY
order = NewOrderRequest(cl_id='test', cl_ord_id=1, inst_id=1, action=OrdAction.BUY, type=OrdType.LIMIT,
qty=1000, limit_price=18.5)
fill_info = handler.process_w_price_qty(order, 20, 1000)
self.assertEquals(None, fill_info)
fill_info = handler.process_w_price_qty(order, 18, 1000)
self.assertEquals(18.5, fill_info.fill_price)
self.assertEquals(1000, fill_info.fill_qty)
# BUY with bar
fill_info = handler.process(order, bar1)
self.assertEquals(None, fill_info)
fill_info = handler.process(order, bar2)
self.assertEquals(18.5, fill_info.fill_price)
self.assertEquals(1000, fill_info.fill_qty)
# SELL
order2 = NewOrderRequest(cl_id='test', cl_ord_id=2, inst_id=1, action=OrdAction.SELL, type=OrdType.LIMIT,
qty=1000,
limit_price=18.5)
fill_info = handler.process_w_price_qty(order2, 18, 1000)
self.assertEquals(None, fill_info)
fill_info = handler.process_w_price_qty(order2, 20, 1000)
self.assertEquals(18.5, fill_info.fill_price)
self.assertEquals(1000, fill_info.fill_qty)
# SELL with bar
fill_info = handler.process(order2, bar2)
self.assertEquals(None, fill_info)
fill_info = handler.process(order2, bar1)
self.assertEquals(18.5, fill_info.fill_price)
self.assertEquals(1000, fill_info.fill_qty)
def test_position(self):
ord_req1 = NewOrderRequest(cl_id='test', cl_ord_id=1, portf_id="test", broker_id="Dummy", inst_id=1,
action=OrdAction.BUY, type=OrdType.LIMIT, qty=1000, limit_price=18.5)
ord_req2 = NewOrderRequest(cl_id='test', cl_ord_id=2, portf_id="test", broker_id="Dummy", inst_id=1,
action=OrdAction.BUY, type=OrdType.LIMIT, qty=1800, limit_price=18.2)
self.assertEqual(0, len(self.portfolio.positions))
self.assertEqual(100000, self.portfolio.cash)
self.assertEqual(0, (self.portfolio.performance_series.now("total_equity")))
order1 = self.portfolio.send_order(ord_req1)
self.check_order(self.portfolio, [order1], {1: (1000, 0)})
self.assertEqual(100000, self.portfolio.cash)
self.assertEqual(0, (self.portfolio.performance_series.now("total_equity")))
order2 = self.portfolio.send_order(ord_req2)
self.check_order(self.portfolio, [order1, order2], {1: (2800, 0)})
self.assertEqual(100000, self.portfolio.cash)
self.assertEqual(0, (self.portfolio.performance_series.now("total_equity")))
def test_market_order_handler(self):
handler = MarketOrderHandler(self.config)
order = NewOrderRequest(cl_id='test', cl_ord_id=1, inst_id=1, action=OrdAction.BUY, type=OrdType.LIMIT,
qty=1000, limit_price=18.5)
quote = Quote(inst_id=1, bid=18, ask=19, bid_size=200, ask_size=500)
trade = Trade(inst_id=1, price=20, size=200)
fill_info = handler.process_w_price_qty(order, 18, 500)
self.assertEquals(18, fill_info.fill_price)
self.assertEquals(500, fill_info.fill_qty)
def test_is_sell(self):
order = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.SELL,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
self.assertFalse(order.is_buy())
self.assertTrue(order.is_sell())
order = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.SSHORT,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
self.assertFalse(order.is_buy())
self.assertTrue(order.is_sell())
def test_exec_report(self):
order = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
self.assertEqual(1000, order.leave_qty())
self.assertEqual(0, len(order.get_events(ExecutionReport)))
er1 = ExecutionReport(cl_id='test',
cl_ord_id=1,
ord_id=1,
er_id=1,
inst_id=1,
last_qty=800,
last_price=18.4,
status=OrdStatus.PARTIALLY_FILLED)
order.on_exec_report(er1)
self.assertEqual(1, len(order.get_events(ExecutionReport)))
self.assertTrue(er1 in order.get_events(ExecutionReport))
self.assertEqual(er1.ord_id, order.broker_ord_id)
self.assertEqual(800, order.last_qty)
self.assertAlmostEqual(18.4, order.last_price)
self.assertEqual(800, order.filled_qty)
self.assertAlmostEqual(18.4, order.avg_price)
self.assertEqual(OrdStatus.PARTIALLY_FILLED, order.status)
er2 = ExecutionReport(cl_id='test',
cl_ord_id=1,
ord_id=1,
er_id=2,
inst_id=1,
last_qty=200,
last_price=18.4,
status=OrdStatus.FILLED)
order.on_exec_report(er2)
self.assertEqual(2, len(order.get_events(ExecutionReport)))
self.assertTrue(er1 in order.get_events(ExecutionReport))
self.assertTrue(er2 in order.get_events(ExecutionReport))
self.assertEqual(er2.ord_id, order.broker_ord_id)
self.assertEqual(200, order.last_qty)
self.assertAlmostEqual(18.4, order.last_price)
self.assertEqual(1000, order.filled_qty)
self.assertAlmostEqual(18.4, order.avg_price)
self.assertEqual(OrdStatus.FILLED, order.status)
def test_add_order_with_diff_inst(self):
position = Position(1)
order1 = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
order2 = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=2,
inst_id=2,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
position.add_order(order1)
with self.assertRaises(RuntimeError) as ex:
position.add_order(order2)
def test_save():
context = get_default_app_context()
store = context.provider_mgr.get(DataStore.Mongo)
store.start(app_context=context)
stg_mgr = context.stg_mgr
stg_mgr.start(app_context=context)
portf_mgr = context.portf_mgr
portf_mgr.start(app_context=context)
ord_mrg = context.order_mgr
ord_mrg.start(app_context=context)
p1 = portf_mgr.new_portfolio(portf_id=1, cash=1000)
p2 = portf_mgr.new_portfolio(portf_id=2, cash=1000)
p1.start(app_context=context)
p2.start(app_context=context)
stg1 = stg_mgr.new_stg(
stg_id='test1', stg_cls='algotrader.strategy.ema_strategy.EMAStrategy')
stg2 = stg_mgr.new_stg(
stg_id='test2', stg_cls='algotrader.strategy.ema_strategy.EMAStrategy')
stg1.start(app_context=context)
stg2.start(app_context=context)
nos = NewOrderRequest(cl_id='test1',
cl_ord_id='1',
inst_id=1,
portf_id='test_porf',
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5)
order = ord_mrg.send_order(nos)
stg1.ord_reqs[nos.cl_ord_id] = nos
stg1.orders[order.cl_ord_id] = order
stg1.add_position(nos.inst_id, nos.cl_id, nos.cl_ord_id, nos.qty)
stg1.update_position_price(time=0, inst_id=nos.inst_id, price=100)
print portf_mgr.get(1)
print portf_mgr.get(2)
print stg_mgr.get('test1')
print stg_mgr.get('test2')
print ord_mrg.all_orders()
def test_save_strategies():
print "test_save_strategies"
context = get_default_app_context()
store = context.provider_mgr.get(DataStore.Mongo)
store.start(app_context=context)
stg_mgr = context.stg_mgr
stg_mgr.start(app_context=context)
stg_mgr.reset()
stg1 = stg_mgr.new_stg(trading_config=BacktestingConfig(
id='1',
stg_id='test1',
stg_cls='algotrader.strategy.ema_strategy.EMAStrategy'))
ord_mrg = context.order_mgr
ord_mrg.start(app_context=context)
nos = NewOrderRequest(cl_id='test1',
cl_ord_id='1',
inst_id=1,
portf_id='test_porf',
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5)
order = ord_mrg.send_order(nos)
stg1.ord_reqs[nos.cl_ord_id] = nos
stg1.orders[order.cl_ord_id] = order
stg1.add_position(nos.inst_id, nos.cl_id, nos.cl_ord_id, nos.qty)
stg1.update_position_price(time=0, inst_id=nos.inst_id, price=100)
stg2 = stg_mgr.new_stg(trading_config=BacktestingConfig(
id='2',
stg_id='test2',
stg_cls='algotrader.strategy.ema_strategy.EMAStrategy'))
before = stg_mgr.get('test1')
stg_mgr.stop()
stg_mgr.start(app_context=context)
after = stg_mgr.get('test1')
after.start(app_context=context)
print "before %s" % MapSerializer.serialize(before)
print "after %s" % MapSerializer.serialize(after)
def test_trader_processor(self):
config = SimConfig()
processor = TradeProcessor()
order = NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5)
trade = Trade(price=20, size=200)
self.assertEqual(20, processor.get_price(order, trade, config))
self.assertEqual(200, processor.get_qty(order, trade, config))
def test_new_order_request(self, name, datastore):
persistable = NewOrderRequest(timestamp=clock.now(),
cl_id=1,
cl_ord_id=2,
portf_id=3,
broker_id='IB',
inst_id=3,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=10,
limit_price=16.01,
stop_price=17.5,
tif=TIF.DAY,
oca_tag="WTF",
params=None)
DataStoreTest.save_load(name, persistable, datastore,
datastore.save_new_order_req, 'new_order_reqs')
def test_on_exec_report(self):
ord_req = NewOrderRequest(cl_id='test', cl_ord_id=1, portf_id="test", broker_id="Dummy", inst_id=1,
action=OrdAction.BUY, type=OrdType.LIMIT, qty=1000, limit_price=18.5)
order1 = self.portfolio.send_order(ord_req)
er1 = ExecutionReport(cl_id='test', cl_ord_id=1, ord_id=1, er_id=1, inst_id=1, last_qty=500, last_price=18.4,
status=OrdStatus.PARTIALLY_FILLED)
self.app_context.order_mgr.on_exec_report(er1)
self.assertEqual(500, order1.last_qty)
self.assertEqual(18.4, order1.last_price)
self.assertEqual(500, order1.filled_qty)
self.assertEqual(18.4, order1.avg_price)
self.assertEqual(OrdStatus.PARTIALLY_FILLED, order1.status)
self.check_order(self.portfolio, [order1], {1: (1000, 500)})
expected_cash = 100000 - 500 * 18.4
expected_stock_value = 500 * 18.4
expected_total_equity = expected_cash + expected_stock_value
self.assertEqual(expected_cash, self.portfolio.cash)
self.assertEqual(expected_stock_value, self.portfolio.performance_series.now('stock_value'))
self.assertEqual(expected_total_equity, self.portfolio.performance_series.now('total_equity'))
er2 = ExecutionReport(cl_id='test', cl_ord_id=1, ord_id=1, er_id=2, inst_id=1, last_qty=500, last_price=18.2,
status=OrdStatus.FILLED)
self.app_context.order_mgr.on_exec_report(er2)
self.assertEqual(500, order1.last_qty)
self.assertEqual(18.2, order1.last_price)
self.assertEqual(1000, order1.filled_qty)
self.assertEqual(18.3, order1.avg_price)
self.assertEqual(OrdStatus.FILLED, order1.status)
self.check_order(self.portfolio, [order1], {1: (1000, 1000)})
expected_cash = 100000 - 500 * 18.4 - 500 * 18.2
expected_stock_value = 1000 * 18.2
expected_total_equity = expected_cash + expected_stock_value
self.assertEqual(expected_cash, self.portfolio.cash)
self.assertEqual(expected_stock_value, self.portfolio.performance_series.now('stock_value'))
self.assertEqual(expected_total_equity, self.portfolio.performance_series.now('total_equity'))
def test_order(self, name, datastore):
nos = NewOrderRequest(timestamp=None,
cl_id=None,
cl_ord_id=None,
portf_id=None,
broker_id=None,
inst_id=None,
action=None,
type=None,
qty=0,
limit_price=0,
stop_price=0,
tif=TIF.DAY,
oca_tag=None,
params=None)
persistable = Order(nos=nos)
DataStoreTest.save_load(name, persistable, datastore,
datastore.save_order, 'orders')
def test_bar_processor(self):
config = SimConfig()
processor = BarProcessor()
order = NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5)
bar = Bar(open=18, high=19, low=17, close=17.5, vol=1000)
self.assertEqual(17.5, processor.get_price(order, bar, config))
self.assertEqual(1000, processor.get_qty(order, bar, config))
config2 = SimConfig(fill_on_bar_mode=SimConfig.FillMode.NEXT_OPEN)
self.assertEqual(18, processor.get_price(order, bar, config2))
self.assertEqual(1000, processor.get_qty(order, bar, config2))
def test_on_market_date_update(self):
ord_req = NewOrderRequest(cl_id='test', cl_ord_id=1, portf_id="test", broker_id="Dummy", inst_id=1,
action=OrdAction.BUY, type=OrdType.LIMIT, qty=1000, limit_price=18.5,
timestamp=0)
order1 = self.portfolio.on_new_ord_req(ord_req)
er1 = ExecutionReport(cl_id='test', cl_ord_id=1, ord_id=1, er_id=1, inst_id=1, last_qty=500, last_price=18.4,
status=OrdStatus.PARTIALLY_FILLED, timestamp=1)
self.app_context.order_mgr.on_exec_report(er1)
expected_cash = 100000 - 500 * 18.4
expected_stock_value = 500 * 18.4
expected_total_equity = expected_cash + expected_stock_value
self.assertEqual(expected_cash, self.portfolio.cash)
self.assertEqual(expected_stock_value, self.portfolio.performance_series.get_by_idx(0, 'stock_value'))
self.assertEqual(expected_total_equity, self.portfolio.performance_series.get_by_idx(0, 'total_equity'))
self.portfolio.on_trade(Trade(inst_id=1, price=20, size=1000, timestamp=2))
expected_cash = 100000 - 500 * 18.4
expected_stock_value = 500 * 20
expected_total_equity = expected_cash + expected_stock_value
self.assertEqual(expected_cash, self.portfolio.cash)
self.assertEqual(expected_stock_value, self.portfolio.performance_series.get_by_idx(1, 'stock_value'))
self.assertEqual(expected_total_equity, self.portfolio.performance_series.get_by_idx(1, 'total_equity'))
self.portfolio.on_bar(Bar(inst_id=1, close=16, adj_close=16, vol=1000, timestamp=3))
expected_cash = 100000 - 500 * 18.4
expected_stock_value = 500 * 16
expected_total_equity = expected_cash + expected_stock_value
self.assertEqual(expected_cash, self.portfolio.cash)
self.assertEqual(expected_stock_value, self.portfolio.performance_series.get_by_idx(2, 'stock_value'))
self.assertEqual(expected_total_equity, self.portfolio.performance_series.get_by_idx(2, 'total_equity'))
self.portfolio.on_quote(Quote(inst_id=1, bid=16, ask=18, timestamp=4))
expected_cash = 100000 - 500 * 18.4
expected_stock_value = 500 * 17
expected_total_equity = expected_cash + expected_stock_value
self.assertEqual(expected_cash, self.portfolio.cash)
self.assertEqual(expected_stock_value, self.portfolio.performance_series.get_by_idx(3, 'stock_value'))
self.assertEqual(expected_total_equity, self.portfolio.performance_series.get_by_idx(3, 'total_equity'))
def test_on_ord_upd(self):
order = Order(
NewOrderRequest(cl_id='test',
cl_ord_id=1,
inst_id=1,
action=OrdAction.BUY,
type=OrdType.LIMIT,
qty=1000,
limit_price=18.5))
self.assertEquals(OrdStatus.NEW, order.status)
status_update = OrderStatusUpdate(cl_id='test',
cl_ord_id=1,
ord_id=1,
inst_id=1,
status=OrdStatus.SUBMITTED)
order.on_ord_upd(status_update)
self.assertEqual(status_update.ord_id, order.broker_ord_id)
self.assertEquals(OrdStatus.SUBMITTED, order.status)
