def test_on_fill(mock_trade_class,
mock_exchange_class,
fill_listener):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
order.attach(fill_listener)
order.execute(exchange)
trade = mock_trade_class.return_value
trade.size = 3997.00
trade.commission = 3.00 * USD
assert not fill_listener.listened
order.fill(exchange, trade)
assert fill_listener.listened
def test_on_complete(mock_trade_class, mock_exchange_class, complete_listener):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_name="coinbase",
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
order.attach(complete_listener)
order.execute(exchange)
trade = mock_trade_class.return_value
trade.size = 5217.00
trade.commission = 3.00 * USD
order.fill(exchange, trade)
assert not complete_listener.listened
order.complete(exchange)
assert complete_listener.listened
def get_order(self, action: int, exchange: 'Exchange',
portfolio: 'Portfolio') -> Order:
if action == 0:
return None
(side, pair, criteria, size) = self._actions[action]
instrument = pair.base if side == TradeSide.BUY else pair.quote
wallet = portfolio.get_wallet(exchange.id, instrument=instrument)
price = exchange.quote_price(instrument)
size = min(wallet.balance.size, (wallet.balance.size * size))
if size < 10**-instrument.precision:
return None
quantity = size * instrument
order = Order(side=side,
trade_type=self._trade_type,
pair=pair,
price=price,
quantity=quantity,
portfolio=portfolio,
criteria=criteria)
if self._order_listener is not None:
order.attach(self._order_listener)
return order
def test_on_complete(mock_trade_class, mock_exchange_class, complete_listener):
exchange = mock_exchange_class.return_value
exchange.options = ExchangeOptions()
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
exchange.clock = mock.Mock()
exchange.clock.step = 0
exchange.quote_price = mock.Mock(return_value=Decimal(7000.00))
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5200.00 * USD,
portfolio=portfolio,
price=Decimal(7000.00))
order.attach(complete_listener)
order.execute()
trade = mock_trade_class.return_value
trade.size = Decimal(5197.00)
trade.quantity = trade.size * USD
trade.commission = 3.00 * USD
order.fill(trade)
assert not complete_listener.listened
order.complete()
assert complete_listener.listened
def test_on_cancel(mock_exchange_class, cancel_listener):
exchange = mock_exchange_class.return_value
exchange.options = ExchangeOptions()
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
exchange.clock = mock.Mock()
exchange.clock.step = 0
exchange.quote_price = mock.Mock(return_value=Decimal(7000.00))
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5200.00 * USD,
portfolio=portfolio,
price=Decimal(7000.00))
order.attach(cancel_listener)
assert not cancel_listener.listened
order.cancel()
assert cancel_listener.listened
def test_fill(mock_order_listener_class,
mock_trade_class,
mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
listener = mock_order_listener_class.return_value
listener.on_fill = mock.Mock(return_value=None)
order.attach(listener)
order.execute(exchange)
trade = mock_trade_class.return_value
trade.size = 3997.00
trade.commission = 3.00 * USD
assert order.status == OrderStatus.OPEN
order.fill(exchange, trade)
assert order.status == OrderStatus.PARTIALLY_FILLED
assert order.remaining_size == 1200.00
listener.on_fill.assert_called_once_with(order, exchange, trade)
def get_order(self, action: int, portfolio: 'Portfolio') -> Order:
if action == 0:
return None
(exchange_pair, (criteria, proportion, duration, side)) = self.actions[action]
instrument = side.instrument(exchange_pair.pair)
wallet = portfolio.get_wallet(exchange_pair.exchange.id, instrument=instrument)
balance = wallet.balance.as_float()
size = (balance * proportion)
size = min(balance, size)
quantity = (size * instrument).quantize()
if size < 10 ** -instrument.precision:
return None
order = Order(step=self.clock.step,
side=side,
trade_type=self._trade_type,
exchange_pair=exchange_pair,
price=exchange_pair.price,
quantity=quantity,
criteria=criteria,
end=self.clock.step + duration if duration else None,
portfolio=portfolio)
if self._order_listener is not None:
order.attach(self._order_listener)
return order
def test_detach(mock_exchange_class, mock_order_listener_class):
exchange = mock_exchange_class.return_value
exchange.options = ExchangeOptions()
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
exchange.clock = mock.Mock()
exchange.clock.step = 0
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5000.00 * USD,
portfolio=portfolio,
price=Decimal(7000.00))
listener = mock_order_listener_class.return_value
order.attach(listener)
assert len(order._listeners) == 1
assert listener in order._listeners
order.detach(listener)
assert len(order._listeners) == 0
assert listener not in order._listeners
def test_on_fill(mock_trade_class, mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
broker = Broker(exchange)
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
order.attach(broker)
order.execute(exchange)
broker._executed[order.id] = order
trade = mock_trade_class.return_value
trade.size = 5197.00
trade.commission = 3.00 * USD
trade.order_id = order.id
assert order.status == OrderStatus.OPEN
order.fill(exchange, trade)
assert order.status == OrderStatus.FILLED
assert order.remaining_size == 0
assert trade in broker.trades[order.id]
def get_order(self, action: int, portfolio: 'Portfolio') -> Order:
if action == 0:
return None
((exchange, pair), (criteria, prop, duration,
side)) = self.actions[action]
price = exchange.quote_price(pair)
instrument = side.instrument(pair)
wallet = portfolio.get_wallet(exchange.id, instrument=instrument)
size = (wallet.balance.size * prop)
size = min(wallet.balance.size, size)
if size < 10**-instrument.precision:
return None
order = Order(step=self.clock.step,
exchange_name=exchange.name,
side=side,
trade_type=self._trade_type,
pair=pair,
price=price,
quantity=(size * instrument),
criteria=criteria,
end=self.clock.step + duration if duration else None,
portfolio=portfolio)
if self._order_listener is not None:
order.attach(self._order_listener)
return order
def test_execute(mock_order_listener_class,
mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.id = "fake_id"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
listener = mock_order_listener_class.return_value
listener.on_execute = mock.Mock(return_value=None)
order.attach(listener)
assert order.status == OrderStatus.PENDING
order.execute(exchange)
assert order.status == OrderStatus.OPEN
wallet_usd = portfolio.get_wallet(exchange.id, USD)
wallet_btc = portfolio.get_wallet(exchange.id, BTC)
assert wallet_usd.balance == 4800 * USD
assert wallet_usd.locked_balance == 5200 * USD
assert order.path_id in wallet_usd.locked.keys()
assert wallet_btc.balance == 0 * BTC
listener.on_execute.assert_called_once_with(order, exchange)
def get_order(self, action: int, portfolio: 'Portfolio') -> Order:
if action == 0:
return None
((exchange, pair), (side, criteria, size)) = self.actions[action]
instrument = side.instrument(pair)
wallet = portfolio.get_wallet(exchange.id, instrument=instrument)
price = exchange.quote_price(pair)
size = min(wallet.balance.size, (wallet.balance.size * size))
if size < 10**-instrument.precision:
return None
quantity = size * instrument
order = Order(step=exchange.clock.step,
side=side,
trade_type=self._trade_type,
pair=pair,
price=price,
quantity=quantity,
portfolio=portfolio,
criteria=criteria)
if self._order_listener is not None:
order.attach(self._order_listener)
return order
def test_cancel(mock_order_listener_class,
mock_trade_class,
mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_name="coinbase",
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
listener = mock_order_listener_class.return_value
listener.on_cancel = mock.Mock(return_value=None)
order.attach(listener)
order.execute(exchange)
# Execute fake trade
price = 7010.00
scale = order.price / price
commission = 3.00 * USD
trade = mock_trade_class.return_value
trade.size = scale * order.size - commission.size
trade.price = price
trade.commission = commission
base_wallet = portfolio.get_wallet(exchange.id, USD)
quote_wallet = portfolio.get_wallet(exchange.id, BTC)
base_size = trade.size + commission.size
quote_size = (order.price / trade.price) * (trade.size / trade.price)
base_wallet -= Quantity(USD, size=base_size, path_id=order.path_id)
quote_wallet += Quantity(BTC, size=quote_size, path_id=order.path_id)
order.fill(exchange, trade)
assert order.status == OrderStatus.PARTIALLY_FILLED
assert base_wallet.balance == 4800.00 * USD
assert round(base_wallet.locked[order.path_id].size, 2) == 7.42
assert quote_wallet.balance == 0 * BTC
assert round(quote_wallet.locked[order.path_id].size, 8) == 0.73925519
order.cancel()
listener.on_cancel.assert_called_once_with(order)
assert round(base_wallet.balance.size, 2) == 4807.42
assert order.path_id not in base_wallet.locked
assert round(quote_wallet.balance.size, 8) == 0.73925519
assert order.path_id not in quote_wallet.locked
def test_attach(mock_portfolio_class, mock_order_listener_class):
portfolio = mock_portfolio_class.return_value
order = Order(side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5000.00 * USD,
portfolio=portfolio,
price=7000.00)
listener = mock_order_listener_class.return_value
assert len(order._listeners) == 0
order.attach(listener)
assert len(order._listeners) == 1
assert listener in order._listeners
def test_detach(mock_portfolio_class, mock_order_listener_class):
portfolio = mock_portfolio_class.return_value
order = Order(step=0,
exchange_name="coinbase",
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5000.00 * USD,
portfolio=portfolio,
price=7000.00)
listener = mock_order_listener_class.return_value
order.attach(listener)
assert len(order._listeners) == 1
assert listener in order._listeners
order.detach(listener)
assert len(order._listeners) == 0
assert listener not in order._listeners
def get_order(self, action: int, exchange: 'Exchange',
portfolio: 'Portfolio') -> Order:
if action == 0:
return None
(pair, stop_loss, take_profit, size) = self._actions[action]
base_instrument = pair.base if self._trade_side == TradeSide.BUY else pair.quote
base_wallet = portfolio.get_wallet(exchange.id,
instrument=base_instrument)
price = exchange.quote_price(pair)
size = min(base_wallet.balance.size, (base_wallet.balance.size * size))
if size < 10**-base_instrument.precision:
return None
buy_quantity = size * base_instrument
order = Order(side=self._trade_side,
trade_type=self._trade_type,
pair=pair,
price=price,
quantity=buy_quantity,
portfolio=portfolio)
risk_criteria = StopLoss(direction='either',
up_percent=take_profit,
down_percent=stop_loss)
risk_management = Recipe(side=TradeSide.SELL if self._trade_side
== TradeSide.BUY else TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=pair,
criteria=risk_criteria)
order.add_recipe(risk_management)
if self._order_listener is not None:
order.attach(self._order_listener)
return order
def test_on_execute(mock_exchange_class,
execute_listener):
exchange = mock_exchange_class.return_value
exchange.id = "fake_id"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
order.attach(execute_listener)
assert not execute_listener.listened
order.execute(exchange)
assert execute_listener.listened
def test_complete_basic_order(mock_order_listener_class, mock_trade_class,
mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.options = ExchangeOptions()
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
exchange.clock = mock.Mock()
exchange.clock.step = 0
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5200.00 * USD,
portfolio=portfolio,
price=Decimal(7000.00))
listener = mock_order_listener_class.return_value
listener.on_complete = mock.Mock(return_value=None)
order.attach(listener)
order.execute()
trade = mock_trade_class.return_value
trade.size = Decimal(5197.00)
trade.quantity = 5197.00 * USD
trade.commission = 3.00 * USD
order.fill(trade)
assert order.status == OrderStatus.PARTIALLY_FILLED
next_order = order.complete()
assert order.status == OrderStatus.FILLED
listener.on_complete.assert_called_once_with(order)
assert not next_order
def test_on_fill(mock_trade_class, mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.options.max_trade_size = 1e6
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
exchange.quote_price = lambda pair: Decimal(7000.00)
broker = Broker()
broker.exchanges = [exchange]
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
order.attach(broker)
order.execute()
broker._executed[order.id] = order
trade = mock_trade_class.return_value
trade.quantity = 5197.00 * USD
trade.commission = 3.00 * USD
trade.order_id = order.id
assert order.status == OrderStatus.OPEN
order.fill(trade)
assert order.status == OrderStatus.FILLED
assert order.remaining == 0
assert trade in broker.trades[order.id]
def test_on_cancel(mock_exchange_class, cancel_listener):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_name="coinbase",
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
order.attach(cancel_listener)
assert not cancel_listener.listened
order.cancel()
assert cancel_listener.listened
def test_complete_basic_order(mock_order_listener_class,
mock_trade_class,
mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_name="coinbase",
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
listener = mock_order_listener_class.return_value
listener.on_complete = mock.Mock(return_value=None)
order.attach(listener)
order.execute(exchange)
trade = mock_trade_class.return_value
trade.size = 5217.00
trade.commission = 3.00 * USD
order.fill(exchange, trade)
assert order.status == OrderStatus.PARTIALLY_FILLED
next_order = order.complete(exchange)
assert order.status == OrderStatus.FILLED
listener.on_complete.assert_called_once_with(order, exchange)
assert not next_order
def test_cancel(mock_order_listener_class, mock_trade_class,
mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.options = ExchangeOptions()
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
exchange.clock = mock.Mock()
exchange.clock.step = 0
exchange.quote_price = mock.Mock(return_value=Decimal(7000.00))
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
order = Order(step=0,
exchange_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5200.00 * USD,
portfolio=portfolio,
price=Decimal(7000.00))
listener = mock_order_listener_class.return_value
listener.on_cancel = mock.Mock(return_value=None)
order.attach(listener)
order.execute()
# Execute fake trade
price = Decimal(7010.00)
scale = order.price / price
commission = 3.00 * USD
trade = mock_trade_class.return_value
trade.size = Decimal(scale * order.size - commission.size)
trade.quantity = trade.size * USD
trade.price = price
trade.commission = commission
base_wallet = portfolio.get_wallet(exchange.id, USD)
quote_wallet = portfolio.get_wallet(exchange.id, BTC)
base_size = trade.size + commission.size
quote_size = (order.price / trade.price) * (trade.size / trade.price)
base_wallet.withdraw(quantity=Quantity(USD,
size=base_size,
path_id=order.path_id),
reason="test")
quote_wallet.deposit(quantity=Quantity(BTC,
size=quote_size,
path_id=order.path_id),
reason="test")
order.fill(trade)
assert order.status == OrderStatus.PARTIALLY_FILLED
assert base_wallet.balance == 4800.00 * USD
assert float(round(base_wallet.locked[order.path_id].size, 2)) == 7.42
assert quote_wallet.balance == 0 * BTC
assert float(round(quote_wallet.locked[order.path_id].size,
8)) == 0.73925519
order.cancel()
listener.on_cancel.assert_called_once_with(order)
assert float(round(base_wallet.balance.size, 2)) == 4807.42
assert order.path_id not in base_wallet.locked
assert float(round(quote_wallet.balance.size, 8)) == 0.73925519
assert order.path_id not in quote_wallet.locked
def test_on_fill_with_complex_order(mock_trade_class, mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.id = "fake_exchange_id"
broker = Broker(exchange)
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
side = TradeSide.BUY
order = Order(step=0,
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
quantity=5200.00 * USD,
portfolio=portfolio,
price=7000.00)
risk_criteria = Stop("down", 0.03) ^ Stop("up", 0.02)
risk_management = OrderSpec(
side=TradeSide.SELL if side == TradeSide.BUY else TradeSide.BUY,
trade_type=TradeType.MARKET,
pair=USD / BTC,
criteria=risk_criteria)
order += risk_management
order.attach(broker)
order.execute(exchange)
broker._executed[order.id] = order
# Execute fake trade
price = 7000.00
scale = order.price / price
commission = 3.00 * USD
base_size = scale * order.size - commission.size
trade = mock_trade_class.return_value
trade.order_id = order.id
trade.size = base_size
trade.price = price
trade.commission = commission
base_wallet = portfolio.get_wallet(exchange.id, USD)
quote_wallet = portfolio.get_wallet(exchange.id, BTC)
base_size = trade.size + trade.commission.size
quote_size = (order.price / trade.price) * (trade.size / trade.price)
base_wallet -= Quantity(USD, size=base_size, path_id=order.path_id)
quote_wallet += Quantity(BTC, size=quote_size, path_id=order.path_id)
assert trade.order_id in broker.executed.keys()
assert trade not in broker.trades
assert broker.unexecuted == []
order.fill(exchange, trade)
assert order.remaining_size == 0
assert trade in broker.trades[order.id]
assert broker.unexecuted != []
def test_on_fill_with_complex_order(mock_trade_class, mock_exchange_class):
exchange = mock_exchange_class.return_value
exchange.options.max_trade_size = 1e6
exchange.id = "fake_exchange_id"
exchange.name = "coinbase"
exchange.quote_price = lambda pair: Decimal(7000.00)
broker = Broker()
broker.exchanges = [exchange]
wallets = [Wallet(exchange, 10000 * USD), Wallet(exchange, 0 * BTC)]
portfolio = Portfolio(USD, wallets)
side = TradeSide.BUY
order = Order(step=0,
exchange_pair=ExchangePair(exchange, USD / BTC),
side=TradeSide.BUY,
trade_type=TradeType.MARKET,
quantity=5200.00 * USD,
portfolio=portfolio,
price=Decimal(7000.00))
risk_criteria = Stop("down", 0.03) ^ Stop("up", 0.02)
risk_management = OrderSpec(
side=TradeSide.SELL if side == TradeSide.BUY else TradeSide.BUY,
trade_type=TradeType.MARKET,
exchange_pair=ExchangePair(exchange, USD / BTC),
criteria=risk_criteria)
order += risk_management
order.attach(broker)
order.execute()
broker._executed[order.id] = order
# Execute fake trade
price = Decimal(7000.00)
scale = order.price / price
commission = 3.00 * USD
base_size = scale * order.size - commission.size
trade = mock_trade_class.return_value
trade.order_id = order.id
trade.size = base_size
trade.quantity = base_size * USD
trade.price = price
trade.commission = commission
base_wallet = portfolio.get_wallet(exchange.id, USD)
quote_wallet = portfolio.get_wallet(exchange.id, BTC)
base_size = trade.size + trade.commission.size
quote_size = (order.price / trade.price) * (trade.size / trade.price)
base_wallet.withdraw(quantity=Quantity(USD,
size=base_size,
path_id=order.path_id),
reason="test")
quote_wallet.deposit(quantity=Quantity(BTC,
size=quote_size,
path_id=order.path_id),
reason="test")
assert trade.order_id in broker.executed.keys()
assert trade not in broker.trades
assert broker.unexecuted == []
order.fill(trade)
assert order.remaining == 0
assert trade in broker.trades[order.id]
assert broker.unexecuted != []
