class TransferTest(unittest.TestCase):
def setUp(self):
self.longMessage = True # Print complete error message on failure
self.maxDiff = None # View the complete diff when there is a mismatch in a test
self.interface = TransactionsInterface()
self.asset_manager_id = random.randint(1, 2**31-1)
self.asset = generate_asset(asset_manager_id=self.asset_manager_id, fungible=True)
self.trader_one_book = generate_book(asset_manager_id=self.asset_manager_id)
self.trader_two_book = generate_book(asset_manager_id=self.asset_manager_id)
self.wash_book = generate_book(asset_manager_id=self.asset_manager_id)
self.setup_cache()
def setup_cache(self):
self.create_transaction_asset()
self.create_transaction_book(self.trader_one_book)
self.create_transaction_book(self.trader_two_book)
self.create_transaction_book(self.wash_book)
def tearDown(self):
pass
def create_transaction_asset(self):
transaction_asset_fields = ['asset_manager_id', 'asset_id', 'asset_status', 'asset_class', 'asset_type',
'fungible']
asset_json = self.asset.to_json()
transaction_asset_json = {attr: asset_json.get(attr) for attr in transaction_asset_fields}
self.interface.upsert_transaction_asset(transaction_asset_json=transaction_asset_json)
def create_transaction_book(self, book):
transaction_book_fields = ['asset_manager_id', 'book_id', 'party_id', 'book_status']
book_json = book.to_json()
transaction_book_json = {attr: book_json.get(attr) for attr in transaction_book_fields}
self.interface.upsert_transaction_book(transaction_book_json=transaction_book_json)
def test_BookTransfer(self):
deliver, receive = self.interface.book_transfer(asset_manager_id=self.asset_manager_id,
source_book_id=self.trader_one_book.book_id,
target_book_id=self.trader_two_book.book_id,
wash_book_id=self.wash_book.book_id,
asset_id=self.asset.asset_id,
quantity=100,
price=Decimal('3.14'),
currency='USD')
self.assertEqual(deliver.quantity, 100)
self.assertEqual(receive.quantity, 100)
self.assertEqual(deliver.transaction_action, 'Deliver')
self.assertEqual(receive.transaction_action, 'Receive')
self.assertEqual(deliver.transaction_type, 'Transfer')
self.assertEqual(deliver.transaction_type, 'Transfer')
self.assertEqual(deliver.counterparty_book_id, self.wash_book.book_id)
self.assertEqual(receive.counterparty_book_id, self.wash_book.book_id)
class NettingTest(unittest.TestCase):
def setUp(self):
self.longMessage = True # Print complete error message on failure
self.maxDiff = None # View the complete diff when there is a mismatch in a test
self.interface = TransactionsInterface()
self.asset_manager_id = 1
self.asset = generate_asset(asset_manager_id=self.asset_manager_id,
fungible=True)
self.asset_book = generate_book(asset_manager_id=self.asset_manager_id)
self.counterparty_book = generate_book(
asset_manager_id=self.asset_manager_id)
self.transaction1 = generate_transaction(
asset_manager_id=self.asset_manager_id,
asset_id=self.asset.asset_id,
asset_book_id=self.asset_book.book_id,
counterparty_book_id=self.counterparty_book.book_id,
transaction_currency='USD',
net_affecting_charges=True,
charge_currency='USD')
self.transaction2 = generate_transaction(
asset_manager_id=self.asset_manager_id,
asset_id=self.asset.asset_id,
asset_book_id=self.asset_book.book_id,
counterparty_book_id=self.counterparty_book.book_id,
transaction_currency='USD',
net_affecting_charges=True,
charge_currency='USD')
self.setup_cache()
self.interface.new(self.transaction1)
self.interface.new(self.transaction2)
self.transaction_id1 = self.transaction1.transaction_id
self.transaction_id2 = self.transaction2.transaction_id
def tearDown(self):
pass
def create_transaction_asset(self):
transaction_asset_fields = [
'asset_manager_id', 'asset_id', 'asset_status', 'asset_class',
'asset_type', 'fungible'
]
asset_json = self.asset.to_json()
transaction_asset_json = {
attr: asset_json.get(attr)
for attr in transaction_asset_fields
}
self.interface.upsert_transaction_asset(
transaction_asset_json=transaction_asset_json)
def setup_cache(self):
self.create_transaction_asset()
self.create_transaction_book(self.asset_book)
self.create_transaction_book(self.counterparty_book)
def create_transaction_book(self, book):
transaction_book_fields = [
'asset_manager_id', 'book_id', 'party_id', 'book_status'
]
book_json = book.to_json()
transaction_book_json = {
attr: book_json.get(attr)
for attr in transaction_book_fields
}
self.interface.upsert_transaction_book(
transaction_book_json=transaction_book_json)
def test_GenerateNettingSet(self):
net = self.interface.net_transactions(
asset_manager_id=self.asset_manager_id,
transaction_ids=[self.transaction_id1, self.transaction_id2])
self.assertEqual(type(net), Transaction)
transaction_ids = {
link.linked_transaction_id
for link in net.links.get('NettingSet')
}
self.assertEqual(transaction_ids,
{self.transaction_id1, self.transaction_id2})
def test_RetrieveNettingSet(self):
net = self.interface.net_transactions(
asset_manager_id=self.asset_manager_id,
transaction_ids=[self.transaction_id1, self.transaction_id2])
net_transaction_id, netting_set = self.interface.retrieve_netting_set(
asset_manager_id=self.asset_manager_id,
transaction_id=net.transaction_id)
self.assertEqual(net_transaction_id, net.transaction_id)
self.assertEqual(len(netting_set), 2)
transaction_ids = {
transaction.transaction_id
for transaction in netting_set
}
self.assertEqual(transaction_ids,
{self.transaction_id1, self.transaction_id2})
class AllocationTest(unittest.TestCase):
def setUp(self):
self.longMessage = True # Print complete error message on failure
self.maxDiff = None # View the complete diff when there is a mismatch in a test
self.transactions_interface = TransactionsInterface()
self.asset_manager_id = 1
self.asset = generate_asset(asset_manager_id=self.asset_manager_id)
self.asset_book = generate_book(asset_manager_id=self.asset_manager_id)
self.counterparty_book = generate_book(asset_manager_id=self.asset_manager_id)
self.transaction = generate_transaction(asset_manager_id=self.asset_manager_id, asset_id=self.asset.asset_id,
asset_book_id=self.asset_book.book_id,
counterparty_book_id=self.counterparty_book.book_id)
self.transaction_id = self.transaction.transaction_id
self.setup_cache()
def tearDown(self):
pass
def create_transaction_asset(self):
transaction_asset_fields = ['asset_manager_id', 'asset_id', 'asset_status', 'asset_class', 'asset_type',
'fungible']
asset_json = self.asset.to_json()
transaction_asset_json = {attr: asset_json.get(attr) for attr in transaction_asset_fields}
self.transactions_interface.upsert_transaction_asset(transaction_asset_json=transaction_asset_json)
def setup_cache(self):
self.create_transaction_asset()
self.create_transaction_book(self.asset_book)
self.create_transaction_book(self.counterparty_book)
def create_transaction_book(self, book):
transaction_book_fields = ['asset_manager_id', 'book_id', 'party_id', 'book_status']
book_json = book.to_json()
transaction_book_json = {attr: book_json.get(attr) for attr in transaction_book_fields}
self.transactions_interface.upsert_transaction_book(transaction_book_json=transaction_book_json)
def test_Allocations(self):
transaction = generate_transaction(asset_manager_id=self.asset_manager_id, asset_id=self.asset.asset_id,
asset_book_id=self.asset_book.book_id,
counterparty_book_id=self.counterparty_book.book_id,
quantity=Decimal('100'))
transaction.charges['TEST'] = Charge(charge_value=Decimal('10'), currency='SGD')
self.transactions_interface.new(transaction)
allocation_dicts = [{'book_id': 'ABC', 'quantity': Decimal('40')},
{'book_id': 'XYZ', 'quantity': Decimal('60')}]
abc_book = generate_book(asset_manager_id=self.asset_manager_id, book_id='ABC')
xyz_book = generate_book(asset_manager_id=self.asset_manager_id, book_id='XYZ')
self.create_transaction_book(abc_book)
self.create_transaction_book(xyz_book)
allocations = self.transactions_interface.allocate_transaction(asset_manager_id=self.asset_manager_id,
transaction_id=transaction.transaction_id,
allocation_type='asset_manager',
allocation_dicts=allocation_dicts)
self.assertEqual(len(allocations), 2)
book_ids = sorted([allocation.asset_book_id for allocation in allocations])
self.assertEqual(book_ids, ['ABC', 'XYZ'])
quantities = sorted([allocation.quantity for allocation in allocations])
self.assertEqual(quantities, [Decimal('40'), Decimal('60')])
charges = sorted([allocation.charges.get('TEST').charge_value for allocation in allocations])
self.assertEqual(charges, [Decimal('4'), Decimal('6')])
def test_AllocationWithExplictID(self):
transaction = generate_transaction(asset_manager_id=self.asset_manager_id, asset_id=self.asset.asset_id,
asset_book_id=self.asset_book.book_id,
counterparty_book_id=self.counterparty_book.book_id,
quantity=Decimal('100'))
self.transactions_interface.new(transaction)
partial_tran_id = transaction.transaction_id[:10]
allocation_dicts = [{'book_id': 'ABC', 'quantity': Decimal('60'), 'transaction_id': partial_tran_id + '_ABC'},
{'book_id': 'XYZ', 'quantity': Decimal('40'), 'transaction_id': partial_tran_id + '_XYZ'}]
abc_book = generate_book(asset_manager_id=self.asset_manager_id, book_id='ABC')
xyz_book = generate_book(asset_manager_id=self.asset_manager_id, book_id='XYZ')
self.create_transaction_book(abc_book)
self.create_transaction_book(xyz_book)
allocations = self.transactions_interface.allocate_transaction(asset_manager_id=self.asset_manager_id,
transaction_id=transaction.transaction_id,
allocation_type='counterparty',
allocation_dicts=allocation_dicts)
self.assertEqual(len(allocations), 2)
book_ids = sorted([allocation.counterparty_book_id for allocation in allocations])
self.assertEqual(book_ids, ['ABC', 'XYZ'])
quantities = sorted([allocation.quantity for allocation in allocations])
self.assertEqual(quantities, [Decimal('40'), Decimal('60')])
transaction_ids = sorted([allocation.transaction_id for allocation in allocations])
self.assertEqual(transaction_ids, [partial_tran_id + '_ABC', partial_tran_id + '_XYZ'])
def test_RetrieveTransactionAllocations(self):
pass