def create_portfolios():
logger.info("Portfolios initialization. Creating test portfolios...")
wm_api = wm_api_init()
# create all portfolios from resources folder
db_portfolios = p_info()
test_portfolios = portfolios_to_test()
for portfolio, p_data in test_portfolios.items():
if portfolio in db_portfolios:
logger.info("Portfolios initialization. %s already exists!" % portfolio)
else:
body = {"name": portfolio, "portfolioType": "CLIENT", "currencyId": p_data['ccy']}
api_data = wm_api['portfolio'].post(json.dumps(body), url_param='.create')
p_id = api_data['id']
# load trades into created portfolio
p_file = {'file': (p_data['file'], open(p_data['path'], 'rb'))}
api_data = wm_api['common'].post(files=p_file, url_param='trades/upload?portfolioId=%s' % p_id)
loaded_cnt = api_data
# confirm trades for created portfolio
body = {"portfolioId": p_id}
api_data = wm_api['portfolio'].post(json.dumps(body), url_param='.confirm.trades')
confirmed_cnt = api_data
if confirmed_cnt == loaded_cnt:
logger.info("Portfolios initialization. %s is created successfully!" % portfolio)
time.sleep(10)
else:
logger.warning("Portfolios initialization. %s is not created properly! "
"Trades loaded: %s. Trades confirmed: %s" % (portfolio, loaded_cnt, confirmed_cnt))
import json
import pytest
from definitions import RECENT_DATE
from tests.db_support import db_top_positions, db_get_portfolio_info as p_info
@pytest.mark.parametrize('order, limit', [('DESC', 10), ('DESC', 15),
('ASC', 10), ('ASC', 15)])
@pytest.mark.parametrize('p_name, p_id',
p_info(parametrized=True, ids_only=True))
def test_top_positions(wm_api, p_name, p_id, order, limit, expect):
pos_in = db_top_positions(p_name,
RECENT_DATE,
desc=order == 'DESC',
limit=limit)
# get top positions
body = {
'portfolioId': p_id,
'number': limit,
'viewType': 'MONEY',
'order': {
'name': 'value',
'direction': order
}
}
pos_out = wm_api['common'].post(json.dumps(body), url_param='position.top')
for pos_db, pos_api in zip(pos_in, pos_out):
expect(
pos_db['instrument'] == pos_api['name'],
from datetime import datetime
import pytest
import json
from definitions import RECENT_DATE
from tests.WM_API.totals import calculate_totals_for_period, calculate_income, calculate_nav, calculate_yield
from tests.db_support import db_get_portfolio_info as p_info
@pytest.mark.parametrize(
'p_name, p_id, from_dt, to_dt',
[(p_name, p_id, _from, _to)
for p_name, p_id, start_dt in p_info(parametrized=True)
for _from, _to in [(
start_dt, RECENT_DATE
), (RECENT_DATE.replace(year=RECENT_DATE.year - 1),
RECENT_DATE), (RECENT_DATE.replace(month=1, day=1), RECENT_DATE)]])
def test_report_income(p_name, p_id, from_dt, to_dt, wm_api, expect):
flags = {
'aggregated': True,
'all': False,
'specific': False,
'income': True
}
income_in = calculate_totals_for_period(p_name, from_dt, to_dt,
**flags)['income']
# get income
body = {
"portfolioId": p_id,
"period": {
"from":
from datetime import datetime, timedelta
import pytest
import json
from definitions import RECENT_DATE
from tests.WM_API.totals import calculate_totals_for_period
from tests.db_support import db_get_portfolio_info as p_info
@pytest.mark.parametrize(
'p_name, p_id, tense, from_dt, to_dt',
[(p_name, p_id, tense, _from, _to)
for p_name, p_id, start_dt in p_info(parametrized=True) for tense, _from,
_to in [(0, RECENT_DATE.replace(year=RECENT_DATE.year - 1, day=1),
RECENT_DATE.replace(day=1) - timedelta(days=1)),
(1, RECENT_DATE.replace(day=1),
(RECENT_DATE.replace(day=1, year=RECENT_DATE.year + 1) -
timedelta(days=1)))]])
def test_coupons(p_name, p_id, tense, from_dt, to_dt, wm_api, expect):
# calculate only income for equity
flags = {
class_name.lower(): True,
'income': True,
'aggregated': True,
'specific': True,
'interval': 'Monthly'
}
income_in = calculate_totals_for_period(p_name, from_dt, to_dt,
**flags)['income']
# get dividends
body = {"portfolioId": p_id}
from datetime import datetime
import pytest
import json
from definitions import RECENT_DATE
from tests.WM_API.totals import calculate_performance
from tests.db_support import db_get_portfolio_info as p_info
@pytest.mark.parametrize('p_name, p_id, from_dt, to_dt, p_dt',
[(p_name, p_id, _from, _to, p_dt)
for p_name, p_id, p_dt in p_info(parametrized=True)
for _from, _to in
sorted({
([p_dt, RECENT_DATE.replace(day=1)][p_dt < RECENT_DATE.replace(day=1)], RECENT_DATE),
(p_dt, RECENT_DATE),
([p_dt, RECENT_DATE.replace(month=1, day=1)][p_dt < RECENT_DATE.replace(month=1, day=1)], RECENT_DATE)
})])
def test_credit_performance(p_name, p_id, from_dt, to_dt, p_dt, wm_api, expect):
# correct 'start' date according to portfolio start date
actual_start_dt = [p_dt, from_dt][p_dt < from_dt]
periodicity = ['Monthly', 'Daily'][(to_dt - actual_start_dt).days < 31]
flags = {class_name.lower(): True, 'aggregated': True, 'specific': True, 'interval': periodicity}
performance_in = calculate_performance(p_name, actual_start_dt, to_dt, **flags)
# get performance
body = {'portfolioId': p_id, 'assetClassId': class_id, 'period': {'from': str(from_dt), 'to': str(to_dt)},
'detalization': periodicity}
api_data = wm_api['portfolio'].post(json.dumps(body), url_param='.performance')
performance_out = {datetime.strptime(v[0], '%Y-%m-%d').date(): round(v[1], 3) for v in api_data['data']}
for dt in performance_in:
import json
import pytest
from definitions import RECENT_DATE
from tests.WM_API.totals import calculate_pnl
from tests.db_support import db_portfolio_snapshot, db_get_portfolio_info as p_info
@pytest.mark.parametrize('p_name, p_id, p_dt', p_info(parametrized=True))
def test_portfolio_snapshot(wm_api, p_name, p_id, p_dt, expect):
snap_in = db_portfolio_snapshot(p_name)
pnl_in = calculate_pnl(p_name, start_date=p_dt, end_date=RECENT_DATE, **{'all': False, 'detailed': True})
# get portfolio snapshot
body = {'portfolioId': p_id, 'page': 0, 'size': 1000,
'order': {'name': 'name', 'direction': 'ASC'}, 'confirmed': True}
api_data = wm_api['portfolio'].post(json.dumps(body), url_param='.snapshot')
snap_out = api_data['content']
for pos_db, pos_api in zip(snap_in, snap_out):
if pos_db['instrument'] == pos_api['name']:
expect(pos_db['quantity'] == pos_api['quantity'],
'Fail: Instrument %s quantity: api %s != %s db' % (pos_db['instrument'], pos_api['quantity'], pos_db['quantity']))
expect(round(pos_db['price'], 2) == round(pos_api['currentPriceNative'], 2),
'Fail: Instrument %s price: api %s != %s db' % (pos_db['instrument'], round(pos_api['currentPriceNative'], 2), round(pos_db['price'], 2)))
expect(pos_db['currency'] == pos_api['currencyNative'],
'Fail: Instrument %s currency: api %s != %s db' % (pos_db['instrument'], pos_api['currencyNative'], pos_db['currency']))
expect(round(pos_db['exd_value']) == round(pos_api['amount']),
'Fail: Instrument %s value: api %s != %s db' % (pos_db['instrument'], round(pos_api['amount']), round(pos_db['exd_value'])))
expect(pytest.approx(round(pnl_in[pos_db['code']], 2), abs=0.1) == round(pos_api['profitAndLoss'], 2),
'Fail: Instrument %s PnL: api %s != %s db' % (pos_db['instrument'], round(pos_api['profitAndLoss'], 2), round(pnl_in[pos_db['code']], 2)))
else:
import json
import pytest
from definitions import RECENT_DATE
from tests.db_support import db_principal_pay, db_get_portfolio_info as p_info
@pytest.mark.parametrize('p_name, p_id', p_info(parametrized=True, ids_only=True))
def test_credit_principal(wm_api, p_name, p_id, expect):
pr_in = db_principal_pay(p_name, RECENT_DATE)
# get total wealth
body = {"portfolioId": p_id}
api_data = wm_api['credit'].post(json.dumps(body), url_param='.principal.repayments')
pr_out = {v[0]: v[1] for v in api_data['data']}
for dt in pr_in:
p_in, p_out = round(pr_in[dt], 2), round(pr_out[str(dt)], 2)
expect(p_in == p_out, 'Fail: Principal repayment: %s: api %s != %s db' % (dt, p_out, p_in))
import json
import pytest
from datetime import timedelta
from definitions import RECENT_DATE
from tests.db_support import db_wealth_per_asset, db_get_portfolio_info as p_info
from tests.WM_API.totals import calculate_income, calculate_yield
@pytest.mark.parametrize('p_name, p_id',
p_info(parametrized=True, ids_only=True))
def test_private_equity_tw(wm_api, p_name, p_id):
tw_in = db_wealth_per_asset(p_name, RECENT_DATE)[class_name]
# get total wealth
body = {
"portfolioId": p_id,
"asset": {
"id": class_id,
"type": "AssetSubClass"
}
}
api_data = wm_api['common'].post(json.dumps(body),
url_param='dashboard.info')
tw_out = api_data['total']['value']
assert round(tw_in, 2) == round(
tw_out, 2), 'Fail: Total wealth: api %s != %s db' % (tw_out, tw_in)
@pytest.mark.skip('No requirements')
@pytest.mark.parametrize(
