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)
Beispiel #2
0
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})
Beispiel #3
0
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