def test_order_hold(self):
"""
Held orders act almost identically to open orders, except for the
status indication. When a fill happens, the order should switch
status to OPEN/FILLED as necessary
"""
blotter = SimulationBlotter(self.sim_params,
equity_slippage=VolumeShareSlippage())
# Nothing happens on held of a non-existent order
blotter.hold(56)
self.assertEqual(blotter.new_orders, [])
open_id = blotter.order(self.asset_24, 100, MarketOrder())
open_order = blotter.open_orders[self.asset_24][0]
self.assertEqual(open_order.id, open_id)
blotter.hold(open_id)
self.assertEqual(len(blotter.new_orders), 1)
self.assertEqual(len(blotter.open_orders[self.asset_24]), 1)
held_order = blotter.new_orders[0]
self.assertEqual(held_order.status, ORDER_STATUS.HELD)
self.assertEqual(held_order.reason, '')
blotter.cancel(held_order.id)
self.assertEqual(len(blotter.new_orders), 1)
self.assertEqual(len(blotter.open_orders[self.asset_24]), 0)
cancelled_order = blotter.new_orders[0]
self.assertEqual(cancelled_order.id, held_order.id)
self.assertEqual(cancelled_order.status, ORDER_STATUS.CANCELLED)
for data in ([100, self.sim_params.sessions[0]],
[400, self.sim_params.sessions[1]]):
# Verify that incoming fills will change the order status.
trade_amt = data[0]
dt = data[1]
order_size = 100
expected_filled = int(trade_amt *
DEFAULT_EQUITY_VOLUME_SLIPPAGE_BAR_LIMIT)
expected_open = order_size - expected_filled
expected_status = ORDER_STATUS.OPEN if expected_open else \
ORDER_STATUS.FILLED
blotter = SimulationBlotter(self.sim_params,
equity_slippage=VolumeShareSlippage())
open_id = blotter.order(self.asset_24, order_size, MarketOrder())
open_order = blotter.open_orders[self.asset_24][0]
self.assertEqual(open_id, open_order.id)
blotter.hold(open_id)
held_order = blotter.new_orders[0]
filled_order = None
blotter.current_dt = dt
bar_data = self.create_bardata(simulation_dt_func=lambda: dt, )
txns, _, _ = blotter.get_transactions(bar_data)
for txn in txns:
filled_order = blotter.orders[txn.order_id]
self.assertEqual(filled_order.id, held_order.id)
self.assertEqual(filled_order.status, expected_status)
self.assertEqual(filled_order.filled, expected_filled)
self.assertEqual(filled_order.open_amount, expected_open)
def test_order_rejection(self):
blotter = SimulationBlotter(self.sim_params)
# Reject a nonexistent order -> no order appears in new_order,
# no exceptions raised out
blotter.reject(56)
self.assertEqual(blotter.new_orders, [])
# Basic tests of open order behavior
open_order_id = blotter.order(self.asset_24, 100, MarketOrder())
second_order_id = blotter.order(self.asset_24, 50, MarketOrder())
self.assertEqual(len(blotter.open_orders[self.asset_24]), 2)
open_order = blotter.open_orders[self.asset_24][0]
self.assertEqual(open_order.status, ORDER_STATUS.OPEN)
self.assertEqual(open_order.id, open_order_id)
self.assertIn(open_order, blotter.new_orders)
# Reject that order immediately (same bar, i.e. still in new_orders)
blotter.reject(open_order_id)
self.assertEqual(len(blotter.new_orders), 2)
self.assertEqual(len(blotter.open_orders[self.asset_24]), 1)
still_open_order = blotter.new_orders[0]
self.assertEqual(still_open_order.id, second_order_id)
self.assertEqual(still_open_order.status, ORDER_STATUS.OPEN)
rejected_order = blotter.new_orders[1]
self.assertEqual(rejected_order.status, ORDER_STATUS.REJECTED)
self.assertEqual(rejected_order.reason, '')
# Do it again, but reject it at a later time (after tradesimulation
# pulls it from new_orders)
blotter = SimulationBlotter(self.sim_params)
new_open_id = blotter.order(self.asset_24, 10, MarketOrder())
new_open_order = blotter.open_orders[self.asset_24][0]
self.assertEqual(new_open_id, new_open_order.id)
# Pretend that the trade simulation did this.
blotter.new_orders = []
rejection_reason = "Not enough cash on hand."
blotter.reject(new_open_id, reason=rejection_reason)
rejected_order = blotter.new_orders[0]
self.assertEqual(rejected_order.id, new_open_id)
self.assertEqual(rejected_order.status, ORDER_STATUS.REJECTED)
self.assertEqual(rejected_order.reason, rejection_reason)
# You can't reject a filled order.
# Reset for paranoia
blotter = SimulationBlotter(self.sim_params)
blotter.slippage_models[Equity] = FixedSlippage()
filled_id = blotter.order(self.asset_24, 100, MarketOrder())
filled_order = None
blotter.current_dt = self.sim_params.sessions[-1]
bar_data = self.create_bardata(
simulation_dt_func=lambda: self.sim_params.sessions[-1], )
txns, _, closed_orders = blotter.get_transactions(bar_data)
for txn in txns:
filled_order = blotter.orders[txn.order_id]
blotter.prune_orders(closed_orders)
self.assertEqual(filled_order.id, filled_id)
self.assertIn(filled_order, blotter.new_orders)
self.assertEqual(filled_order.status, ORDER_STATUS.FILLED)
self.assertNotIn(filled_order, blotter.open_orders[self.asset_24])
blotter.reject(filled_id)
updated_order = blotter.orders[filled_id]
self.assertEqual(updated_order.status, ORDER_STATUS.FILLED)
def test_order_rejection(self):
blotter = SimulationBlotter()
# Reject a nonexistent order -> no order appears in new_order,
# no exceptions raised out
blotter.reject(56)
self.assertEqual(blotter.new_orders, [])
# Basic tests of open order behavior
open_order_id = blotter.order(self.asset_24, 100, MarketOrder())
second_order_id = blotter.order(self.asset_24, 50, MarketOrder())
self.assertEqual(len(blotter.open_orders[self.asset_24]), 2)
open_order = blotter.open_orders[self.asset_24][0]
self.assertEqual(open_order.status, ORDER_STATUS.OPEN)
self.assertEqual(open_order.id, open_order_id)
self.assertIn(open_order, blotter.new_orders)
# Reject that order immediately (same bar, i.e. still in new_orders)
blotter.reject(open_order_id)
self.assertEqual(len(blotter.new_orders), 2)
self.assertEqual(len(blotter.open_orders[self.asset_24]), 1)
still_open_order = blotter.new_orders[0]
self.assertEqual(still_open_order.id, second_order_id)
self.assertEqual(still_open_order.status, ORDER_STATUS.OPEN)
rejected_order = blotter.new_orders[1]
self.assertEqual(rejected_order.status, ORDER_STATUS.REJECTED)
self.assertEqual(rejected_order.reason, '')
# Do it again, but reject it at a later time (after tradesimulation
# pulls it from new_orders)
blotter = SimulationBlotter()
new_open_id = blotter.order(self.asset_24, 10, MarketOrder())
new_open_order = blotter.open_orders[self.asset_24][0]
self.assertEqual(new_open_id, new_open_order.id)
# Pretend that the trade simulation did this.
blotter.new_orders = []
rejection_reason = "Not enough cash on hand."
blotter.reject(new_open_id, reason=rejection_reason)
rejected_order = blotter.new_orders[0]
self.assertEqual(rejected_order.id, new_open_id)
self.assertEqual(rejected_order.status, ORDER_STATUS.REJECTED)
self.assertEqual(rejected_order.reason, rejection_reason)
# You can't reject a filled order.
# Reset for paranoia
blotter = SimulationBlotter()
blotter.slippage_models[Equity] = FixedSlippage()
filled_id = blotter.order(self.asset_24, 100, MarketOrder())
filled_order = None
blotter.current_dt = self.sim_params.sessions[-1]
bar_data = self.create_bardata(
simulation_dt_func=lambda: self.sim_params.sessions[-1],
)
txns, _, closed_orders = blotter.get_transactions(bar_data)
for txn in txns:
filled_order = blotter.orders[txn.order_id]
blotter.prune_orders(closed_orders)
self.assertEqual(filled_order.id, filled_id)
self.assertIn(filled_order, blotter.new_orders)
self.assertEqual(filled_order.status, ORDER_STATUS.FILLED)
self.assertNotIn(filled_order, blotter.open_orders[self.asset_24])
blotter.reject(filled_id)
updated_order = blotter.orders[filled_id]
self.assertEqual(updated_order.status, ORDER_STATUS.FILLED)
def test_order_hold(self):
"""
Held orders act almost identically to open orders, except for the
status indication. When a fill happens, the order should switch
status to OPEN/FILLED as necessary
"""
blotter = SimulationBlotter(equity_slippage=VolumeShareSlippage())
# Nothing happens on held of a non-existent order
blotter.hold(56)
self.assertEqual(blotter.new_orders, [])
open_id = blotter.order(self.asset_24, 100, MarketOrder())
open_order = blotter.open_orders[self.asset_24][0]
self.assertEqual(open_order.id, open_id)
blotter.hold(open_id)
self.assertEqual(len(blotter.new_orders), 1)
self.assertEqual(len(blotter.open_orders[self.asset_24]), 1)
held_order = blotter.new_orders[0]
self.assertEqual(held_order.status, ORDER_STATUS.HELD)
self.assertEqual(held_order.reason, '')
blotter.cancel(held_order.id)
self.assertEqual(len(blotter.new_orders), 1)
self.assertEqual(len(blotter.open_orders[self.asset_24]), 0)
cancelled_order = blotter.new_orders[0]
self.assertEqual(cancelled_order.id, held_order.id)
self.assertEqual(cancelled_order.status, ORDER_STATUS.CANCELLED)
for data in ([100, self.sim_params.sessions[0]],
[400, self.sim_params.sessions[1]]):
# Verify that incoming fills will change the order status.
trade_amt = data[0]
dt = data[1]
order_size = 100
expected_filled = int(trade_amt *
DEFAULT_EQUITY_VOLUME_SLIPPAGE_BAR_LIMIT)
expected_open = order_size - expected_filled
expected_status = ORDER_STATUS.OPEN if expected_open else \
ORDER_STATUS.FILLED
blotter = SimulationBlotter(equity_slippage=VolumeShareSlippage())
open_id = blotter.order(self.asset_24, order_size, MarketOrder())
open_order = blotter.open_orders[self.asset_24][0]
self.assertEqual(open_id, open_order.id)
blotter.hold(open_id)
held_order = blotter.new_orders[0]
filled_order = None
blotter.current_dt = dt
bar_data = self.create_bardata(
simulation_dt_func=lambda: dt,
)
txns, _, _ = blotter.get_transactions(bar_data)
for txn in txns:
filled_order = blotter.orders[txn.order_id]
self.assertEqual(filled_order.id, held_order.id)
self.assertEqual(filled_order.status, expected_status)
self.assertEqual(filled_order.filled, expected_filled)
self.assertEqual(filled_order.open_amount, expected_open)
def test_order_rejection(self):
blotter = SimulationBlotter()
# Reject a nonexistent order -> no order appears in new_order,
# no exceptions raised out
blotter.reject(56)
assert blotter.new_orders == []
# Basic tests of open order behavior
open_order_id = blotter.order(self.asset_24, 100, MarketOrder())
second_order_id = blotter.order(self.asset_24, 50, MarketOrder())
assert len(blotter.open_orders[self.asset_24]) == 2
open_order = blotter.open_orders[self.asset_24][0]
assert open_order.status == ORDER_STATUS.OPEN
assert open_order.id == open_order_id
assert open_order in blotter.new_orders
# Reject that order immediately (same bar, i.e. still in new_orders)
blotter.reject(open_order_id)
assert len(blotter.new_orders) == 2
assert len(blotter.open_orders[self.asset_24]) == 1
still_open_order = blotter.new_orders[0]
assert still_open_order.id == second_order_id
assert still_open_order.status == ORDER_STATUS.OPEN
rejected_order = blotter.new_orders[1]
assert rejected_order.status == ORDER_STATUS.REJECTED
assert rejected_order.reason == ""
# Do it again, but reject it at a later time (after tradesimulation
# pulls it from new_orders)
blotter = SimulationBlotter()
new_open_id = blotter.order(self.asset_24, 10, MarketOrder())
new_open_order = blotter.open_orders[self.asset_24][0]
assert new_open_id == new_open_order.id
# Pretend that the trade simulation did this.
blotter.new_orders = []
rejection_reason = "Not enough cash on hand."
blotter.reject(new_open_id, reason=rejection_reason)
rejected_order = blotter.new_orders[0]
assert rejected_order.id == new_open_id
assert rejected_order.status == ORDER_STATUS.REJECTED
assert rejected_order.reason == rejection_reason
# You can't reject a filled order.
# Reset for paranoia
blotter = SimulationBlotter()
blotter.slippage_models[Equity] = FixedSlippage()
filled_id = blotter.order(self.asset_24, 100, MarketOrder())
filled_order = None
blotter.current_dt = self.sim_params.sessions[-1]
bar_data = self.create_bardata(
simulation_dt_func=lambda: self.sim_params.sessions[-1], )
txns, _, closed_orders = blotter.get_transactions(bar_data)
for txn in txns:
filled_order = blotter.orders[txn.order_id]
blotter.prune_orders(closed_orders)
assert filled_order.id == filled_id
assert filled_order in blotter.new_orders
assert filled_order.status == ORDER_STATUS.FILLED
assert filled_order not in blotter.open_orders[self.asset_24]
blotter.reject(filled_id)
updated_order = blotter.orders[filled_id]
assert updated_order.status == ORDER_STATUS.FILLED