async def setUp(self): super(TestDatabase, self).setUp() path = os.path.join(self.getStateDir(), 'sqlite') if not os.path.exists(path): os.makedirs(path) self.database = MarketDB(self.getStateDir(), 'market') self.order_id1 = OrderId(TraderId(b'3' * 20), OrderNumber(4)) self.order_id2 = OrderId(TraderId(b'4' * 20), OrderNumber(5)) self.order1 = Order( self.order_id1, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')), Timeout(3600), Timestamp.now(), True) self.order2 = Order( self.order_id2, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')), Timeout(3600), Timestamp.now(), False) self.order2.reserve_quantity_for_tick( OrderId(TraderId(b'3' * 20), OrderNumber(4)), 3) self.transaction_id1 = TransactionId(b'a' * 32) self.transaction1 = Transaction( self.transaction_id1, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MB')), OrderId(TraderId(b'0' * 20), OrderNumber(1)), OrderId(TraderId(b'1' * 20), OrderNumber(2)), Timestamp(20000)) self.payment1 = Payment(TraderId(b'0' * 20), self.transaction_id1, AssetAmount(5, 'BTC'), WalletAddress('abc'), WalletAddress('def'), PaymentId("abc"), Timestamp(20000)) self.transaction1.add_payment(self.payment1)
def setUp(self): yield super(MatchingEngineTestSuite, self).setUp() # Object creation self.ask = Ask( OrderId(TraderId(b'2' * 20), OrderNumber(1)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(30), Timestamp.now()) self.bid = Bid( OrderId(TraderId(b'4' * 20), OrderNumber(2)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(30), Timestamp.now()) self.ask_order = Order( OrderId(TraderId(b'5' * 20), OrderNumber(3)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(30), Timestamp.now(), True) self.bid_order = Order( OrderId(TraderId(b'6' * 20), OrderNumber(4)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(30), Timestamp.now(), False) self.order_book = OrderBook() self.matching_engine = MatchingEngine( PriceTimeStrategy(self.order_book)) self.ask_count = 2 self.bid_count = 2
def setUp(self): # Object creation self.transaction_id = TransactionId(b'a' * 32) self.transaction = Transaction( self.transaction_id, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MC')), OrderId(TraderId(b'0' * 20), OrderNumber(2)), OrderId(TraderId(b'1' * 20), OrderNumber(1)), Timestamp(0)) self.proposed_trade = Trade.propose( TraderId(b'0' * 20), OrderId(TraderId(b'0' * 20), OrderNumber(2)), OrderId(TraderId(b'1' * 20), OrderNumber(3)), AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MC')), Timestamp(0)) self.tick = Tick( OrderId(TraderId(b'0' * 20), OrderNumber(1)), AssetPair(AssetAmount(5, 'BTC'), AssetAmount(5, 'MC')), Timeout(0), Timestamp(00), True) self.tick2 = Tick( OrderId(TraderId(b'0' * 20), OrderNumber(2)), AssetPair(AssetAmount(500, 'BTC'), AssetAmount(5, 'MC')), Timeout(0), Timestamp(0), True) self.order_timestamp = Timestamp.now() self.order = Order( OrderId(TraderId(b'0' * 20), OrderNumber(3)), AssetPair(AssetAmount(50, 'BTC'), AssetAmount(40, 'MC')), Timeout(5000), self.order_timestamp, False) self.order.set_verified() self.order2 = Order( OrderId(TraderId(b'0' * 20), OrderNumber(4)), AssetPair(AssetAmount(50, 'BTC'), AssetAmount(10, 'MC')), Timeout(5), Timestamp(int(time.time() * 1000) - 1000 * 1000), True) self.order2.set_verified()
def setUp(self): # Object creation self.memory_order_repository = MemoryOrderRepository(b'0' * 20) self.order_id = OrderId(TraderId(b'0' * 20), OrderNumber(1)) self.order = Order(self.order_id, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MC')), Timeout(0), Timestamp(10), False) self.order2 = Order(self.order_id, AssetPair(AssetAmount(1000, 'BTC'), AssetAmount(30, 'MC')), Timeout(0), Timestamp(10), False)
def order2(): order_id2 = OrderId(TraderId(b'4' * 20), OrderNumber(5)) order2 = Order(order_id2, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')), Timeout(3600), Timestamp.now(), False) order2.reserve_quantity_for_tick( OrderId(TraderId(b'3' * 20), OrderNumber(4)), 3) return order2
def setUp(self): order_id = OrderId(TraderId(b'3' * 20), OrderNumber(1)) self.ask_order = Order( order_id, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')), Timeout(3600), Timestamp.now(), True) self.bid_order = Order( order_id, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')), Timeout(3600), Timestamp.now(), False) self.queue = MatchPriorityQueue(self.ask_order)
def test_has_acceptable_price(self): """ Test the acceptable price method """ order = Order(OrderId(TraderId(b'0' * 20), OrderNumber(3)), AssetPair(AssetAmount(60, 'BTC'), AssetAmount(30, 'MB')), Timeout(5000), self.order_timestamp, True) pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(30, 'MB')) self.assertTrue(order.has_acceptable_price(pair)) pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(15, 'MB')) self.assertFalse(order.has_acceptable_price(pair)) pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(60, 'MB')) self.assertTrue(order.has_acceptable_price(pair)) order._is_ask = False pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(30, 'MB')) self.assertTrue(order.has_acceptable_price(pair)) pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(15, 'MB')) self.assertTrue(order.has_acceptable_price(pair)) pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(60, 'MB')) self.assertFalse(order.has_acceptable_price(pair))
def setUp(self): yield super(PriceTimeStrategyTestSuite, self).setUp() # Object creation self.ask = Ask( OrderId(TraderId(b'0' * 20), OrderNumber(1)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(100), Timestamp.now()) self.ask2 = Ask( OrderId(TraderId(b'1' * 20), OrderNumber(2)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(100), Timestamp.now()) self.ask3 = Ask( OrderId(TraderId(b'0' * 20), OrderNumber(3)), AssetPair(AssetAmount(40000, 'BTC'), AssetAmount(200, 'MB')), Timeout(100), Timestamp.now()) self.ask4 = Ask( OrderId(TraderId(b'1' * 20), OrderNumber(4)), AssetPair(AssetAmount(3000, 'A'), AssetAmount(3000, 'MB')), Timeout(100), Timestamp.now()) self.ask5 = Ask( OrderId(TraderId(b'1' * 20), OrderNumber(4)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'C')), Timeout(100), Timestamp.now()) self.bid = Bid( OrderId(TraderId(b'0' * 20), OrderNumber(5)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(100), Timestamp.now()) self.bid2 = Bid( OrderId(TraderId(b'0' * 20), OrderNumber(6)), AssetPair(AssetAmount(6000, 'BTC'), AssetAmount(30, 'MB')), Timeout(100), Timestamp.now()) self.ask_order = Order( OrderId(TraderId(b'9' * 20), OrderNumber(11)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(100), Timestamp.now(), True) self.ask_order2 = Order( OrderId(TraderId(b'9' * 20), OrderNumber(12)), AssetPair(AssetAmount(600, 'BTC'), AssetAmount(60, 'MB')), Timeout(100), Timestamp.now(), True) self.bid_order = Order( OrderId(TraderId(b'9' * 20), OrderNumber(13)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(100), Timestamp.now(), False) self.bid_order2 = Order( OrderId(TraderId(b'9' * 20), OrderNumber(14)), AssetPair(AssetAmount(6000, 'BTC'), AssetAmount(60, 'MB')), Timeout(100), Timestamp.now(), False) self.order_book = OrderBook() self.price_time_strategy = PriceTimeStrategy(self.order_book)
def get_tx_done_block(ask_amount, bid_amount, traded_amount, ask_total_traded, bid_total_traded): ask_pair = AssetPair(AssetAmount(ask_amount, 'BTC'), AssetAmount(ask_amount, 'MB')) bid_pair = AssetPair(AssetAmount(bid_amount, 'BTC'), AssetAmount(bid_amount, 'MB')) ask = Order(OrderId(TraderId(b'0' * 20), OrderNumber(1)), ask_pair, Timeout(3600), Timestamp.now(), True) ask._traded_quantity = ask_total_traded bid = Order(OrderId(TraderId(b'1' * 20), OrderNumber(1)), bid_pair, Timeout(3600), Timestamp.now(), False) bid._traded_quantity = bid_total_traded tx = Transaction( TransactionId(TraderId(b'0' * 20), TransactionNumber(1)), AssetPair(AssetAmount(traded_amount, 'BTC'), AssetAmount(traded_amount, 'MB')), OrderId(TraderId(b'0' * 20), OrderNumber(1)), OrderId(TraderId(b'1' * 20), OrderNumber(1)), Timestamp(0)) tx.transferred_assets.first += AssetAmount(traded_amount, 'BTC') tx.transferred_assets.second += AssetAmount(traded_amount, 'MB') tx_done_block = MarketBlock() tx_done_block.type = b'tx_done' tx_done_block.transaction = { 'ask': ask.to_status_dictionary(), 'bid': bid.to_status_dictionary(), 'tx': tx.to_dictionary(), 'version': MarketCommunity.PROTOCOL_VERSION } tx_done_block.transaction['ask']['address'], tx_done_block.transaction[ 'ask']['port'] = "1.1.1.1", 1234 tx_done_block.transaction['bid']['address'], tx_done_block.transaction[ 'bid']['port'] = "1.1.1.1", 1234 return tx_done_block
def get_all_orders(self): """ Return all orders in the database. """ db_result = self.execute(u"SELECT * FROM orders") return [Order.from_database(db_item, self.get_reserved_ticks( OrderId(TraderId(bytes(db_item[0])), OrderNumber(db_item[1])))) for db_item in db_result]
def setUp(self): # Object creation self.timestamp_now = Timestamp.now() self.tick = Tick( OrderId(TraderId(b'0' * 20), OrderNumber(1)), AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')), Timeout(30), Timestamp(0), True) self.tick2 = Tick( OrderId(TraderId(b'0' * 20), OrderNumber(2)), AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')), Timeout(0), Timestamp(0), False) self.order_ask = Order( OrderId(TraderId(b'0' * 20), OrderNumber(2)), AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')), Timeout(0), Timestamp(0), True) self.order_bid = Order( OrderId(TraderId(b'0' * 20), OrderNumber(2)), AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')), Timeout(0), Timestamp(0), False)
def get_order(self, order_id): """ Return an order with a specific id. """ try: db_result = next(self.execute(u"SELECT * FROM orders WHERE trader_id = ? AND order_number = ?", (database_blob(bytes(order_id.trader_id)), text_type(order_id.order_number)))) except StopIteration: return None return Order.from_database(db_result, self.get_reserved_ticks(order_id))
def test_match_order_divided(order_book, strategy, ask): """ Test for match order divided over two ticks """ order_book.insert_ask(ask) ask2 = Ask(OrderId(TraderId(b'1' * 20), OrderNumber(2)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(100), Timestamp.now()) bid_order2 = Order( OrderId(TraderId(b'9' * 20), OrderNumber(14)), AssetPair(AssetAmount(6000, 'BTC'), AssetAmount(60, 'MB')), Timeout(100), Timestamp.now(), False) order_book.insert_ask(ask2) matching_ticks = strategy.match(bid_order2.order_id, bid_order2.price, bid_order2.available_quantity, False) assert len(matching_ticks) == 2
def create_bid_order(self, assets, timeout): """ Create a bid order (buy order) :param assets: The assets to be exchanged :param timeout: The timeout of the order, when does the order need to be timed out :type assets: AssetPair :type timeout: Timeout :return: The order that is created :rtype: Order """ order = Order(self.order_repository.next_identity(), assets, timeout, Timestamp.now(), False) self.order_repository.add(order) self._logger.info("Bid order created with id: " + str(order.order_id)) return order
def bid_order(): return Order(OrderId(TraderId(b'9' * 20), OrderNumber(13)), AssetPair(AssetAmount(3000, 'BTC'), AssetAmount(30, 'MB')), Timeout(100), Timestamp.now(), False)
def bid_order(): order_id = OrderId(TraderId(b'3' * 20), OrderNumber(1)) return Order(order_id, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')), Timeout(3600), Timestamp.now(), False)
def order1(): order_id1 = OrderId(TraderId(b'3' * 20), OrderNumber(4)) return Order(order_id1, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')), Timeout(3600), Timestamp.now(), True)
class OrderTestSuite(unittest.TestCase): """Order test cases.""" def setUp(self): # Object creation self.transaction_id = TransactionId(b'a' * 32) self.transaction = Transaction( self.transaction_id, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MC')), OrderId(TraderId(b'0' * 20), OrderNumber(2)), OrderId(TraderId(b'1' * 20), OrderNumber(1)), Timestamp(0)) self.proposed_trade = Trade.propose( TraderId(b'0' * 20), OrderId(TraderId(b'0' * 20), OrderNumber(2)), OrderId(TraderId(b'1' * 20), OrderNumber(3)), AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MC')), Timestamp(0)) self.tick = Tick( OrderId(TraderId(b'0' * 20), OrderNumber(1)), AssetPair(AssetAmount(5, 'BTC'), AssetAmount(5, 'MC')), Timeout(0), Timestamp(00), True) self.tick2 = Tick( OrderId(TraderId(b'0' * 20), OrderNumber(2)), AssetPair(AssetAmount(500, 'BTC'), AssetAmount(5, 'MC')), Timeout(0), Timestamp(0), True) self.order_timestamp = Timestamp.now() self.order = Order( OrderId(TraderId(b'0' * 20), OrderNumber(3)), AssetPair(AssetAmount(50, 'BTC'), AssetAmount(40, 'MC')), Timeout(5000), self.order_timestamp, False) self.order.set_verified() self.order2 = Order( OrderId(TraderId(b'0' * 20), OrderNumber(4)), AssetPair(AssetAmount(50, 'BTC'), AssetAmount(10, 'MC')), Timeout(5), Timestamp(int(time.time() * 1000) - 1000 * 1000), True) self.order2.set_verified() def test_add_trade(self): """ Test the add trade method of an order """ self.order.reserve_quantity_for_tick( OrderId(TraderId(b'5' * 20), OrderNumber(1)), 10) self.assertEqual(self.order.traded_quantity, 0) self.order.add_trade(OrderId(TraderId(b'5' * 20), OrderNumber(1)), AssetAmount(10, 'BTC')) self.assertEqual(self.order.traded_quantity, 10) self.order.reserve_quantity_for_tick( OrderId(TraderId(b'6' * 20), OrderNumber(1)), 40) self.order.add_trade(OrderId(TraderId(b'6' * 20), OrderNumber(1)), AssetAmount(40, 'MC')) self.order.add_trade(OrderId(TraderId(b'6' * 20), OrderNumber(1)), AssetAmount(40, 'BTC')) self.assertTrue(self.order.is_complete()) self.assertFalse(self.order.cancelled) def test_has_acceptable_price(self): """ Test the acceptable price method """ order = Order(OrderId(TraderId(b'0' * 20), OrderNumber(3)), AssetPair(AssetAmount(60, 'BTC'), AssetAmount(30, 'MB')), Timeout(5000), self.order_timestamp, True) pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(30, 'MB')) self.assertTrue(order.has_acceptable_price(pair)) pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(15, 'MB')) self.assertFalse(order.has_acceptable_price(pair)) pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(60, 'MB')) self.assertTrue(order.has_acceptable_price(pair)) order._is_ask = False pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(30, 'MB')) self.assertTrue(order.has_acceptable_price(pair)) pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(15, 'MB')) self.assertTrue(order.has_acceptable_price(pair)) pair = AssetPair(AssetAmount(60, 'BTC'), AssetAmount(60, 'MB')) self.assertFalse(order.has_acceptable_price(pair)) def test_is_ask(self): # Test for is ask self.assertTrue(self.order2.is_ask()) self.assertFalse(self.order.is_ask()) def test_reserve_quantity_insufficient(self): # Test for reserve insufficient quantity self.assertRaises(ValueError, self.order.reserve_quantity_for_tick, self.tick2.order_id, self.tick2.assets.first.amount) def test_reserve_quantity(self): # Test for reserve quantity self.assertEqual(0, self.order.reserved_quantity) self.order.reserve_quantity_for_tick(self.tick.order_id, 5) self.assertEqual(5, self.order.reserved_quantity) self.order.reserve_quantity_for_tick(self.tick.order_id, 5) self.assertEqual(10, self.order.reserved_quantity) def test_release_quantity(self): # Test for release quantity self.order.reserve_quantity_for_tick(self.tick.order_id, 5) self.assertEqual(5, self.order.reserved_quantity) self.order.release_quantity_for_tick(self.tick.order_id, 5) self.assertEqual(0, self.order.reserved_quantity) self.order.reserve_quantity_for_tick(self.tick.order_id, self.tick.assets.first.amount) quantity = self.tick.assets.first.amount + 1 self.assertRaises(ValueError, self.order.release_quantity_for_tick, self.tick.order_id, quantity) def test_release_unreserved_quantity(self): # Test for release unreserved quantity with self.assertRaises(TickWasNotReserved): self.order.release_quantity_for_tick(self.tick.order_id, AssetAmount(5, 'BTC')) def test_is_valid(self): self.assertTrue(self.order.is_valid()) self.assertFalse(self.order2.is_valid()) def test_status(self): """ Test the status of an order """ self.order._verified = False self.assertEqual(self.order.status, "unverified") self.order.set_verified() self.assertEqual(self.order.status, "open") self.order._timeout = Timeout(0) self.assertEqual(self.order.status, "expired") self.order._timeout = Timeout(3600) self.order._traded_quantity = self.order.assets.first.amount self.order._received_quantity = self.order.assets.second.amount self.assertEqual(self.order.status, "completed") self.order._cancelled = True self.assertEqual(self.order.status, "cancelled") def test_to_dict(self): """ Test the conversion of an order to a dictionary """ self.assertEqual( self.order.to_dictionary(), { "trader_id": "30" * 20, "cancelled": False, "completed_timestamp": None, "is_ask": False, "order_number": 3, "assets": { "first": { "amount": 50, "type": "BTC", }, "second": { "amount": 40, "type": "MC" } }, "reserved_quantity": 0, "traded": 0, "status": "open", "timeout": 5000, "timestamp": int(self.order_timestamp) })
class TestDatabase(AbstractServer): async def setUp(self): super(TestDatabase, self).setUp() path = os.path.join(self.getStateDir(), 'sqlite') if not os.path.exists(path): os.makedirs(path) self.database = MarketDB(self.getStateDir(), 'market') self.order_id1 = OrderId(TraderId(b'3' * 20), OrderNumber(4)) self.order_id2 = OrderId(TraderId(b'4' * 20), OrderNumber(5)) self.order1 = Order( self.order_id1, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')), Timeout(3600), Timestamp.now(), True) self.order2 = Order( self.order_id2, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')), Timeout(3600), Timestamp.now(), False) self.order2.reserve_quantity_for_tick( OrderId(TraderId(b'3' * 20), OrderNumber(4)), 3) self.transaction_id1 = TransactionId(b'a' * 32) self.transaction1 = Transaction( self.transaction_id1, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MB')), OrderId(TraderId(b'0' * 20), OrderNumber(1)), OrderId(TraderId(b'1' * 20), OrderNumber(2)), Timestamp(20000)) self.payment1 = Payment(TraderId(b'0' * 20), self.transaction_id1, AssetAmount(5, 'BTC'), WalletAddress('abc'), WalletAddress('def'), PaymentId("abc"), Timestamp(20000)) self.transaction1.add_payment(self.payment1) async def tearDown(self): self.database.close() await super(TestDatabase, self).tearDown() def test_add_get_order(self): """ Test the insertion and retrieval of an order in the database """ self.database.add_order(self.order1) self.database.add_order(self.order2) orders = self.database.get_all_orders() self.assertEqual(len(orders), 2) def test_get_specific_order(self): """ Test the retrieval of a specific order """ order_id = OrderId(TraderId(b'3' * 20), OrderNumber(4)) self.assertIsNone(self.database.get_order(order_id)) self.database.add_order(self.order1) self.assertIsNotNone(self.database.get_order(order_id)) def test_delete_order(self): """ Test the deletion of an order from the database """ self.database.add_order(self.order1) self.assertEqual(len(self.database.get_all_orders()), 1) self.database.delete_order(self.order_id1) self.assertEqual(len(self.database.get_all_orders()), 0) def test_get_next_order_number(self): """ Test the retrieval of the next order number from the database """ self.assertEqual(self.database.get_next_order_number(), 1) self.database.add_order(self.order1) self.assertEqual(self.database.get_next_order_number(), 5) def test_add_delete_reserved_ticks(self): """ Test the retrieval, addition and deletion of reserved ticks in the database """ self.database.add_reserved_tick(self.order_id1, self.order_id2, self.order1.total_quantity) self.assertEqual(len(self.database.get_reserved_ticks(self.order_id1)), 1) self.database.delete_reserved_ticks(self.order_id1) self.assertEqual(len(self.database.get_reserved_ticks(self.order_id1)), 0) def test_add_get_transaction(self): """ Test the insertion and retrieval of a transaction in the database """ self.database.add_transaction(self.transaction1) transactions = self.database.get_all_transactions() self.assertEqual(len(transactions), 1) self.assertEqual( len(self.database.get_payments(self.transaction1.transaction_id)), 1) def test_insert_or_update_transaction(self): """ Test the conditional insertion or update of a transaction in the database """ # Test insertion self.database.insert_or_update_transaction(self.transaction1) transactions = self.database.get_all_transactions() self.assertEqual(len(transactions), 1) # Test try to update with older timestamp before_trans1 = Transaction( self.transaction1.transaction_id, self.transaction1.assets, self.transaction1.order_id, self.transaction1.partner_order_id, Timestamp(int(self.transaction1.timestamp) - 1000)) self.database.insert_or_update_transaction(before_trans1) transaction = self.database.get_transaction( self.transaction1.transaction_id) self.assertEqual(int(transaction.timestamp), int(self.transaction1.timestamp)) # Test update with newer timestamp after_trans1 = Transaction( self.transaction1.transaction_id, self.transaction1.assets, self.transaction1.order_id, self.transaction1.partner_order_id, Timestamp(int(self.transaction1.timestamp) + 1000)) self.database.insert_or_update_transaction(after_trans1) transaction = self.database.get_transaction( self.transaction1.transaction_id) self.assertEqual(int(transaction.timestamp), int(after_trans1.timestamp)) def test_get_specific_transaction(self): """ Test the retrieval of a specific transaction """ transaction_id = TransactionId(b'a' * 32) self.assertIsNone(self.database.get_transaction(transaction_id)) self.database.add_transaction(self.transaction1) self.assertIsNotNone(self.database.get_transaction(transaction_id)) def test_delete_transaction(self): """ Test the deletion of a transaction from the database """ self.database.add_transaction(self.transaction1) self.assertEqual(len(self.database.get_all_transactions()), 1) self.database.delete_transaction(self.transaction_id1) self.assertEqual(len(self.database.get_all_transactions()), 0) def test_add_get_payment(self): """ Test the insertion and retrieval of a payment in the database """ self.database.add_payment(self.payment1) payments = self.database.get_payments(self.transaction_id1) self.assertEqual(len(payments), 1) def test_add_remove_tick(self): """ Test addition, retrieval and deletion of ticks in the database """ ask = Tick.from_order(self.order1) self.database.add_tick(ask) bid = Tick.from_order(self.order2) self.database.add_tick(bid) self.assertEqual(len(self.database.get_ticks()), 2) self.database.delete_all_ticks() self.assertEqual(len(self.database.get_ticks()), 0) def test_check_database(self): """ Test the check of the database """ self.assertEqual( self.database.check_database(b"%d" % LATEST_DB_VERSION), LATEST_DB_VERSION) def test_get_upgrade_script(self): """ Test fetching the upgrade script of the database """ self.assertTrue(self.database.get_upgrade_script(1)) def test_db_upgrade(self): self.database.execute(u"DROP TABLE orders;") self.database.execute(u"DROP TABLE ticks;") self.database.execute( u"CREATE TABLE orders(x INTEGER PRIMARY KEY ASC);") self.database.execute( u"CREATE TABLE ticks(x INTEGER PRIMARY KEY ASC);") self.assertEqual(self.database.check_database(b"1"), 5)