async def test_split_create_new_order():
config, exchange, trader, symbol = await _get_tools()
portfolio = trader.get_portfolio()
order_creator = DailyTradingModeCreator(None)
last_btc_price = 6943.01
market_status = exchange.get_market_status(symbol)
trader.portfolio.portfolio["BTC"] = {
Portfolio.TOTAL: 2000000001,
Portfolio.AVAILABLE: 2000000001
}
# split orders because order too big and coin price too high
orders = await order_creator.create_new_order(0.6, symbol, exchange,
trader, portfolio,
EvaluatorStates.SHORT)
assert len(orders) == 11
adapted_order = orders[0]
identical_orders = orders[1:]
assert isinstance(adapted_order, SellLimitOrder)
assert adapted_order.currency == "BTC"
assert adapted_order.symbol == "BTC/USDT"
assert adapted_order.origin_price == 6998.55407999
assert adapted_order.created_last_price == last_btc_price
assert adapted_order.order_type == TraderOrderType.SELL_LIMIT
assert adapted_order.side == TradeOrderSide.SELL
assert adapted_order.status == OrderStatus.OPEN
assert adapted_order.exchange == exchange
assert adapted_order.trader == trader
assert adapted_order.fee is None
assert adapted_order.market_total_fees == 0
assert adapted_order.filled_price == 0
assert adapted_order.origin_quantity == 51133425.486746
assert adapted_order.filled_quantity == adapted_order.origin_quantity
assert adapted_order.is_simulated is True
assert adapted_order.linked_to is None
check_order_limits(adapted_order, market_status)
assert len(adapted_order.linked_orders) == 1
check_linked_order(adapted_order, adapted_order.linked_orders[0],
TraderOrderType.STOP_LOSS, 6595.8595, market_status)
for order in identical_orders:
assert isinstance(order, SellLimitOrder)
assert order.currency == adapted_order.currency
assert order.symbol == adapted_order.symbol
assert order.origin_price == adapted_order.origin_price
assert order.created_last_price == adapted_order.created_last_price
assert order.order_type == adapted_order.order_type
assert order.side == adapted_order.side
assert order.status == adapted_order.status
assert order.exchange == adapted_order.exchange
assert order.trader == adapted_order.trader
assert order.fee == adapted_order.fee
assert order.market_total_fees == adapted_order.market_total_fees
assert order.filled_price == adapted_order.filled_price
assert order.origin_quantity == 142886657.52532542
assert order.origin_quantity > adapted_order.origin_quantity
assert order.filled_quantity > adapted_order.filled_quantity
assert order.is_simulated == adapted_order.is_simulated
assert order.linked_to == adapted_order.linked_to
assert len(order.linked_orders) == 1
check_order_limits(order, market_status)
check_linked_order(order, order.linked_orders[0],
TraderOrderType.STOP_LOSS, 6595.8595, market_status)
trader.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 20000000000,
Portfolio.AVAILABLE: 20000000000
}
# set btc last price to 6998.55407999 * 0.000001 = 0.00699855408
exchange.get_exchange().set_recent_trades_multiplier_factor(0.000001)
# split orders because order too big and too many coins
orders = await order_creator.create_new_order(-0.6, symbol, exchange,
trader, portfolio,
EvaluatorStates.LONG)
assert len(orders) == 3
adapted_order = orders[0]
identical_orders = orders[1:]
assert isinstance(adapted_order, BuyLimitOrder)
assert adapted_order.currency == "BTC"
assert adapted_order.symbol == "BTC/USDT"
assert adapted_order.origin_price == 0.00688746
assert adapted_order.created_last_price == 0.0069430099999999995
assert adapted_order.order_type == TraderOrderType.BUY_LIMIT
assert adapted_order.side == TradeOrderSide.BUY
assert adapted_order.status == OrderStatus.OPEN
assert adapted_order.exchange == exchange
assert adapted_order.trader == trader
assert adapted_order.fee is None
assert adapted_order.market_total_fees == 0
assert adapted_order.filled_price == 0
assert adapted_order.origin_quantity == 131640311622.76904
assert adapted_order.filled_quantity == adapted_order.origin_quantity
assert adapted_order.is_simulated is True
assert adapted_order.linked_to is None
check_order_limits(adapted_order, market_status)
# assert len(order.linked_orders) == 1 # check linked orders when it will be developed
for order in identical_orders:
assert isinstance(order, BuyLimitOrder)
assert order.currency == adapted_order.currency
assert order.symbol == adapted_order.symbol
assert order.origin_price == adapted_order.origin_price
assert order.created_last_price == adapted_order.created_last_price
assert order.order_type == adapted_order.order_type
assert order.side == adapted_order.side
assert order.status == adapted_order.status
assert order.exchange == adapted_order.exchange
assert order.trader == adapted_order.trader
assert order.fee == adapted_order.fee
assert order.market_total_fees == adapted_order.market_total_fees
assert order.filled_price == adapted_order.filled_price
assert order.origin_quantity == 1000000000000.0
assert order.origin_quantity > adapted_order.origin_quantity
assert order.filled_quantity > adapted_order.filled_quantity
assert order.is_simulated == adapted_order.is_simulated
assert order.linked_to == adapted_order.linked_to
check_order_limits(order, market_status)
async def test_valid_create_new_order():
config, exchange, trader, symbol = await _get_tools()
portfolio = trader.get_portfolio()
order_creator = DailyTradingModeCreator(None)
market_status = exchange.get_market_status(symbol)
# portfolio: "BTC": 10 "USD": 1000
last_btc_price = 6943.01
# order from neutral state
assert await order_creator.create_new_order(-1, symbol, exchange, trader, portfolio, EvaluatorStates.NEUTRAL) \
is None
assert await order_creator.create_new_order(0.5, symbol, exchange, trader, portfolio, EvaluatorStates.NEUTRAL) \
is None
assert await order_creator.create_new_order(0, symbol, exchange, trader, portfolio, EvaluatorStates.NEUTRAL) \
is None
assert await order_creator.create_new_order(-0.5, symbol, exchange, trader, portfolio, EvaluatorStates.NEUTRAL) \
is None
assert await order_creator.create_new_order(-1, symbol, exchange, trader, portfolio, EvaluatorStates.NEUTRAL) \
is None
# valid sell limit order (price adapted)
orders = await order_creator.create_new_order(0.65, symbol, exchange,
trader, portfolio,
EvaluatorStates.SHORT)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, SellLimitOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == 6995.95045125
assert order.created_last_price == last_btc_price
assert order.order_type == TraderOrderType.SELL_LIMIT
assert order.side == TradeOrderSide.SELL
assert order.status == OrderStatus.OPEN
assert order.exchange == exchange
assert order.trader == trader
assert order.fee is None
assert order.market_total_fees == 0
assert order.filled_price == 0
assert order.origin_quantity == 7.6
assert order.filled_quantity == order.origin_quantity
assert order.is_simulated is True
assert order.linked_to is None
check_order_limits(order, market_status)
assert len(order.linked_orders) == 1
check_linked_order(order, order.linked_orders[0],
TraderOrderType.STOP_LOSS, 6595.8595, market_status)
# valid buy limit order with (price and quantity adapted)
orders = await order_creator.create_new_order(-0.65, symbol, exchange,
trader, portfolio,
EvaluatorStates.LONG)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, BuyLimitOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == 6890.06954875
assert order.created_last_price == last_btc_price
assert order.order_type == TraderOrderType.BUY_LIMIT
assert order.side == TradeOrderSide.BUY
assert order.status == OrderStatus.OPEN
assert order.exchange == exchange
assert order.trader == trader
assert order.fee is None
assert order.market_total_fees == 0
assert order.filled_price == 0
assert order.origin_quantity == 0.21892522
assert order.filled_quantity == order.origin_quantity
assert order.is_simulated is True
assert order.linked_to is None
check_order_limits(order, market_status)
# assert len(order.linked_orders) == 1 # check linked orders when it will be developed
# valid buy market order with (price and quantity adapted)
orders = await order_creator.create_new_order(-1, symbol, exchange, trader,
portfolio,
EvaluatorStates.VERY_LONG)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, BuyMarketOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == last_btc_price
assert order.created_last_price == last_btc_price
assert order.order_type == TraderOrderType.BUY_MARKET
assert order.side == TradeOrderSide.BUY
assert order.status == OrderStatus.OPEN
assert order.exchange == exchange
assert order.trader == trader
assert order.fee is None
assert order.market_total_fees == 0
assert order.filled_price == 0
assert order.origin_quantity == 0.03540179
assert order.filled_quantity == order.origin_quantity
assert order.is_simulated is True
assert order.linked_to is None
check_order_limits(order, market_status)
# valid buy market order with (price and quantity adapted)
orders = await order_creator.create_new_order(1, symbol, exchange, trader,
portfolio,
EvaluatorStates.VERY_SHORT)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, SellMarketOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == last_btc_price
assert order.created_last_price == last_btc_price
assert order.order_type == TraderOrderType.SELL_MARKET
assert order.side == TradeOrderSide.SELL
assert order.status == OrderStatus.OPEN
assert order.exchange == exchange
assert order.trader == trader
assert order.fee is None
assert order.market_total_fees == 0
assert order.filled_price == 0
assert order.origin_quantity == 2.4
assert order.filled_quantity == order.origin_quantity
assert order.is_simulated is True
assert order.linked_to is None
check_order_limits(order, market_status)
async def test_split_create_new_orders():
try:
exchange_manager, trader, symbol, consumer, last_btc_price = await _get_tools(
)
# change reference market to get more orders
exchange_manager.exchange_personal_data.portfolio_manager.reference_market = "USDT"
exchange_manager.exchange_personal_data.portfolio_manager.reference_market = "USDT"
market_status = exchange_manager.exchange.get_market_status(
symbol, with_fixer=False)
exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio = {
"BTC": {
commons_constants.PORTFOLIO_TOTAL: 2000000001,
commons_constants.PORTFOLIO_AVAILABLE: 2000000001
}
}
exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.last_prices_by_trading_pair[
symbol] = last_btc_price
exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.portfolio_current_value = \
last_btc_price * 2000000001 + 1000
# split orders because order too big and coin price too high
orders = await consumer.create_new_orders(
symbol, 0.6, trading_enums.EvaluatorStates.SHORT.value)
assert len(orders) == 11
adapted_order = orders[0]
identical_orders = orders[1:]
assert isinstance(adapted_order, trading_personal_data.SellLimitOrder)
assert adapted_order.currency == "BTC"
assert adapted_order.symbol == "BTC/USDT"
assert adapted_order.origin_price == 7065.26855999
assert adapted_order.created_last_price == last_btc_price
assert adapted_order.order_type == trading_enums.TraderOrderType.SELL_LIMIT
assert adapted_order.side == trading_enums.TradeOrderSide.SELL
assert adapted_order.status == trading_enums.OrderStatus.OPEN
assert adapted_order.exchange_manager == exchange_manager
assert adapted_order.trader == trader
assert adapted_order.fee is None
assert adapted_order.filled_price == 0
assert adapted_order.origin_quantity == 64625635.97358092
assert adapted_order.filled_quantity == adapted_order.origin_quantity
assert adapted_order.simulated is True
assert adapted_order.linked_to is None
trading_mode_test_toolkit.check_order_limits(adapted_order,
market_status)
assert len(adapted_order.linked_orders) == 1
trading_mode_test_toolkit.check_linked_order(
adapted_order, adapted_order.linked_orders[0],
trading_enums.TraderOrderType.STOP_LOSS, 6658.73524999,
market_status)
for order in identical_orders:
assert isinstance(order, trading_personal_data.SellLimitOrder)
assert order.currency == adapted_order.currency
assert order.symbol == adapted_order.symbol
assert order.origin_price == adapted_order.origin_price
assert order.created_last_price == adapted_order.created_last_price
assert order.order_type == adapted_order.order_type
assert order.side == adapted_order.side
assert order.status == adapted_order.status
assert order.exchange_manager == adapted_order.exchange_manager
assert order.trader == adapted_order.trader
assert order.fee == adapted_order.fee
assert order.filled_price == adapted_order.filled_price
assert order.origin_quantity == 141537436.47664192
assert order.origin_quantity > adapted_order.origin_quantity
assert order.filled_quantity > adapted_order.filled_quantity
assert order.simulated == adapted_order.simulated
assert order.linked_to == adapted_order.linked_to
assert len(order.linked_orders) == 1
trading_mode_test_toolkit.check_order_limits(order, market_status)
trading_mode_test_toolkit.check_linked_order(
order, order.linked_orders[0],
trading_enums.TraderOrderType.STOP_LOSS, 6658.73524999,
market_status)
exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio = {
"USDT": {
commons_constants.PORTFOLIO_TOTAL: 40000000000,
commons_constants.PORTFOLIO_AVAILABLE: 40000000000
}
}
# set btc last price to 6998.55407999 * 0.000001 = 0.00699855408
trading_api.force_set_mark_price(exchange_manager, symbol,
last_btc_price * 0.000001)
# split orders because order too big and too many coins
orders = await consumer.create_new_orders(
symbol, -0.6, trading_enums.EvaluatorStates.LONG.value)
assert len(orders) == 3
adapted_order = orders[0]
identical_orders = orders[1:]
assert isinstance(adapted_order, trading_personal_data.BuyLimitOrder)
assert adapted_order.currency == "BTC"
assert adapted_order.symbol == "BTC/USDT"
assert adapted_order.origin_price == 0.00695312
assert adapted_order.created_last_price == 0.007009194999999998
assert adapted_order.order_type == trading_enums.TraderOrderType.BUY_LIMIT
assert adapted_order.side == trading_enums.TradeOrderSide.BUY
assert adapted_order.status == trading_enums.OrderStatus.OPEN
assert adapted_order.exchange_manager == exchange_manager
assert adapted_order.trader == trader
assert adapted_order.fee is None
assert adapted_order.filled_price == 0
assert adapted_order.origin_quantity == 396851564266.65326
assert adapted_order.filled_quantity == adapted_order.origin_quantity
assert adapted_order.simulated is True
assert adapted_order.linked_to is None
trading_mode_test_toolkit.check_order_limits(adapted_order,
market_status)
# assert len(order.linked_orders) == 1 # check linked orders when it will be developed
for order in identical_orders:
assert isinstance(order, trading_personal_data.BuyLimitOrder)
assert order.currency == adapted_order.currency
assert order.symbol == adapted_order.symbol
assert order.origin_price == adapted_order.origin_price
assert order.created_last_price == adapted_order.created_last_price
assert order.order_type == adapted_order.order_type
assert order.side == adapted_order.side
assert order.status == adapted_order.status
assert order.exchange_manager == adapted_order.exchange_manager
assert order.trader == adapted_order.trader
assert order.fee == adapted_order.fee
assert order.filled_price == adapted_order.filled_price
assert order.origin_quantity == 1000000000000.0
assert order.origin_quantity > adapted_order.origin_quantity
assert order.filled_quantity > adapted_order.filled_quantity
assert order.simulated == adapted_order.simulated
assert order.linked_to == adapted_order.linked_to
trading_mode_test_toolkit.check_order_limits(order, market_status)
# assert len(order.linked_orders) == 1 # check linked orders when it will be developed
finally:
await _stop(exchange_manager)
async def test_valid_create_new_orders_ref_market_as_quote():
try:
exchange_manager, trader, symbol, consumer, last_btc_price = await _get_tools(
)
exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.last_prices_by_trading_pair[
symbol] = last_btc_price
exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.portfolio_current_value = \
10 + 1000 / last_btc_price
# portfolio: "BTC": 10 "USD": 1000
# order from neutral state
assert await consumer.create_new_orders(
symbol, -1, trading_enums.EvaluatorStates.NEUTRAL.value) == []
assert await consumer.create_new_orders(
symbol, 0.5, trading_enums.EvaluatorStates.NEUTRAL.value) == []
assert await consumer.create_new_orders(
symbol, 0, trading_enums.EvaluatorStates.NEUTRAL.value) == []
assert await consumer.create_new_orders(
symbol, -0.5, trading_enums.EvaluatorStates.NEUTRAL.value) == []
assert await consumer.create_new_orders(
symbol, -1, trading_enums.EvaluatorStates.NEUTRAL.value) == []
# valid sell limit order (price adapted)
orders = await consumer.create_new_orders(
symbol, 0.65, trading_enums.EvaluatorStates.SHORT.value)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, trading_personal_data.SellLimitOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == 7062.64011187
assert order.created_last_price == last_btc_price
assert order.order_type == trading_enums.TraderOrderType.SELL_LIMIT
assert order.side == trading_enums.TradeOrderSide.SELL
assert order.status == trading_enums.OrderStatus.OPEN
assert order.exchange_manager == exchange_manager
assert order.trader == trader
assert order.fee is None
assert order.filled_price == 0
assert order.origin_quantity == 4.4
assert order.filled_quantity == order.origin_quantity
assert order.simulated is True
assert order.linked_to is None
market_status = exchange_manager.exchange.get_market_status(
symbol, with_fixer=False)
trading_mode_test_toolkit.check_order_limits(order, market_status)
assert len(order.linked_orders) == 1
trading_mode_test_toolkit.check_linked_order(
order, order.linked_orders[0],
trading_enums.TraderOrderType.STOP_LOSS, 6658.73524999,
market_status)
# valid buy limit order with (price and quantity adapted)
orders = await consumer.create_new_orders(
symbol, -0.65, trading_enums.EvaluatorStates.LONG.value)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, trading_personal_data.BuyLimitOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == 6955.74988812
assert order.created_last_price == last_btc_price
assert order.order_type == trading_enums.TraderOrderType.BUY_LIMIT
assert order.side == trading_enums.TradeOrderSide.BUY
assert order.status == trading_enums.OrderStatus.OPEN
assert order.exchange_manager == exchange_manager
assert order.trader == trader
assert order.fee is None
assert order.filled_price == 0
assert order.origin_quantity == 0.21685799
assert order.filled_quantity == order.origin_quantity
assert order.simulated is True
assert order.linked_to is None
trading_mode_test_toolkit.check_order_limits(order, market_status)
# assert len(order.linked_orders) == 1 # check linked orders when it will be developed
truncated_last_price = trading_personal_data.trunc_with_n_decimal_digits(
last_btc_price, 8)
# valid buy market order with (price and quantity adapted)
orders = await consumer.create_new_orders(
symbol, -1, trading_enums.EvaluatorStates.VERY_LONG.value)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, trading_personal_data.BuyMarketOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == truncated_last_price
assert order.created_last_price == truncated_last_price
assert order.order_type == trading_enums.TraderOrderType.BUY_MARKET
assert order.side == trading_enums.TradeOrderSide.BUY
assert order.status == trading_enums.OrderStatus.FILLED
assert order.filled_price == 7009.19499999
assert order.origin_quantity == 0.07013502
assert order.filled_quantity == order.origin_quantity
assert order.simulated is True
assert order.linked_to is None
trading_mode_test_toolkit.check_order_limits(order, market_status)
# valid buy market order with (price and quantity adapted)
orders = await consumer.create_new_orders(
symbol, 1, trading_enums.EvaluatorStates.VERY_SHORT.value)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, trading_personal_data.SellMarketOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == truncated_last_price
assert order.created_last_price == truncated_last_price
assert order.order_type == trading_enums.TraderOrderType.SELL_MARKET
assert order.side == trading_enums.TradeOrderSide.SELL
assert order.status == trading_enums.OrderStatus.FILLED
assert order.fee
assert order.filled_price == 7009.19499999
assert order.origin_quantity == 4.08244671
assert order.filled_quantity == order.origin_quantity
assert order.simulated is True
assert order.linked_to is None
trading_mode_test_toolkit.check_order_limits(order, market_status)
finally:
await _stop(exchange_manager)
async def test_split_create_new_order():
config, exchange, trader, symbol = await _get_tools()
portfolio = trader.get_portfolio()
# change reference market to get more orders
trader.get_trades_manager().reference_market = "USDT"
order_creator = DailyTradingModeCreator(None)
last_btc_price = 7009.194999999998
market_status = exchange.get_market_status(symbol)
trader.portfolio.portfolio["BTC"] = {
Portfolio.TOTAL: 2000000001,
Portfolio.AVAILABLE: 2000000001
}
# split orders because order too big and coin price too high
orders = await order_creator.create_new_order(0.6, symbol, exchange,
trader, portfolio,
EvaluatorStates.SHORT)
assert len(orders) == 11
adapted_order = orders[0]
identical_orders = orders[1:]
assert isinstance(adapted_order, SellLimitOrder)
assert adapted_order.currency == "BTC"
assert adapted_order.symbol == "BTC/USDT"
assert adapted_order.origin_price == 7065.26855999
assert adapted_order.created_last_price == last_btc_price
assert adapted_order.order_type == TraderOrderType.SELL_LIMIT
assert adapted_order.side == TradeOrderSide.SELL
assert adapted_order.status == OrderStatus.OPEN
assert adapted_order.exchange == exchange
assert adapted_order.trader == trader
assert adapted_order.fee is None
assert adapted_order.market_total_fees == 0
assert adapted_order.filled_price == 0
assert adapted_order.origin_quantity == 64625635.97358092
assert adapted_order.filled_quantity == adapted_order.origin_quantity
assert adapted_order.is_simulated is True
assert adapted_order.linked_to is None
check_order_limits(adapted_order, market_status)
assert len(adapted_order.linked_orders) == 1
check_linked_order(adapted_order, adapted_order.linked_orders[0],
TraderOrderType.STOP_LOSS, 6658.73524999, market_status)
for order in identical_orders:
assert isinstance(order, SellLimitOrder)
assert order.currency == adapted_order.currency
assert order.symbol == adapted_order.symbol
assert order.origin_price == adapted_order.origin_price
assert order.created_last_price == adapted_order.created_last_price
assert order.order_type == adapted_order.order_type
assert order.side == adapted_order.side
assert order.status == adapted_order.status
assert order.exchange == adapted_order.exchange
assert order.trader == adapted_order.trader
assert order.fee == adapted_order.fee
assert order.market_total_fees == adapted_order.market_total_fees
assert order.filled_price == adapted_order.filled_price
assert order.origin_quantity == 141537436.47664192
assert order.origin_quantity > adapted_order.origin_quantity
assert order.filled_quantity > adapted_order.filled_quantity
assert order.is_simulated == adapted_order.is_simulated
assert order.linked_to == adapted_order.linked_to
assert len(order.linked_orders) == 1
check_order_limits(order, market_status)
check_linked_order(order, order.linked_orders[0],
TraderOrderType.STOP_LOSS, 6658.73524999,
market_status)
trader.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 40000000000,
Portfolio.AVAILABLE: 40000000000
}
# set btc last price to 6998.55407999 * 0.000001 = 0.00699855408
exchange.get_exchange().set_recent_trades_multiplier_factor(0.000001)
# split orders because order too big and too many coins
orders = await order_creator.create_new_order(-0.6, symbol, exchange,
trader, portfolio,
EvaluatorStates.LONG)
assert len(orders) == 3
adapted_order = orders[0]
identical_orders = orders[1:]
assert isinstance(adapted_order, BuyLimitOrder)
assert adapted_order.currency == "BTC"
assert adapted_order.symbol == "BTC/USDT"
assert adapted_order.origin_price == 0.00695312
assert adapted_order.created_last_price == 0.0070091949999999984
assert adapted_order.order_type == TraderOrderType.BUY_LIMIT
assert adapted_order.side == TradeOrderSide.BUY
assert adapted_order.status == OrderStatus.OPEN
assert adapted_order.exchange == exchange
assert adapted_order.trader == trader
assert adapted_order.fee is None
assert adapted_order.market_total_fees == 0
assert adapted_order.filled_price == 0
assert adapted_order.origin_quantity == 396851564266.65326
assert adapted_order.filled_quantity == adapted_order.origin_quantity
assert adapted_order.is_simulated is True
assert adapted_order.linked_to is None
check_order_limits(adapted_order, market_status)
# assert len(order.linked_orders) == 1 # check linked orders when it will be developed
for order in identical_orders:
assert isinstance(order, BuyLimitOrder)
assert order.currency == adapted_order.currency
assert order.symbol == adapted_order.symbol
assert order.origin_price == adapted_order.origin_price
assert order.created_last_price == adapted_order.created_last_price
assert order.order_type == adapted_order.order_type
assert order.side == adapted_order.side
assert order.status == adapted_order.status
assert order.exchange == adapted_order.exchange
assert order.trader == adapted_order.trader
assert order.fee == adapted_order.fee
assert order.market_total_fees == adapted_order.market_total_fees
assert order.filled_price == adapted_order.filled_price
assert order.origin_quantity == 1000000000000.0
assert order.origin_quantity > adapted_order.origin_quantity
assert order.filled_quantity > adapted_order.filled_quantity
assert order.is_simulated == adapted_order.is_simulated
assert order.linked_to == adapted_order.linked_to
check_order_limits(order, market_status)
async def test_valid_create_new_order_ref_market_as_quote():
config, exchange, trader, symbol = await _get_tools()
portfolio = trader.get_portfolio()
order_creator = DailyTradingModeCreator(None)
market_status = exchange.get_market_status(symbol)
# portfolio: "BTC": 10 "USD": 1000
last_btc_price = 7009.194999999998
# order from neutral state
assert await order_creator.create_new_order(-1, symbol, exchange, trader, portfolio, EvaluatorStates.NEUTRAL) \
is None
assert await order_creator.create_new_order(0.5, symbol, exchange, trader, portfolio, EvaluatorStates.NEUTRAL) \
is None
assert await order_creator.create_new_order(0, symbol, exchange, trader, portfolio, EvaluatorStates.NEUTRAL) \
is None
assert await order_creator.create_new_order(-0.5, symbol, exchange, trader, portfolio, EvaluatorStates.NEUTRAL) \
is None
assert await order_creator.create_new_order(-1, symbol, exchange, trader, portfolio, EvaluatorStates.NEUTRAL) \
is None
# valid sell limit order (price adapted)
orders = await order_creator.create_new_order(0.65, symbol, exchange,
trader, portfolio,
EvaluatorStates.SHORT)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, SellLimitOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == 7062.64011187
assert order.created_last_price == last_btc_price
assert order.order_type == TraderOrderType.SELL_LIMIT
assert order.side == TradeOrderSide.SELL
assert order.status == OrderStatus.OPEN
assert order.exchange == exchange
assert order.trader == trader
assert order.fee is None
assert order.market_total_fees == 0
assert order.filled_price == 0
assert order.origin_quantity == 4.4
assert order.filled_quantity == order.origin_quantity
assert order.is_simulated is True
assert order.linked_to is None
check_order_limits(order, market_status)
assert len(order.linked_orders) == 1
check_linked_order(order, order.linked_orders[0],
TraderOrderType.STOP_LOSS, 6658.73524999, market_status)
# valid buy limit order with (price and quantity adapted)
orders = await order_creator.create_new_order(-0.65, symbol, exchange,
trader, portfolio,
EvaluatorStates.LONG)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, BuyLimitOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == 6955.74988812
assert order.created_last_price == last_btc_price
assert order.order_type == TraderOrderType.BUY_LIMIT
assert order.side == TradeOrderSide.BUY
assert order.status == OrderStatus.OPEN
assert order.exchange == exchange
assert order.trader == trader
assert order.fee is None
assert order.market_total_fees == 0
assert order.filled_price == 0
assert order.origin_quantity == 0.21685799
assert order.filled_quantity == order.origin_quantity
assert order.is_simulated is True
assert order.linked_to is None
check_order_limits(order, market_status)
# assert len(order.linked_orders) == 1 # check linked orders when it will be developed
truncated_last_price = order_creator._trunc_with_n_decimal_digits(
last_btc_price, 8)
# valid buy market order with (price and quantity adapted)
orders = await order_creator.create_new_order(-1, symbol, exchange, trader,
portfolio,
EvaluatorStates.VERY_LONG)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, BuyMarketOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == truncated_last_price
assert order.created_last_price == truncated_last_price
assert order.order_type == TraderOrderType.BUY_MARKET
assert order.side == TradeOrderSide.BUY
assert order.status == OrderStatus.OPEN
assert order.exchange == exchange
assert order.trader == trader
assert order.fee is None
assert order.market_total_fees == 0
assert order.filled_price == 0
assert order.origin_quantity == 0.07013502
assert order.filled_quantity == order.origin_quantity
assert order.is_simulated is True
assert order.linked_to is None
check_order_limits(order, market_status)
# valid buy market order with (price and quantity adapted)
orders = await order_creator.create_new_order(1, symbol, exchange, trader,
portfolio,
EvaluatorStates.VERY_SHORT)
assert len(orders) == 1
order = orders[0]
assert isinstance(order, SellMarketOrder)
assert order.currency == "BTC"
assert order.symbol == "BTC/USDT"
assert order.origin_price == truncated_last_price
assert order.created_last_price == truncated_last_price
assert order.order_type == TraderOrderType.SELL_MARKET
assert order.side == TradeOrderSide.SELL
assert order.status == OrderStatus.OPEN
assert order.exchange == exchange
assert order.trader == trader
assert order.fee is None
assert order.market_total_fees == 0
assert order.filled_price == 0
assert order.origin_quantity == 4.032
assert order.filled_quantity == order.origin_quantity
assert order.is_simulated is True
assert order.linked_to is None
check_order_limits(order, market_status)
