def assert_all_balances(
data,
db,
expected_data_in_db,
setup: BalancesTestSetup,
) -> None:
result = data['result']
total_eth = get_asset_balance_total('ETH', setup)
total_rdn = get_asset_balance_total('RDN', setup)
total_btc = get_asset_balance_total('BTC', setup)
total_eur = get_asset_balance_total('EUR', setup)
got_external = any(x.location == Location.EXTERNAL
for x in setup.manually_tracked_balances)
assert FVal(result['ETH']['amount']) == total_eth
assert result['ETH']['usd_value'] is not None
assert result['ETH']['percentage_of_net_value'] is not None
assert FVal(result['RDN']['amount']) == total_rdn
assert result['RDN']['usd_value'] is not None
assert result['RDN']['percentage_of_net_value'] is not None
assert FVal(result['BTC']['amount']) == total_btc
assert result['BTC']['usd_value'] is not None
assert result['BTC']['percentage_of_net_value'] is not None
assert FVal(result['EUR']['amount']) == total_eur
assert result['BTC']['usd_value'] is not None
assert result['EUR']['percentage_of_net_value'] is not None
assert result['net_usd'] is not None
# Check that the 4 locations are there
assert len(result['location']) == 5 if got_external else 4
assert result['location']['binance']['usd_value'] is not None
assert result['location']['binance']['percentage_of_net_value'] is not None
assert result['location']['poloniex']['usd_value'] is not None
assert result['location']['poloniex'][
'percentage_of_net_value'] is not None
assert result['location']['blockchain']['usd_value'] is not None
assert result['location']['blockchain'][
'percentage_of_net_value'] is not None
assert result['location']['banks']['usd_value'] is not None
assert result['location']['banks']['percentage_of_net_value'] is not None
if got_external:
assert result['location']['external']['usd_value'] is not None
assert result['location']['external'][
'percentage_of_net_value'] is not None
assert len(result) == 6 # 4 assets + location + net_usd
eth_tbalances = db.query_timed_balances(from_ts=None,
to_ts=None,
asset=A_ETH)
if not expected_data_in_db:
assert len(eth_tbalances) == 0
else:
assert len(eth_tbalances) == 1
assert FVal(eth_tbalances[0].amount) == total_eth
btc_tbalances = db.query_timed_balances(from_ts=None,
to_ts=None,
asset=A_BTC)
if not expected_data_in_db:
assert len(btc_tbalances) == 0
else:
assert len(btc_tbalances) == 1
assert FVal(btc_tbalances[0].amount) == total_btc
rdn_tbalances = db.query_timed_balances(from_ts=None,
to_ts=None,
asset=A_RDN)
if not expected_data_in_db:
assert len(rdn_tbalances) == 0
else:
assert len(rdn_tbalances) == 1
assert FVal(rdn_tbalances[0].amount) == total_rdn
times, net_values = db.get_netvalue_data()
if not expected_data_in_db:
assert len(times) == 0
assert len(net_values) == 0
else:
assert len(times) == 1
assert len(net_values) == 1
location_data = db.get_latest_location_value_distribution()
if not expected_data_in_db:
assert len(location_data) == 0
else:
expected_locations = {
Location.POLONIEX.serialize_for_db(),
Location.BINANCE.serialize_for_db(),
Location.TOTAL.serialize_for_db(),
Location.BANKS.serialize_for_db(),
Location.BLOCKCHAIN.serialize_for_db(),
}
if got_external:
expected_locations.add(Location.EXTERNAL.serialize_for_db())
assert len(location_data) == 6
else:
assert len(location_data) == 5
assert len(location_data) == 6 if got_external else 5
locations = {x.location for x in location_data}
assert locations == expected_locations
def assert_all_balances(
result,
db,
expected_data_in_db,
setup: BalancesTestSetup,
) -> None:
total_eth = get_asset_balance_total(A_ETH, setup)
total_rdn = get_asset_balance_total(A_RDN, setup)
total_btc = get_asset_balance_total(A_BTC, setup)
total_eur = get_asset_balance_total(A_EUR, setup)
got_external = any(x.location == Location.EXTERNAL
for x in setup.manually_tracked_balances)
assert len(result) == 4
assert result['liabilities'] == {}
assets = result['assets']
assert FVal(assets['ETH']['amount']) == total_eth
assert assets['ETH']['usd_value'] is not None
assert assets['ETH']['percentage_of_net_value'] is not None
assert FVal(assets[A_RDN.identifier]['amount']) == total_rdn
assert assets[A_RDN.identifier]['usd_value'] is not None
assert assets[A_RDN.identifier]['percentage_of_net_value'] is not None
assert FVal(assets['BTC']['amount']) == total_btc
assert assets['BTC']['usd_value'] is not None
assert assets['BTC']['percentage_of_net_value'] is not None
if total_eur != ZERO:
assert FVal(assets['EUR']['amount']) == total_eur
assert assets['EUR']['percentage_of_net_value'] is not None
assert result['net_usd'] is not None
# Check that the 4 locations are there
assert len(result['location']) == 5 if got_external else 4
assert result['location']['binance']['usd_value'] is not None
assert result['location']['binance']['percentage_of_net_value'] is not None
assert result['location']['poloniex']['usd_value'] is not None
assert result['location']['poloniex'][
'percentage_of_net_value'] is not None
assert result['location']['blockchain']['usd_value'] is not None
assert result['location']['blockchain'][
'percentage_of_net_value'] is not None
if total_eur != ZERO:
assert result['location']['banks']['usd_value'] is not None
assert result['location']['banks'][
'percentage_of_net_value'] is not None
if got_external:
assert result['location']['external']['usd_value'] is not None
assert result['location']['external'][
'percentage_of_net_value'] is not None
eth_tbalances = db.query_timed_balances(asset=A_ETH)
if not expected_data_in_db:
assert len(eth_tbalances) == 0
else:
assert len(eth_tbalances) == 1
assert FVal(eth_tbalances[0].amount) == total_eth
btc_tbalances = db.query_timed_balances(asset=A_BTC)
if not expected_data_in_db:
assert len(btc_tbalances) == 0
else:
assert len(btc_tbalances) == 1
assert FVal(btc_tbalances[0].amount) == total_btc
rdn_tbalances = db.query_timed_balances(asset=A_RDN)
if not expected_data_in_db:
assert len(rdn_tbalances) == 0
else:
assert len(rdn_tbalances) == 1
assert FVal(rdn_tbalances[0].amount) == total_rdn
times, net_values = db.get_netvalue_data(Timestamp(0))
if not expected_data_in_db:
assert len(times) == 0
assert len(net_values) == 0
else:
assert len(times) == 1
assert len(net_values) == 1
location_data = db.get_latest_location_value_distribution()
if not expected_data_in_db:
assert len(location_data) == 0
else:
expected_locations = {
Location.POLONIEX.serialize_for_db(),
Location.BINANCE.serialize_for_db(),
Location.TOTAL.serialize_for_db(),
Location.BLOCKCHAIN.serialize_for_db(),
}
if got_external:
expected_locations.add(Location.EXTERNAL.serialize_for_db())
if total_eur != ZERO:
expected_locations.add(Location.BANKS.serialize_for_db())
locations = {x.location for x in location_data}
assert locations == expected_locations
def assert_all_balances(
data,
db,
expected_data_in_db,
setup: BalancesTestSetup,
) -> None:
result = data['result']
total_eth = get_asset_balance_total('ETH', setup)
total_rdn = get_asset_balance_total('RDN', setup)
total_btc = get_asset_balance_total('BTC', setup)
assert FVal(result['ETH']['amount']) == total_eth
assert result['ETH']['usd_value'] is not None
assert result['ETH']['percentage_of_net_value'] is not None
assert FVal(result['RDN']['amount']) == total_rdn
assert result['RDN']['usd_value'] is not None
assert result['RDN']['percentage_of_net_value'] is not None
assert FVal(result['BTC']['amount']) == total_btc
assert result['BTC']['usd_value'] is not None
assert result['BTC']['percentage_of_net_value'] is not None
assert FVal(result['EUR']['amount']) == setup.fiat_balances['EUR']
assert result['BTC']['usd_value'] is not None
assert result['EUR']['percentage_of_net_value'] is not None
assert result['net_usd'] is not None
# Check that the 4 locations are there
assert len(result['location']) == 4
assert result['location']['binance']['usd_value'] is not None
assert result['location']['binance']['percentage_of_net_value'] is not None
assert result['location']['poloniex']['usd_value'] is not None
assert result['location']['poloniex'][
'percentage_of_net_value'] is not None
assert result['location']['blockchain']['usd_value'] is not None
assert result['location']['blockchain'][
'percentage_of_net_value'] is not None
assert result['location']['banks']['usd_value'] is not None
assert result['location']['banks']['percentage_of_net_value'] is not None
assert len(result) == 6 # 4 assets + location + net_usd
eth_tbalances = db.query_timed_balances(from_ts=None,
to_ts=None,
asset=A_ETH)
if not expected_data_in_db:
assert len(eth_tbalances) == 0
else:
assert len(eth_tbalances) == 1
assert FVal(eth_tbalances[0].amount) == total_eth
btc_tbalances = db.query_timed_balances(from_ts=None,
to_ts=None,
asset=A_BTC)
if not expected_data_in_db:
assert len(btc_tbalances) == 0
else:
assert len(btc_tbalances) == 1
assert FVal(btc_tbalances[0].amount) == total_btc
rdn_tbalances = db.query_timed_balances(from_ts=None,
to_ts=None,
asset=A_RDN)
if not expected_data_in_db:
assert len(rdn_tbalances) == 0
else:
assert len(rdn_tbalances) == 1
assert FVal(rdn_tbalances[0].amount) == total_rdn
times, net_values = db.get_netvalue_data()
if not expected_data_in_db:
assert len(times) == 0
assert len(net_values) == 0
else:
assert len(times) == 1
assert len(net_values) == 1
location_data = db.get_latest_location_value_distribution()
if not expected_data_in_db:
assert len(location_data) == 0
else:
assert len(location_data) == 5
assert location_data[0].location == Location.POLONIEX.serialize_for_db(
)
assert location_data[1].location == Location.BINANCE.serialize_for_db()
assert location_data[2].location == Location.TOTAL.serialize_for_db()
assert location_data[3].location == Location.BANKS.serialize_for_db()
assert location_data[
4].location == Location.BLOCKCHAIN.serialize_for_db()
def test_query_statistics_asset_balance(
rotkehlchen_api_server_with_exchanges,
ethereum_accounts,
btc_accounts,
start_with_valid_premium,
):
"""Test that using the statistics asset balance over time endpoint works"""
start_time = ts_now()
# Disable caching of query results
rotki = rotkehlchen_api_server_with_exchanges.rest_api.rotkehlchen
rotki.chain_manager.cache_ttl_secs = 0
setup = setup_balances(rotki, ethereum_accounts, btc_accounts)
# query balances and save data in DB to have data to test the statistics endpoint
with ExitStack() as stack:
setup.enter_all_patches(stack)
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
'allbalancesresource',
),
json={'save_data': True},
)
assert_proper_response(response)
# and now test that statistics work fine for ETH, with default time range (0 - now)
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsassetbalanceresource",
asset="ETH",
), )
if start_with_valid_premium:
result = assert_proper_response_with_result(response)
assert len(result) == 1
entry = result[0]
assert len(entry) == 4
assert FVal(entry['amount']) == get_asset_balance_total(A_ETH, setup)
assert entry['category'] == 'asset'
assert entry['time'] >= start_time
assert entry['usd_value'] is not None
else:
assert_error_response(
response=response,
contained_in_msg=
'logged in user testuser does not have a premium subscription',
status_code=HTTPStatus.CONFLICT,
)
# and now test that statistics work fine for BTC, with given time range
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsassetbalanceresource",
asset="BTC",
),
json={
'from_timestamp': 0,
'to_timestamp': start_time + 60000
},
)
if start_with_valid_premium:
result = assert_proper_response_with_result(response)
assert len(result) == 1
entry = result[0]
assert len(entry) == 4
assert FVal(entry['amount']) == get_asset_balance_total(A_BTC, setup)
assert entry['time'] >= start_time
assert entry['category'] == 'asset'
assert entry['usd_value'] is not None
else:
assert_error_response(
response=response,
contained_in_msg=
'logged in user testuser does not have a premium subscription',
status_code=HTTPStatus.CONFLICT,
)
# finally test that if the time range is not including the saved balances we get nothing back
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsassetbalanceresource",
asset="BTC",
),
json={
'from_timestamp': 0,
'to_timestamp': start_time - 1
},
)
if start_with_valid_premium:
result = assert_proper_response_with_result(response)
assert len(result) == 0
else:
assert_error_response(
response=response,
contained_in_msg=
'logged in user testuser does not have a premium subscription',
status_code=HTTPStatus.CONFLICT,
)
def test_query_statistics_value_distribution(
rotkehlchen_api_server_with_exchanges,
ethereum_accounts,
btc_accounts,
start_with_valid_premium,
):
"""Test that using the statistics value distribution endpoint works"""
start_time = ts_now()
# Disable caching of query results
rotki = rotkehlchen_api_server_with_exchanges.rest_api.rotkehlchen
rotki.chain_manager.cache_ttl_secs = 0
token_balances = {A_RDN: ['111000', '4000000']}
setup = setup_balances(
rotki=rotki,
ethereum_accounts=ethereum_accounts,
btc_accounts=btc_accounts,
token_balances=token_balances,
manually_tracked_balances=[
ManuallyTrackedBalance(
asset=A_EUR,
label='My EUR bank',
amount=FVal('1550'),
location=Location.BANKS,
tags=None,
balance_type=BalanceType.ASSET,
)
],
)
# query balances and save data in DB to have data to test the statistics endpoint
with ExitStack() as stack:
setup.enter_all_patches(stack)
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"allbalancesresource",
),
json={'save_data': True},
)
assert_proper_response(response)
def assert_okay_by_location(response):
"""Helper function to run next query and its assertion twice"""
if start_with_valid_premium:
result = assert_proper_response_with_result(response)
assert len(result) == 5
locations = {'poloniex', 'binance', 'banks', 'blockchain', 'total'}
for entry in result:
assert len(entry) == 3
assert entry['time'] >= start_time
assert entry['usd_value'] is not None
assert entry['location'] in locations
locations.remove(entry['location'])
assert len(locations) == 0
else:
assert_error_response(
response=response,
contained_in_msg=
'logged in user testuser does not have a premium subscription',
status_code=HTTPStatus.CONFLICT,
)
# and now test that statistics work fine for distribution by location for json body
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsvaluedistributionresource",
),
json={'distribution_by': 'location'},
)
assert_okay_by_location(response)
# and now test that statistics work fine for distribution by location for query params
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsvaluedistributionresource",
) + '?distribution_by=location', )
assert_okay_by_location(response)
# finally test that statistics work fine for distribution by asset
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsvaluedistributionresource",
),
json={'distribution_by': 'asset'},
)
if start_with_valid_premium:
result = assert_proper_response_with_result(response)
assert len(result) == 4
totals = {
'ETH': get_asset_balance_total(A_ETH, setup),
'BTC': get_asset_balance_total(A_BTC, setup),
'EUR': get_asset_balance_total(A_EUR, setup),
A_RDN.identifier: get_asset_balance_total(A_RDN, setup),
}
for entry in result:
assert len(entry) == 5
assert entry['time'] >= start_time
assert entry['category'] == 'asset'
assert entry['usd_value'] is not None
assert FVal(entry['amount']) == totals[entry['asset']]
else:
assert_error_response(
response=response,
contained_in_msg=
'logged in user testuser does not have a premium subscription',
status_code=HTTPStatus.CONFLICT,
)
def test_query_statistics_value_distribution(
rotkehlchen_api_server_with_exchanges,
ethereum_accounts,
btc_accounts,
number_of_eth_accounts,
start_with_valid_premium,
):
"""Test that using the statistics value distribution endpoint works"""
start_time = ts_now()
# Disable caching of query results
rotki = rotkehlchen_api_server_with_exchanges.rest_api.rotkehlchen
rotki.chain_manager.cache_ttl_secs = 0
setup = setup_balances(rotki, ethereum_accounts, btc_accounts)
# query balances and save data in DB to have data to test the statistics endpoint
with ExitStack() as stack:
setup.enter_all_patches(stack)
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"allbalancesresource",
), json={'save_data': True},
)
assert_proper_response(response)
def assert_okay_by_location(response):
"""Helper function to run next query and its assertion twice"""
if start_with_valid_premium:
assert_proper_response(response)
data = response.json()
assert data['message'] == ''
assert len(data['result']) == 5
locations = {'poloniex', 'binance', 'banks', 'blockchain', 'total'}
for entry in data['result']:
assert len(entry) == 3
assert entry['time'] >= start_time
assert entry['usd_value'] is not None
assert entry['location'] in locations
locations.remove(entry['location'])
assert len(locations) == 0
else:
assert_error_response(
response=response,
contained_in_msg='logged in user testuser does not have a premium subscription',
status_code=HTTPStatus.CONFLICT,
)
# and now test that statistics work fine for distribution by location for json body
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsvaluedistributionresource",
), json={'distribution_by': 'location'},
)
assert_okay_by_location(response)
# and now test that statistics work fine for distribution by location for query params
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsvaluedistributionresource",
) + '?distribution_by=location',
)
assert_okay_by_location(response)
# finally test that statistics work fine for distribution by asset
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsvaluedistributionresource",
), json={'distribution_by': 'asset'},
)
if start_with_valid_premium:
assert_proper_response(response)
data = response.json()
assert data['message'] == ''
assert len(data['result']) == 4
totals = {
'ETH': get_asset_balance_total('ETH', setup),
'BTC': get_asset_balance_total('BTC', setup),
'EUR': get_asset_balance_total('EUR', setup),
'RDN': get_asset_balance_total('RDN', setup),
}
for entry in data['result']:
assert len(entry) == 4
assert entry['time'] >= start_time
assert entry['usd_value'] is not None
assert FVal(entry['amount']) == totals[entry['asset']]
else:
assert_error_response(
response=response,
contained_in_msg='logged in user testuser does not have a premium subscription',
status_code=HTTPStatus.CONFLICT,
)
def test_query_statistics_asset_balance(
rotkehlchen_api_server_with_exchanges,
ethereum_accounts,
btc_accounts,
number_of_eth_accounts,
start_with_valid_premium,
):
"""Test that using the statistics asset balance over time endpoint works"""
start_time = ts_now()
# Disable caching of query results
rotki = rotkehlchen_api_server_with_exchanges.rest_api.rotkehlchen
rotki.blockchain.cache_ttl_secs = 0
setup = setup_balances(rotki, ethereum_accounts, btc_accounts)
# query balances and save data in DB to have data to test the statistics endpoint
with setup.poloniex_patch, setup.binance_patch, setup.etherscan_patch, setup.bitcoin_patch:
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"allbalancesresource",
),
json={'save_data': True},
)
assert_proper_response(response)
# and now test that statistics work fine for ETH, with default time range (0 - now)
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsassetbalanceresource",
asset="ETH",
), )
if start_with_valid_premium:
assert_proper_response(response)
data = response.json()
assert data['message'] == ''
assert len(data['result']) == 1
entry = data['result'][0]
assert len(entry) == 3
assert FVal(entry['amount']) == get_asset_balance_total('ETH', setup)
assert entry['time'] >= start_time
assert entry['usd_value'] is not None
else:
assert_error_response(
response=response,
contained_in_msg=
'logged in user testuser does not have a premium subscription',
status_code=HTTPStatus.CONFLICT,
)
# and now test that statistics work fine for BTC, with given time range
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsassetbalanceresource",
asset="BTC",
),
json={
'from_timestamp': 0,
'to_timestamp': start_time + 60000
},
)
if start_with_valid_premium:
assert_proper_response(response)
data = response.json()
assert data['message'] == ''
assert len(data['result']) == 1
entry = data['result'][0]
assert len(entry) == 3
assert FVal(entry['amount']) == get_asset_balance_total('BTC', setup)
assert entry['time'] >= start_time
assert entry['usd_value'] is not None
else:
assert_error_response(
response=response,
contained_in_msg=
'logged in user testuser does not have a premium subscription',
status_code=HTTPStatus.CONFLICT,
)
# finally test that if the time range is not including the saved balances we get nothing back
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"statisticsassetbalanceresource",
asset="BTC",
),
json={
'from_timestamp': 0,
'to_timestamp': start_time - 1
},
)
if start_with_valid_premium:
assert_proper_response(response)
data = response.json()
assert data['message'] == ''
assert len(data['result']) == 0
else:
assert_error_response(
response=response,
contained_in_msg=
'logged in user testuser does not have a premium subscription',
status_code=HTTPStatus.CONFLICT,
)
