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 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('0' * 40), OrderNumber(1)), ask_pair,
Timeout(3600), Timestamp.now(), True)
ask._traded_quantity = ask_total_traded
bid = Order(OrderId(TraderId('1' * 40), OrderNumber(1)), bid_pair,
Timeout(3600), Timestamp.now(), False)
bid._traded_quantity = bid_total_traded
tx = Transaction(
TransactionId(TraderId('0' * 40), TransactionNumber(1)),
AssetPair(AssetAmount(traded_amount, 'BTC'),
AssetAmount(traded_amount, 'MB')),
OrderId(TraderId('0' * 40), OrderNumber(1)),
OrderId(TraderId('1' * 40), OrderNumber(1)), Timestamp(0.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 = '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 setUp(self):
yield 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'), OrderNumber(4))
self.order_id2 = OrderId(TraderId(b'4'), 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'), OrderNumber(4)), 3)
self.transaction_id1 = TransactionId(TraderId(b"0"), TransactionNumber(4))
self.transaction1 = Transaction(self.transaction_id1, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MB')),
OrderId(TraderId(b"0"), OrderNumber(1)),
OrderId(TraderId(b"1"), OrderNumber(2)), Timestamp(20.0))
self.payment1 = Payment(TraderId(b"0"), self.transaction_id1, AssetAmount(5, 'BTC'),
WalletAddress('abc'), WalletAddress('def'), PaymentId("abc"), Timestamp(20.0), False)
self.transaction1.add_payment(self.payment1)
def test_unitize(self):
"""
Test the unitize method of a Transaction
"""
self.assertEqual(Transaction.unitize(1, 1), 1)
self.assertEqual(Transaction.unitize(0.03, 0.02), 0.04)
self.assertEqual(Transaction.unitize(50, 0.05), 50)
self.assertEqual(Transaction.unitize(50.1818, 25), 75)
def setUp(self, annotate=True):
yield super(TestMarketBlock, self).setUp(annotate=annotate)
self.ask = Ask(
OrderId(TraderId('0' * 40), OrderNumber(1)),
AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')),
Timeout(30), Timestamp(0.0), True)
self.bid = Ask(
OrderId(TraderId('1' * 40), OrderNumber(1)),
AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')),
Timeout(30), Timestamp(0.0), False)
self.transaction = Transaction(
TransactionId(TraderId('0' * 40), TransactionNumber(1)),
AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')),
OrderId(TraderId('0' * 40), OrderNumber(1)),
OrderId(TraderId('1' * 40), OrderNumber(1)), Timestamp(0.0))
ask_tx = self.ask.to_block_dict()
ask_tx["address"], ask_tx["port"] = "127.0.0.1", 1337
bid_tx = self.bid.to_block_dict()
bid_tx["address"], bid_tx["port"] = "127.0.0.1", 1337
self.tick_block = MarketBlock()
self.tick_block.type = 'tick'
self.tick_block.transaction = {'tick': ask_tx}
self.cancel_block = MarketBlock()
self.cancel_block.type = 'cancel_order'
self.cancel_block.transaction = {
'trader_id': 'a' * 40,
'order_number': 1
}
self.tx_block = MarketBlock()
self.tx_block.type = 'tx_init'
self.tx_block.transaction = {
'ask': ask_tx,
'bid': bid_tx,
'tx': self.transaction.to_dictionary()
}
payment = {
'trader_id': 'a' * 40,
'transaction_number': 3,
'transferred': {
'amount': 3,
'type': 'BTC'
},
'payment_id': 'a',
'address_from': 'a',
'address_to': 'b',
'timestamp': 1234.3,
'success': True
}
self.payment_block = MarketBlock()
self.payment_block.type = 'tx_payment'
self.payment_block.transaction = {'payment': payment}
def create_from_start_transaction(self, start_transaction, match_id):
"""
:type start_transaction: StartTransaction
:type match_id: str
:rtype: Transaction
"""
transaction = Transaction(start_transaction.transaction_id, start_transaction.assets,
start_transaction.recipient_order_id, start_transaction.order_id, Timestamp.now())
transaction.match_id = match_id
self.transaction_repository.add(transaction)
self._logger.info("Transaction created with id: %s, asset pair %s",
transaction.transaction_id, transaction.assets)
return transaction
def setUp(self):
# Object creation
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
Quantity(30, 'MC'),
OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(1)),
Timestamp(0.0))
self.proposed_trade = Trade.propose(
MessageId(TraderId('0'), MessageNumber('1')),
OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(3)), Price(100, 'BTC'),
Quantity(30, 'MC'), Timestamp(0.0))
self.tick = Tick(
MessageId(TraderId('0'), MessageNumber('message_number')),
OrderId(TraderId('0'), OrderNumber(1)), Price(100, 'BTC'),
Quantity(5, 'MC'), Timeout(0.0), Timestamp(float("inf")), True)
self.tick2 = Tick(
MessageId(TraderId('0'), MessageNumber('message_number')),
OrderId(TraderId('0'), OrderNumber(2)), Price(100, 'BTC'),
Quantity(100, 'MC'), Timeout(0.0), Timestamp(float("inf")), True)
self.order = Order(OrderId(TraderId("0"), OrderNumber(3)),
Price(100, 'BTC'), Quantity(30, 'MC'),
Timeout(5000), Timestamp(time.time()), False)
self.order2 = Order(OrderId(TraderId("0"), OrderNumber(4)),
Price(100, 'BTC'), Quantity(30, 'MC'), Timeout(5),
Timestamp(time.time() - 1000), True)
def test_from_proposed_trade(self):
"""
Test creating a transaction from a proposed trade
"""
transaction = Transaction.from_proposed_trade(self.proposed_trade,
self.transaction_id)
self.assertEqual(transaction.assets, self.transaction.assets)
def setUp(self):
# Object creation
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(
self.transaction_id,
AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MC')),
OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(1)), Timestamp(0.0))
self.proposed_trade = Trade.propose(
TraderId('0'), OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(3)),
AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MC')),
Timestamp(0.0))
self.tick = Tick(
OrderId(TraderId('0'), OrderNumber(1)),
AssetPair(AssetAmount(5, 'BTC'), AssetAmount(5, 'MC')), Timeout(0),
Timestamp(float("inf")), True)
self.tick2 = Tick(
OrderId(TraderId('0'), OrderNumber(2)),
AssetPair(AssetAmount(500, 'BTC'), AssetAmount(5, 'MC')),
Timeout(0), Timestamp(float("inf")), True)
self.order_timestamp = Timestamp.now()
self.order = Order(
OrderId(TraderId("0"), OrderNumber(3)),
AssetPair(AssetAmount(50, 'BTC'), AssetAmount(5, 'MC')),
Timeout(5000), self.order_timestamp, False)
self.order.set_verified()
self.order2 = Order(
OrderId(TraderId("0"), OrderNumber(4)),
AssetPair(AssetAmount(50, 'BTC'), AssetAmount(5, 'MC')),
Timeout(5), Timestamp(time.time() - 1000), True)
self.order2.set_verified()
def create_from_start_transaction(self, start_transaction, match_id):
"""
:type start_transaction: StartTransaction
:type match_id: str
:rtype: Transaction
"""
transaction = Transaction(start_transaction.transaction_id,
start_transaction.assets,
start_transaction.recipient_order_id,
start_transaction.order_id, Timestamp.now())
transaction.match_id = match_id
self.transaction_repository.add(transaction)
self._logger.info("Transaction created with id: %s, asset pair %s",
transaction.transaction_id, transaction.assets)
return transaction
def test_from_proposed_trade(self):
# Test from proposed trade
transaction = Transaction.from_proposed_trade(self.proposed_trade,
self.transaction_id)
self.assertEqual(transaction.price, self.transaction.price)
self.assertEqual(transaction.total_quantity,
self.transaction.total_quantity)
self.assertEqual(transaction.timestamp, self.transaction.timestamp)
def setUp(self):
# Object creation
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(
self.transaction_id,
AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB')),
OrderId(TraderId('3'), OrderNumber(2)),
OrderId(TraderId('2'), OrderNumber(1)), Timestamp(0.0))
self.proposed_trade = Trade.propose(
TraderId('0'), OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(3)),
AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB')),
Timestamp(0.0))
self.payment = Payment(
TraderId("0"), TransactionId(TraderId('2'), TransactionNumber(2)),
AssetAmount(3, 'MB'), WalletAddress('a'), WalletAddress('b'),
PaymentId('aaa'), Timestamp(4.0), True)
def get_all_transactions(self):
"""
Return all transactions in the database.
"""
db_result = self.execute(u"SELECT * FROM transactions")
return [Transaction.from_database(db_item,
self.get_payments(TransactionId(TraderId(str(db_item[0])),
TransactionNumber(db_item[1]))))
for db_item in db_result]
def setUp(self):
# Object creation
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
Quantity(30, 'MC'),
OrderId(TraderId('3'), OrderNumber(2)),
OrderId(TraderId('2'), OrderNumber(1)),
Timestamp(0.0))
self.proposed_trade = Trade.propose(
MessageId(TraderId('0'), MessageNumber('1')),
OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(3)), Price(100, 'BTC'),
Quantity(30, 'MC'), Timestamp(0.0))
self.payment = Payment(
MessageId(TraderId("0"), MessageNumber("1")),
TransactionId(TraderId('2'), TransactionNumber(2)),
Quantity(3, 'MC'), Price(2, 'BTC'), WalletAddress('a'),
WalletAddress('b'), PaymentId('aaa'), Timestamp(4.0), True)
def setUp(self):
# Object creation
self.memory_transaction_repository = MemoryTransactionRepository("0")
self.transaction_id = TransactionId(TraderId(b"0"),
TransactionNumber(1))
self.transaction = Transaction(
self.transaction_id,
AssetPair(AssetAmount(10, 'BTC'), AssetAmount(10, 'MB')),
OrderId(TraderId(b"0"), OrderNumber(1)),
OrderId(TraderId(b"2"), OrderNumber(2)), Timestamp(0.0))
def setUp(self):
# Object creation
self.memory_transaction_repository = MemoryTransactionRepository("0")
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
Quantity(30, 'MC'),
OrderId(TraderId("0"), OrderNumber(1)),
OrderId(TraderId("2"), OrderNumber(2)),
Timestamp(0.0))
def test_from_block(self):
"""
Test the from block method of a transaction
"""
block = {
'tx': {
'payment_complete': False,
'status': 'pending',
'partner_trader_id': '1111111111111111111111111111111111111111',
'trader_id': '0000000000000000000000000000000000000000',
'timestamp': 0.0,
'transferred': {
'second': {
'amount': 0,
'type': 'MB'
},
'first': {
'amount': 0,
'type': 'BTC'
}
},
'partner_order_number': 1,
'order_number': 1,
'transaction_number': 1,
'assets': {
'second': {
'amount': 30,
'type': 'MB'
},
'first': {
'amount': 30,
'type': 'BTC'
}
}
}
}
transaction = Transaction.from_block(block)
self.assertEqual(block['tx']['trader_id'], six.text_type(transaction.transaction_id.trader_id))
self.assertEqual(block['tx']['transaction_number'], int(transaction.transaction_id.transaction_number))
self.assertEqual(block['tx']['trader_id'], six.text_type(transaction.order_id.trader_id))
self.assertEqual(block['tx']['transaction_number'], int(transaction.order_id.order_number))
self.assertEqual(block['tx']['partner_trader_id'], six.text_type(transaction.partner_order_id.trader_id))
self.assertEqual(block['tx']['partner_order_number'], int(transaction.partner_order_id.order_number))
self.assertEqual(block['tx']['timestamp'], float(transaction.timestamp))
self.assertEqual(block['tx']['assets']['first']['amount'], transaction.assets.first.amount)
self.assertEqual(block['tx']['assets']['first']['type'], transaction.assets.first.asset_id)
self.assertEqual(block['tx']['assets']['second']['amount'], transaction.assets.second.amount)
self.assertEqual(block['tx']['assets']['second']['type'], transaction.assets.second.asset_id)
self.assertEqual(block['tx']['transferred']['first']['amount'], transaction.transferred_assets.first.amount)
self.assertEqual(block['tx']['transferred']['first']['type'], transaction.transferred_assets.first.asset_id)
self.assertEqual(block['tx']['transferred']['second']['amount'], transaction.transferred_assets.second.amount)
self.assertEqual(block['tx']['transferred']['second']['type'], transaction.transferred_assets.second.asset_id)
def get_transaction(self, transaction_id):
"""
Return a transaction with a specific id.
"""
try:
db_result = self.execute(u"SELECT * FROM transactions WHERE trader_id = ? AND transaction_number = ?",
(unicode(transaction_id.trader_id),
unicode(transaction_id.transaction_number))).next()
except StopIteration:
return None
return Transaction.from_database(db_result, self.get_payments(transaction_id))
def get_transaction(self, transaction_id):
"""
Return a transaction with a specific id.
"""
db_result = self.execute(
u"SELECT * FROM transactions WHERE trader_id = ? AND transaction_number = ?",
(unicode(transaction_id.trader_id),
unicode(transaction_id.transaction_number))).fetchone()
return Transaction.from_database(
db_result,
self.get_payments(transaction_id)) if db_result else None
def create_from_proposed_trade(self, proposed_trade, match_id):
"""
:type proposed_trade: ProposedTrade
:type match_id: str
:rtype: Transaction
"""
transaction = Transaction.from_proposed_trade(proposed_trade, self.transaction_repository.next_identity())
transaction.match_id = match_id
self.transaction_repository.add(transaction)
self._logger.info("Transaction created with id: %s, asset pair %s",
transaction.transaction_id, transaction.assets)
return transaction
def get_all_transactions(self):
"""
Return all transactions in the database.
"""
db_result = self.execute(u"SELECT * FROM transactions")
return [
Transaction.from_database(
db_item,
self.get_payments(
TransactionId(TraderId(str(db_item[0])),
TransactionNumber(db_item[1]))))
for db_item in db_result
]
def get_transaction(self, transaction_id):
"""
Return a transaction with a specific id.
"""
try:
db_result = self.execute(
u"SELECT * FROM transactions WHERE trader_id = ? AND transaction_number = ?",
(unicode(transaction_id.trader_id),
unicode(transaction_id.transaction_number))).next()
except StopIteration:
return None
return Transaction.from_database(db_result,
self.get_payments(transaction_id))
def setUp(self):
# Object creation
self.transaction_id = TransactionId(TraderId("0"), TransactionNumber(1))
self.transaction = Transaction(self.transaction_id, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB')),
OrderId(TraderId('3'), OrderNumber(2)),
OrderId(TraderId('2'), OrderNumber(1)), Timestamp(0.0))
self.proposed_trade = Trade.propose(TraderId('0'),
OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(3)),
AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB')), Timestamp(0.0))
self.payment = Payment(TraderId("0"), TransactionId(TraderId('2'), TransactionNumber(2)),
AssetAmount(3, 'MB'), WalletAddress('a'), WalletAddress('b'),
PaymentId('aaa'), Timestamp(4.0), True)
def create_from_start_transaction(self, start_transaction, match_id):
"""
:type start_transaction: StartTransaction
:type match_id: str
:rtype: Transaction
"""
assert isinstance(start_transaction,
StartTransaction), type(start_transaction)
transaction = Transaction(start_transaction.transaction_id,
start_transaction.price,
start_transaction.quantity,
start_transaction.recipient_order_id,
start_transaction.order_id, Timestamp.now())
transaction.match_id = match_id
self.transaction_repository.add(transaction)
self._logger.info(
"Transaction created with id: %s, quantity: %s, price: %s",
str(transaction.transaction_id), str(transaction.total_quantity),
str(transaction.price))
return transaction
def create_from_proposed_trade(self, proposed_trade, match_id):
"""
:type proposed_trade: ProposedTrade
:type match_id: str
:rtype: Transaction
"""
transaction = Transaction.from_proposed_trade(
proposed_trade, self.transaction_repository.next_identity())
transaction.match_id = match_id
self.transaction_repository.add(transaction)
self._logger.info("Transaction created with id: %s, asset pair %s",
transaction.transaction_id, transaction.assets)
return transaction
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(float(self.transaction1.timestamp) - 1.0))
self.database.insert_or_update_transaction(before_trans1)
transaction = self.database.get_transaction(self.transaction1.transaction_id)
self.assertEqual(float(transaction.timestamp), float(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(float(self.transaction1.timestamp) + 1.0))
self.database.insert_or_update_transaction(after_trans1)
transaction = self.database.get_transaction(self.transaction1.transaction_id)
self.assertEqual(float(transaction.timestamp), float(after_trans1.timestamp))
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('0' * 40), OrderNumber(1)), ask_pair, Timeout(3600), Timestamp.now(), True)
ask._traded_quantity = ask_total_traded
bid = Order(OrderId(TraderId('1' * 40), OrderNumber(1)), bid_pair, Timeout(3600), Timestamp.now(), False)
bid._traded_quantity = bid_total_traded
tx = Transaction(TransactionId(TraderId('0' * 40), TransactionNumber(1)),
AssetPair(AssetAmount(traded_amount, 'BTC'), AssetAmount(traded_amount, 'MB')),
OrderId(TraderId('0' * 40), OrderNumber(1)),
OrderId(TraderId('1' * 40), OrderNumber(1)), Timestamp(0.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 = '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 create_from_proposed_trade(self, proposed_trade, match_id):
"""
:type proposed_trade: ProposedTrade
:type match_id: str
:rtype: Transaction
"""
assert isinstance(proposed_trade, ProposedTrade), type(proposed_trade)
transaction = Transaction.from_proposed_trade(
proposed_trade, self.transaction_repository.next_identity())
transaction.match_id = match_id
self.transaction_repository.add(transaction)
self._logger.info(
"Transaction created with id: %s, quantity: %s, price: %s",
str(transaction.transaction_id), str(transaction.total_quantity),
str(transaction.price))
return transaction
def setUp(self):
# Object creation
self.memory_transaction_repository = MemoryTransactionRepository("0")
self.transaction_manager = TransactionManager(self.memory_transaction_repository)
self.transaction_id = TransactionId(TraderId(b"0"), TransactionNumber(1))
self.transaction = Transaction(self.transaction_id, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MB')),
OrderId(TraderId(b'3'), OrderNumber(2)),
OrderId(TraderId(b'2'), OrderNumber(1)), Timestamp(0.0))
self.proposed_trade = Trade.propose(TraderId(b'0'),
OrderId(TraderId(b'0'), OrderNumber(1)),
OrderId(TraderId(b'1'), OrderNumber(2)),
AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')),
Timestamp(1462224447.117))
self.start_transaction = StartTransaction(TraderId(b'0'),
TransactionId(TraderId(b"0"), TransactionNumber(1)),
OrderId(TraderId(b'0'), OrderNumber(1)),
OrderId(TraderId(b'1'), OrderNumber(2)), 1235,
AssetPair(AssetAmount(20, 'BTC'), AssetAmount(20, 'MB')),
Timestamp(0.0))
def setUp(self):
# Object creation
self.memory_transaction_repository = MemoryTransactionRepository("0")
self.transaction_manager = TransactionManager(
self.memory_transaction_repository)
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
Quantity(30, 'MC'),
OrderId(TraderId('3'), OrderNumber(2)),
OrderId(TraderId('2'), OrderNumber(1)),
Timestamp(0.0))
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.start_transaction = StartTransaction(
MessageId(TraderId('0'), MessageNumber('1')),
TransactionId(TraderId("0"), TransactionNumber(1)),
OrderId(TraderId('0'), OrderNumber(1)),
OrderId(TraderId('1'), OrderNumber(2)), 1235, Price(3600, 'BTC'),
Quantity(20, 'MC'), Timestamp(0.0))
class TestMarketBlock(AbstractServer):
"""
This class contains tests for a TrustChain block as used in the market.
"""
@inlineCallbacks
def setUp(self):
yield super(TestMarketBlock, self).setUp()
self.ask = Ask(
OrderId(TraderId('0' * 40), OrderNumber(1)),
AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')),
Timeout(30), Timestamp(0.0), True)
self.bid = Ask(
OrderId(TraderId('1' * 40), OrderNumber(1)),
AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')),
Timeout(30), Timestamp(0.0), False)
self.transaction = Transaction(
TransactionId(TraderId('0' * 40), TransactionNumber(1)),
AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')),
OrderId(TraderId('0' * 40), OrderNumber(1)),
OrderId(TraderId('1' * 40), OrderNumber(1)), Timestamp(0.0))
ask_tx = self.ask.to_block_dict()
bid_tx = self.bid.to_block_dict()
self.tick_block = MarketBlock()
self.tick_block.type = 'ask'
self.tick_block.transaction = {'tick': ask_tx}
self.cancel_block = MarketBlock()
self.cancel_block.type = 'cancel_order'
self.cancel_block.transaction = {
'trader_id': 'a' * 40,
'order_number': 1
}
self.tx_block = MarketBlock()
self.tx_block.type = 'tx_init'
self.tx_block.transaction = {
'ask': ask_tx,
'bid': bid_tx,
'tx': self.transaction.to_dictionary()
}
payment = {
'trader_id': 'a' * 40,
'transaction_number': 3,
'transferred': {
'amount': 3,
'type': 'BTC'
},
'payment_id': 'a',
'address_from': 'a',
'address_to': 'b',
'timestamp': 1234.3,
'success': True
}
self.payment_block = MarketBlock()
self.payment_block.type = 'tx_payment'
self.payment_block.transaction = {'payment': payment}
def test_tick_block(self):
"""
Test whether a tick block can be correctly verified
"""
self.assertTrue(self.tick_block.is_valid_tick_block())
self.tick_block.type = 'test'
self.assertFalse(self.tick_block.is_valid_tick_block())
self.tick_block.type = 'ask'
self.tick_block.transaction['test'] = self.tick_block.transaction.pop(
'tick')
self.assertFalse(self.tick_block.is_valid_tick_block())
self.tick_block.transaction['tick'] = self.tick_block.transaction.pop(
'test')
self.tick_block.transaction['tick'].pop('timeout')
self.assertFalse(self.tick_block.is_valid_tick_block())
self.tick_block.transaction['tick']['timeout'] = "300"
self.assertFalse(self.tick_block.is_valid_tick_block())
self.tick_block.transaction['tick']['timeout'] = 300
self.tick_block.transaction['tick']['trader_id'] = 'g' * 40
self.assertFalse(self.tick_block.is_valid_tick_block())
# Make the asset pair invalid
assets = self.tick_block.transaction['tick']['assets']
self.tick_block.transaction['tick']['trader_id'] = 'a' * 40
assets['test'] = assets.pop('first')
self.assertFalse(self.tick_block.is_valid_tick_block())
assets['first'] = assets.pop('test')
assets['first']['test'] = assets['first'].pop('amount')
self.assertFalse(self.tick_block.is_valid_tick_block())
assets['first']['amount'] = assets['first']['test']
assets['second']['test'] = assets['second'].pop('amount')
self.assertFalse(self.tick_block.is_valid_tick_block())
assets['second']['amount'] = assets['second']['test']
assets['first']['amount'] = 3.4
self.assertFalse(self.tick_block.is_valid_tick_block())
assets['first']['amount'] = 3
assets['second']['type'] = 4
self.assertFalse(self.tick_block.is_valid_tick_block())
def test_cancel_block(self):
"""
Test whether a cancel block can be correctly verified
"""
self.assertTrue(self.cancel_block.is_valid_cancel_block())
self.cancel_block.type = 'cancel'
self.assertFalse(self.cancel_block.is_valid_cancel_block())
self.cancel_block.type = 'cancel_order'
self.cancel_block.transaction.pop('trader_id')
self.assertFalse(self.cancel_block.is_valid_cancel_block())
self.cancel_block.transaction['trader_id'] = 3
self.assertFalse(self.cancel_block.is_valid_cancel_block())
def test_tx_init_done_block(self):
"""
Test whether a tx_init/tx_done block can be correctly verified
"""
self.assertTrue(self.tx_block.is_valid_tx_init_done_block())
self.tx_block.type = 'test'
self.assertFalse(self.tx_block.is_valid_tx_init_done_block())
self.tx_block.type = 'tx_init'
self.tx_block.transaction['test'] = self.tx_block.transaction.pop(
'ask')
self.assertFalse(self.tx_block.is_valid_tx_init_done_block())
self.tx_block.transaction['ask'] = self.tx_block.transaction.pop(
'test')
self.tx_block.transaction['ask']['timeout'] = 3.44
self.assertFalse(self.tx_block.is_valid_tx_init_done_block())
self.tx_block.transaction['ask']['timeout'] = 3
self.tx_block.transaction['bid']['timeout'] = 3.44
self.assertFalse(self.tx_block.is_valid_tx_init_done_block())
self.tx_block.transaction['bid']['timeout'] = 3
self.tx_block.transaction['tx'].pop('trader_id')
self.assertFalse(self.tx_block.is_valid_tx_init_done_block())
self.tx_block.transaction['tx']['trader_id'] = 'a' * 40
self.tx_block.transaction['tx']['test'] = 3
self.assertFalse(self.tx_block.is_valid_tx_init_done_block())
self.tx_block.transaction['tx'].pop('test')
self.tx_block.transaction['tx']['trader_id'] = 'a'
self.assertFalse(self.tx_block.is_valid_tx_init_done_block())
self.tx_block.transaction['tx']['trader_id'] = 'a' * 40
self.tx_block.transaction['tx']['assets']['first']['amount'] = 3.4
self.assertFalse(self.tx_block.is_valid_tx_init_done_block())
self.tx_block.transaction['tx']['assets']['first']['amount'] = 3
self.tx_block.transaction['tx']['transferred']['first']['amount'] = 3.4
self.assertFalse(self.tx_block.is_valid_tx_init_done_block())
self.tx_block.transaction['tx']['transferred']['first']['amount'] = 3
self.tx_block.transaction['tx']['transaction_number'] = 3.4
self.assertFalse(self.tx_block.is_valid_tx_init_done_block())
def test_tx_payment_block(self):
"""
Test whether a tx_payment block can be correctly verified
"""
self.assertTrue(self.payment_block.is_valid_tx_payment_block())
self.payment_block.type = 'test'
self.assertFalse(self.payment_block.is_valid_tx_payment_block())
self.payment_block.type = 'tx_payment'
self.payment_block.transaction[
'test'] = self.payment_block.transaction.pop('payment')
self.assertFalse(self.payment_block.is_valid_tx_payment_block())
self.payment_block.transaction[
'payment'] = self.payment_block.transaction.pop('test')
self.payment_block.transaction['payment'].pop('address_to')
self.assertFalse(self.payment_block.is_valid_tx_payment_block())
self.payment_block.transaction['payment']['address_to'] = 'a'
self.payment_block.transaction['payment']['test'] = 'a'
self.assertFalse(self.payment_block.is_valid_tx_payment_block())
self.payment_block.transaction['payment'].pop('test')
self.payment_block.transaction['payment']['address_to'] = 3
self.assertFalse(self.payment_block.is_valid_tx_payment_block())
self.payment_block.transaction['payment']['address_to'] = 'a'
self.payment_block.transaction['payment']['trader_id'] = 'a' * 39
self.assertFalse(self.payment_block.is_valid_tx_payment_block())
def test_is_valid_asset_pair(self):
"""
Test the method to verify whether an asset pair is valid
"""
self.assertFalse(MarketBlock.is_valid_asset_pair({'a': 'b'}))
self.assertFalse(
MarketBlock.is_valid_asset_pair({
'first': {
'amount': 3,
'type': 'DUM1'
},
'second': {
'amount': 3
}
}))
self.assertFalse(
MarketBlock.is_valid_asset_pair({
'first': {
'type': 'DUM1'
},
'second': {
'amount': 3,
'type': 'DUM2'
}
}))
self.assertFalse(
MarketBlock.is_valid_asset_pair({
'first': {
'amount': "4",
'type': 'DUM1'
},
'second': {
'amount': 3,
'type': 'DUM2'
}
}))
self.assertFalse(
MarketBlock.is_valid_asset_pair({
'first': {
'amount': 4,
'type': 'DUM1'
},
'second': {
'amount': "3",
'type': 'DUM2'
}
}))
self.assertFalse(
MarketBlock.is_valid_asset_pair({
'first': {
'amount': -4,
'type': 'DUM1'
},
'second': {
'amount': 3,
'type': 'DUM2'
}
}))
class TestDatabase(AbstractServer):
@inlineCallbacks
def setUp(self):
yield 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'), OrderNumber(4))
self.order_id2 = OrderId(TraderId(b'4'), 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'), OrderNumber(4)), 3)
self.transaction_id1 = TransactionId(TraderId(b"0"), TransactionNumber(4))
self.transaction1 = Transaction(self.transaction_id1, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MB')),
OrderId(TraderId(b"0"), OrderNumber(1)),
OrderId(TraderId(b"1"), OrderNumber(2)), Timestamp(20.0))
self.payment1 = Payment(TraderId(b"0"), self.transaction_id1, AssetAmount(5, 'BTC'),
WalletAddress('abc'), WalletAddress('def'), PaymentId("abc"), Timestamp(20.0), False)
self.transaction1.add_payment(self.payment1)
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'), 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(float(self.transaction1.timestamp) - 1.0))
self.database.insert_or_update_transaction(before_trans1)
transaction = self.database.get_transaction(self.transaction1.transaction_id)
self.assertEqual(float(transaction.timestamp), float(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(float(self.transaction1.timestamp) + 1.0))
self.database.insert_or_update_transaction(after_trans1)
transaction = self.database.get_transaction(self.transaction1.transaction_id)
self.assertEqual(float(transaction.timestamp), float(after_trans1.timestamp))
def test_get_specific_transaction(self):
"""
Test the retrieval of a specific transaction
"""
transaction_id = TransactionId(TraderId(b'0'), TransactionNumber(4))
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_get_next_transaction_number(self):
"""
Test the retrieval of the next transaction number from the database
"""
self.assertEqual(self.database.get_next_transaction_number(), 1)
self.database.add_transaction(self.transaction1)
self.assertEqual(self.database.get_next_transaction_number(), 5)
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_add_get_trader_identity(self):
"""
Test the addition and retrieval of a trader identity in the database
"""
self.database.add_trader_identity(TraderId(b"a"), "123", 1234)
self.database.add_trader_identity(TraderId(b"b"), "124", 1235)
traders = self.database.get_traders()
self.assertEqual(len(traders), 2)
def test_check_database(self):
"""
Test the check of the database
"""
self.assertEqual(self.database.check_database(six.text_type(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(u"1"), 3)
class TestDatabase(AbstractServer):
@blocking_call_on_reactor_thread
@inlineCallbacks
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)
@blocking_call_on_reactor_thread
def test_add_get_order(self):
"""
Test the insertion and retrieval of an order in the database
"""
self.database.add_order(self.order1)
orders = self.database.get_all_orders()
self.assertEqual(len(orders), 1)
@blocking_call_on_reactor_thread
def test_get_specific_order(self):
"""
Test the retrieval of a specific order
"""
order_id = OrderId(TraderId('3'), OrderNumber(4))
self.assertIsNone(self.database.get_order(order_id))
self.database.add_order(self.order1)
self.assertIsNotNone(self.database.get_order(order_id))
@blocking_call_on_reactor_thread
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)
@blocking_call_on_reactor_thread
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)
@blocking_call_on_reactor_thread
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)
@blocking_call_on_reactor_thread
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)
@blocking_call_on_reactor_thread
def test_get_specific_transaction(self):
"""
Test the retrieval of a specific transaction
"""
transaction_id = TransactionId(TraderId('0'), TransactionNumber(4))
self.assertIsNone(self.database.get_transaction(transaction_id))
self.database.add_transaction(self.transaction1)
self.assertIsNotNone(self.database.get_transaction(transaction_id))
@blocking_call_on_reactor_thread
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)
@blocking_call_on_reactor_thread
def test_get_next_transaction_number(self):
"""
Test the retrieval of the next transaction number from the database
"""
self.assertEqual(self.database.get_next_transaction_number(), 1)
self.database.add_transaction(self.transaction1)
self.assertEqual(self.database.get_next_transaction_number(), 5)
@blocking_call_on_reactor_thread
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)
@blocking_call_on_reactor_thread
def test_add_remove_tick(self):
"""
Test addition, retrieval and deletion of ticks in the database
"""
ask = Tick.from_order(
self.order1,
MessageId(TraderId('0'), MessageNumber('message_number')))
self.database.add_tick(ask)
bid = Tick.from_order(
self.order2,
MessageId(TraderId('0'), MessageNumber('message_number')))
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)
@blocking_call_on_reactor_thread
def test_add_get_trader_identity(self):
"""
Test the addition and retrieval of a trader identity in the database
"""
self.database.add_trader_identity("a", "123", 1234)
self.database.add_trader_identity("b", "124", 1235)
traders = self.database.get_traders()
self.assertEqual(len(traders), 2)
self.assertEqual(traders, [("a", "123", 1234), ("b", "124", 1235)])
@blocking_call_on_reactor_thread
def test_check_database(self):
"""
Test the check of the database
"""
self.assertEqual(
self.database.check_database(unicode(LATEST_DB_VERSION)),
LATEST_DB_VERSION)
def test_from_block(self):
"""
Test the from block method of a transaction
"""
block = {
'tx': {
'payment_complete': False,
'status': 'pending',
'partner_trader_id':
'1111111111111111111111111111111111111111',
'trader_id': '0000000000000000000000000000000000000000',
'timestamp': 0.0,
'transferred': {
'second': {
'amount': 0,
'type': 'MB'
},
'first': {
'amount': 0,
'type': 'BTC'
}
},
'partner_order_number': 1,
'order_number': 1,
'transaction_number': 1,
'assets': {
'second': {
'amount': 30,
'type': 'MB'
},
'first': {
'amount': 30,
'type': 'BTC'
}
}
}
}
transaction = Transaction.from_block(block)
self.assertEqual(block['tx']['trader_id'],
six.text_type(transaction.transaction_id.trader_id))
self.assertEqual(block['tx']['transaction_number'],
int(transaction.transaction_id.transaction_number))
self.assertEqual(block['tx']['trader_id'],
six.text_type(transaction.order_id.trader_id))
self.assertEqual(block['tx']['transaction_number'],
int(transaction.order_id.order_number))
self.assertEqual(block['tx']['partner_trader_id'],
six.text_type(transaction.partner_order_id.trader_id))
self.assertEqual(block['tx']['partner_order_number'],
int(transaction.partner_order_id.order_number))
self.assertEqual(block['tx']['timestamp'],
float(transaction.timestamp))
self.assertEqual(block['tx']['assets']['first']['amount'],
transaction.assets.first.amount)
self.assertEqual(block['tx']['assets']['first']['type'],
transaction.assets.first.asset_id)
self.assertEqual(block['tx']['assets']['second']['amount'],
transaction.assets.second.amount)
self.assertEqual(block['tx']['assets']['second']['type'],
transaction.assets.second.asset_id)
self.assertEqual(block['tx']['transferred']['first']['amount'],
transaction.transferred_assets.first.amount)
self.assertEqual(block['tx']['transferred']['first']['type'],
transaction.transferred_assets.first.asset_id)
self.assertEqual(block['tx']['transferred']['second']['amount'],
transaction.transferred_assets.second.amount)
self.assertEqual(block['tx']['transferred']['second']['type'],
transaction.transferred_assets.second.asset_id)
def test_from_proposed_trade(self):
"""
Test creating a transaction from a proposed trade
"""
transaction = Transaction.from_proposed_trade(self.proposed_trade, self.transaction_id)
self.assertEqual(transaction.assets, self.transaction.assets)
class TransactionTestSuite(unittest.TestCase):
"""Transaction test cases."""
def setUp(self):
# Object creation
self.transaction_id = TransactionId(TraderId("0"), TransactionNumber(1))
self.transaction = Transaction(self.transaction_id, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB')),
OrderId(TraderId('3'), OrderNumber(2)),
OrderId(TraderId('2'), OrderNumber(1)), Timestamp(0.0))
self.proposed_trade = Trade.propose(TraderId('0'),
OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(3)),
AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB')), Timestamp(0.0))
self.payment = Payment(TraderId("0"), TransactionId(TraderId('2'), TransactionNumber(2)),
AssetAmount(3, 'MB'), WalletAddress('a'), WalletAddress('b'),
PaymentId('aaa'), Timestamp(4.0), True)
def test_from_proposed_trade(self):
"""
Test creating a transaction from a proposed trade
"""
transaction = Transaction.from_proposed_trade(self.proposed_trade, self.transaction_id)
self.assertEqual(transaction.assets, self.transaction.assets)
def test_add_payment(self):
"""
Test the addition of a payment to a transaction
"""
self.transaction.add_payment(self.payment)
self.assertEqual(self.transaction.transferred_assets.first.amount, 0)
self.assertEqual(self.transaction.transferred_assets.second.amount, 3)
self.assertTrue(self.transaction.payments)
def test_next_payment(self):
"""
Test the process of determining the next payment details during a transaction
"""
self.assertEqual(self.transaction.next_payment(True), AssetAmount(100, 'BTC'))
self.assertEqual(self.transaction.next_payment(False), AssetAmount(100, 'MB'))
def test_is_payment_complete(self):
"""
Test whether a payment is correctly marked as complete
"""
self.assertFalse(self.transaction.is_payment_complete())
self.transaction.add_payment(self.payment)
self.assertFalse(self.transaction.is_payment_complete())
self.transaction._transferred_assets = AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB'))
self.assertTrue(self.transaction.is_payment_complete())
def test_to_dictionary(self):
"""
Test the to dictionary method of a transaction
"""
self.assertDictEqual(self.transaction.to_dictionary(), {
'trader_id': '0',
'transaction_number': 1,
'order_number': 2,
'partner_trader_id': '2',
'partner_order_number': 1,
'payment_complete': False,
'assets': {
'first': {
'amount': 100,
'type': 'BTC',
},
'second': {
'amount': 100,
'type': 'MB'
}
},
'transferred': {
'first': {
'amount': 0,
'type': 'BTC',
},
'second': {
'amount': 0,
'type': 'MB'
}
},
'timestamp': 0.0,
'status': 'pending'
})
def test_status(self):
"""
Test the status of a transaction
"""
self.assertEqual(self.transaction.status, 'pending')
self.payment._success = False
self.transaction.add_payment(self.payment)
self.assertEqual(self.transaction.status, 'error')
class TransactionTestSuite(unittest.TestCase):
"""Transaction test cases."""
def setUp(self):
# Object creation
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(
self.transaction_id,
AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB')),
OrderId(TraderId('3'), OrderNumber(2)),
OrderId(TraderId('2'), OrderNumber(1)), Timestamp(0.0))
self.proposed_trade = Trade.propose(
TraderId('0'), OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(3)),
AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB')),
Timestamp(0.0))
self.payment = Payment(
TraderId("0"), TransactionId(TraderId('2'), TransactionNumber(2)),
AssetAmount(3, 'MB'), WalletAddress('a'), WalletAddress('b'),
PaymentId('aaa'), Timestamp(4.0), True)
def test_from_proposed_trade(self):
"""
Test creating a transaction from a proposed trade
"""
transaction = Transaction.from_proposed_trade(self.proposed_trade,
self.transaction_id)
self.assertEqual(transaction.assets, self.transaction.assets)
def test_add_payment(self):
"""
Test the addition of a payment to a transaction
"""
self.transaction.add_payment(self.payment)
self.assertEqual(self.transaction.transferred_assets.first.amount, 0)
self.assertEqual(self.transaction.transferred_assets.second.amount, 3)
self.assertTrue(self.transaction.payments)
def test_next_payment(self):
"""
Test the process of determining the next payment details during a transaction
"""
self.assertEqual(self.transaction.next_payment(True),
AssetAmount(100, 'BTC'))
self.assertEqual(self.transaction.next_payment(False),
AssetAmount(100, 'MB'))
def test_is_payment_complete(self):
"""
Test whether a payment is correctly marked as complete
"""
self.assertFalse(self.transaction.is_payment_complete())
self.transaction.add_payment(self.payment)
self.assertFalse(self.transaction.is_payment_complete())
self.transaction._transferred_assets = AssetPair(
AssetAmount(100, 'BTC'), AssetAmount(100, 'MB'))
self.assertTrue(self.transaction.is_payment_complete())
def test_to_dictionary(self):
"""
Test the to dictionary method of a transaction
"""
self.assertDictEqual(
self.transaction.to_dictionary(), {
'trader_id': '0',
'transaction_number': 1,
'order_number': 2,
'partner_trader_id': '2',
'partner_order_number': 1,
'payment_complete': False,
'assets': {
'first': {
'amount': 100,
'type': 'BTC',
},
'second': {
'amount': 100,
'type': 'MB'
}
},
'transferred': {
'first': {
'amount': 0,
'type': 'BTC',
},
'second': {
'amount': 0,
'type': 'MB'
}
},
'timestamp': 0.0,
'status': 'pending'
})
def test_status(self):
"""
Test the status of a transaction
"""
self.assertEqual(self.transaction.status, 'pending')
self.payment._success = False
self.transaction.add_payment(self.payment)
self.assertEqual(self.transaction.status, 'error')
class TransactionTestSuite(unittest.TestCase):
"""Transaction test cases."""
def setUp(self):
# Object creation
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
Quantity(30, 'MC'),
OrderId(TraderId('3'), OrderNumber(2)),
OrderId(TraderId('2'), OrderNumber(1)),
Timestamp(0.0))
self.proposed_trade = Trade.propose(
MessageId(TraderId('0'), MessageNumber('1')),
OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(3)), Price(100, 'BTC'),
Quantity(30, 'MC'), Timestamp(0.0))
self.payment = Payment(
MessageId(TraderId("0"), MessageNumber("1")),
TransactionId(TraderId('2'), TransactionNumber(2)),
Quantity(3, 'MC'), Price(2, 'BTC'), WalletAddress('a'),
WalletAddress('b'), PaymentId('aaa'), Timestamp(4.0), True)
def test_from_proposed_trade(self):
# Test from proposed trade
transaction = Transaction.from_proposed_trade(self.proposed_trade,
self.transaction_id)
self.assertEqual(transaction.price, self.transaction.price)
self.assertEqual(transaction.total_quantity,
self.transaction.total_quantity)
self.assertEqual(transaction.timestamp, self.transaction.timestamp)
def test_unitize(self):
"""
Test the unitize method of a Transaction
"""
self.assertEqual(Transaction.unitize(1, 1), 1)
self.assertEqual(Transaction.unitize(0.03, 0.02), 0.04)
self.assertEqual(Transaction.unitize(50, 0.05), 50)
self.assertEqual(Transaction.unitize(50.1818, 25), 75)
def test_add_payment(self):
"""
Test the addition of a payment to a transaction
"""
self.transaction.add_payment(self.payment)
self.assertEqual(self.transaction.transferred_price, Price(2, 'BTC'))
self.assertEqual(self.transaction.transferred_quantity,
Quantity(3, 'MC'))
self.assertTrue(self.transaction.payments)
def test_last_payment(self):
"""
Test the retrieval of the last payment
"""
self.assertIsNone(self.transaction.last_payment(True))
self.assertIsNone(self.transaction.last_payment(False))
self.transaction.add_payment(self.payment)
self.assertEqual(self.transaction.last_payment(True), self.payment)
self.assertEqual(self.transaction.last_payment(False), self.payment)
def test_next_payment(self):
"""
Test the process of determining the next payment details during a transaction
"""
def set_transaction_data(trans_price, trans_quantity, payment_price,
payment_quantity):
self.transaction._transferred_price = trans_price
self.transaction._transferred_quantity = trans_quantity
self.payment._transferee_price = payment_price
self.payment._transferee_quantity = payment_quantity
self.transaction._payments = [self.payment]
# No incremental payments
self.assertEqual(
self.transaction.next_payment(True, 1, incremental=False),
Quantity(30, 'MC'))
self.assertEqual(
self.transaction.next_payment(False, 2, incremental=False),
Price(3000, 'BTC'))
self.assertEqual(
self.transaction.next_payment(True, 1, incremental=True),
Quantity(1, 'MC'))
self.assertEqual(
self.transaction.next_payment(False, 2, incremental=True),
Price(2, 'BTC'))
set_transaction_data(Price(1, 'BTC'), Quantity(1, 'MC'),
Price(1, 'BTC'), Quantity(1, 'MC'))
self.assertEqual(
self.transaction.next_payment(True, 0.1, incremental=True),
Quantity(0.2, 'MC'))
# Test completion of trade
set_transaction_data(Price(3000, 'BTC'), Quantity(29, 'MC'),
Price(1, 'BTC'), Quantity(1, 'MC'))
self.assertEqual(
self.transaction.next_payment(True, 1, incremental=True),
Quantity(1, 'MC'))
set_transaction_data(Price(2900, 'BTC'), Quantity(30, 'MC'),
Price(1, 'BTC'), Quantity(1, 'MC'))
self.assertEqual(
self.transaction.next_payment(False, 1, incremental=True),
Price(100, 'BTC'))
# Test whether we don't transfer too much
set_transaction_data(Price(2999, 'BTC'), Quantity(29, 'MC'),
Price(2999, 'BTC'), Quantity(1, 'MC'))
self.assertEqual(
self.transaction.next_payment(True, 1, incremental=True),
Quantity(1, 'MC'))
set_transaction_data(Price(2999, 'BTC'), Quantity(29, 'MC'),
Price(1, 'BTC'), Quantity(29, 'MC'))
self.assertEqual(
self.transaction.next_payment(False, 1, incremental=True),
Price(1, 'BTC'))
def test_to_dictionary(self):
"""
Test the to dictionary method of a transaction
"""
self.assertDictEqual(
self.transaction.to_dictionary(), {
'trader_id': '0',
'transaction_number': 1,
'order_number': 2,
'partner_trader_id': '2',
'partner_order_number': 1,
'payment_complete': False,
'price': 100.0,
'price_type': 'BTC',
'quantity': 30.0,
'quantity_type': 'MC',
'transferred_price': 0.0,
'transferred_quantity': 0.0,
'timestamp': 0.0,
'status': 'pending'
})
def test_status(self):
"""
Test the status of a transaction
"""
self.assertEqual(self.transaction.status, 'pending')
self.payment._success = False
self.transaction.add_payment(self.payment)
self.assertEqual(self.transaction.status, 'error')