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(environment=ENVIRONMENT)
self.asset_manager_id = 1
self.assets_interface = AssetsInterface(environment=ENVIRONMENT)
self.books_interface = BooksInterface(environment=ENVIRONMENT)
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
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(environment=ENVIRONMENT)
self.asset_manager_id = 1
self.assets_interface = AssetsInterface(environment=ENVIRONMENT)
self.books_interface = BooksInterface(environment=ENVIRONMENT)
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):
self.assets_interface.upsert(self.asset)
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):
self.books_interface.new(book)
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 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(environment=STAGE)
self.assets_interface = AssetsInterface(environment=STAGE)
self.books_interface = BooksInterface(environment=STAGE)
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,
book_type='Wash')
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):
self.assets_interface.upsert(self.asset)
def create_transaction_book(self, book):
self.books_interface.new(book)
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)
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(environment=ENVIRONMENT)
self.assets_interface = AssetsInterface(environment=ENVIRONMENT)
self.books_interface = BooksInterface(environment=ENVIRONMENT)
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(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.asset_manager_id = random.randint(1, 2**31 - 1)
self.assets_interface = AssetsInterface(environment=ENVIRONMENT)
self.books_interface = BooksInterface(environment=ENVIRONMENT)
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 interface_direct_class(data_class):
"""help to direct to the correct interface interacting with DB by class name only"""
if data_class in ASSET:
interface = AssetsInterface()
elif data_class in PARTY:
interface = PartiesInterface()
elif data_class in BOOK:
interface = BooksInterface()
elif data_class in CORPORATE_ACTION:
interface = CorporateActionsInterface()
elif data_class in MARKET_DATA:
interface = MarketDataInterface()
elif data_class in TRANSACTION:
interface = TransactionsInterface()
else:
interface = AssetManagersInterface()
return interface
def _import_book(asset_manager_id, rowdata):
rowdata = {to_snake_case(key): value for key, value in rowdata.items()}
if not rowdata.get('book_id'):
return
mapped_fields = [{
mapped_field: rowdata.pop(field)
} for field, mapped_field in BOOK_FIELD_MAPPINGS.items()]
[rowdata.update(field) for field in mapped_fields]
book = Book(**rowdata)
book_api = BooksInterface(environment=ENVIRONMENT)
existing_book = book_api.search(asset_manager_id=asset_manager_id,
book_ids=[book.book_id])
if not existing_book:
book_api.new(book)
else:
book_api.amend(book)
return book
from amaascore.assets.bond import BondGovernment
from amaascore.assets.interface import AssetsInterface
from amaascore.books.book import Book
from amaascore.books.interface import BooksInterface
from amaascore.core.reference import Reference
from amaascore.parties.broker import Broker
from amaascore.parties.company import Company
from amaascore.parties.interface import PartiesInterface
from amaascore.transactions.interface import TransactionsInterface
from amaascore.transactions.transaction import Transaction
logging.config.dictConfig(DEFAULT_LOGGING)
# Create the interfaces
assets_interface = AssetsInterface()
books_interface = BooksInterface()
parties_interface = PartiesInterface()
transaction_interface = TransactionsInterface()
def create_jgb(asset_manager_id):
jgb_symbol = 'JB355'
jgb_references = {
'ISIN': Reference(reference_value='JP1234567890'),
'Ticker': Reference(reference_value=jgb_symbol)
}
jgb = BondGovernment(asset_manager_id=asset_manager_id,
asset_id=jgb_symbol,
currency='JPY',
references=jgb_references,
class TransactionsInterfaceTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.transactions_interface = TransactionsInterface(
environment=ENVIRONMENT)
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.asset_manager_id = random.randint(1, 2**31 - 1)
self.assets_interface = AssetsInterface(environment=ENVIRONMENT)
self.books_interface = BooksInterface(environment=ENVIRONMENT)
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 test_New_MTM(self):
mtm_result = generate_mtm_result()
result = self.transactions_interface.new_mtm_result(
mtm_results=mtm_result,
asset_manager_id=mtm_result.asset_manager_id)
self.assertEqual(mtm_result.asset_id, result[0].asset_id)
self.assertEqual(mtm_result.mtm_value, result[0].mtm_value)
def test_Amend_MTM(self):
mtm_result = generate_mtm_result()
result = self.transactions_interface.new_mtm_result(
mtm_results=mtm_result,
asset_manager_id=mtm_result.asset_manager_id)
self.assertEqual(mtm_result.asset_id, result[0].asset_id)
self.assertEqual(mtm_result.mtm_value, result[0].mtm_value)
mtm_result.mtm_value = Decimal(random.random() * 10000)
amended = self.transactions_interface.amend_mtm_result(
mtm_results=mtm_result,
asset_manager_id=mtm_result.asset_manager_id)
self.assertEqual(amended[0].mtm_value, mtm_result.mtm_value)
def test_Retrieve_MTM(self):
mtm_result = generate_mtm_result(asset_manager_id=1)
result = self.transactions_interface.new_mtm_result(
mtm_results=mtm_result,
asset_manager_id=mtm_result.asset_manager_id)
self.assertEqual(mtm_result.asset_id, result[0].asset_id)
self.assertEqual(mtm_result.mtm_value, result[0].mtm_value)
parameters = {
'book_id': mtm_result.book_id,
'asset_id': mtm_result.asset_id
}
result = self.transactions_interface.retrieve_mtm_result(
asset_manager_id=mtm_result.asset_manager_id,
book_id=mtm_result.book_id,
paramaters=parameters)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].asset_id, mtm_result.asset_id)
def create_transaction_asset(self):
self.assets_interface.upsert(self.asset)
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):
self.books_interface.new(book)
def test_New(self):
self.assertIsNone(self.transaction.created_time)
transaction = self.transactions_interface.new(self.transaction)
# TODO - this should be populated by the New call.
#self.assertIsNotNone(transaction.created_time)
self.assertEqual(transaction.transaction_id, self.transaction_id)
def test_Amend(self):
transaction = self.transactions_interface.new(self.transaction)
self.assertEqual(transaction.version, 1)
new_settlement_date = transaction.settlement_date + datetime.timedelta(
days=1)
transaction.settlement_date = new_settlement_date
transaction = self.transactions_interface.amend(transaction)
self.assertEqual(transaction.settlement_date, new_settlement_date)
self.assertEqual(transaction.version, 2)
def test_Partial(self):
self.transactions_interface.new(self.transaction)
price = Decimal('3.14')
updates = {'price': price}
transaction = self.transactions_interface.partial(
asset_manager_id=self.asset_manager_id,
transaction_id=self.transaction_id,
updates=updates)
self.assertEqual(transaction.version, 2)
self.assertEqual(transaction.price, price)
def test_Retrieve(self):
self.transactions_interface.new(self.transaction)
transaction = self.transactions_interface.retrieve(
self.transaction.asset_manager_id, self.transaction.transaction_id)
self.assertEqual(type(transaction), Transaction)
def test_Cancel(self):
self.transactions_interface.new(self.transaction)
self.transactions_interface.cancel(self.transaction.asset_manager_id,
self.transaction.transaction_id)
transaction = self.transactions_interface.retrieve(
self.transaction.asset_manager_id, self.transaction.transaction_id)
self.assertEqual(transaction.transaction_id, self.transaction_id)
self.assertEqual(transaction.transaction_status, 'Cancelled')
@requests_mock.Mocker()
def test_Search(self, mocker):
# This test is somewhat fake - but the integration tests are for the bigger picture
endpoint = self.transactions_interface.endpoint + '/transactions'
asset_manager_ids = [self.asset_manager_id, self.asset_manager_id + 1]
transactions = generate_transactions(
asset_manager_ids=asset_manager_ids)
mocker.get(
endpoint,
json=[transaction.to_json() for transaction in transactions])
all_transactions = self.transactions_interface.search(
self.asset_manager_id)
self.assertEqual(all_transactions, transactions)
@requests_mock.Mocker()
def test_TransactionsByAssetManager(self, mocker):
# This test is somewhat fake - but the integration tests are for the bigger picture
endpoint = '%s/transactions/%s' % (
self.transactions_interface.endpoint, self.asset_manager_id)
asset_manager_ids = [self.asset_manager_id]
transactions = generate_transactions(
asset_manager_ids=asset_manager_ids)
mocker.get(
endpoint,
json=[transaction.to_json() for transaction in transactions])
results = self.transactions_interface.transactions_by_asset_manager(
asset_manager_id=self.asset_manager_id)
self.assertEqual(results, transactions)
@requests_mock.Mocker()
def test_PositionSearch(self, mocker):
# This test is somewhat fake - but the integration tests are for the bigger picture
endpoint = '%s/positions' % self.transactions_interface.endpoint
positions = generate_positions(
asset_manager_ids=[self.asset_manager_id])
mocker.get(endpoint,
json=[position.to_json() for position in positions])
all_positions = self.transactions_interface.position_search(
self.asset_manager_id)
self.assertEqual(all_positions, positions)
@requests_mock.Mocker()
def test_PositionsByBook(self, mocker):
# This test is somewhat fake - but the integration tests are for the bigger picture
book_id = self.asset_book.book_id
endpoint = '%s/positions/%s/%s' % (
self.transactions_interface.endpoint, self.asset_manager_id,
book_id)
positions = generate_positions(
asset_manager_ids=[self.asset_manager_id], book_ids=[book_id])
mocker.get(endpoint,
json=[position.to_json() for position in positions])
results = self.transactions_interface.positions_by_asset_manager_book(
asset_manager_id=self.asset_manager_id, book_id=book_id)
self.assertEqual(positions, results)
@requests_mock.Mocker()
def test_PositionsByAssetManager(self, mocker):
# This test is somewhat fake - but the integration tests are for the bigger picture
endpoint = '%s/positions/%s' % (self.transactions_interface.endpoint,
self.asset_manager_id)
positions = generate_positions(
asset_manager_ids=[self.asset_manager_id])
mocker.get(endpoint,
json=[position.to_json() for position in positions])
results = self.transactions_interface.positions_by_asset_manager(
asset_manager_id=self.asset_manager_id)
self.assertEqual(positions, results)
@requests_mock.Mocker()
def test_PositionsByAssetManagerWithBooks(self, mocker):
# This test is somewhat fake - but the integration tests are for the bigger picture
endpoint = '%s/positions/%s' % (self.transactions_interface.endpoint,
self.asset_manager_id)
positions = [
generate_position(asset_manager_id=self.asset_manager_id,
book_id='TEST')
]
mocker.get(endpoint,
json=[position.to_json() for position in positions])
results = self.transactions_interface.positions_by_asset_manager(
asset_manager_id=self.asset_manager_id, book_ids=['TEST'])
self.assertEqual(positions, results)
def test_MultipleLink(self):
transaction = self.transactions_interface.new(self.transaction)
links = transaction.links.get('Multiple')
self.assertEqual(len(links), 3) # The test script inserts 3 links
# Add a link
random_id = random_string(8)
transaction.add_link('Multiple', linked_transaction_id=random_id)
transaction = self.transactions_interface.amend(transaction)
self.assertEqual(len(transaction.links.get('Multiple')), 4)
transaction.remove_link('Multiple', linked_transaction_id=random_id)
transaction = self.transactions_interface.amend(transaction)
self.assertEqual(len(transaction.links.get('Multiple')), 3)
def test_ChildrenPopulated(self):
transaction = self.transactions_interface.new(self.transaction)
retrieved_transaction = self.transactions_interface.retrieve(
asset_manager_id=self.asset_manager_id,
transaction_id=self.transaction_id)
self.assertGreater(len(transaction.charges), 0)
self.assertGreater(len(transaction.codes), 0)
self.assertGreater(len(transaction.comments), 0)
self.assertGreater(len(transaction.links), 0)
self.assertGreater(len(transaction.parties), 0)
self.assertGreater(len(transaction.references), 0)
self.assertEqual(transaction.charges, retrieved_transaction.charges)
self.assertEqual(transaction.codes, retrieved_transaction.codes)
self.assertEqual(transaction.comments, retrieved_transaction.comments)
self.assertEqual(transaction.links, retrieved_transaction.links)
self.assertEqual(transaction.parties, retrieved_transaction.parties)
self.assertEqual(transaction.references,
retrieved_transaction.references)
def test_Unicode(self):
unicode_comment = '日本語入力'
self.transaction.comments['Unicode'] = Comment(
comment_value=unicode_comment)
transaction = self.transactions_interface.new(self.transaction)
self.assertEqual(
transaction.comments.get('Unicode').comment_value, unicode_comment)
def test_Clear(self):
self.transactions_interface.new(self.transaction)
count = self.transactions_interface.clear(self.asset_manager_id)
self.assertEqual(count['transaction_count'], 1)
self.assertGreater(count['position_count'], 0)
results = self.transactions_interface.search(
asset_manager_id=self.asset_manager_id)
self.assertEqual(len(results), 0)
def test_CashTransaction(self):
transaction = generate_cash_transaction(
asset_manager_id=self.asset_manager_id,
asset_id='JPY',
asset_book_id=self.asset_book.book_id,
counterparty_book_id=self.counterparty_book.book_id)
self.transactions_interface.new(transaction)
transaction = self.transactions_interface.retrieve(
transaction.asset_manager_id, transaction.transaction_id)
self.assertEqual(type(transaction), CashTransaction)
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(environment=STAGE)
self.assets_interface = AssetsInterface(environment=STAGE)
self.books_interface = BooksInterface(environment=STAGE)
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):
self.assets_interface.upsert(asset)
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):
self.books_interface.new(book)
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
def setUpClass(cls):
cls.books_interface = BooksInterface(environment=ENVIRONMENT)
cls.asset_manager_id = random.randint(1, 2**31 - 1)
def setUpClass(cls):
cls.books_interface = BooksInterface()
cls.asset_manager_id = random.randint(1, 2**31 - 1)
