def test_reserve_quantity(self): # Test for reserve quantity self.assertEquals(Quantity(0, 'MC'), self.order.reserved_quantity) self.order.reserve_quantity_for_tick(self.tick.order_id, self.tick.quantity) self.assertEquals(Quantity(5, 'MC'), self.order.reserved_quantity) self.order.reserve_quantity_for_tick(self.tick.order_id, self.tick.quantity) self.assertEquals(Quantity(10, 'MC'), self.order.reserved_quantity)
def test_update_ticks(self): """ Test updating ticks in an orderbook """ self.order_book.insert_ask(self.ask) self.order_book.insert_bid(self.bid) ask_dict = { "trader_id": str(self.ask.order_id.trader_id), "order_number": int(self.ask.order_id.order_number), "quantity": 3, "quantity_type": self.ask.quantity.wallet_id, "traded_quantity": 3 } bid_dict = { "trader_id": str(self.bid.order_id.trader_id), "order_number": int(self.bid.order_id.order_number), "quantity": 3, "quantity_type": self.bid.quantity.wallet_id, "traded_quantity": 3 } self.order_book.get_tick(self.ask.order_id).reserve_for_matching( Quantity(3, self.ask.quantity.wallet_id)) self.order_book.get_tick(self.bid.order_id).reserve_for_matching( Quantity(3, self.bid.quantity.wallet_id)) self.order_book.update_ticks(ask_dict, bid_dict, Quantity(3, self.ask.quantity.wallet_id), unreserve=True) self.assertEqual(len(self.order_book.asks), 0) self.assertEqual(len(self.order_book.bids), 0)
def setUp(self, annotate=True): yield super(TestDatabase, self).setUp(annotate=annotate) path = os.path.join(self.getStateDir(), 'sqlite') if not os.path.exists(path): os.makedirs(path) self.database = MarketDB(self.getStateDir()) self.order_id1 = OrderId(TraderId('3'), OrderNumber(4)) self.order_id2 = OrderId(TraderId('4'), OrderNumber(5)) self.order1 = Order(self.order_id1, Price(5, 'EUR'), Quantity(6, 'BTC'), Timeout(3600), Timestamp.now(), True) self.order2 = Order(self.order_id2, Price(5, 'EUR'), Quantity(6, 'BTC'), Timeout(3600), Timestamp.now(), False) self.transaction_id1 = TransactionId(TraderId("0"), TransactionNumber(4)) self.transaction1 = Transaction(self.transaction_id1, Price(100, 'BTC'), Quantity(30, 'MC'), OrderId(TraderId("0"), OrderNumber(1)), OrderId(TraderId("1"), OrderNumber(2)), Timestamp(20.0)) self.payment1 = Payment(MessageId(TraderId("0"), MessageNumber("4")), self.transaction_id1, Quantity(5, 'MC'), Price(6, 'BTC'), WalletAddress('abc'), WalletAddress('def'), PaymentId("abc"), Timestamp(20.0), False) self.transaction1.add_payment(self.payment1)
def test_from_network(self): # Test for from network now = Timestamp.now() data = Bid.from_network( type( 'Data', (object, ), { "trader_id": TraderId('0'), "order_number": OrderNumber(2), "message_number": MessageNumber('message_number'), "price": Price(63400, 'BTC'), "quantity": Quantity(40, 'MC'), "timeout": Timeout(30), "timestamp": now, "public_key": 'a', "signature": 'b' })) self.assertEquals( MessageId(TraderId('0'), MessageNumber('message_number')), data.message_id) self.assertEquals(Price(63400, 'BTC'), data.price) self.assertEquals(Quantity(40, 'MC'), data.quantity) self.assertEquals(float(Timeout(30)), float(data.timeout)) self.assertEquals(now, data.timestamp) self.assertEquals('a', data._public_key) self.assertEquals('b', data._signature)
def test_proposed_trade_cache_timeout(self): """ Test the timeout method of a proposed trade request in the cache """ ask = Ask( OrderId(TraderId(self.market_community.mid), OrderNumber(24)), Price(63400, 'DUM1'), Quantity(30, 'DUM2'), Timeout(3600), Timestamp.now()) order = Order(OrderId(TraderId("0"), OrderNumber(23)), Price(20, 'DUM1'), Quantity(30, 'DUM2'), Timeout(3600.0), Timestamp.now(), False) self.market_community.order_book.insert_ask(ask) self.assertEqual(len(self.market_community.order_book.asks), 1) self.market_community.order_manager.order_repository.add(order) order.reserve_quantity_for_tick(self.proposed_trade.recipient_order_id, Quantity(30, 'DUM2')) self.market_community.order_manager.order_repository.update(order) mocked_match_message = MockObject() mocked_match_message.payload = MockObject() mocked_match_message.payload.matchmaker_trader_id = 'a' self.market_community.incoming_match_messages[ 'a'] = mocked_match_message def mocked_send_decline(*_): mocked_send_decline.called = True mocked_send_decline.called = False self.market_community.send_decline_match_message = mocked_send_decline cache = ProposedTradeRequestCache(self.market_community, self.proposed_trade, 'a') cache.on_timeout() self.assertTrue(mocked_send_decline.called)
def test_from_network(self): # Test for from network data = ProposedTrade.from_network( type( 'Data', (object, ), { "trader_id": TraderId('0'), "message_id": MessageId(TraderId('0'), MessageNumber(1)), "order_number": OrderNumber(1), "recipient_order_id": OrderId(TraderId('1'), OrderNumber(2)), "proposal_id": 1234, "timestamp": Timestamp(1462224447.117), "price": Price(63400, 'BTC'), "quantity": Quantity(30, 'MC') })) self.assertEquals(MessageId(TraderId('0'), MessageNumber(1)), data.message_id) self.assertEquals(OrderId(TraderId('0'), OrderNumber(1)), data.order_id) self.assertEquals(OrderId(TraderId('1'), OrderNumber(2)), data.recipient_order_id) self.assertEquals(1234, data.proposal_id) self.assertEquals(Price(63400, 'BTC'), data.price) self.assertEquals(Quantity(30, 'MC'), data.quantity) self.assertEquals(Timestamp(1462224447.117), data.timestamp)
def on_received_half_block(_): on_received_half_block.num_called += 1 if on_received_half_block.num_called == 2: # We received a block in both sessions self.assertEqual(ask_community.wallets['DUM1'].balance, 1100) self.assertEqual(bid_community.wallets['DUM1'].balance, 900) balance_ask = yield ask_community.wallets['MC'].get_balance() balance_bid = yield bid_community.wallets['MC'].get_balance() self.assertEqual(balance_ask['available'], -10) self.assertEqual(balance_bid['available'], 10) # Verify whether everything is cleaned up correctly order_ask = ask_community.order_manager.order_repository.find_all( )[0] order_bid = ask_community.order_manager.order_repository.find_all( )[0] self.assertEqual(order_ask.reserved_quantity, Quantity(0, 'MC')) self.assertEqual(order_ask.traded_quantity, Quantity(10, 'MC')) self.assertEqual(order_bid.reserved_quantity, Quantity(0, 'MC')) self.assertEqual(order_bid.traded_quantity, Quantity(10, 'MC')) self.assertEqual(len(order_ask.reserved_ticks.keys()), 0) self.assertEqual(len(order_bid.reserved_ticks.keys()), 0) self.assertEqual( len(ask_community.order_book.asks) + len(ask_community.order_book.bids), 0) self.assertEqual( len(bid_community.order_book.asks) + len(bid_community.order_book.bids), 0) test_deferred.callback(None)
def test_bid_side_depth(self): # Test for bid side depth self.order_book.insert_bid(self.bid) self.order_book.insert_bid(self.bid2) self.assertEquals(Quantity(30, 'MC'), self.order_book.bid_side_depth(Price(300, 'BTC'))) self.assertEquals([(Price(200, 'BTC'), Quantity(30, 'MC')), (Price(300, 'BTC'), Quantity(30, 'MC'))], self.order_book.get_bid_side_depth_profile('BTC', 'MC'))
def release_quantity_for_tick(self, order_id, quantity): """ Release all quantity for a specific tick. :param order_id: The order id from another peer that the quantity needs to be released for :type order_id: OrderId :raises TickWasNotReserved: Thrown when the tick was not reserved first """ if order_id not in self._reserved_ticks: raise TickWasNotReserved() if self._reserved_quantity >= quantity: self._reserved_quantity -= quantity self._reserved_ticks[order_id] -= quantity assert self.available_quantity >= Quantity( 0, self._quantity.wallet_id), str(self.available_quantity) if self._reserved_ticks[order_id] <= Quantity( 0, quantity.wallet_id): # Remove the quantity if it's zero del self._reserved_ticks[order_id] else: raise ValueError("Not enough reserved quantity for order id %s" % order_id) self._logger.debug( "Released quantity for order id %s (own order id: %s)," "total quantity: %s, traded quantity: %s, reserved quantity: %s", str(order_id), str(self.order_id), self.total_quantity, self.traded_quantity, self.reserved_quantity)
def test_ask_side_depth(self): # Test for ask side depth self.order_book.insert_ask(self.ask) self.order_book.insert_ask(self.ask2) self.assertEquals(Quantity(30, 'MC'), self.order_book.ask_side_depth(Price(100, 'BTC'))) self.assertEquals([(Price(100, 'BTC'), Quantity(30, 'MC')), (Price(400, 'BTC'), Quantity(30, 'MC'))], self.order_book.get_ask_side_depth_profile('BTC', 'MC'))
def test_encode_match(self): """ Test encoding and decoding of a match message """ message = MockObject() meta_msg = self.market_community.get_meta_message(u"match") match_payload = MatchPayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'), OrderNumber(4), Price(1, 'BTC'), Quantity(2, 'MC'), Timeout(3600), Timestamp.now(), '192.168.1.1', 1234, OrderNumber(3), Quantity(2, 'MC'), TraderId('abc'), TraderId('def'), 'match_id') message.payload = match_payload packet, = self.conversion._encode_match(message) self.assertTrue(packet) _, decoded = self.conversion._decode_match( self.get_placeholder_msg(u"match"), 0, packet) self.assertTrue(decoded) self.assertEqual(decoded.match_id, 'match_id')
def from_database(cls, data, payments): """ Create a Transaction object based on information in the database. """ trader_id, transaction_number, order_trader_id, order_number, partner_trader_id, partner_order_number, price,\ price_type, transferred_price, quantity, quantity_type, transferred_quantity, transaction_timestamp,\ sent_wallet_info, received_wallet_info, incoming_address, outgoing_address, partner_incoming_address,\ partner_outgoing_address, match_id = data transaction_id = TransactionId(TraderId(str(trader_id)), TransactionNumber(transaction_number)) transaction = cls( transaction_id, Price(price, str(price_type)), Quantity(quantity, str(quantity_type)), OrderId(TraderId(str(order_trader_id)), OrderNumber(order_number)), OrderId(TraderId(str(partner_trader_id)), OrderNumber(partner_order_number)), Timestamp(float(transaction_timestamp))) transaction._transferred_price = Price(transferred_price, str(price_type)) transaction._transferred_quantity = Quantity(transferred_quantity, str(quantity_type)) transaction.sent_wallet_info = sent_wallet_info transaction.received_wallet_info = received_wallet_info transaction.incoming_address = WalletAddress(str(incoming_address)) transaction.outgoing_address = WalletAddress(str(outgoing_address)) transaction.partner_incoming_address = WalletAddress( str(partner_incoming_address)) transaction.partner_outgoing_address = WalletAddress( str(partner_outgoing_address)) transaction.match_id = str(match_id) transaction._payments = payments return transaction
def test_from_network(self): # Test for from network data = Payment.from_network( type( 'Data', (object, ), { "message_id": MessageId(TraderId("0"), MessageNumber(1)), "transaction_id": TransactionId(TraderId('2'), TransactionNumber(2)), "transferee_quantity": Quantity(3, 'MC'), "transferee_price": Price(2, 'BTC'), "address_from": WalletAddress('a'), "address_to": WalletAddress('b'), "payment_id": PaymentId('aaa'), "timestamp": Timestamp(4.0), "success": True })) self.assertEquals(MessageId(TraderId("0"), MessageNumber(1)), data.message_id) self.assertEquals(TransactionId(TraderId('2'), TransactionNumber(2)), data.transaction_id) self.assertEquals(Quantity(3, 'MC'), data.transferee_quantity) self.assertEquals(Price(2, 'BTC'), data.transferee_price) self.assertEquals(Timestamp(4.0), data.timestamp) self.assertTrue(data.success)
def from_unpack_list(cls, trader_id, message_number, timestamp, order_number, price, price_type, quantity, quantity_type, timeout, ip, port, recipient_order_number, match_quantity, match_quantity_type, match_trader_id, matchmaker_trader_id, match_id): return MatchPayload(MessageId(TraderId(trader_id), MessageNumber(message_number)), Timestamp(timestamp), OrderNumber(order_number), Price(price, price_type), Quantity(quantity, quantity_type), Timeout(timeout), SocketAddress(ip, port), OrderNumber(recipient_order_number), Quantity(match_quantity, match_quantity_type), TraderId(match_trader_id), TraderId(matchmaker_trader_id), match_id)
def test_init(self): """ Test the initialization of a quantity """ with self.assertRaises(ValueError): Quantity('1', 'MC') with self.assertRaises(ValueError): Quantity(1, 2)
def setUp(self): # Object creation self.match_payload = MatchPayload.Implementation( MetaObject(), TraderId('0'), MessageNumber('message_number'), OrderNumber(1), Price(63400, 'BTC'), Quantity(30, 'MC'), Timeout(1470004447.117), Timestamp(1462224447.117), "1.1.1.1", 1, OrderNumber(2), Quantity(20, 'MC'), TraderId('1'), TraderId('2'), 'a')
def test_pagerank_2(self): """ Test isolated nodes during a Temporal Pagerank computation """ self.insert_transaction('a', 'b', Quantity(1, 'BTC'), Price(1, 'MC')) self.insert_transaction('c', 'd', Quantity(1, 'BTC'), Price(1, 'MC')) rep_dict = self.compute_reputations() self.assertTrue('c' in rep_dict) self.assertTrue('d' in rep_dict)
def setUp(self): # Object creation self.proposed_trade = Trade.propose(MessageId(TraderId('0'), MessageNumber('message_number')), OrderId(TraderId('0'), OrderNumber(1)), OrderId(TraderId('1'), OrderNumber(2)), Price(63400, 'BTC'), Quantity(30, 'MC'), Timestamp(1462224447.117)) self.counter_trade = Trade.counter(MessageId(TraderId('0'), MessageNumber('message_number')), Quantity(15, 'MC'), Timestamp(1462224447.117), self.proposed_trade)
def test_search_for_quantity_in_order_book_partial_ask_low(self): # Test for protected search for quantity in order book partial ask when price is too low self.order_book.insert_bid(self.bid) self.order_book.insert_bid(self.bid2) self.order_book.insert_bid(self.bid3) self.order_book.insert_bid(self.bid4) quantity_to_trade, proposed_trades = self.price_time_strategy._search_for_quantity_in_order_book_partial_ask( Price(100, 'BTC'), Quantity(30, 'MC'), [], self.ask_order2) self.assertEquals(1, len(proposed_trades)) self.assertEquals(Quantity(0, 'MC'), quantity_to_trade)
def test_release_quantity(self): # Test for release quantity self.order.reserve_quantity_for_tick(self.tick.order_id, self.tick.quantity) self.assertEquals(Quantity(5, 'MC'), self.order.reserved_quantity) self.order.release_quantity_for_tick(self.tick.order_id, Quantity(5, 'MC')) self.assertEquals(Quantity(0, 'MC'), self.order.reserved_quantity) self.order.reserve_quantity_for_tick(self.tick.order_id, self.tick.quantity) quantity = self.tick.quantity + Quantity(1, self.tick.quantity.wallet_id) self.assertRaises(ValueError, self.order.release_quantity_for_tick, self.tick.order_id, quantity)
def setUp(self): # Object creation self.memory_order_repository = MemoryOrderRepository("0") self.order_id = OrderId(TraderId("0"), OrderNumber(1)) self.order = Order(self.order_id, Price(100, 'BTC'), Quantity(30, 'MC'), Timeout(0.0), Timestamp(10.0), False) self.order2 = Order(self.order_id, Price(1000, 'BTC'), Quantity(30, 'MC'), Timeout(0.0), Timestamp(10.0), False)
def setUp(self): # Object creation self.tick = Tick(OrderId(TraderId('0'), OrderNumber(1)), Price(400, 'BTC'), Quantity(30, 'MC'), Timeout(float("inf")), Timestamp(float("inf")), True) self.tick2 = Tick(OrderId(TraderId('1'), OrderNumber(2)), Price(800, 'BTC'), Quantity(30, 'MC'), Timeout(float("inf")), Timestamp(float("inf")), True) self.side = Side()
def test_add_trade(self): """ Test the add trade method of an order """ self.order.reserve_quantity_for_tick( OrderId(TraderId('5'), OrderNumber(1)), Quantity(10, 'MC')) self.assertEquals(self.order.traded_quantity, Quantity(0, 'MC')) self.order.add_trade(OrderId(TraderId('5'), OrderNumber(1)), Quantity(10, 'MC')) self.assertEquals(self.order.traded_quantity, Quantity(10, 'MC'))
def test_match_order_divided(self): # Test for match order divided over two ticks self.order_book.insert_ask(self.ask) self.order_book.insert_ask(self.ask2) proposed_trades = self.price_time_strategy.match_order(self.bid_order2) self.assertEquals(2, len(proposed_trades)) self.assertEquals(Price(100, 'BTC'), proposed_trades[0].price) self.assertEquals(Quantity(30, 'MC'), proposed_trades[0].quantity) self.assertEquals(Price(100, 'BTC'), proposed_trades[1].price) self.assertEquals(Quantity(30, 'MC'), proposed_trades[1].quantity)
def test_search_for_quantity_in_order_book_partial_bid(self): # Test for protected search for quantity in order book partial bid self.order_book.insert_ask(self.ask) self.order_book.insert_ask(self.ask2) self.order_book.insert_ask(self.ask3) self.order_book.insert_ask(self.ask4) quantity_to_trade, proposed_trades = self.price_time_strategy._search_for_quantity_in_order_book_partial_bid( Price(50, 'BTC'), Quantity(30, 'MC'), [], self.bid_order) self.assertEquals(1, len(proposed_trades)) self.assertEquals(Quantity(0, 'MC'), quantity_to_trade)
def test_create_bid_order(self): # Test for create bid order bid_order = self.order_manager.create_bid_order( Price(100, 'BTC'), Quantity(10, 'MC'), Timeout(0.0)) self.assertFalse(bid_order.is_ask()) self.assertEquals(OrderId(TraderId("0"), OrderNumber(1)), bid_order.order_id) self.assertEquals(Price(100, 'BTC'), bid_order.price) self.assertEquals(Quantity(10, 'MC'), bid_order.total_quantity) self.assertEquals(0.0, float(bid_order.timeout))
def test_match_order_partial_bid(self): """ Test partial matching of an ask order with the matching engine """ self.bid._quantity = Quantity(20, 'MC') self.order_book.insert_bid(self.bid) matching_ticks = self.price_time_strategy.match( self.ask_order2.order_id, self.ask_order2.price, self.ask_order2.available_quantity, True) self.assertEquals(1, len(matching_ticks)) self.assertEquals(Quantity(20, 'MC'), matching_ticks[0][2])
def test_match_order_divided(self): """ Test for match order divided over two ticks """ self.order_book.insert_ask(self.ask) self.order_book.insert_ask(self.ask2) matching_ticks = self.price_time_strategy.match( self.bid_order2.order_id, self.bid_order2.price, self.bid_order2.available_quantity, False) self.assertEquals(2, len(matching_ticks)) self.assertEquals(Quantity(30, 'MC'), matching_ticks[0][2]) self.assertEquals(Quantity(30, 'MC'), matching_ticks[1][2])
def test_search_for_quantity_in_order_book_partial_ask_low(self): """ Test for protected search for quantity in order book partial ask when price is too low """ self.order_book.insert_bid(self.bid) self.order_book.insert_bid(self.bid2) self.order_book.insert_bid(self.bid3) self.order_book.insert_bid(self.bid4) matching_ticks = self.price_time_strategy._search_for_quantity_in_order_book_partial_ask( self.ask_order2.order_id, Price(100, 'BTC'), Quantity(30, 'MC'), [], self.ask_order2.price, True) self.assertEquals(1, len(matching_ticks)) self.assertEquals(Quantity(30, 'MC'), matching_ticks[0][2])
def test_search_for_quantity_in_order_book_partial_bid(self): """ Test for protected search for quantity in order book partial bid """ self.order_book.insert_ask(self.ask) self.order_book.insert_ask(self.ask2) self.order_book.insert_ask(self.ask3) self.order_book.insert_ask(self.ask4) matching_ticks = self.price_time_strategy._search_for_quantity_in_order_book_partial_bid( self.bid_order.order_id, Price(50, 'BTC'), Quantity(30, 'MC'), [], self.bid_order.price, False) self.assertEquals(1, len(matching_ticks)) self.assertEquals(Quantity(30, 'MC'), matching_ticks[0][2])