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, [])