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 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_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 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 calculate_signals(self): # Compute the moving averages long_ma_len = 20 short_ma_len = 5 # Use data handler to download last 20 daily close prices and use them to compute the moving averages long_ma_series = self.data_handler.historical_price(self.ticker, PriceField.Close, long_ma_len) long_ma_price = long_ma_series.mean() short_ma_series = long_ma_series.tail(short_ma_len) short_ma_price = short_ma_series.mean() # Map the given ticker onto a Contract object, which can be further used to place an Order contract = self.contract_ticker_mapper.ticker_to_contract(self.ticker) if short_ma_price >= long_ma_price: # Place a buy Market Order, adjusting the position to a value equal to 100% of the portfolio orders = self.order_factory.target_percent_orders({contract: 1.0}, MarketOrder(), TimeInForce.DAY) else: orders = self.order_factory.target_percent_orders({contract: 0.0}, MarketOrder(), TimeInForce.DAY) # Cancel any open orders and place the newly created ones self.broker.cancel_all_open_orders() self.broker.place_orders(orders)
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_generate_close_orders__multiple_orders_close(self, future_ticker, order_factory, broker): """ There exist positions open in the portfolio for tickers, which belong to the same family as the future_ticker. Test if the order factory will be called with the necessary function and parameters to close the existing positions and if any errors have been logged (as the expiration dates did not occur, no logs should be generated). """ # Make the broker return positions with contracts_in_portfolio from the get_positions function tickers_in_portfolio = [BloombergTicker("CLG00 Comdty", SecurityType.FUTURE, 1), BloombergTicker("CLN00 Comdty", SecurityType.FUTURE, 1)] broker.get_positions.side_effect = lambda: [BacktestPositionFactory.create_position(t) for t in tickers_in_portfolio] # Set current ticker to be different then any ticker from expired_contracts future_ticker.get_current_specific_ticker.return_value = BloombergTicker("CLG01 Comdty", SecurityType.FUTURE, 1) future_ticker.get_expiration_dates.return_value = QFSeries(data=tickers_in_portfolio, index=[self.current_date - RelativeDelta(days=10), self.current_date + RelativeDelta(days=5)]) rolling_orders_generator = FuturesRollingOrdersGenerator([future_ticker], self.timer, broker, order_factory) rolling_orders_generator.logger = MagicMock() rolling_orders_generator.generate_close_orders() # The order factory should be called exactly once and in should contain all contracts from # contracts_in_portfolio order_factory.target_percent_orders.assert_called_once_with( {c: 0 for c in tickers_in_portfolio}, MarketOrder(), TimeInForce.GTC ) # The logger error function should be called only once, as only expiration date of one of the contracts in the # portfolio already passed rolling_orders_generator.logger.error.assert_called_once()
def _generate_market_order(self, contract: Contract, signal: Signal): assert is_finite_number( self._initial_risk), "Initial risk has to be a finite number" assert is_finite_number(signal.fraction_at_risk ), "fraction_at_risk has to be a finite number" target_percentage = self._initial_risk / signal.fraction_at_risk self.logger.info("Target Percentage: {}".format(target_percentage)) target_percentage = self._cap_max_target_percentage(target_percentage) target_percentage *= signal.suggested_exposure.value # preserve the direction (-1, 0 , 1) self.logger.info("Target Percentage considering direction: {}".format( target_percentage)) assert is_finite_number( target_percentage), "target_percentage has to be a finite number" market_order_list = self._order_factory.target_percent_orders( {contract: target_percentage}, MarketOrder(), TimeInForce.OPG) if len(market_order_list) == 0: return None assert len( market_order_list) == 1, "Only one order should be generated" return market_order_list[0]
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_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 test_generate_close_orders__current_ticker_in_portfolio(self, future_ticker, order_factory, broker): """ There exist positions open in the portfolio for tickers, which belong to the same family as the future_ticker and for the current ticker. Test if only the expired contracts will be closed. """ expired_contract = BloombergTicker("CLG00 Comdty", SecurityType.FUTURE, 1) # Set current ticker to be different then ticker corresponding to expired_contract current_contract = BloombergTicker("CLG01 Comdty", SecurityType.FUTURE, 1) future_ticker.get_current_specific_ticker.return_value = current_contract tickers_in_portfolio = [expired_contract, current_contract] broker.get_positions.side_effect = lambda: [BacktestPositionFactory.create_position(c) for c in tickers_in_portfolio] future_ticker.get_expiration_dates.return_value = QFSeries(data=tickers_in_portfolio, index=[self.current_date + RelativeDelta(days=1), self.current_date + RelativeDelta(days=5)]) rolling_orders_generator = FuturesRollingOrdersGenerator([future_ticker], self.timer, broker, order_factory) rolling_orders_generator.logger = MagicMock() rolling_orders_generator.generate_close_orders() # The order factory should be called exactly once and in should contain all contracts from # contracts_in_portfolio order_factory.target_percent_orders.assert_called_once_with( {expired_contract: 0}, MarketOrder(), TimeInForce.GTC ) # The logger error function should not have been called rolling_orders_generator.logger.error.assert_not_called()
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_generate_close_orders__multiple_future_tickers(self, future_ticker, order_factory, broker): tickers_in_portfolio = [BloombergTicker("CLG00 Comdty", SecurityType.FUTURE, 1), BloombergTicker("CLG01 Comdty", SecurityType.FUTURE, 1)] tickers_in_portfolio_2 = [BloombergTicker("CTG00 Comdty", SecurityType.FUTURE, 1), BloombergTicker("CTG01 Comdty", SecurityType.FUTURE, 1)] broker.get_positions.side_effect = lambda: [BacktestPositionFactory.create_position(c) for c in tickers_in_portfolio + tickers_in_portfolio_2] # Generate the FuturesRollingOrdersGenerator for two different Future Tickers future_ticker.get_current_specific_ticker.return_value = BloombergTicker("CLG01 Comdty", SecurityType.FUTURE, 1) future_ticker.belongs_to_family.side_effect = lambda t: t in tickers_in_portfolio future_ticker.get_expiration_dates.return_value = QFSeries(data=tickers_in_portfolio, index=[self.current_date - RelativeDelta(days=10), self.current_date + RelativeDelta(days=5)]) future_ticker2 = MagicMock() future_ticker2.get_current_specific_ticker.return_value = BloombergTicker("CTG01 Comdty") future_ticker2.belongs_to_family.side_effect = lambda t: t in tickers_in_portfolio_2 future_ticker2.get_expiration_dates.return_value = QFSeries(data=tickers_in_portfolio_2, index=[self.current_date - RelativeDelta(days=10), self.current_date + RelativeDelta(days=5)]) rolling_orders_generator = FuturesRollingOrdersGenerator([future_ticker, future_ticker2], self.timer, broker, order_factory) rolling_orders_generator.logger = MagicMock() rolling_orders_generator.generate_close_orders() order_factory.target_percent_orders.assert_called_once_with( {BloombergTicker("CLG00 Comdty", SecurityType.FUTURE, 1): 0, BloombergTicker("CTG00 Comdty", SecurityType.FUTURE, 1): 0}, MarketOrder(), TimeInForce.GTC )
def test_generate_close_orders__no_valid_ticker(self, future_ticker, order_factory, broker): """ There exist a position open in the portfolio for tickers, which belong to the same family as the future_ticker. Currently there is no valid ticker for the FutureTicker, which means the contract corresponding to the open position expired and the position should be closed. """ contract_in_portfolio = Contract("CLG00 Comdty", "FUT", "SIM_EXCHANGE") broker.get_positions.return_value = [ BacktestPositionFactory.create_position(contract_in_portfolio) ] # No valid ticker currently exists for the future ticker future_ticker.get_current_specific_ticker.side_effect = NoValidTickerException( ) future_ticker.belongs_to_family.return_value = True future_ticker.get_expiration_dates.return_value = QFSeries( data=[BloombergTicker("CLG00 Comdty")], index=[self.current_date - RelativeDelta(days=10)]) rolling_orders_generator = FuturesRollingOrdersGenerator( [future_ticker], self.timer, broker, order_factory, self.contract_ticker_mapper) rolling_orders_generator.generate_close_orders() # The order factory should be called exactly once and in should contain all contracts from # contracts_in_portfolio order_factory.target_percent_orders.assert_called_once_with( {contract_in_portfolio: 0}, MarketOrder(), TimeInForce.GTC)
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 calculate_signals(self): if not self.invested: orders = self.order_factory.percent_orders({self.CONTRACT: 1.0}, MarketOrder(), TimeInForce.GTC) self.broker.place_orders(orders) self.invested = True
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 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 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 calculate_signals(self): long_ma_len = 20 short_ma_len = 5 long_ma_series = self.data_handler.historical_price(self.ticker, PriceField.Close, long_ma_len) long_ma_price = long_ma_series.mean() short_ma_series = long_ma_series.tail(short_ma_len) short_ma_price = short_ma_series.mean() contract = self.contract_ticker_mapper.ticker_to_contract(self.ticker) if short_ma_price >= long_ma_price: orders = self.order_factory.target_percent_orders({contract: 1.0}, MarketOrder(), TimeInForce.GTC) else: orders = self.order_factory.target_percent_orders({contract: 0.0}, MarketOrder(), TimeInForce.GTC) self.broker.cancel_all_open_orders() self.broker.place_orders(orders)
def test_order_target_tolerance2(self): # there already are 10 shares quantity = 12 execution_style = MarketOrder() time_in_force = TimeInForce.DAY tolerance = {self.contract: 2} # tolerance is 2 and the difference is 2 -> we should not trade orders = self.order_factory.target_orders({self.contract: quantity}, execution_style, time_in_force, tolerance) self.assertEqual(orders, [])
def test_order_target_percent_tolerance3(self): # there are 10 shares price per share is 10 so position value is 100 ex_style = MarketOrder() tif = TimeInForce.DAY tolerance_percentage = 1 / 9 target_value = 0.09 orders = self.order_factory.target_percent_orders( {self.ticker: target_value}, ex_style, tif, tolerance_percentage) self.assertEqual(orders, [])
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 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() self.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, self.timer, self.scheduler, self.spied_monitor, self.commission_model, self.contracts_to_tickers_mapper, self.portfolio, slippage_model) self._set_last_msft_price(100.0) self.order_1 = Order(self.msft_contract, quantity=10, execution_style=MarketOrder(), time_in_force=TimeInForce.OPG) self.order_2 = Order(self.msft_contract, quantity=-5, execution_style=MarketOrder(), time_in_force=TimeInForce.OPG) self.order_3 = Order(self.msft_contract, quantity=-7, execution_style=MarketOrder(), time_in_force=TimeInForce.OPG) self.order_4 = Order(self.msft_contract, quantity=4, execution_style=MarketOnCloseOrder(), time_in_force=TimeInForce.DAY)
def test_order_target_percent_tolerance3(self): # there are 10 shares price per share is 10 so position value is 100, it corresponds to 10% of portfolio ex_style = MarketOrder() tif = TimeInForce.DAY tolerance = 0.01 target_value = 0.09 orders = self.order_factory.target_percent_orders( {self.contract: target_value}, ex_style, tif, tolerance) self.assertEqual(orders, [])
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 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))
def test_order_target_value_tolerance9(self): # there already are 10 shares price per share is 10 so position value is 100 execution_style = MarketOrder() tif = TimeInForce.DAY target_value = 9.0 tolerance_percentage = 1 / 9 orders = self.order_factory.target_value_orders({self.contract: target_value}, execution_style, tif, tolerance_percentage) quantity = -10 self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, tif))
def test_order_target_tolerance3a(self): # there already are 10 shares quantity = 150 execution_style = MarketOrder() time_in_force = TimeInForce.DAY tolerance = {self.contract: 139} # tolerance is 139 and the difference is 140 -> we should buy new shares orders = self.order_factory.target_orders({self.contract: quantity}, execution_style, time_in_force, tolerance) trade_quantity = 140 self.assertEqual(orders[0], Order(self.contract, trade_quantity, execution_style, time_in_force))
def test_order_target_value_tolerance5(self): # there already are 10 shares price per share is 10 so position value is 100 execution_style = MarketOrder() tif = TimeInForce.DAY tolerance = 10.0 target_value = 90.1 # tolerance is 10.0$ and the difference is 9.9$ -> we should not trade orders = self.order_factory.target_value_orders( {self.contract: target_value}, execution_style, tif, tolerance) self.assertEqual(orders, [])