def test_initializing_exchanges(uninitialized_rotkehlchen):
"""Test that initializing exchanges for which credentials exist in the DB works
This also tests db.get_exchange_credentials() since we also pretend to have
a premium subscription credentials and that function should not return it.
"""
rotki = uninitialized_rotkehlchen
username = '******'
db_password = '******'
rotki.data.unlock(username, db_password, create_new=True)
database = rotki.data.db
# Mock having user_credentials for all exchanges and for premium
cmd = 'INSERT OR REPLACE INTO user_credentials(name, api_key, api_secret) VALUES (?, ?, ?)'
credentials = []
for name in SUPPORTED_EXCHANGES:
credentials.append((name, make_api_key(), make_api_secret()))
credentials.append(('rotkehlchen', make_api_key(), make_api_secret()))
cursor = rotki.data.db.conn.cursor()
for entry in credentials:
cursor.execute(cmd, entry)
rotki.data.db.conn.commit()
exchange_credentials = rotki.data.db.get_exchange_credentials()
rotki.exchange_manager.initialize_exchanges(
exchange_credentials=exchange_credentials,
database=database,
)
assert all(name in rotki.exchange_manager.connected_exchanges
for name in SUPPORTED_EXCHANGES)
def test_exchanges_filtering(database, exchange_manager,
function_scope_messages_aggregator):
kraken1 = MockKraken(
name='mockkraken_1',
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=function_scope_messages_aggregator,
)
kraken2 = MockKraken(
name='mockkraken_2',
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=function_scope_messages_aggregator,
)
ftx1 = Ftx(
name='mockftx_1',
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=function_scope_messages_aggregator,
ftx_subaccount=None,
)
ftx2 = Ftx(
name='mockftx_2',
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=function_scope_messages_aggregator,
ftx_subaccount=None,
)
exchange_manager.initialize_exchanges({}, database)
exchange_manager.connected_exchanges[Location.KRAKEN].append(kraken1)
exchange_manager.connected_exchanges[Location.KRAKEN].append(kraken2)
exchange_manager.connected_exchanges[Location.FTX].append(ftx1)
exchange_manager.connected_exchanges[Location.FTX].append(ftx2)
assert set(exchange_manager.iterate_exchanges()) == {
kraken1, kraken2, ftx1, ftx2
}
database.set_settings(
ModifiableDBSettings(non_syncing_exchanges=[
kraken1.location_id(),
kraken2.location_id()
], ))
assert set(exchange_manager.iterate_exchanges()) == {ftx1, ftx2}
database.set_settings(
ModifiableDBSettings(non_syncing_exchanges=[ftx1.location_id()], ))
assert set(
exchange_manager.iterate_exchanges()) == {ftx2, kraken1, kraken2}
def test_iconomi_assets_are_known(
database,
inquirer, # pylint: disable=unused-argument
):
unsupported_assets = set(UNSUPPORTED_ICONOMI_ASSETS)
common_items = unsupported_assets.intersection(
set(WORLD_TO_ICONOMI.values()))
assert not common_items, f'Iconomi assets {common_items} should not be unsupported'
# use a real Iconomi instance so that we always get the latest data
iconomi = Iconomi(
name='iconomi1',
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=MessagesAggregator(),
)
supported_tickers = iconomi.query_supported_tickers()
for ticker in supported_tickers:
try:
_ = asset_from_iconomi(ticker)
except UnknownAsset as e:
test_warnings.warn(
UserWarning(
f'Found unknown asset {e.asset_name} in ICONOMI. '
f'Support for it has to be added', ))
def create_test_binance(
database: DBHandler,
msg_aggregator: MessagesAggregator,
location: Location = Location.BINANCE,
name: str = 'binance',
) -> Binance:
if location == Location.BINANCE:
uri = BINANCE_BASE_URL
elif location == Location.BINANCEUS:
uri = BINANCEUS_BASE_URL
else:
raise AssertionError(
f'Tried to create binance exchange with location {location}')
binance = Binance(
name=name,
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
uri=uri,
)
this_dir = os.path.dirname(os.path.abspath(__file__))
json_path = Path(this_dir) / 'data' / 'binance_exchange_info.json'
with json_path.open('r') as f:
json_data = json.loads(f.read())
binance._symbols_to_pair = create_binance_symbols_to_pair(
json_data, location)
binance.first_connection_made = True
return binance
def test_binance_assets_are_known(
database,
inquirer, # pylint: disable=unused-argument
):
# use a real binance instance so that we always get the latest data
binance = Binance(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=MessagesAggregator(),
)
mapping = binance.symbols_to_pair
binance_assets = set()
for _, pair in mapping.items():
binance_assets.add(pair.binance_base_asset)
binance_assets.add(pair.binance_quote_asset)
sorted_assets = sorted(binance_assets)
for binance_asset in sorted_assets:
try:
_ = asset_from_binance(binance_asset)
except UnsupportedAsset:
assert binance_asset in UNSUPPORTED_BINANCE_ASSETS
except UnknownAsset as e:
test_warnings.warn(
UserWarning(
f'Found unknown asset {e.asset_name} in Binance. Support for it has to be added',
))
def coinbasepro(session_database, session_inquirer, messages_aggregator):
mock = MockCoinbasepro(
api_key=make_api_key(),
secret=make_api_secret(),
database=session_database,
msg_aggregator=messages_aggregator,
)
return mock
def kraken(session_inquirer, messages_aggregator, session_database):
mock = MockKraken(
api_key=make_api_key(),
secret=make_api_secret(),
database=session_database,
msg_aggregator=messages_aggregator,
)
return mock
def poloniex(session_database, session_inquirer, messages_aggregator):
mock = MockPoloniex(
api_key=make_api_key(),
secret=make_api_secret(),
database=session_database,
msg_aggregator=messages_aggregator,
)
return mock
def function_scope_bittrex(database, function_scope_messages_aggregator):
mock = MockBittrex(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=function_scope_messages_aggregator,
)
return mock
def coinbase(session_data_dir, session_inquirer, messages_aggregator):
mock = MockCoinbase(
api_key=make_api_key(),
secret=make_api_secret(),
user_directory=session_data_dir,
msg_aggregator=messages_aggregator,
)
return mock
def function_scope_kraken(inquirer, function_scope_messages_aggregator,
database):
mock = MockKraken(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=function_scope_messages_aggregator,
)
return mock
def function_scope_poloniex(database, inquirer,
function_scope_messages_aggregator):
mock = MockPoloniex(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=function_scope_messages_aggregator,
)
return mock
def function_scope_kraken(accounting_data_dir, inquirer,
function_scope_messages_aggregator):
mock = MockKraken(
api_key=make_api_key(),
secret=make_api_secret(),
user_directory=accounting_data_dir,
msg_aggregator=function_scope_messages_aggregator,
)
return mock
def create_test_poloniex(
database: DBHandler,
msg_aggregator: MessagesAggregator,
) -> Poloniex:
return Poloniex(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
)
def create_test_bitstamp(
database,
msg_aggregator,
) -> Bitstamp:
return Bitstamp(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
)
def create_test_iconomi(
database: DBHandler,
msg_aggregator: MessagesAggregator,
) -> Iconomi:
return Iconomi(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
)
def create_test_bitcoinde(
database: DBHandler,
msg_aggregator: MessagesAggregator,
) -> Bitcoinde:
return Bitcoinde(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
)
def test_initializing_exchanges(uninitialized_rotkehlchen):
"""Test that initializing exchanges for which credentials exist in the DB works
This also tests db.get_exchange_credentials() since we also pretend to have
a premium subscription credentials and that function should not return it.
"""
rotki = uninitialized_rotkehlchen
username = '******'
db_password = '******'
rotki.data.unlock(username, db_password, create_new=True)
database = rotki.data.db
# Mock having user_credentials for all exchanges and for premium
cmd = (
'INSERT OR REPLACE INTO user_credentials '
'(name, location, api_key, api_secret, passphrase) VALUES (?, ?, ?, ?, ?)'
)
credentials = []
for location in SUPPORTED_EXCHANGES:
passphrase = None
if location in EXCHANGES_WITH_PASSPHRASE:
passphrase = 'supersecretpassphrase'
credentials.append(
(str(location), location.serialize_for_db(), make_api_key(),
make_api_secret().decode(), passphrase), # noqa: E501 # pylint: disable=no-member
)
credentials.append(
('rotkehlchen', Location.EXTERNAL.serialize_for_db(), make_api_key(),
make_api_secret().decode(), None), # noqa: E501 # pylint: disable=no-member
)
cursor = rotki.data.db.conn.cursor()
for entry in credentials:
cursor.execute(cmd, entry)
rotki.data.db.conn.commit()
exchange_credentials = rotki.data.db.get_exchange_credentials()
rotki.exchange_manager.initialize_exchanges(
exchange_credentials=exchange_credentials,
database=database,
)
assert all(location in rotki.exchange_manager.connected_exchanges
for location in SUPPORTED_EXCHANGES) # noqa: E501
def create_test_kraken(
database: DBHandler,
msg_aggregator: MessagesAggregator,
) -> MockKraken:
return MockKraken(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
)
def create_test_bittrex(
database: DBHandler,
msg_aggregator: MessagesAggregator,
) -> Bittrex:
bittrex = Bittrex(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
)
return bittrex
def create_test_coinbase(
database: DBHandler,
msg_aggregator: MessagesAggregator,
) -> Coinbase:
mock = Coinbase(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
)
return mock
def create_test_independentreserve(
database: DBHandler,
msg_aggregator: MessagesAggregator,
) -> Independentreserve:
return Independentreserve(
name='independentreserve',
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
)
def create_test_ftx(
database: DBHandler,
msg_aggregator: MessagesAggregator,
) -> Ftx:
mock = Ftx(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
)
return mock
def function_scope_coinbase(
database,
inquirer, # pylint: disable=unused-argument,
function_scope_messages_aggregator,
):
mock = MockCoinbase(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=function_scope_messages_aggregator,
)
return mock
def function_scope_coinbase(
accounting_data_dir,
inquirer, # pylint: disable=unused-argument,
function_scope_messages_aggregator,
):
mock = MockCoinbase(
api_key=make_api_key(),
secret=make_api_secret(),
user_directory=accounting_data_dir,
msg_aggregator=function_scope_messages_aggregator,
)
return mock
def create_test_coinbasepro(
database: DBHandler,
msg_aggregator: MessagesAggregator,
passphrase: str,
) -> Coinbasepro:
coinbasepro = Coinbasepro(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
passphrase=passphrase,
)
return coinbasepro
def create_test_ftx(
database: DBHandler,
msg_aggregator: MessagesAggregator,
) -> Ftx:
mock = Ftx(
name='ftx',
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
ftx_subaccount=None,
)
return mock
def create_test_bitstamp(
database: DBHandler,
msg_aggregator: MessagesAggregator,
api_key: Optional[ApiKey] = None,
secret: Optional[ApiSecret] = None,
) -> Bitstamp:
if api_key is None:
api_key = make_api_key()
if secret is None:
secret = make_api_secret()
return Bitstamp(
api_key=api_key,
secret=secret,
database=database,
msg_aggregator=msg_aggregator,
)
def create_test_bitstamp(
database,
msg_aggregator,
api_key=None,
secret=None,
) -> Bitstamp:
if api_key is None:
api_key = make_api_key()
if secret is None:
secret = make_api_secret()
return Bitstamp(
api_key=api_key,
secret=secret,
database=database,
msg_aggregator=msg_aggregator,
)
def create_test_binance(
database: DBHandler,
msg_aggregator: MessagesAggregator,
) -> Binance:
binance = Binance(
api_key=make_api_key(),
secret=make_api_secret(),
database=database,
msg_aggregator=msg_aggregator,
)
this_dir = os.path.dirname(os.path.abspath(__file__))
json_path = Path(this_dir) / 'data' / 'binance_exchange_info.json'
with json_path.open('r') as f:
json_data = json.loads(f.read())
binance._symbols_to_pair = create_binance_symbols_to_pair(json_data)
binance.first_connection_made = True
return binance
