def setUp(self): msft_ticker = BloombergTicker("MSFT US Equity") aapl_ticker = BloombergTicker("AAPL US Equity") googl_ticker = BloombergTicker("GOOGL US Equity") self.tickers = [msft_ticker, aapl_ticker, googl_ticker] self.data_provider = self._create_data_provider_mock() self.orders = [ Order( ticker=msft_ticker, quantity=1250, execution_style=MarketOrder(), time_in_force=TimeInForce.GTC ), Order( ticker=aapl_ticker, quantity=-200, execution_style=MarketOrder(), time_in_force=TimeInForce.GTC ), Order( ticker=googl_ticker, quantity=1, execution_style=MarketOrder(), time_in_force=TimeInForce.GTC ) ] self.market_on_close_order = [Order( ticker=msft_ticker, quantity=1250, execution_style=MarketOnCloseOrder(), time_in_force=TimeInForce.GTC )]
def setUp(self): msft_ticker = BloombergTicker("MSFT US Equity") aapl_ticker = BloombergTicker("AAPL US Equity") googl_ticker = BloombergTicker("GOOGL US Equity") self.tickers = [msft_ticker, aapl_ticker, googl_ticker] self.data_handler = self._create_data_handler_mock() self.contract_ticker_mapper = DummyBloombergContractTickerMapper() self.orders = [ Order(contract=self.contract_ticker_mapper.ticker_to_contract( msft_ticker), quantity=1000, execution_style=MarketOrder(), time_in_force=TimeInForce.GTC), Order(contract=self.contract_ticker_mapper.ticker_to_contract( aapl_ticker), quantity=-10, execution_style=MarketOrder(), time_in_force=TimeInForce.GTC), Order(contract=self.contract_ticker_mapper.ticker_to_contract( googl_ticker), quantity=1, execution_style=MarketOrder(), time_in_force=TimeInForce.GTC) ] self.prices_without_slippage = [1.0, 100.0, 1000.0]
def test_volume_orders_filter__adjust_buy_stop_orders(self): """ Test if StopOrders are adjusted in a correct way. Suppose, the StopOrder quantity will be much bigger than the current MarketOrder, because the position for the contract already existed for some time, e.g. - there exists an open LONG position of size 100 - the position needs to be adjusted to 200 - a new MarketOrder of size 100 is created - a new StopOrder of size -200 is created - the volume percentage limit limits the MarketOrder to 15% of avg daily volume (set to volume_value = 100) - then the StopOrder needs to be adjusted to -115 """ volume_percentage_limit = 0.15 volume_value = 100.0 data_handler = self._setup_data_handler(volume_value) volume_orders_verifier = VolumeOrdersFilter( data_handler, self.contract_ticker_mapper, volume_percentage_limit) # Initialize a list of orders, which do not exceed the maximum volume limit contract = self.contract_ticker_mapper.ticker_to_contract(self.ticker) buy_order = [ Order(contract, 100, MarketOrder(), TimeInForce.GTC), Order(contract, -200, StopOrder(1.0), TimeInForce.GTC) ] new_orders = volume_orders_verifier.adjust_orders(buy_order) expected_buy_order = [ Order(contract, 15, MarketOrder(), TimeInForce.GTC), Order(contract, -115, StopOrder(1.0), TimeInForce.GTC) ] self.assertCountEqual(new_orders, expected_buy_order)
def test_initial_risk_position_sizer_without_cap(self): """ Max leverage will not be limited by position sizer """ fraction_at_risk = 0.23 signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk, self.last_price) orders = self.initial_risk_position_sizer.size_signals([signal]) self.assertEqual(len(orders), 2) # market order and stop order portfolio_value = self.initial_position / self.initial_allocation target_quantity = int( np.floor(portfolio_value * self.initial_risk / fraction_at_risk)) additional_contracts = target_quantity - self.initial_position self.assertEqual( orders[0], Order(self.contract, additional_contracts, MarketOrder(), TimeInForce.OPG)) stop_price = self.last_price * (1 - fraction_at_risk) stop_quantity = -(self.initial_position + additional_contracts) self.assertEqual( orders[1], Order(self.contract, stop_quantity, StopOrder(stop_price), TimeInForce.GTC))
def test_volume_orders_filter__adjust_sell_stop_orders(self): """ Test if StopOrders are adjusted in a correct way. The MarketOrder corresponding to StopOrder is a sell order. """ volume_percentage_limit = 0.15 volume_value = 100.0 data_handler = self._setup_data_handler(volume_value) volume_orders_verifier = VolumeOrdersFilter( data_handler, self.contract_ticker_mapper, volume_percentage_limit) # Initialize a list of orders, which do not exceed the maximum volume limit contract = self.contract_ticker_mapper.ticker_to_contract(self.ticker) sell_order = [ Order(contract, -100, MarketOrder(), TimeInForce.GTC), Order(contract, 200, StopOrder(1.0), TimeInForce.GTC) ] new_orders = volume_orders_verifier.adjust_orders(sell_order) expected_sell_order = [ Order(contract, -15, MarketOrder(), TimeInForce.GTC), Order(contract, 115, StopOrder(1.0), TimeInForce.GTC) ] self.assertCountEqual(new_orders, expected_sell_order)
def test_initial_risk_position_sizer_with_cap(self): """ Max leverage will be limited by position sizer to 1.5 """ fraction_at_risk = 0.01 # will give leverage of 2, that will be capped to 1.5 signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk, self.last_price, self.timer.now()) orders = self.initial_risk_position_sizer.size_signals([signal]) self.assertEqual(len(orders), 2) # market order and stop order portfolio_value = self.initial_position / self.initial_allocation max_leverage = self.initial_risk_position_sizer.max_target_percentage target_quantity = int(np.floor(portfolio_value * max_leverage)) additional_contracts = target_quantity - self.initial_position self.assertEqual( orders[0], Order(self.ticker, additional_contracts, MarketOrder(), TimeInForce.OPG)) stop_price = self.last_price * (1 - fraction_at_risk) stop_quantity = -(self.initial_position + additional_contracts) self.assertEqual( orders[1], Order(self.ticker, stop_quantity, StopOrder(stop_price), TimeInForce.GTC))
def openOrder(self, orderId: OrderId, ib_contract: Contract, ib_order: IBOrder, orderState: OrderState): super().openOrder(orderId, ib_contract, ib_order, orderState) if ib_order.orderType.upper() == 'STP': execution_style = StopOrder(ib_order.auxPrice) elif ib_order.orderType.upper() == 'MKT': execution_style = MarketOrder() else: error_message = "Order Type is not supported: {}".format( ib_order.orderType) self.logger.error(error_message) raise ValueError(error_message) if ib_order.action.upper() == 'SELL': quantity = -ib_order.totalQuantity elif ib_order.action.upper() == 'BUY': quantity = ib_order.totalQuantity else: error_message = "Order Action is not supported: {}".format( ib_order.action) self.logger.error(error_message) raise ValueError(error_message) if ib_order.tif.upper() == 'DAY': time_in_force = TimeInForce.DAY elif ib_order.tif.upper() == 'GTC': time_in_force = TimeInForce.GTC elif ib_order.tif.upper() == 'OPG': time_in_force = TimeInForce.OPG else: error_message = "Time in Force is not supported: {}".format( ib_order.tif) self.logger.error(error_message) raise ValueError(error_message) try: ticker = self.contract_ticker_mapper.contract_to_ticker( IBContract.from_ib_contract(ib_contract)) order = Order(ticker=ticker, quantity=quantity, execution_style=execution_style, time_in_force=time_in_force, order_state=orderState.status) order.id = int(orderId) self.order_list.append(order) except ValueError as e: self.logger.error( f"Open Order for contract {ib_contract} will be skipped due to the following error " f"during parsing: \n{e}")
def test_volume_orders_filter__no_volume_data(self): """Tests if VolumeOrdersVerifier does not change orders, which do not have the volume data.""" # Setup DataHandler and VolumeOrdersVerifier volume_percentage_limit = 0.15 volume_value = None data_handler = self._setup_data_handler(volume_value) volume_orders_verifier = VolumeOrdersFilter(data_handler, volume_percentage_limit) # Initialize a list of orders, which do not exceed the maximum volume limit orders = [Order(self.ticker, 100, MarketOrder(), TimeInForce.GTC), Order(self.ticker, 200, MarketOrder(), TimeInForce.GTC), Order(self.ticker, -300, MarketOrder(), TimeInForce.GTC)] new_orders = volume_orders_verifier.adjust_orders(orders) self.assertCountEqual(orders, new_orders)
def test_order_target_percent(self): quantity = 40 execution_style = StopOrder(4.20) time_in_force = TimeInForce.GTC orders = self.order_factory.target_percent_orders({self.contract: 0.5}, execution_style, time_in_force) self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, time_in_force))
def test_order_target_value(self): execution_style = StopOrder(4.20) time_in_force = TimeInForce.GTC quantity = 4 orders = self.order_factory.target_value_orders({self.contract: 140.0}, execution_style, time_in_force) self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, time_in_force))
def test_order(self): quantity = 5 execution_style = MarketOrder() time_in_force = TimeInForce.GTC orders = self.order_factory.orders({self.contract: quantity}, execution_style, time_in_force) self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, time_in_force))
def test_market_opens_at_much_higher_price_than_it_closed_at_yesterday( self): self.buy_stop_loss_order = Order(self.msft_contract, quantity=1, execution_style=StopOrder(120.0), time_in_force=TimeInForce.GTC) self.exec_hanlder.accept_orders([self.buy_stop_loss_order]) self._set_bar_for_today(open=120.0, high=130.0, low=68.0, close=90.0, volume=100000000.0) self.exec_hanlder.on_market_close(...) assert_lists_equal([], self.exec_hanlder.get_open_orders()) verify(self.spied_monitor, times=3).record_transaction(...) verify(self.portfolio, times=3).transact_transaction(...) self.assertEqual(3, len(self.monitor.transactions)) actual_transaction_3 = self.monitor.transactions[2] self.assertEqual(self.msft_contract, actual_transaction_3.contract) self.assertEqual(1, actual_transaction_3.quantity) self.assertEqual(120.0, actual_transaction_3.price) self.assertEqual(0.0, actual_transaction_3.commission)
def test_market_opens_at_much_higher_price_than_it_closed_at_yesterday( self): self.buy_stop_loss_order = Order(self.msft_contract, quantity=1, execution_style=StopOrder(120.0), time_in_force=TimeInForce.GTC) self.exec_handler.assign_order_ids([self.buy_stop_loss_order]) self._set_bar_for_today(open_price=120.0, high_price=130.0, low_price=68.0, close_price=90.0, volume=100000000.0) self._trigger_single_time_event() self.exec_handler.on_market_close(...) assert_lists_equal([], self.exec_handler.get_open_orders()) expected_transactions = [ Transaction(self.timer.now(), self.msft_contract, -1, self.stop_loss_order_1.execution_style.stop_price, 0), Transaction(self.timer.now(), self.msft_contract, -1, self.stop_loss_order_2.execution_style.stop_price, 0), Transaction(self.timer.now(), self.msft_contract, 1, 120, 0), ] self.monitor.record_transaction.assert_has_calls( call(t) for t in expected_transactions) self.portfolio.transact_transaction.assert_has_calls( call(t) for t in expected_transactions) self.assertEqual(self.monitor.record_transaction.call_count, 3) self.assertEqual(self.portfolio.transact_transaction.call_count, 3)
def test_volume_orders_filter__no_resize_orders(self): """Tests if VolumeOrdersVerifier does not change orders, which do not exceed the limit.""" # Setup DataHandler and VolumeOrdersVerifier volume_percentage_limit = 0.15 volume_value = 100.0 data_handler = self._setup_data_handler(volume_value) volume_orders_verifier = VolumeOrdersFilter(data_handler, volume_percentage_limit) # Initialize a list of orders, which do not exceed the maximum volume limit max_quantity = int(volume_percentage_limit * volume_value) orders = [Order(self.ticker, max_quantity, MarketOrder(), TimeInForce.GTC), Order(self.ticker, -max_quantity // 2, MarketOrder(), TimeInForce.GTC), Order(self.ticker, max_quantity // 3, MarketOrder(), TimeInForce.GTC)] new_orders = volume_orders_verifier.adjust_orders(orders) self.assertCountEqual(orders, new_orders)
def orders(self, quantities: Mapping[Ticker, int], execution_style: ExecutionStyle, time_in_force: TimeInForce) -> List[Order]: """ Creates a list of Orders for given numbers of shares for each given asset. Orders requiring 0 shares will be removed from resulting order list Parameters ---------- quantities: Mapping[Ticker, int] mapping of a Ticker to an amount of shares which should be bought/sold. If number is positive then asset will be bought. Otherwise it will be sold. execution_style: ExecutionStyle execution style of an order (e.g. MarketOrder, StopOrder, etc.) time_in_force: TimeInForce e.g. 'DAY' (Order valid for one trading session), 'GTC' (good till cancelled) Returns -------- List[Order] list of generated orders """ self._log_function_call(vars()) self._check_tickers_type(list(quantities.keys())) return [ Order(ticker, quantity, execution_style, time_in_force) for ticker, quantity in quantities.items() if quantity != 0 ]
def orders(self, quantities: Mapping[Contract, int], execution_style: ExecutionStyle, time_in_force: TimeInForce) -> List[Order]: """ Creates a list of Orders for given numbers of shares for each given asset. Orders requiring 0 shares will be removed from resulting order list Parameters ---------- quantities mapping of a Contract to an amount of shares which should be bought/sold. If number is positive then asset will be bought. Otherwise it will be sold. execution_style execution style of an order (e.g. MarketOrder, StopOrder, etc.) time_in_force e.g. 'DAY' (Order valid for one trading session), 'GTC' (good till cancelled) """ self._log_function_call(vars()) order_list = [] for contract, quantity in quantities.items(): if quantity != 0: order_list.append( Order(contract, quantity, execution_style, time_in_force)) return order_list
def _adjust_quantity(self, order: Order, stop_order: Optional[Order], volume_df: QFDataFrame) -> \ Tuple[Order, Order]: """Returns order with adjusted quantity if applicable.""" ticker = self._contract_ticker_mapper.contract_to_ticker(order.contract) def average_past_volume(ticker: Ticker) -> Optional[float]: volume_series = volume_df[ticker] volume_series = volume_series.dropna() volume_series = volume_series[volume_series >= 0] return volume_series.mean() past_volume = average_past_volume(ticker) if is_finite_number(past_volume): volume_limit: int = math.floor(past_volume * self._volume_percentage_limit) # Check if the order quantity exceeds the limit if abs(order.quantity) > volume_limit: final_quantity = volume_limit * np.sign(order.quantity) adjustment_difference = final_quantity - order.quantity self.logger.info("{} VolumeOrdersFilter: Quantity change {} " "\n\tfinal quantity: {}".format(self._data_handler.timer.now(), order, final_quantity)) order.quantity = final_quantity if stop_order: # Adjust the corresponding stop order stop_order_final_quantity = stop_order.quantity - adjustment_difference self.logger.info("{} VolumeOrdersFilter: Quantity change {} " "\n\tfinal quantity: {}".format(self._data_handler.timer.now(), stop_order, final_quantity)) stop_order.quantity = stop_order_final_quantity return order, stop_order
def setUpClass(cls) -> None: cls.contract_ticker_mapper = SimulatedBloombergContractTickerMapper() cls.example_ticker = BloombergTicker("Example Index") cls.example_ticker_2 = BloombergTicker("Example2 Index") cls.orders = [ Order(contract=cls.contract_ticker_mapper.ticker_to_contract( cls.example_ticker), quantity=1000, execution_style=MarketOrder(), time_in_force=TimeInForce.GTC), Order(contract=cls.contract_ticker_mapper.ticker_to_contract( cls.example_ticker_2), quantity=1000, execution_style=MarketOrder(), time_in_force=TimeInForce.GTC), ] cls.backtest_date = str_to_date("2020-01-01")
def setUp(self): self.scheduling_time_delay = 1 start_date = str_to_date("2018-02-04") before_close = start_date + MarketCloseEvent.trigger_time( ) - RelativeDelta(minutes=self.scheduling_time_delay) self.timer = SettableTimer(initial_time=before_close) contracts_to_tickers_mapper = SimulatedBloombergContractTickerMapper() msft_contract = Contract("MSFT US Equity", security_type='STK', exchange='TEST') self.msft_ticker = contracts_to_tickers_mapper.contract_to_ticker( msft_contract) self.data_handler = Mock(spec=DataHandler) self.scheduler = Mock(spec=Scheduler) self.commission_model = FixedCommissionModel(commission=0.0) self.monitor = Mock(spec=AbstractMonitor) self.portfolio = Mock(spec=Portfolio) slippage_model = PriceBasedSlippage(0.0, self.data_handler, contracts_to_tickers_mapper) self.exec_handler = SimulatedExecutionHandler( self.data_handler, self.timer, self.scheduler, self.monitor, self.commission_model, contracts_to_tickers_mapper, self.portfolio, slippage_model, RelativeDelta(minutes=self.scheduling_time_delay)) self.order_1 = Order(msft_contract, quantity=10, execution_style=MarketOrder(), time_in_force=TimeInForce.OPG) self.order_2 = Order(msft_contract, quantity=-5, execution_style=MarketOrder(), time_in_force=TimeInForce.OPG) self.order_3 = Order(msft_contract, quantity=-7, execution_style=MarketOrder(), time_in_force=TimeInForce.OPG) self.order_4 = Order(msft_contract, quantity=4, execution_style=MarketOnCloseOrder(), time_in_force=TimeInForce.DAY)
def test_order_value(self): value = 100.0 quantity = floor(100.0 / self.share_price) # type: int execution_style = StopOrder(4.20) time_in_force = TimeInForce.DAY orders = self.order_factory.value_orders({self.contract: value}, execution_style, time_in_force) self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, time_in_force))
def test_order_percent(self): percentage = 0.5 execution_style = StopOrder(4.20) time_in_force = TimeInForce.GTC quantity = floor(percentage * self.current_portfolio_value / self.share_price) # type: int orders = self.order_factory.percent_orders({self.contract: percentage}, execution_style, time_in_force) self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, time_in_force))
def openOrder(self, orderId: OrderId, ib_contract: IBContract, ib_order: IBOrder, orderState: OrderState): contract = Contract(ib_contract.symbol, ib_contract.secType, ib_contract.exchange) if ib_order.orderType.upper() == 'STP': execution_style = StopOrder(ib_order.auxPrice) elif ib_order.orderType.upper() == 'MKT': execution_style = MarketOrder() else: error_message = "Order Type is not supported: {}".format( ib_order.orderType) self.logger.error(error_message) raise ValueError(error_message) if ib_order.action.upper() == 'SELL': quantity = -ib_order.totalQuantity elif ib_order.action.upper() == 'BUY': quantity = ib_order.totalQuantity else: error_message = "Order Action is not supported: {}".format( ib_order.action) self.logger.error(error_message) raise ValueError(error_message) if ib_order.tif.upper() == 'DAY': time_in_force = TimeInForce.DAY elif ib_order.tif.upper() == 'GTC': time_in_force = TimeInForce.GTC elif ib_order.tif.upper() == 'OPG': time_in_force = TimeInForce.OPG else: error_message = "Time in Force is not supported: {}".format( ib_order.tif) self.logger.error(error_message) raise ValueError(error_message) order = Order(contract=contract, quantity=quantity, execution_style=execution_style, time_in_force=time_in_force, order_state=orderState.status) order.id = int(orderId) self.order_list.append(order)
def test_simple_position_sizer(self): fraction_at_risk = 0.02 signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk) orders = self.simple_position_sizer.size_signals([signal]) quantity = np.floor(self.initial_position * (1 / self.initial_allocation - 1)) self.assertEqual(len(orders), 2) # market order and stop order self.assertEqual( orders[0], Order(self.contract, quantity, MarketOrder(), TimeInForce.OPG)) stop_price = self.last_price * (1 - fraction_at_risk) stop_quantity = -(self.initial_position + quantity) self.assertEqual( orders[1], Order(self.contract, stop_quantity, StopOrder(stop_price), TimeInForce.GTC))
def test_out_signal(self): fraction_at_risk = 0.02 signal = Signal(self.ticker, Exposure.OUT, fraction_at_risk) orders = self.simple_position_sizer.size_signals([signal]) self.assertEqual(len(orders), 1) # market order only self.assertEqual( orders[0], Order(self.contract, -200, MarketOrder(), TimeInForce.OPG))
def setUp(self): self.start_date = str_to_date("2018-02-04") self.msft_contract = Contract(self.MSFT_TICKER_STR, security_type='SEK', exchange='TEST') self.msft_ticker = BloombergTicker(self.MSFT_TICKER_STR) self.contracts_to_tickers_mapper = DummyBloombergContractTickerMapper() timer = SettableTimer(initial_time=self.start_date) self.data_handler = mock(strict=True) self.scheduler = mock() self.commission_model = FixedCommissionModel(commission=0.0) self.monitor = _MonitorMock() self.spied_monitor = spy(self.monitor) self.portfolio = mock() slippage_model = PriceBasedSlippage(0.0) self.exec_hanlder = SimulatedExecutionHandler( self.data_handler, timer, self.scheduler, self.spied_monitor, self.commission_model, self.contracts_to_tickers_mapper, self.portfolio, slippage_model) self._set_current_msft_price(100.0) self.stop_loss_order_1 = Order(self.msft_contract, quantity=-1, execution_style=StopOrder(95.0), time_in_force=TimeInForce.GTC) self.stop_loss_order_2 = Order(self.msft_contract, quantity=-1, execution_style=StopOrder(90.0), time_in_force=TimeInForce.GTC) self.stop_loss_order_3 = Order(self.msft_contract, quantity=-1, execution_style=StopOrder(50.0), time_in_force=TimeInForce.DAY) self.exec_hanlder.accept_orders([ self.stop_loss_order_1, self.stop_loss_order_2, self.stop_loss_order_3 ])
def setUp(self): self.scheduling_time_delay = 1 start_date = str_to_date("2018-02-04") before_close = start_date + MarketCloseEvent.trigger_time( ) - RelativeDelta(minutes=self.scheduling_time_delay) self.timer = SettableTimer(initial_time=before_close) self.msft_ticker = BloombergTicker("MSFT US Equity") self.data_handler = Mock(spec=DataHandler) self.data_handler.frequency = Frequency.DAILY self.data_handler.data_provider = Mock(spec=DataProvider) self.scheduler = Mock(spec=Scheduler) self.commission_model = FixedCommissionModel(commission=0.0) self.monitor = Mock(spec=AbstractMonitor) self.portfolio = Mock(spec=Portfolio) slippage_model = PriceBasedSlippage(0.0, self.data_handler) self.exec_handler = SimulatedExecutionHandler( self.data_handler, self.timer, self.scheduler, self.monitor, self.commission_model, self.portfolio, slippage_model, RelativeDelta(minutes=self.scheduling_time_delay)) self.order_1 = Order(self.msft_ticker, quantity=10, execution_style=MarketOrder(), time_in_force=TimeInForce.OPG) self.order_2 = Order(self.msft_ticker, quantity=-5, execution_style=MarketOrder(), time_in_force=TimeInForce.OPG) self.order_3 = Order(self.msft_ticker, quantity=-7, execution_style=MarketOrder(), time_in_force=TimeInForce.OPG) self.order_4 = Order(self.msft_ticker, quantity=4, execution_style=MarketOnCloseOrder(), time_in_force=TimeInForce.DAY)
def test_order_target_percent_tolerance6(self): # there are 10 shares price per share is 10 so position value is 100 ex_style = MarketOrder() tif = TimeInForce.DAY tolerance_percentage = 2 / 50 target_value = 0.5 orders = self.order_factory.target_percent_orders({self.contract: target_value}, ex_style, tif, tolerance_percentage) quantity = 40 self.assertEqual(orders[0], Order(self.contract, quantity, ex_style, tif))
def orders( self, quantities: Mapping[Contract, int], execution_style: ExecutionStyle, time_in_force: TimeInForce = TimeInForce.DAY) -> Sequence[Order]: order_list = [] for contract, quantity in quantities.items(): if quantity != 0: order_list.append( Order(contract, quantity, execution_style, time_in_force)) return order_list
def test_order_target(self): quantity = -5 execution_style = StopOrder(4.20) time_in_force = TimeInForce.DAY orders = self.order_factory.target_orders({self.ticker: 5}, execution_style, time_in_force) self.assertEqual( orders[0], Order(self.ticker, quantity, execution_style, time_in_force))
def test_volume_orders_filter__resize_orders(self): """Tests VolumeOrdersVerifier with orders exceeding the limit.""" # Setup DataHandler and VolumeOrdersVerifier volume_percentage_limit = 0.15 volume_value = 100.0 data_handler = self._setup_data_handler(volume_value) volume_orders_verifier = VolumeOrdersFilter(data_handler, volume_percentage_limit) # Initialize a list of orders, which exceed the maximum volume limit buy_orders = [Order(self.ticker, 100, MarketOrder(), TimeInForce.GTC)] sell_orders = [Order(self.ticker, 100, MarketOrder(), TimeInForce.GTC)] new_buy_orders = volume_orders_verifier.adjust_orders(buy_orders) new_sell_orders = volume_orders_verifier.adjust_orders(sell_orders) self.assertEqual(len(new_buy_orders), len(buy_orders)) self.assertEqual(len(new_sell_orders), len(sell_orders)) for order in new_buy_orders + new_sell_orders: self.assertLessEqual(abs(order.quantity), abs(volume_value * volume_percentage_limit))