def test_ticker(self):
ordersA = Orders(self.market, Market.TYPE_ASK)
ordersB = Orders(self.market, Market.TYPE_BID)
self.market.depth_bid(3.5, 1)
self.market.depth_bid(3.3, 1)
self.market.depth_bid(3.0, 1)
self.market.depth_bid(2.2, 1)
self.market.depth_bid(1.3, 1)
self.market.depth_bid(1.0, 1)
self.market.depth_ask(4.6, 1)
self.market.depth_ask(5.0, 1)
self.market.depth_ask(5.2, 1)
self.market.depth_ask(6.0, 1)
self.market.depth_ask(6.5, 1)
self.market.ticker(3.0, 5.0)
self.assertEquals(4, ordersA.size())
self.assertEquals(to_money(5.0), ordersA.get_price(0))
self.assertEquals(4, ordersB.size())
self.assertEquals(to_money(3.0), ordersB.get_price(0))
def test_depth_ask(self):
orders = Orders(self.market, Market.TYPE_ASK, 1)
self.market.depth_ask(10, 1)
self.market.depth_ask(20, 1)
self.market.depth_ask(30, 1)
self.assertEquals(to_money(10), orders.get_price(0))
self.assertEquals(to_money(20), orders.get_price(1))
self.assertEquals(to_money(30), orders.get_price(2))
def test_total(self):
orders = Orders(self.market, Market.TYPE_ASK)
self.market.depth_ask(10, 3)
self.market.depth_ask(20, 2)
self.market.depth_ask(30, 1)
self.assertEquals(3, orders.size())
self.assertEquals(to_money(3), orders.get_total(0))
self.assertEquals(to_money(5), orders.get_total(1))
self.assertEquals(to_money(6), orders.get_total(2))
def test_grouping_price(self):
orders = Orders(self.market, Market.TYPE_ASK, 1)
# group 0
self.market.depth_ask(120.0, 1)
# group 1
self.market.depth_ask(120.4, 1)
self.market.depth_ask(121.0, 1)
# group 2
self.market.depth_ask(121.8, 1)
self.assertEquals(to_money(120.0), orders.get_price(0))
self.assertEquals(to_money(121.0), orders.get_price(1))
self.assertEquals(to_money(122.0), orders.get_price(2))
def __init__(self, market, typ, grouping=0):
QObject.__init__(self)
self.__typ = typ
self.__market = market
self.__market.signal_trade.connect(self.__slot_trade)
self.__market.signal_ticker.connect(self.__slot_ticker)
if typ == Market.TYPE_BID:
self.__market.signal_bid.connect(self.__slot_depth)
self.__market.signal_bids.connect(self.__slot_depths)
self.__compare = lambda x, y: x > y
elif typ == Market.TYPE_ASK:
self.__market.signal_ask.connect(self.__slot_depth)
self.__market.signal_asks.connect(self.__slot_depths)
self.__compare = lambda x, y: x < y
else:
raise Exception('Invalid order book type {}.'.format(typ))
self.__levels = []
if grouping == 0:
self.__grouping = 1
else:
self.__grouping = money.to_money(grouping)
def test_delete_all(self):
level = Level(0)
level.update(to_money(120), to_money(1))
level.update(to_money(121), to_money(1))
level.update(to_money(122), to_money(1))
level.delete_all(lambda x, y: x < y, to_money(122))
self.assertEquals(1, level.size())
def test_grouping(self):
orders = Orders(self.market, Market.TYPE_ASK, 0.6)
# group 0
self.market.depth_ask(0.0, 1)
# group 1
self.market.depth_ask(0.1, 1)
self.market.depth_ask(0.3, 1)
self.market.depth_ask(0.6, 1)
self.assertEquals(2, orders.size())
self.assertEquals(to_money(3), orders.get_volume(1))
# group 2
self.market.depth_ask(1.1, 1)
self.market.depth_ask(1.2, 1)
self.assertEquals(3, orders.size())
# remove group 2
self.market.depth_ask(1.1, 0)
self.market.depth_ask(1.2, 0)
self.assertEquals(2, orders.size())
def test_update(self):
level = Level(0)
level.update(to_money(120), to_money(1))
self.assertEquals(to_money(1), level.volume)
self.assertEquals(to_money(120), level.price)
level.update(to_money(121), to_money(1))
self.assertEquals(to_money(2), level.volume)
self.assertEquals(to_money(120.5), level.price)
level.update(to_money(120), to_money(0))
self.assertEquals(to_money(1), level.volume)
self.assertEquals(to_money(121), level.price)
def get_trade_total(self):
return money.to_money(self.ui.doubleSpinBoxTotal.value())
def get_trade_price(self):
return money.to_money(self.ui.doubleSpinBoxPrice.value())
def get_trade_size(self):
return money.to_money(self.ui.doubleSpinBoxSize.value())
def ticker(self, bid, ask):
self.signal_ticker.emit(to_money(bid), to_money(ask))
def depth_asks(self, depths):
for depth in depths:
depth[0] = to_money(depth[0])
depth[1] = to_money(depth[1])
self.signal_asks.emit(depths)
def depth_ask(self, price, volume):
self.signal_ask.emit(to_money(price), to_money(volume))
def depth_bid(self, price, volume):
self.signal_bid.emit(to_money(price), to_money(volume))
def test_to_money(self):
self.assertEquals(1550000000, money.to_money(15.5))
