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