async def test_parse_exchange_order_to_order_instance(self):
_, exchange_manager, trader_inst = await self.init_default()
timestamp = time.time()
exchange_order = {
"side": TradeOrderSide.SELL.value,
"type": TradeOrderType.LIMIT.value,
"symbol": self.DEFAULT_SYMBOL,
"amount": 1564.7216721637,
"filled": 15.15467,
"id": "1546541123",
"status": OrderStatus.OPEN.value,
"price": 10254.4515,
"timestamp": timestamp
}
order_to_test = create_order_instance_from_raw(trader_inst, exchange_order)
assert order_to_test.order_type == TraderOrderType.SELL_LIMIT
assert order_to_test.status == OrderStatus.OPEN
assert order_to_test.linked_to is None
assert order_to_test.origin_stop_price == constants.ZERO
assert order_to_test.origin_quantity == decimal.Decimal("1564.7216721637")
assert order_to_test.origin_price == decimal.Decimal("10254.4515")
assert order_to_test.filled_quantity == decimal.Decimal("15.15467")
assert order_to_test.creation_time != constants.ZERO
assert order_to_test.order_id == "1546541123"
await self.stop(exchange_manager)
async def upsert_order_from_raw(self, order_id, raw_order) -> bool:
if not self.has_order(order_id):
self.logger.debug(f"Creating new order from exchange data: {raw_order}")
new_order = order_factory.create_order_instance_from_raw(self.trader, raw_order)
self.orders[order_id] = new_order
await new_order.initialize(is_from_exchange_data=True)
self._check_orders_size()
return True
return await _update_order_from_raw(self.orders[order_id], raw_order)
async def test_create_trade_from_order(self):
_, exchange_manager, trader = await self.init_default()
raw_order = json.loads("""
{
"id": "12345-67890:09876/54321",
"datetime": "2017-08-17 12:42:48.000",
"timestamp": 1502962946216,
"lastTradeTimestamp": 1502962956216,
"status": "open",
"symbol": "BTC/USDT",
"type": "limit",
"side": "sell",
"price": 7684,
"amount": 1.5,
"filled": 1.1,
"remaining": 0.4,
"cost": 0.076094524,
"trades": [],
"fee": {
"currency": "BTC",
"cost": 0.0009,
"rate": 0.002
},
"info": {}
}
""")
order = create_order_instance_from_raw(trader, raw_order)
trade = create_trade_from_order(order, close_status=OrderStatus.FILLED)
assert trade.trade_id == '12345-67890:09876/54321'
assert trade.origin_order_id == '12345-67890:09876/54321'
assert trade.simulated is True
assert trade.trade_type == TraderOrderType.SELL_LIMIT
assert trade.symbol == 'BTC/USDT'
assert trade.total_cost == 0.076094524
assert trade.executed_quantity == 1.1
assert trade.origin_quantity == 1.5
assert trade.origin_price == 7684
assert trade.executed_price == 7684
assert trade.status == OrderStatus.FILLED
assert trade.is_closing_order is True
trade = create_trade_from_order(order)
assert trade.status == OrderStatus.FILLED
exec_time = time.time()
trade = create_trade_from_order(order, executed_time=exec_time)
assert trade.executed_time == exec_time
await self.stop(exchange_manager)
async def _create_new_order(self, new_order: object, portfolio) -> object:
"""
Creates an exchange managed order, it might be a simulated or a real order. Then updates the portfolio.
"""
if not self.simulate and not new_order.is_self_managed():
created_order = await self.exchange_manager.exchange.create_order(
new_order.order_type, new_order.symbol,
new_order.origin_quantity, new_order.origin_price,
new_order.origin_stop_price)
self.logger.info(
f"Created order on {self.exchange_manager.exchange_name}: {created_order}"
)
# get real order from exchange
new_order = order_factory.create_order_instance_from_raw(
self, created_order, force_open=True)
# rebind linked portfolio to new order instance
new_order.linked_portfolio = portfolio
return new_order
async def test_create_trade_from_order(self):
_, exchange_manager, trader = await self.init_default()
# limit order
raw_order = json.loads("""
{
"id": "12345-67890:09876/54321",
"datetime": "2017-08-17 12:42:48.000",
"timestamp": 1502962946216,
"lastTradeTimestamp": 1502962956216,
"status": "open",
"symbol": "BTC/USDT",
"type": "limit",
"side": "sell",
"price": 7684,
"amount": 1.5,
"filled": 1.1,
"remaining": 0.4,
"cost": 0.076094524,
"trades": [],
"fee": {
"currency": "BTC",
"cost": 0.0009,
"rate": 0.002
},
"info": {}
}
""")
order = create_order_instance_from_raw(trader, raw_order)
trade = create_trade_from_order(order, close_status=OrderStatus.FILLED)
assert trade.trade_id == '12345-67890:09876/54321'
assert trade.origin_order_id == '12345-67890:09876/54321'
assert trade.simulated is True
assert trade.trade_type == TraderOrderType.SELL_LIMIT
assert trade.symbol == 'BTC/USDT'
assert trade.total_cost == decimal.Decimal(str(0.076094524))
assert trade.executed_quantity == decimal.Decimal(str(1.1))
assert trade.origin_quantity == decimal.Decimal(str(1.5))
assert trade.origin_price == decimal.Decimal("7684")
assert trade.executed_price == decimal.Decimal("7684")
assert trade.status == OrderStatus.FILLED
assert trade.is_closing_order is True
trade = create_trade_from_order(order)
assert trade.status == OrderStatus.FILLED
exec_time = time.time()
trade = create_trade_from_order(order, executed_time=exec_time)
assert trade.executed_time == exec_time
# market order
raw_order = {
'id': '362550114',
'clientOrderId': 'x-T9698eeeeeeeeeeeeee792',
'timestamp': 1637579281.377,
'datetime': '2021-11-22T11:08:01.377Z',
'lastTradeTimestamp': None,
'symbol': 'WIN/USDT',
'type': 'market',
'timeInForce': 'GTC',
'postOnly': False,
'side': 'sell',
'price': None,
'stopPrice': None,
'amount': 44964.0,
'cost': None,
'average': None,
'filled': 44964.0,
'remaining': 0.0,
'status': 'closed',
'fee': {
'cost': 0.03764836,
'currency': 'USDT'
},
'trades': [],
'fees': []
}
order = create_order_instance_from_raw(trader, raw_order)
trade = create_trade_from_order(order, close_status=OrderStatus.FILLED)
assert trade.trade_id == '362550114'
assert trade.origin_order_id == '362550114'
assert trade.trade_type == TraderOrderType.SELL_MARKET
assert trade.symbol == 'WIN/USDT'
assert trade.total_cost == ZERO
assert trade.executed_quantity == decimal.Decimal("44964.0")
assert trade.origin_quantity == decimal.Decimal("44964.0")
assert trade.origin_price == ZERO
assert trade.executed_price == ZERO
assert trade.status == OrderStatus.FILLED
assert trade.executed_time == 1637579281.377
assert trade.is_closing_order is True
await self.stop(exchange_manager)