def test_exchange_query_balances_async(rotkehlchen_api_server_with_exchanges):
"""Test that using the exchange balances query endpoint works fine for async calls"""
# async query balances of one specific exchange
server = rotkehlchen_api_server_with_exchanges
binance = server.rest_api.rotkehlchen.exchange_manager.connected_exchanges[
'binance']
binance_patch = patch_binance_balances_query(binance)
with binance_patch:
response = requests.get(api_url_for(
server,
"named_exchanges_balances_resource",
name='binance',
),
json={'async_query': True})
task_id = assert_ok_async_response(response)
outcome = wait_for_async_task(server, task_id)
assert_binance_balances_result(outcome['result'])
# async query of one exchange with querystring parameters
poloniex = server.rest_api.rotkehlchen.exchange_manager.connected_exchanges[
'poloniex']
poloniex_patch = patch_poloniex_balances_query(poloniex)
with poloniex_patch:
response = requests.get(
api_url_for(
server,
"named_exchanges_balances_resource",
name='poloniex',
) + '?async_query=true')
task_id = assert_ok_async_response(response)
outcome = wait_for_async_task(server, task_id)
assert_poloniex_balances_result(outcome['result'])
# async query balances of all setup exchanges
with binance_patch, poloniex_patch:
response = requests.get(
api_url_for(server, "exchangebalancesresource"),
json={'async_query': True},
)
task_id = assert_ok_async_response(response)
outcome = wait_for_async_task(server, task_id)
result = outcome['result']
assert_binance_balances_result(result['binance'])
assert_poloniex_balances_result(result['poloniex'])
def test_exchange_query_balances(rotkehlchen_api_server_with_exchanges):
"""Test that using the exchange balances query endpoint works fine"""
async_query = random.choice([False, True])
# query balances of one specific exchange
server = rotkehlchen_api_server_with_exchanges
binance = server.rest_api.rotkehlchen.exchange_manager.connected_exchanges[
'binance']
binance_patch = patch_binance_balances_query(binance)
with binance_patch:
response = requests.get(api_url_for(
server,
"named_exchanges_balances_resource",
name='binance',
),
json={'async_query': async_query})
if async_query:
task_id = assert_ok_async_response(response)
outcome = wait_for_async_task_with_result(server, task_id)
else:
outcome = assert_proper_response_with_result(response)
assert_binance_balances_result(outcome)
# query balances of all setup exchanges
poloniex = server.rest_api.rotkehlchen.exchange_manager.connected_exchanges[
'poloniex']
poloniex_patch = patch_poloniex_balances_query(poloniex)
with binance_patch, poloniex_patch:
response = requests.get(
api_url_for(server, "exchangebalancesresource"),
json={'async_query': async_query},
)
if async_query:
task_id = assert_ok_async_response(response)
result = wait_for_async_task_with_result(server, task_id)
else:
result = assert_proper_response_with_result(response)
assert_binance_balances_result(result['binance'])
assert_poloniex_balances_result(result['poloniex'])
def test_exchange_query_balances(rotkehlchen_api_server_with_exchanges):
"""Test that using the exchange balances query endpoint works fine"""
# query balances of one specific exchange
server = rotkehlchen_api_server_with_exchanges
binance = server.rest_api.rotkehlchen.exchange_manager.connected_exchanges[
'binance']
binance_patch = patch_binance_balances_query(binance)
with binance_patch:
response = requests.get(
api_url_for(
server,
"named_exchanges_balances_resource",
name='binance',
))
assert_proper_response(response)
json_data = response.json()
assert json_data['message'] == ''
result = json_data['result']
assert_binance_balances_result(json_data['result'])
# query balances of all setup exchanges
poloniex = server.rest_api.rotkehlchen.exchange_manager.connected_exchanges[
'poloniex']
poloniex_patch = patch_poloniex_balances_query(poloniex)
with binance_patch, poloniex_patch:
response = requests.get(api_url_for(server,
"exchangebalancesresource"))
assert_proper_response(response)
json_data = response.json()
assert json_data['message'] == ''
result = json_data['result']
assert_binance_balances_result(result['binance'])
assert_poloniex_balances_result(result['poloniex'])
def test_exchange_query_balances_ignore_cache(
rotkehlchen_api_server_with_exchanges):
"""Test that using the exchange balances query endpoint can ignore cache"""
server = rotkehlchen_api_server_with_exchanges
binance = server.rest_api.rotkehlchen.exchange_manager.connected_exchanges[
'binance']
binance_patch = patch_binance_balances_query(binance)
binance_api_query = patch.object(binance,
'api_query_dict',
wraps=binance.api_query_dict)
with binance_patch, binance_api_query as bn:
# Query balances for the first time
response = requests.get(
api_url_for(
server,
"named_exchanges_balances_resource",
name='binance',
))
assert_proper_response(response)
json_data = response.json()
assert json_data['message'] == ''
assert_binance_balances_result(json_data['result'])
assert bn.call_count == 3
# Do the query again. Cache should be used.
binance_patch = patch_binance_balances_query(binance)
response = requests.get(
api_url_for(
server,
"named_exchanges_balances_resource",
name='binance',
))
assert_proper_response(response)
json_data = response.json()
assert json_data['message'] == ''
assert_binance_balances_result(json_data['result'])
assert bn.call_count == 3, 'call count should not have changed. Cache must have been used'
# Finally do the query and request ignoring of the cache
binance_patch = patch_binance_balances_query(binance)
response = requests.get(api_url_for(
server,
"named_exchanges_balances_resource",
name='binance',
),
json={'ignore_cache': True})
assert_proper_response(response)
json_data = response.json()
assert json_data['message'] == ''
assert_binance_balances_result(json_data['result'])
assert bn.call_count == 6, 'call count should have changed. Cache should have been ignored'
def test_exchange_query_balances_ignore_cache(
rotkehlchen_api_server_with_exchanges):
"""Test that using the exchange balances query endpoint can ignore cache"""
server = rotkehlchen_api_server_with_exchanges
rotki = rotkehlchen_api_server_with_exchanges.rest_api.rotkehlchen
binance = try_get_first_exchange(rotki.exchange_manager, Location.BINANCE)
binance_patch = patch_binance_balances_query(binance)
binance_api_query = patch.object(binance,
'api_query_dict',
wraps=binance.api_query_dict)
with binance_patch, binance_api_query as bn:
# Query balances for the first time
response = requests.get(
api_url_for(
server,
'named_exchanges_balances_resource',
location='binance',
))
result = assert_proper_response_with_result(response)
assert_binance_balances_result(result)
assert bn.call_count == 3
# Do the query again. Cache should be used.
binance_patch = patch_binance_balances_query(binance)
response = requests.get(
api_url_for(
server,
'named_exchanges_balances_resource',
location='binance',
))
result = assert_proper_response_with_result(response)
assert_binance_balances_result(result)
assert bn.call_count == 3, 'call count should not have changed. Cache must have been used'
# Finally do the query and request ignoring of the cache
binance_patch = patch_binance_balances_query(binance)
response = requests.get(api_url_for(
server,
'named_exchanges_balances_resource',
location='binance',
),
json={'ignore_cache': True})
result = assert_proper_response_with_result(response)
assert_binance_balances_result(result)
assert bn.call_count == 6, 'call count should have changed. Cache should have been ignored'
def test_multiple_balance_queries_not_concurrent(
rotkehlchen_api_server_with_exchanges,
ethereum_accounts,
btc_accounts,
separate_blockchain_calls,
):
"""Test multiple different balance query requests happening concurrently
This tests that if multiple balance query requests happen concurrently we
do not end up doing them multiple times, but reuse the results thanks to cache.
Try running both all blockchain balances in one call and each blockchain call separately.
"""
rotki = rotkehlchen_api_server_with_exchanges.rest_api.rotkehlchen
setup = setup_balances(rotki, ethereum_accounts, btc_accounts)
multieth_balance_patch = patch.object(
rotki.chain_manager.ethereum,
'get_multieth_balance',
wraps=rotki.chain_manager.ethereum.get_multieth_balance,
)
btc_balances_patch = patch(
'rotkehlchen.chain.manager.get_bitcoin_addresses_balances',
wraps=get_bitcoin_addresses_balances,
)
binance = rotki.exchange_manager.connected_exchanges['binance']
binance_querydict_patch = patch.object(binance,
'api_query_dict',
wraps=binance.api_query_dict)
# Test all balances request by requesting to not save the data
with ExitStack() as stack:
setup.enter_all_patches(stack)
eth = stack.enter_context(multieth_balance_patch)
btc = stack.enter_context(btc_balances_patch)
bn = stack.enter_context(binance_querydict_patch)
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"allbalancesresource",
),
json={'async_query': True},
)
task_id_all = assert_ok_async_response(response)
response = requests.get(api_url_for(
rotkehlchen_api_server_with_exchanges,
"named_exchanges_balances_resource",
name='binance',
),
json={'async_query': True})
task_id_one_exchange = assert_ok_async_response(response)
if separate_blockchain_calls:
response = requests.get(api_url_for(
rotkehlchen_api_server_with_exchanges,
"blockchainbalancesresource",
),
json={
'async_query': True,
'blockchain': 'ETH'
})
task_id_blockchain_eth = assert_ok_async_response(response)
response = requests.get(api_url_for(
rotkehlchen_api_server_with_exchanges,
"blockchainbalancesresource",
),
json={
'async_query': True,
'blockchain': 'BTC'
})
task_id_blockchain_btc = assert_ok_async_response(response)
else:
response = requests.get(api_url_for(
rotkehlchen_api_server_with_exchanges,
"blockchainbalancesresource",
),
json={'async_query': True})
task_id_blockchain = assert_ok_async_response(response)
outcome_all = wait_for_async_task_with_result(
rotkehlchen_api_server_with_exchanges,
task_id_all,
timeout=ASYNC_TASK_WAIT_TIMEOUT * 2,
)
outcome_one_exchange = wait_for_async_task(
rotkehlchen_api_server_with_exchanges,
task_id_one_exchange,
timeout=ASYNC_TASK_WAIT_TIMEOUT * 2,
)
if separate_blockchain_calls:
outcome_eth = wait_for_async_task_with_result(
rotkehlchen_api_server_with_exchanges,
task_id_blockchain_eth,
timeout=ASYNC_TASK_WAIT_TIMEOUT * 2,
)
outcome_btc = wait_for_async_task_with_result(
rotkehlchen_api_server_with_exchanges,
task_id_blockchain_btc,
timeout=ASYNC_TASK_WAIT_TIMEOUT * 2,
)
else:
outcome_blockchain = wait_for_async_task_with_result(
rotkehlchen_api_server_with_exchanges,
task_id_blockchain,
timeout=ASYNC_TASK_WAIT_TIMEOUT * 2,
)
assert eth.call_count == 1, 'eth balance query should only fire once'
assert btc.call_count == 1, 'btc balance query should only happen once'
assert bn.call_count == 3, 'binance balance query should do 2 calls'
assert_all_balances(
result=outcome_all,
db=rotki.data.db,
expected_data_in_db=True,
setup=setup,
)
assert_binance_balances_result(outcome_one_exchange['result'])
if not separate_blockchain_calls:
outcome_eth = outcome_blockchain
outcome_btc = outcome_blockchain
assert_eth_balances_result(
rotki=rotki,
result=outcome_eth,
eth_accounts=ethereum_accounts,
eth_balances=setup.eth_balances,
token_balances=setup.token_balances,
also_btc=not separate_blockchain_calls,
)
assert_btc_balances_result(
result=outcome_btc,
btc_accounts=btc_accounts,
btc_balances=setup.btc_balances,
also_eth=not separate_blockchain_calls,
)
def test_multiple_balance_queries_not_concurrent(
rotkehlchen_api_server_with_exchanges,
ethereum_accounts,
btc_accounts,
):
"""Test multiple different balance query requests happening concurrently
This tests that if multiple balance query requests happen concurrently we
do not end up doing them multiple times, but reuse the results thanks to cache.
"""
rotki = rotkehlchen_api_server_with_exchanges.rest_api.rotkehlchen
setup = setup_balances(rotki, ethereum_accounts, btc_accounts)
multieth_balance_patch = patch.object(
rotki.chain_manager.ethereum,
'get_multieth_balance',
wraps=rotki.chain_manager.ethereum.get_multieth_balance,
)
binance = rotki.exchange_manager.connected_exchanges['binance']
binance_querydict_patch = patch.object(binance, 'api_query_dict', wraps=binance.api_query_dict)
# Test all balances request by requesting to not save the data
with ExitStack() as stack:
setup.enter_all_patches(stack)
eth = stack.enter_context(multieth_balance_patch)
bn = stack.enter_context(binance_querydict_patch)
response = requests.get(
api_url_for(
rotkehlchen_api_server_with_exchanges,
"allbalancesresource",
), json={'async_query': True},
)
task_id_all = assert_ok_async_response(response)
response = requests.get(api_url_for(
rotkehlchen_api_server_with_exchanges,
"named_exchanges_balances_resource",
name='binance',
), json={'async_query': True})
task_id_one_exchange = assert_ok_async_response(response)
response = requests.get(api_url_for(
rotkehlchen_api_server_with_exchanges,
"blockchainbalancesresource",
), json={'async_query': True})
task_id_blockchain = assert_ok_async_response(response)
outcome_all = wait_for_async_task_with_result(
rotkehlchen_api_server_with_exchanges,
task_id_all,
)
outcome_one_exchange = wait_for_async_task(
rotkehlchen_api_server_with_exchanges,
task_id_one_exchange,
)
outcome_blockchain = wait_for_async_task_with_result(
rotkehlchen_api_server_with_exchanges,
task_id_blockchain,
)
assert eth.call_count == 1, 'blockchain balance call should not happen concurrently'
assert bn.call_count == 1, 'binance balance call should not happen concurrently'
assert_all_balances(
result=outcome_all,
db=rotki.data.db,
expected_data_in_db=True,
setup=setup,
)
assert_binance_balances_result(outcome_one_exchange['result'])
assert_eth_balances_result(
rotki=rotki,
result=outcome_blockchain,
eth_accounts=ethereum_accounts,
eth_balances=setup.eth_balances,
token_balances=setup.token_balances,
also_btc=True,
)
