def test_check_premium_status(rotkehlchen_api_server):
"""
Test that the premium check tasks works correctly. The tests creates a valid subscription
and verifies that after the task was scheduled the users premium is deactivated.
"""
rotki = rotkehlchen_api_server.rest_api.rotkehlchen
gevent.killall(rotki.api_task_greenlets)
task_manager = rotki.task_manager
task_manager.potential_tasks = [task_manager._maybe_check_premium_status]
task_manager.last_premium_status_check = ts_now() - 3601
premium_credentials = PremiumCredentials(VALID_PREMIUM_KEY,
VALID_PREMIUM_SECRET)
premium = Premium(premium_credentials)
premium.status = SubscriptionStatus.ACTIVE
with patch(
'rotkehlchen.db.dbhandler.DBHandler.get_rotkehlchen_premium',
MagicMock(return_value=premium_credentials),
):
assert premium.is_active() is True
assert rotki.premium is not None
timeout = 5
try:
with gevent.Timeout(timeout):
task_manager.schedule()
except gevent.Timeout as e:
raise AssertionError(
f'Premium check query was not completed within {timeout} seconds'
) from e # noqa: E501
assert rotki.premium is None
def blockchain(
blockchain_backend, # pylint: disable=unused-argument
ethereum_manager,
blockchain_accounts,
inquirer, # pylint: disable=unused-argument
messages_aggregator,
greenlet_manager,
owned_eth_tokens,
ethereum_modules,
alethio,
start_with_valid_premium,
rotki_premium_credentials,
):
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
return ChainManager(
blockchain_accounts=blockchain_accounts,
owned_eth_tokens=owned_eth_tokens,
ethereum_manager=ethereum_manager,
msg_aggregator=messages_aggregator,
alethio=alethio,
greenlet_manager=greenlet_manager,
premium=premium,
eth_modules=ethereum_modules,
)
def fixture_makerdao_vaults(
ethereum_manager,
database,
function_scope_messages_aggregator,
use_etherscan,
start_with_valid_premium,
rotki_premium_credentials,
makerdao_test_data,
):
if not use_etherscan:
ethereum_manager.connected = True
ethereum_manager.web3 = Web3()
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
web3_patch = create_web3_mock(web3=ethereum_manager.web3, test_data=makerdao_test_data)
with web3_patch:
makerdao_vaults = MakerDAOVaults(
ethereum_manager=ethereum_manager,
database=database,
premium=premium,
msg_aggregator=function_scope_messages_aggregator,
)
return makerdao_vaults
def blockchain(
blockchain_backend, # pylint: disable=unused-argument
ethereum_manager,
blockchain_accounts,
inquirer, # pylint: disable=unused-argument
messages_aggregator,
greenlet_manager,
ethereum_modules,
start_with_valid_premium,
rotki_premium_credentials,
database,
data_dir,
beaconchain,
):
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
chain_manager = ChainManager(
blockchain_accounts=blockchain_accounts,
ethereum_manager=ethereum_manager,
msg_aggregator=messages_aggregator,
database=database,
greenlet_manager=greenlet_manager,
premium=premium,
eth_modules=ethereum_modules,
data_directory=data_dir,
beaconchain=beaconchain,
)
return chain_manager
def fixture_accountant(
price_historian, # pylint: disable=unused-argument
database,
data_dir,
accounting_create_csv,
function_scope_messages_aggregator,
start_with_logged_in_user,
accounting_initialize_parameters,
start_with_valid_premium,
rotki_premium_credentials,
) -> Optional[Accountant]:
if not start_with_logged_in_user:
return None
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
accountant = Accountant(
db=database,
user_directory=data_dir,
msg_aggregator=function_scope_messages_aggregator,
create_csv=accounting_create_csv,
premium=premium,
)
if accounting_initialize_parameters:
db_settings = accountant.db.get_settings()
accountant._customize(db_settings)
return accountant
def create_patched_premium(
premium_credentials: PremiumCredentials,
patch_get: bool,
metadata_last_modify_ts=None,
metadata_data_hash=None,
metadata_data_size=None,
saved_data=None,
):
premium = Premium(premium_credentials)
patched_get = None
if patch_get:
patched_get = create_patched_premium_session_get(
session=premium.session,
metadata_last_modify_ts=metadata_last_modify_ts,
metadata_data_hash=metadata_data_hash,
metadata_data_size=metadata_data_size,
saved_data=saved_data,
)
patched_premium = patch(
# note the patch location is in premium/sync.py
'rotkehlchen.premium.sync.premium_create_and_verify',
return_value=premium,
)
return patched_premium, patched_get
def blockchain(
blockchain_backend, # pylint: disable=unused-argument
ethereum_manager,
blockchain_accounts,
inquirer, # pylint: disable=unused-argument
messages_aggregator,
greenlet_manager,
ethereum_modules,
start_with_valid_premium,
rotki_premium_credentials,
database,
):
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
with create_zerion_patch():
chain_manager = ChainManager(
blockchain_accounts=blockchain_accounts,
ethereum_manager=ethereum_manager,
msg_aggregator=messages_aggregator,
database=database,
greenlet_manager=greenlet_manager,
premium=premium,
eth_modules=ethereum_modules,
)
wait_until_zerion_is_initialized(chain_manager)
return chain_manager
def create_patched_premium(
premium_credentials: PremiumCredentials,
patch_get: bool,
metadata_last_modify_ts=None,
metadata_data_hash=None,
metadata_data_size=None,
saved_data=None,
consider_authentication_invalid: bool = False,
):
premium = Premium(premium_credentials)
patched_get = None
if patch_get:
patched_get = create_patched_requests_get_for_premium(
session=premium.session,
metadata_last_modify_ts=metadata_last_modify_ts,
metadata_data_hash=metadata_data_hash,
metadata_data_size=metadata_data_size,
saved_data=saved_data,
consider_authentication_invalid=consider_authentication_invalid,
)
patched_premium_at_start = patch(
# note the patch location is in premium/sync.py
'rotkehlchen.premium.sync.premium_create_and_verify',
return_value=premium,
)
patched_premium_at_set = patch(
# note the patch location is in rotkehlchen/rotkehlchen.py
'rotkehlchen.rotkehlchen.premium_create_and_verify',
return_value=premium,
)
return patched_premium_at_start, patched_premium_at_set, patched_get
def initialize_mock_rotkehlchen_instance(
rotki,
start_with_logged_in_user,
start_with_valid_premium,
msg_aggregator,
accountant,
blockchain,
db_password,
rotki_premium_credentials,
data_dir,
database,
username,
etherscan,
):
if start_with_logged_in_user:
# Rotkehlchen initializes its own messages aggregator normally but here we
# should use the one all other fixtures use so that the same aggregator is
# used across all objects in a test
# TODO: Find a better way to achieve this
rotki.msg_aggregator = msg_aggregator
rotki.data.msg_aggregator = rotki.msg_aggregator
# Unlock must come after we have set the aggregator if we are to get the
# messages caused by DB initialization
rotki.data.db = database
rotki.data.username = username
rotki.data.logged_in = True
rotki.data_importer = DataImporter(db=rotki.data.db)
rotki.password = db_password
rotki.etherscan = etherscan
rotki.cryptocompare.set_database(rotki.data.db)
# Remember accountant fixture has a mocked accounting data dir
# different to the usual user one. Accountant would normally be unlocked
# during the normal unlock but due to mocking initialization has to be tweaked here
rotki.accountant = accountant
rotki.chain_manager = blockchain
rotki.trades_historian = TradesHistorian(
user_directory=data_dir,
db=rotki.data.db,
msg_aggregator=rotki.msg_aggregator,
exchange_manager=rotki.exchange_manager,
chain_manager=rotki.chain_manager,
)
rotki.ethereum_analyzer = EthereumAnalyzer(
ethchain=blockchain.ethchain,
database=database,
)
rotki.user_is_logged_in = True
rotki.premium_sync_manager = PremiumSyncManager(
data=rotki.data,
password=db_password,
)
if start_with_valid_premium:
rotki.premium = Premium(rotki_premium_credentials)
rotki.premium_sync_manager.premium = rotki.premium
else:
rotki.premium = None
def test_get_events_history_get_all_events(
rotkehlchen_api_server,
ethereum_accounts, # pylint: disable=unused-argument
rotki_premium_credentials, # pylint: disable=unused-argument
start_with_valid_premium, # pylint: disable=unused-argument
):
"""Test get all the events balances
LPs involved by the address: minimum 6
By calling the endpoint without a specific time range:
- All the events are queried.
- The events balances factorise in the current balances in the
protocol (do not assert amounts).
As the structures are already tested in the tests above, only the response
length is tested.
"""
async_query = random.choice([False, True])
rotki = rotkehlchen_api_server.rest_api.rotkehlchen
# Set module premium is required for calling `get_balances()`
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
rotki.chain_manager.uniswap.premium = premium
setup = setup_balances(
rotki,
ethereum_accounts=ethereum_accounts,
eth_balances=['33000030003'],
token_balances={},
btc_accounts=None,
original_queries=['zerion', 'logs', 'blocknobytime'],
)
with ExitStack() as stack:
# patch ethereum/etherscan to not autodetect tokens
setup.enter_ethereum_patches(stack)
response = requests.get(api_url_for(
rotkehlchen_api_server, 'uniswapeventshistoryresource'),
json={'async_query': async_query},
)
if async_query:
task_id = assert_ok_async_response(response)
outcome = wait_for_async_task(rotkehlchen_api_server, task_id, timeout=120)
assert outcome['message'] == ''
result = outcome['result']
else:
result = assert_proper_response_with_result(response)
events_balances = result[AAVE_TEST_ACC_1]
assert len(events_balances) >= 6
def test_get_balances_premium(
rotkehlchen_api_server,
ethereum_accounts, # pylint: disable=unused-argument
rotki_premium_credentials, # pylint: disable=unused-argument
start_with_valid_premium, # pylint: disable=unused-argument
):
"""Test get balances for premium users works as expected
"""
async_query = random.choice([False, True])
rotki = rotkehlchen_api_server.rest_api.rotkehlchen
# Set module premium is required for calling `get_balances()`
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
rotki.chain_manager.adex.premium = premium
setup = setup_balances(
rotki,
ethereum_accounts=ethereum_accounts,
btc_accounts=None,
original_queries=['zerion', 'logs', 'blocknobytime'],
)
with ExitStack() as stack:
# patch ethereum/etherscan to not autodetect tokens
setup.enter_ethereum_patches(stack)
response = requests.get(api_url_for(
rotkehlchen_api_server, 'adexbalancesresource'),
json={'async_query': async_query},
)
if async_query:
task_id = assert_ok_async_response(response)
outcome = wait_for_async_task(rotkehlchen_api_server, task_id)
assert outcome['message'] == ''
result = outcome['result']
else:
result = assert_proper_response_with_result(response)
if len(result) != 1:
test_warnings.warn(
UserWarning(f'Test account {ADEX_TEST_ADDR} has no balances'),
)
return
for staking_balance in result[ADEX_TEST_ADDR]:
assert staking_balance['pool_id'] is not None
assert 'pool_name' in staking_balance
assert staking_balance['contract_address'] is not None
assert staking_balance['adx_balance']['amount']
assert staking_balance['adx_balance']['usd_value']
assert staking_balance['dai_unclaimed_balance']['amount']
assert staking_balance['dai_unclaimed_balance']['usd_value']
def initialize_mock_rotkehlchen_instance(
rotki,
start_with_logged_in_user,
start_with_valid_premium,
db_password,
rotki_premium_credentials,
username,
blockchain_accounts,
owned_eth_tokens,
include_etherscan_key,
include_cryptocompare_key,
should_mock_price_queries,
mocked_price_queries,
ethereum_modules,
db_settings,
ignored_assets,
tags,
manually_tracked_balances,
default_mock_price_value,
):
if start_with_logged_in_user:
rotki.unlock_user(
user=username,
password=db_password,
create_new=True,
sync_approval='no',
premium_credentials=None,
given_ethereum_modules=ethereum_modules,
)
if start_with_valid_premium:
rotki.premium = Premium(rotki_premium_credentials)
rotki.premium_sync_manager.premium = rotki.premium
# After unlocking when all objects are created we need to also include
# customized fixtures that may have been set by the tests
rotki.chain_manager.owned_eth_tokens = owned_eth_tokens
rotki.chain_manager.accounts = blockchain_accounts
add_settings_to_test_db(rotki.data.db, db_settings, ignored_assets)
maybe_include_etherscan_key(rotki.data.db, include_etherscan_key)
maybe_include_cryptocompare_key(rotki.data.db,
include_cryptocompare_key)
add_blockchain_accounts_to_db(rotki.data.db, blockchain_accounts)
add_tags_to_test_db(rotki.data.db, tags)
add_manually_tracked_balances_to_test_db(rotki.data.db,
manually_tracked_balances)
maybe_mock_historical_price_queries(
historian=PriceHistorian(),
should_mock_price_queries=should_mock_price_queries,
mocked_price_queries=mocked_price_queries,
default_mock_value=default_mock_price_value,
)
def initialize_mock_rotkehlchen_instance(
rotki,
start_with_logged_in_user,
start_with_valid_premium,
msg_aggregator,
username,
accountant,
blockchain,
db_password,
rotkehlchen_api_key,
rotkehlchen_api_secret,
data_dir,
):
if start_with_logged_in_user:
# Rotkehlchen initializes its own messages aggregator normally but here we
# should use the one all other fixtures use so that the same aggregator is
# used across all objects in a test
# TODO: Find a better way to achieve this
rotki.msg_aggregator = msg_aggregator
rotki.data.msg_aggregator = rotki.msg_aggregator
# Unlock must come after we have set the aggregator if we are to get the
# messages caused by DB initialization
rotki.data.unlock(username, db_password, create_new=True)
rotki.data_importer = DataImporter(db=rotki.data.db)
rotki.password = db_password
# Remember accountant fixture has a mocked accounting data dir
# different to the usual user one
rotki.accountant = accountant
rotki.blockchain = blockchain
rotki.trades_historian = TradesHistorian(
user_directory=data_dir,
db=rotki.data.db,
eth_accounts=rotki.data.get_eth_accounts(),
msg_aggregator=rotki.msg_aggregator,
exchange_manager=rotki.exchange_manager,
)
rotki.user_is_logged_in = True
if start_with_valid_premium:
rotki.premium = Premium(
api_key=rotkehlchen_api_key,
api_secret=rotkehlchen_api_secret,
)
rotki.premium_sync_manager = PremiumSyncManager(
data=rotki.data,
password=db_password,
)
rotki.premium_sync_manager.premium = rotki.premium
else:
rotki.premium = None
rotki.premium_sync_manager = None
def test_get_balances_premium(
rotkehlchen_api_server,
ethereum_accounts, # pylint: disable=unused-argument
rotki_premium_credentials, # pylint: disable=unused-argument
start_with_valid_premium, # pylint: disable=unused-argument
):
"""Test get balances for premium users works as expected
"""
async_query = random.choice([False, True])
rotki = rotkehlchen_api_server.rest_api.rotkehlchen
# Set module premium is required for calling `get_balances()`
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
adex = rotki.chain_manager.get_module('adex')
adex.premium = premium
setup = setup_balances(
rotki,
ethereum_accounts=ethereum_accounts,
btc_accounts=None,
# original_queries=['adex_staking'],
extra_flags=['mocked_adex_staking_balance'],
)
with ExitStack() as stack:
# patch ethereum/etherscan to not autodetect tokens
setup.enter_ethereum_patches(stack)
response = requests.get(
api_url_for(rotkehlchen_api_server, 'adexbalancesresource'),
json={'async_query': async_query},
)
if async_query:
task_id = assert_ok_async_response(response)
outcome = wait_for_async_task(rotkehlchen_api_server, task_id)
assert outcome['message'] == ''
result = outcome['result']
else:
result = assert_proper_response_with_result(response)
if len(result) != 1:
test_warnings.warn(
UserWarning(f'Test account {ADEX_TEST_ADDR} has no balances'), )
return
assert FVal(result[ADEX_TEST_ADDR][0]['adx_balance']['amount']) == FVal(
'113547.9817118382760270384899') # noqa: E501
assert result[ADEX_TEST_ADDR][0]['adx_balance']['usd_value'] is not None
def fixture_eth2(
ethereum_manager,
database,
messages_aggregator,
start_with_valid_premium,
rotki_premium_credentials,
):
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
return Eth2(
ethereum_manager=ethereum_manager,
database=database,
premium=premium,
msg_aggregator=messages_aggregator,
)
def aave(
ethereum_manager,
database,
function_scope_messages_aggregator,
start_with_valid_premium,
rotki_premium_credentials,
):
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
aave = Aave(
ethereum_manager=ethereum_manager,
database=database,
premium=premium,
msg_aggregator=function_scope_messages_aggregator,
)
return aave
def test_get_events_history_get_all_events_empty(
rotkehlchen_api_server,
ethereum_accounts, # pylint: disable=unused-argument
rotki_premium_credentials, # pylint: disable=unused-argument
start_with_valid_premium, # pylint: disable=unused-argument
):
"""Test get all the events balances for an address without events.
"""
async_query = random.choice([False, True])
rotki = rotkehlchen_api_server.rest_api.rotkehlchen
# Set module premium is required for calling `get_balances()`
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
rotki.chain_manager.uniswap.premium = premium
setup = setup_balances(
rotki,
ethereum_accounts=ethereum_accounts,
eth_balances=['33000030003'],
token_balances={},
btc_accounts=None,
original_queries=['zerion', 'logs', 'blocknobytime'],
)
with ExitStack() as stack:
# patch ethereum/etherscan to not autodetect tokens
setup.enter_ethereum_patches(stack)
response = requests.get(api_url_for(
rotkehlchen_api_server, 'uniswapeventshistoryresource'),
json={'async_query': async_query},
)
if async_query:
task_id = assert_ok_async_response(response)
outcome = wait_for_async_task(rotkehlchen_api_server, task_id, timeout=120)
assert outcome['message'] == ''
result = outcome['result']
else:
result = assert_proper_response_with_result(response)
assert result == {}
def uniswap_module(
ethereum_manager,
database,
start_with_valid_premium,
rotki_premium_credentials,
function_scope_messages_aggregator,
data_dir,
) -> Uniswap:
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
uniswap = Uniswap(
ethereum_manager=ethereum_manager,
database=database,
premium=premium,
msg_aggregator=function_scope_messages_aggregator,
data_directory=data_dir,
)
return uniswap
def mock_uniswap(
ethereum_manager,
database,
start_with_valid_premium,
rotki_premium_credentials,
function_scope_messages_aggregator,
mock_graph, # pylint: disable=unused-argument
mock_amm_graph, # pylint: disable=unused-argument
) -> Uniswap:
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
uniswap = Uniswap(
ethereum_manager=ethereum_manager,
database=database,
premium=premium,
msg_aggregator=function_scope_messages_aggregator,
)
return uniswap
def blockchain(
ethereum_manager,
kusama_manager,
polkadot_manager,
avalanche_manager,
blockchain_accounts,
inquirer, # pylint: disable=unused-argument
messages_aggregator,
greenlet_manager,
ethereum_modules,
start_with_valid_premium,
rotki_premium_credentials,
database,
data_dir,
beaconchain,
btc_derivation_gap_limit,
):
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
chain_manager = ChainManager(
blockchain_accounts=blockchain_accounts,
ethereum_manager=ethereum_manager,
kusama_manager=kusama_manager,
polkadot_manager=polkadot_manager,
avalanche_manager=avalanche_manager,
msg_aggregator=messages_aggregator,
database=database,
greenlet_manager=greenlet_manager,
premium=premium,
eth_modules=ethereum_modules,
data_directory=data_dir,
beaconchain=beaconchain,
btc_derivation_gap_limit=btc_derivation_gap_limit,
)
return chain_manager
def fixture_accountant(
price_historian, # pylint: disable=unused-argument
database,
function_scope_messages_aggregator,
start_with_logged_in_user,
accounting_initialize_parameters,
evm_accounting_aggregator,
start_with_valid_premium,
rotki_premium_credentials,
) -> Optional[Accountant]:
if not start_with_logged_in_user:
return None
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
accountant = Accountant(
db=database,
evm_accounting_aggregator=evm_accounting_aggregator,
msg_aggregator=function_scope_messages_aggregator,
premium=premium,
)
if accounting_initialize_parameters:
db_settings = accountant.db.get_settings()
for pot in accountant.pots:
pot.reset(
settings=db_settings,
start_ts=Timestamp(0),
end_ts=Timestamp(0),
report_id=1,
)
accountant.csvexporter.reset(start_ts=Timestamp(0),
end_ts=Timestamp(0))
return accountant
def initialize_mock_rotkehlchen_instance(
rotki,
start_with_logged_in_user,
start_with_valid_premium,
db_password,
rotki_premium_credentials,
username,
blockchain_accounts,
include_etherscan_key,
include_cryptocompare_key,
should_mock_price_queries,
mocked_price_queries,
ethereum_modules,
db_settings,
ignored_assets,
tags,
manually_tracked_balances,
default_mock_price_value,
ethereum_manager_connect_at_start,
):
if not start_with_logged_in_user:
return
# Mock the initial get settings to include the specified ethereum modules
def mock_get_settings() -> DBSettings:
settings = DBSettings(active_modules=ethereum_modules)
return settings
settings_patch = patch.object(rotki, 'get_settings', side_effect=mock_get_settings)
# Do not connect to the usual nodes at start by default. Do not want to spam
# them during our tests. It's configurable per test, with the default being nothing
rpcconnect_patch = patch(
'rotkehlchen.rotkehlchen.ETHEREUM_NODES_TO_CONNECT_AT_START',
new=ethereum_manager_connect_at_start,
)
zerion_patch = create_zerion_patch()
with settings_patch, zerion_patch, rpcconnect_patch:
rotki.unlock_user(
user=username,
password=db_password,
create_new=True,
sync_approval='no',
premium_credentials=None,
)
wait_until_zerion_is_initialized(rotki.chain_manager)
if start_with_valid_premium:
rotki.premium = Premium(rotki_premium_credentials)
rotki.premium_sync_manager.premium = rotki.premium
# After unlocking when all objects are created we need to also include
# customized fixtures that may have been set by the tests
rotki.chain_manager.accounts = blockchain_accounts
add_settings_to_test_db(rotki.data.db, db_settings, ignored_assets)
maybe_include_etherscan_key(rotki.data.db, include_etherscan_key)
maybe_include_cryptocompare_key(rotki.data.db, include_cryptocompare_key)
add_blockchain_accounts_to_db(rotki.data.db, blockchain_accounts)
add_tags_to_test_db(rotki.data.db, tags)
add_manually_tracked_balances_to_test_db(rotki.data.db, manually_tracked_balances)
maybe_mock_historical_price_queries(
historian=PriceHistorian(),
should_mock_price_queries=should_mock_price_queries,
mocked_price_queries=mocked_price_queries,
default_mock_value=default_mock_price_value,
)
def initialize_mock_rotkehlchen_instance(
rotki,
start_with_logged_in_user,
start_with_valid_premium,
db_password,
rotki_premium_credentials,
username,
blockchain_accounts,
include_etherscan_key,
include_cryptocompare_key,
should_mock_price_queries,
mocked_price_queries,
ethereum_modules,
db_settings,
ignored_assets,
tags,
manually_tracked_balances,
default_mock_price_value,
ethereum_manager_connect_at_start,
kusama_manager_connect_at_start,
eth_rpc_endpoint,
ksm_rpc_endpoint,
aave_use_graph,
max_tasks_num,
):
if not start_with_logged_in_user:
return
# Mock the initial get settings to include the specified ethereum modules
def mock_get_settings() -> DBSettings:
settings = DBSettings(
active_modules=ethereum_modules,
eth_rpc_endpoint=eth_rpc_endpoint,
ksm_rpc_endpoint=ksm_rpc_endpoint,
)
return settings
settings_patch = patch.object(rotki,
'get_settings',
side_effect=mock_get_settings)
# Do not connect to the usual nodes at start by default. Do not want to spam
# them during our tests. It's configurable per test, with the default being nothing
eth_rpcconnect_patch = patch(
'rotkehlchen.rotkehlchen.ETHEREUM_NODES_TO_CONNECT_AT_START',
new=ethereum_manager_connect_at_start,
)
ksm_rpcconnect_patch = patch(
'rotkehlchen.rotkehlchen.KUSAMA_NODES_TO_CONNECT_AT_START',
new=kusama_manager_connect_at_start,
)
ksm_connect_on_startup_patch = patch.object(
rotki,
'_connect_ksm_manager_on_startup',
return_value=bool(blockchain_accounts.ksm),
)
with settings_patch, eth_rpcconnect_patch, ksm_rpcconnect_patch, ksm_connect_on_startup_patch:
rotki.unlock_user(
user=username,
password=db_password,
create_new=True,
sync_approval='no',
premium_credentials=None,
)
# configure when task manager should run for tests
rotki.task_manager.max_tasks_num = max_tasks_num
if start_with_valid_premium:
rotki.premium = Premium(rotki_premium_credentials)
rotki.premium_sync_manager.premium = rotki.premium
# After unlocking when all objects are created we need to also include
# customized fixtures that may have been set by the tests
rotki.chain_manager.accounts = blockchain_accounts
add_settings_to_test_db(rotki.data.db, db_settings, ignored_assets)
maybe_include_etherscan_key(rotki.data.db, include_etherscan_key)
maybe_include_cryptocompare_key(rotki.data.db, include_cryptocompare_key)
add_blockchain_accounts_to_db(rotki.data.db, blockchain_accounts)
add_tags_to_test_db(rotki.data.db, tags)
add_manually_tracked_balances_to_test_db(rotki.data.db,
manually_tracked_balances)
maybe_mock_historical_price_queries(
historian=PriceHistorian(),
should_mock_price_queries=should_mock_price_queries,
mocked_price_queries=mocked_price_queries,
default_mock_value=default_mock_price_value,
)
wait_until_all_nodes_connected(
ethereum_manager_connect_at_start=ethereum_manager_connect_at_start,
ethereum=rotki.chain_manager.ethereum,
)
wait_until_all_substrate_nodes_connected(
substrate_manager_connect_at_start=kusama_manager_connect_at_start,
substrate_manager=rotki.chain_manager.kusama,
)
aave = rotki.chain_manager.get_module('aave')
if aave:
aave.use_graph = aave_use_graph
def initialize_mock_rotkehlchen_instance(
rotki,
start_with_logged_in_user,
start_with_valid_premium,
db_password,
rotki_premium_credentials,
username,
blockchain_accounts,
include_etherscan_key,
include_cryptocompare_key,
should_mock_price_queries,
mocked_price_queries,
ethereum_modules,
db_settings,
ignored_assets,
tags,
manually_tracked_balances,
default_mock_price_value,
ethereum_manager_connect_at_start,
kusama_manager_connect_at_start,
eth_rpc_endpoint,
ksm_rpc_endpoint,
aave_use_graph,
max_tasks_num,
legacy_messages_via_websockets,
data_migration_version,
use_custom_database,
user_data_dir,
perform_migrations_at_unlock,
perform_upgrades_at_unlock,
):
if not start_with_logged_in_user:
return
# Mock the initial get settings to include the specified ethereum modules
def mock_get_settings() -> DBSettings:
settings = DBSettings(
active_modules=ethereum_modules,
eth_rpc_endpoint=eth_rpc_endpoint,
ksm_rpc_endpoint=ksm_rpc_endpoint,
)
return settings
settings_patch = patch.object(rotki,
'get_settings',
side_effect=mock_get_settings)
# Do not connect to the usual nodes at start by default. Do not want to spam
# them during our tests. It's configurable per test, with the default being nothing
eth_rpcconnect_patch = patch(
'rotkehlchen.rotkehlchen.ETHEREUM_NODES_TO_CONNECT_AT_START',
new=ethereum_manager_connect_at_start,
)
ksm_rpcconnect_patch = patch(
'rotkehlchen.rotkehlchen.KUSAMA_NODES_TO_CONNECT_AT_START',
new=kusama_manager_connect_at_start,
)
ksm_connect_on_startup_patch = patch.object(
rotki,
'_connect_ksm_manager_on_startup',
return_value=bool(blockchain_accounts.ksm),
)
# patch the constants to make sure that the periodic query for icons
# does not run during tests
size_patch = patch('rotkehlchen.rotkehlchen.ICONS_BATCH_SIZE', new=0)
sleep_patch = patch('rotkehlchen.rotkehlchen.ICONS_QUERY_SLEEP',
new=999999)
create_new = True
if use_custom_database is not None:
_use_prepared_db(user_data_dir, use_custom_database)
create_new = False
with ExitStack() as stack:
stack.enter_context(settings_patch)
stack.enter_context(eth_rpcconnect_patch)
stack.enter_context(ksm_rpcconnect_patch)
stack.enter_context(ksm_connect_on_startup_patch)
stack.enter_context(size_patch)
stack.enter_context(sleep_patch)
if perform_migrations_at_unlock is False:
migrations_patch = patch.object(
DataMigrationManager,
'maybe_migrate_data',
side_effect=lambda *args: None,
)
stack.enter_context(migrations_patch)
if perform_upgrades_at_unlock is False:
upgrades_patch = patch.object(
DBUpgradeManager,
'run_upgrades',
side_effect=lambda *args: None,
)
stack.enter_context(upgrades_patch)
rotki.unlock_user(
user=username,
password=db_password,
create_new=create_new,
sync_approval='no',
premium_credentials=None,
)
# configure when task manager should run for tests
rotki.task_manager.max_tasks_num = max_tasks_num
if start_with_valid_premium:
rotki.premium = Premium(rotki_premium_credentials)
rotki.premium_sync_manager.premium = rotki.premium
rotki.chain_manager.premium = rotki.premium
# Add premium to all the modules
for module_name in AVAILABLE_MODULES_MAP:
module = rotki.chain_manager.get_module(module_name)
if module is not None:
module.premium = rotki.premium
if legacy_messages_via_websockets is False:
rotki.msg_aggregator.rotki_notifier = None
# After unlocking when all objects are created we need to also include
# customized fixtures that may have been set by the tests
rotki.chain_manager.accounts = blockchain_accounts
add_settings_to_test_db(rotki.data.db, db_settings, ignored_assets,
data_migration_version)
maybe_include_etherscan_key(rotki.data.db, include_etherscan_key)
maybe_include_cryptocompare_key(rotki.data.db, include_cryptocompare_key)
add_blockchain_accounts_to_db(rotki.data.db, blockchain_accounts)
add_tags_to_test_db(rotki.data.db, tags)
add_manually_tracked_balances_to_test_db(rotki.data.db,
manually_tracked_balances)
maybe_mock_historical_price_queries(
historian=PriceHistorian(),
should_mock_price_queries=should_mock_price_queries,
mocked_price_queries=mocked_price_queries,
default_mock_value=default_mock_price_value,
)
wait_until_all_nodes_connected(
ethereum_manager_connect_at_start=ethereum_manager_connect_at_start,
ethereum=rotki.chain_manager.ethereum,
)
wait_until_all_substrate_nodes_connected(
substrate_manager_connect_at_start=kusama_manager_connect_at_start,
substrate_manager=rotki.chain_manager.kusama,
)
aave = rotki.chain_manager.get_module('aave')
if aave:
aave.use_graph = aave_use_graph
def test_get_balances(
rotkehlchen_api_server,
ethereum_accounts, # pylint: disable=unused-argument
rotki_premium_credentials,
start_with_valid_premium,
):
"""Check querying the uniswap balances endpoint works. Uses real data
Checks the functionality both for the graph queries (when premium) and simple
onchain queries (without premium)
THIS IS SUPER FREAKING SLOW. BE WARNED.
"""
async_query = random.choice([False, True])
rotki = rotkehlchen_api_server.rest_api.rotkehlchen
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
# Set module premium attribute
rotki.chain_manager.uniswap.premium = premium
response = requests.get(
api_url_for(rotkehlchen_api_server, 'uniswapbalancesresource'),
json={'async_query': async_query},
)
if async_query:
task_id = assert_ok_async_response(response)
outcome = wait_for_async_task(
server=rotkehlchen_api_server,
task_id=task_id,
timeout=ASYNC_TASK_WAIT_TIMEOUT * 10,
)
assert outcome['message'] == ''
result = outcome['result']
else:
result = assert_proper_response_with_result(response)
if len(result) != 1:
test_warnings.warn(
UserWarning(f'Test account {LP_HOLDER_ADDRESS} has no uniswap balances'),
)
return
address_balances = result[LP_HOLDER_ADDRESS]
for lp in address_balances:
# LiquidityPool attributes
assert lp['address'].startswith('0x')
assert len(lp['assets']) == 2
if start_with_valid_premium:
assert lp['total_supply'] is not None
else:
assert lp['total_supply'] is None
assert lp['user_balance']['amount']
assert lp['user_balance']['usd_value']
# LiquidityPoolAsset attributes
for lp_asset in lp['assets']:
lp_asset_type = type(lp_asset['asset'])
assert lp_asset_type in (str, dict)
# Unknown asset, at least contains token address
if lp_asset_type is dict:
assert lp_asset['asset']['ethereum_address'].startswith('0x')
# Known asset, contains identifier
else:
assert not lp_asset['asset'].startswith('0x')
if start_with_valid_premium:
assert lp_asset['total_amount'] is not None
else:
assert lp_asset['total_amount'] is None
assert lp_asset['usd_price']
assert len(lp_asset['user_balance']) == 2
assert lp_asset['user_balance']['amount']
assert lp_asset['user_balance']['usd_value']
def test_get_events(
rotkehlchen_api_server,
ethereum_accounts, # pylint: disable=unused-argument
rotki_premium_credentials, # pylint: disable=unused-argument
start_with_valid_premium, # pylint: disable=unused-argument
):
async_query = random.choice([False, True])
rotki = rotkehlchen_api_server.rest_api.rotkehlchen
# Set module premium is required for calling `get_balances()`
premium = None
if start_with_valid_premium:
premium = Premium(rotki_premium_credentials)
rotki.chain_manager.adex.premium = premium
setup = setup_balances(
rotki,
ethereum_accounts=ethereum_accounts,
btc_accounts=None,
original_queries=['zerion', 'logs', 'blocknobytime'],
)
with ExitStack() as stack:
# patch ethereum/etherscan to not autodetect tokens
setup.enter_ethereum_patches(stack)
response = requests.get(
api_url_for(rotkehlchen_api_server, 'adexhistoryresource'),
json={
'async_query': async_query,
'to_timestamp': 1611747322
},
)
if async_query:
task_id = assert_ok_async_response(response)
outcome = wait_for_async_task(rotkehlchen_api_server, task_id)
assert outcome['message'] == ''
result = outcome['result']
else:
result = assert_proper_response_with_result(response)
identity_address = '0x2a6c38D16BFdc7b4a20f1F982c058F07BDCe9204'
tom_pool_id = '0x2ce0c96383fb229d9776f33846e983a956a7d95844fac57b180ed0071d93bb28'
bond_id = '0x540cab9883923c01e657d5da4ca5674b6e4626b4a148224635495502d674c7c5'
result = result[ADEX_TEST_ADDR]
expected_events = [
Bond(
tx_hash=
'0x9989f47c6c0a761f98f910ac24e2438d858be96c12124a13be4bb4b3150c55ea',
address=ADEX_TEST_ADDR,
identity_address=identity_address,
timestamp=1604366004,
bond_id=bond_id,
pool_id=tom_pool_id,
value=Balance(FVal(100000), FVal(200000)),
nonce=0,
slashed_at=0,
),
ChannelWithdraw(
tx_hash=
'0xa9ee91af823c0173fc5ada908ff9fe3f4d7c84a2c9da795f0889b3f4ace75b13',
address=ADEX_TEST_ADDR,
identity_address=identity_address,
timestamp=1607453764,
channel_id='',
pool_id=tom_pool_id,
value=Balance(FVal('5056.894263641728544592'),
FVal('10113.788527283457089184')),
token=A_ADX,
),
Unbond(
tx_hash=
'0xa9ee91af823c0173fc5ada908ff9fe3f4d7c84a2c9da795f0889b3f4ace75b13',
address=ADEX_TEST_ADDR,
identity_address=identity_address,
timestamp=1607453764,
bond_id=bond_id,
pool_id=tom_pool_id,
value=Balance(FVal(100000), FVal(200000)),
)
]
assert len(result['events']) == 8
assert result['events'][:len(expected_events)] == [
x.serialize() for x in expected_events
]
assert 'staking_details' in result
# Make sure events end up in the DB
assert len(rotki.data.db.get_adex_events()) != 0
# test adex data purging from the db works
response = requests.delete(
api_url_for(
rotkehlchen_api_server,
'namedethereummoduledataresource',
module_name='adex',
))
assert_simple_ok_response(response)
assert len(rotki.data.db.get_adex_events()) == 0