2018-10-04 18:11:02 +00:00
|
|
|
import copy
|
2017-12-30 07:12:52 +00:00
|
|
|
import logging
|
2021-09-16 04:28:10 +00:00
|
|
|
from copy import deepcopy
|
2020-10-25 09:13:54 +00:00
|
|
|
from datetime import datetime, timedelta, timezone
|
2018-07-04 07:31:35 +00:00
|
|
|
from random import randint
|
2020-06-28 09:17:06 +00:00
|
|
|
from unittest.mock import MagicMock, Mock, PropertyMock, patch
|
2018-03-17 21:44:47 +00:00
|
|
|
|
2018-08-15 11:18:52 +00:00
|
|
|
import arrow
|
2018-05-02 18:03:13 +00:00
|
|
|
import ccxt
|
2017-12-30 07:12:52 +00:00
|
|
|
import pytest
|
2018-12-11 18:48:36 +00:00
|
|
|
from pandas import DataFrame
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2022-02-01 18:53:38 +00:00
|
|
|
from freqtrade.enums import CandleType, MarginMode, TradingMode
|
2022-09-08 05:24:57 +00:00
|
|
|
from freqtrade.exceptions import (DDosProtection, DependencyException, ExchangeError,
|
|
|
|
InvalidOrderException, OperationalException, PricingError,
|
|
|
|
TemporaryError)
|
2022-08-15 06:51:15 +00:00
|
|
|
from freqtrade.exchange import (Binance, Bittrex, Exchange, Kraken, amount_to_precision,
|
|
|
|
date_minus_candles, market_is_active, price_to_precision,
|
|
|
|
timeframe_to_minutes, timeframe_to_msecs, timeframe_to_next_date,
|
|
|
|
timeframe_to_prev_date, timeframe_to_seconds)
|
2020-09-28 17:43:15 +00:00
|
|
|
from freqtrade.exchange.common import (API_FETCH_ORDER_RETRY_COUNT, API_RETRY_COUNT,
|
2021-09-16 04:28:10 +00:00
|
|
|
calculate_backoff, remove_credentials)
|
2022-09-24 12:51:58 +00:00
|
|
|
from freqtrade.exchange.exchange import amount_to_contract_precision
|
2019-02-20 19:13:23 +00:00
|
|
|
from freqtrade.resolvers.exchange_resolver import ExchangeResolver
|
2022-10-05 17:39:28 +00:00
|
|
|
from tests.conftest import (generate_test_data_raw, get_mock_coro, get_patched_exchange, log_has,
|
|
|
|
log_has_re, num_log_has_re)
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2020-09-28 17:43:15 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
# Make sure to always keep one exchange here which is NOT subclassed!!
|
2022-11-14 18:40:57 +00:00
|
|
|
EXCHANGES = ['bittrex', 'binance', 'kraken', 'gateio']
|
2019-02-24 18:59:45 +00:00
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
get_entry_rate_data = [
|
|
|
|
('other', 20, 19, 10, 0.0, 20), # Full ask side
|
|
|
|
('ask', 20, 19, 10, 0.0, 20), # Full ask side
|
|
|
|
('ask', 20, 19, 10, 1.0, 10), # Full last side
|
|
|
|
('ask', 20, 19, 10, 0.5, 15), # Between ask and last
|
|
|
|
('ask', 20, 19, 10, 0.7, 13), # Between ask and last
|
|
|
|
('ask', 20, 19, 10, 0.3, 17), # Between ask and last
|
|
|
|
('ask', 5, 6, 10, 1.0, 5), # last bigger than ask
|
|
|
|
('ask', 5, 6, 10, 0.5, 5), # last bigger than ask
|
|
|
|
('ask', 20, 19, 10, None, 20), # price_last_balance missing
|
|
|
|
('ask', 10, 20, None, 0.5, 10), # last not available - uses ask
|
|
|
|
('ask', 4, 5, None, 0.5, 4), # last not available - uses ask
|
|
|
|
('ask', 4, 5, None, 1, 4), # last not available - uses ask
|
|
|
|
('ask', 4, 5, None, 0, 4), # last not available - uses ask
|
|
|
|
('same', 21, 20, 10, 0.0, 20), # Full bid side
|
|
|
|
('bid', 21, 20, 10, 0.0, 20), # Full bid side
|
|
|
|
('bid', 21, 20, 10, 1.0, 10), # Full last side
|
|
|
|
('bid', 21, 20, 10, 0.5, 15), # Between bid and last
|
|
|
|
('bid', 21, 20, 10, 0.7, 13), # Between bid and last
|
|
|
|
('bid', 21, 20, 10, 0.3, 17), # Between bid and last
|
|
|
|
('bid', 6, 5, 10, 1.0, 5), # last bigger than bid
|
|
|
|
('bid', 21, 20, 10, None, 20), # price_last_balance missing
|
|
|
|
('bid', 6, 5, 10, 0.5, 5), # last bigger than bid
|
|
|
|
('bid', 21, 20, None, 0.5, 20), # last not available - uses bid
|
|
|
|
('bid', 6, 5, None, 0.5, 5), # last not available - uses bid
|
|
|
|
('bid', 6, 5, None, 1, 5), # last not available - uses bid
|
|
|
|
('bid', 6, 5, None, 0, 5), # last not available - uses bid
|
|
|
|
]
|
|
|
|
|
|
|
|
get_sell_rate_data = [
|
|
|
|
('bid', 12.0, 11.0, 11.5, 0.0, 11.0), # full bid side
|
|
|
|
('bid', 12.0, 11.0, 11.5, 1.0, 11.5), # full last side
|
|
|
|
('bid', 12.0, 11.0, 11.5, 0.5, 11.25), # between bid and lat
|
|
|
|
('bid', 12.0, 11.2, 10.5, 0.0, 11.2), # Last smaller than bid
|
|
|
|
('bid', 12.0, 11.2, 10.5, 1.0, 11.2), # Last smaller than bid - uses bid
|
|
|
|
('bid', 12.0, 11.2, 10.5, 0.5, 11.2), # Last smaller than bid - uses bid
|
|
|
|
('bid', 0.003, 0.002, 0.005, 0.0, 0.002),
|
|
|
|
('bid', 0.003, 0.002, 0.005, None, 0.002),
|
|
|
|
('ask', 12.0, 11.0, 12.5, 0.0, 12.0), # full ask side
|
|
|
|
('ask', 12.0, 11.0, 12.5, 1.0, 12.5), # full last side
|
|
|
|
('ask', 12.0, 11.0, 12.5, 0.5, 12.25), # between bid and lat
|
|
|
|
('ask', 12.2, 11.2, 10.5, 0.0, 12.2), # Last smaller than ask
|
|
|
|
('ask', 12.0, 11.0, 10.5, 1.0, 12.0), # Last smaller than ask - uses ask
|
|
|
|
('ask', 12.0, 11.2, 10.5, 0.5, 12.0), # Last smaller than ask - uses ask
|
|
|
|
('ask', 10.0, 11.0, 11.0, 0.0, 10.0),
|
|
|
|
('ask', 10.11, 11.2, 11.0, 0.0, 10.11),
|
|
|
|
('ask', 0.001, 0.002, 11.0, 0.0, 0.001),
|
|
|
|
('ask', 0.006, 1.0, 11.0, 0.0, 0.006),
|
|
|
|
('ask', 0.006, 1.0, 11.0, None, 0.006),
|
|
|
|
]
|
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
|
|
|
|
def ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
2020-06-28 09:56:29 +00:00
|
|
|
fun, mock_ccxt_fun, retries=API_RETRY_COUNT + 1, **kwargs):
|
2020-06-28 09:17:06 +00:00
|
|
|
|
|
|
|
with patch('freqtrade.exchange.common.time.sleep'):
|
|
|
|
with pytest.raises(DDosProtection):
|
|
|
|
api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.DDoSProtection("DDos"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
getattr(exchange, fun)(**kwargs)
|
2020-06-28 09:56:29 +00:00
|
|
|
assert api_mock.__dict__[mock_ccxt_fun].call_count == retries
|
2020-06-28 09:17:06 +00:00
|
|
|
|
2018-06-28 19:22:43 +00:00
|
|
|
with pytest.raises(TemporaryError):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.NetworkError("DeaDBeef"))
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-06-28 19:22:43 +00:00
|
|
|
getattr(exchange, fun)(**kwargs)
|
2020-06-28 09:56:29 +00:00
|
|
|
assert api_mock.__dict__[mock_ccxt_fun].call_count == retries
|
2018-06-28 19:22:43 +00:00
|
|
|
|
|
|
|
with pytest.raises(OperationalException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.BaseError("DeadBeef"))
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-06-28 19:22:43 +00:00
|
|
|
getattr(exchange, fun)(**kwargs)
|
2018-07-01 17:37:55 +00:00
|
|
|
assert api_mock.__dict__[mock_ccxt_fun].call_count == 1
|
2018-06-28 19:22:43 +00:00
|
|
|
|
|
|
|
|
2020-06-28 09:56:29 +00:00
|
|
|
async def async_ccxt_exception(mocker, default_conf, api_mock, fun, mock_ccxt_fun,
|
|
|
|
retries=API_RETRY_COUNT + 1, **kwargs):
|
2020-06-28 09:17:06 +00:00
|
|
|
|
2020-06-28 18:17:03 +00:00
|
|
|
with patch('freqtrade.exchange.common.asyncio.sleep', get_mock_coro(None)):
|
2020-06-28 09:17:06 +00:00
|
|
|
with pytest.raises(DDosProtection):
|
2020-06-28 14:04:04 +00:00
|
|
|
api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.DDoSProtection("Dooh"))
|
2020-06-28 09:17:06 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
await getattr(exchange, fun)(**kwargs)
|
2020-06-28 09:56:29 +00:00
|
|
|
assert api_mock.__dict__[mock_ccxt_fun].call_count == retries
|
2020-06-28 09:17:06 +00:00
|
|
|
|
2018-08-01 19:19:49 +00:00
|
|
|
with pytest.raises(TemporaryError):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.NetworkError("DeadBeef"))
|
2018-08-01 19:19:49 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
await getattr(exchange, fun)(**kwargs)
|
2020-06-28 09:56:29 +00:00
|
|
|
assert api_mock.__dict__[mock_ccxt_fun].call_count == retries
|
2018-08-01 19:19:49 +00:00
|
|
|
|
|
|
|
with pytest.raises(OperationalException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.__dict__[mock_ccxt_fun] = MagicMock(side_effect=ccxt.BaseError("DeadBeef"))
|
2018-08-01 19:19:49 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
await getattr(exchange, fun)(**kwargs)
|
|
|
|
assert api_mock.__dict__[mock_ccxt_fun].call_count == 1
|
|
|
|
|
|
|
|
|
2017-12-30 07:12:52 +00:00
|
|
|
def test_init(default_conf, mocker, caplog):
|
2018-01-31 17:37:38 +00:00
|
|
|
caplog.set_level(logging.INFO)
|
2018-06-17 18:13:39 +00:00
|
|
|
get_patched_exchange(mocker, default_conf)
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Instance is running with dry_run enabled', caplog)
|
2017-12-30 07:12:52 +00:00
|
|
|
|
|
|
|
|
2021-09-16 04:28:10 +00:00
|
|
|
def test_remove_credentials(default_conf, caplog) -> None:
|
|
|
|
conf = deepcopy(default_conf)
|
|
|
|
conf['dry_run'] = False
|
|
|
|
remove_credentials(conf)
|
|
|
|
|
|
|
|
assert conf['exchange']['key'] != ''
|
|
|
|
assert conf['exchange']['secret'] != ''
|
|
|
|
|
|
|
|
conf['dry_run'] = True
|
|
|
|
remove_credentials(conf)
|
|
|
|
assert conf['exchange']['key'] == ''
|
|
|
|
assert conf['exchange']['secret'] == ''
|
|
|
|
assert conf['exchange']['password'] == ''
|
|
|
|
assert conf['exchange']['uid'] == ''
|
|
|
|
|
|
|
|
|
2019-09-10 21:18:07 +00:00
|
|
|
def test_init_ccxt_kwargs(default_conf, mocker, caplog):
|
2018-10-04 18:11:02 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-05-07 08:56:13 +00:00
|
|
|
aei_mock = mocker.patch('freqtrade.exchange.Exchange.additional_exchange_init')
|
|
|
|
|
2018-10-04 18:11:02 +00:00
|
|
|
caplog.set_level(logging.INFO)
|
|
|
|
conf = copy.deepcopy(default_conf)
|
2020-02-03 14:17:36 +00:00
|
|
|
conf['exchange']['ccxt_async_config'] = {'aiohttp_trust_env': True, 'asyncio_loop': True}
|
2018-10-04 18:11:02 +00:00
|
|
|
ex = Exchange(conf)
|
2020-02-03 14:17:36 +00:00
|
|
|
assert log_has(
|
|
|
|
"Applying additional ccxt config: {'aiohttp_trust_env': True, 'asyncio_loop': True}",
|
|
|
|
caplog)
|
2018-10-04 18:11:02 +00:00
|
|
|
assert ex._api_async.aiohttp_trust_env
|
|
|
|
assert not ex._api.aiohttp_trust_env
|
2022-05-07 08:56:13 +00:00
|
|
|
assert aei_mock.call_count == 1
|
2018-10-04 18:11:02 +00:00
|
|
|
|
|
|
|
# Reset logging and config
|
|
|
|
caplog.clear()
|
|
|
|
conf = copy.deepcopy(default_conf)
|
|
|
|
conf['exchange']['ccxt_config'] = {'TestKWARG': 11}
|
2020-05-30 08:45:50 +00:00
|
|
|
conf['exchange']['ccxt_sync_config'] = {'TestKWARG44': 11}
|
2020-02-03 14:17:36 +00:00
|
|
|
conf['exchange']['ccxt_async_config'] = {'asyncio_loop': True}
|
2020-05-30 08:45:50 +00:00
|
|
|
asynclogmsg = "Applying additional ccxt config: {'TestKWARG': 11, 'asyncio_loop': True}"
|
2018-10-04 18:11:02 +00:00
|
|
|
ex = Exchange(conf)
|
|
|
|
assert not ex._api_async.aiohttp_trust_env
|
|
|
|
assert hasattr(ex._api, 'TestKWARG')
|
|
|
|
assert ex._api.TestKWARG == 11
|
2020-05-30 08:45:50 +00:00
|
|
|
# ccxt_config is assigned to both sync and async
|
|
|
|
assert not hasattr(ex._api_async, 'TestKWARG44')
|
|
|
|
|
|
|
|
assert hasattr(ex._api_async, 'TestKWARG')
|
|
|
|
assert log_has("Applying additional ccxt config: {'TestKWARG': 11, 'TestKWARG44': 11}", caplog)
|
|
|
|
assert log_has(asynclogmsg, caplog)
|
2021-09-16 04:28:10 +00:00
|
|
|
# Test additional headers case
|
2022-08-22 18:23:19 +00:00
|
|
|
Exchange._ccxt_params = {'hello': 'world'}
|
2021-09-16 04:28:10 +00:00
|
|
|
ex = Exchange(conf)
|
|
|
|
|
|
|
|
assert log_has("Applying additional ccxt config: {'TestKWARG': 11, 'TestKWARG44': 11}", caplog)
|
2022-08-22 18:23:19 +00:00
|
|
|
assert ex._api.hello == 'world'
|
2021-09-19 23:02:09 +00:00
|
|
|
assert ex._ccxt_config == {}
|
2021-09-16 04:28:10 +00:00
|
|
|
Exchange._headers = {}
|
2018-10-04 18:11:02 +00:00
|
|
|
|
|
|
|
|
2018-08-14 17:51:49 +00:00
|
|
|
def test_destroy(default_conf, mocker, caplog):
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
get_patched_exchange(mocker, default_conf)
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Exchange object destroyed, closing async loop', caplog)
|
2018-08-14 17:51:49 +00:00
|
|
|
|
|
|
|
|
2018-06-28 20:32:28 +00:00
|
|
|
def test_init_exception(default_conf, mocker):
|
2017-12-30 07:12:52 +00:00
|
|
|
default_conf['exchange']['name'] = 'wrong_exchange_name'
|
|
|
|
|
2019-08-25 08:13:35 +00:00
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=f"Exchange {default_conf['exchange']['name']} is not supported"):
|
2018-06-17 18:13:39 +00:00
|
|
|
Exchange(default_conf)
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2018-06-28 20:32:28 +00:00
|
|
|
default_conf['exchange']['name'] = 'binance'
|
2019-08-25 08:13:35 +00:00
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=f"Exchange {default_conf['exchange']['name']} is not supported"):
|
2018-06-28 20:32:28 +00:00
|
|
|
mocker.patch("ccxt.binance", MagicMock(side_effect=AttributeError))
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
2019-08-25 08:13:35 +00:00
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r"Initialization of ccxt failed. Reason: DeadBeef"):
|
|
|
|
mocker.patch("ccxt.binance", MagicMock(side_effect=ccxt.BaseError("DeadBeef")))
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
2018-07-29 08:10:55 +00:00
|
|
|
|
2019-02-20 19:13:23 +00:00
|
|
|
def test_exchange_resolver(default_conf, mocker, caplog):
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=MagicMock()))
|
2020-06-13 10:34:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2020-10-13 18:29:51 +00:00
|
|
|
|
2022-01-16 12:39:19 +00:00
|
|
|
exchange = ExchangeResolver.load_exchange('zaif', default_conf)
|
2019-02-20 19:13:23 +00:00
|
|
|
assert isinstance(exchange, Exchange)
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has_re(r"No .* specific subclass found. Using the generic class instead.", caplog)
|
2019-02-20 19:13:23 +00:00
|
|
|
caplog.clear()
|
|
|
|
|
2020-10-13 18:29:51 +00:00
|
|
|
exchange = ExchangeResolver.load_exchange('Bittrex', default_conf)
|
|
|
|
assert isinstance(exchange, Exchange)
|
|
|
|
assert isinstance(exchange, Bittrex)
|
|
|
|
assert not log_has_re(r"No .* specific subclass found. Using the generic class instead.",
|
|
|
|
caplog)
|
|
|
|
caplog.clear()
|
|
|
|
|
2019-12-23 09:03:18 +00:00
|
|
|
exchange = ExchangeResolver.load_exchange('kraken', default_conf)
|
2019-02-20 19:13:23 +00:00
|
|
|
assert isinstance(exchange, Exchange)
|
2019-02-21 06:07:45 +00:00
|
|
|
assert isinstance(exchange, Kraken)
|
2019-02-24 19:08:27 +00:00
|
|
|
assert not isinstance(exchange, Binance)
|
|
|
|
assert not log_has_re(r"No .* specific subclass found. Using the generic class instead.",
|
2019-08-11 18:17:39 +00:00
|
|
|
caplog)
|
2019-02-24 19:08:27 +00:00
|
|
|
|
2019-12-23 09:03:18 +00:00
|
|
|
exchange = ExchangeResolver.load_exchange('binance', default_conf)
|
2019-02-24 19:08:27 +00:00
|
|
|
assert isinstance(exchange, Exchange)
|
|
|
|
assert isinstance(exchange, Binance)
|
|
|
|
assert not isinstance(exchange, Kraken)
|
|
|
|
|
2019-02-20 19:13:23 +00:00
|
|
|
assert not log_has_re(r"No .* specific subclass found. Using the generic class instead.",
|
2019-08-11 18:17:39 +00:00
|
|
|
caplog)
|
2019-02-20 19:13:23 +00:00
|
|
|
|
2019-10-14 09:36:42 +00:00
|
|
|
# Test mapping
|
2019-12-23 09:03:18 +00:00
|
|
|
exchange = ExchangeResolver.load_exchange('binanceus', default_conf)
|
2019-10-14 09:36:42 +00:00
|
|
|
assert isinstance(exchange, Exchange)
|
|
|
|
assert isinstance(exchange, Binance)
|
|
|
|
assert not isinstance(exchange, Kraken)
|
|
|
|
|
2019-02-20 19:13:23 +00:00
|
|
|
|
2019-03-27 19:51:55 +00:00
|
|
|
def test_validate_order_time_in_force(default_conf, mocker, caplog):
|
|
|
|
caplog.set_level(logging.INFO)
|
2021-09-16 04:28:10 +00:00
|
|
|
# explicitly test bittrex, exchanges implementing other policies need separate tests
|
2019-03-27 19:51:55 +00:00
|
|
|
ex = get_patched_exchange(mocker, default_conf, id="bittrex")
|
|
|
|
tif = {
|
|
|
|
"buy": "gtc",
|
|
|
|
"sell": "gtc",
|
|
|
|
}
|
|
|
|
|
|
|
|
ex.validate_order_time_in_force(tif)
|
|
|
|
tif2 = {
|
|
|
|
"buy": "fok",
|
|
|
|
"sell": "ioc",
|
|
|
|
}
|
|
|
|
with pytest.raises(OperationalException, match=r"Time in force.*not supported for .*"):
|
|
|
|
ex.validate_order_time_in_force(tif2)
|
|
|
|
|
|
|
|
# Patch to see if this will pass if the values are in the ft dict
|
2022-08-27 08:24:56 +00:00
|
|
|
ex._ft_has.update({"order_time_in_force": ["GTC", "FOK", "IOC"]})
|
2019-03-27 19:51:55 +00:00
|
|
|
ex.validate_order_time_in_force(tif2)
|
|
|
|
|
|
|
|
|
2022-08-15 06:51:15 +00:00
|
|
|
@pytest.mark.parametrize("amount,precision_mode,precision,expected", [
|
|
|
|
(2.34559, 2, 4, 2.3455),
|
|
|
|
(2.34559, 2, 5, 2.34559),
|
|
|
|
(2.34559, 2, 3, 2.345),
|
|
|
|
(2.9999, 2, 3, 2.999),
|
|
|
|
(2.9909, 2, 3, 2.990),
|
|
|
|
(2.9909, 2, 0, 2),
|
|
|
|
(29991.5555, 2, 0, 29991),
|
|
|
|
(29991.5555, 2, -1, 29990),
|
|
|
|
(29991.5555, 2, -2, 29900),
|
2020-01-14 15:01:35 +00:00
|
|
|
# Tests for Tick-size
|
2022-08-15 06:51:15 +00:00
|
|
|
(2.34559, 4, 0.0001, 2.3455),
|
|
|
|
(2.34559, 4, 0.00001, 2.34559),
|
|
|
|
(2.34559, 4, 0.001, 2.345),
|
|
|
|
(2.9999, 4, 0.001, 2.999),
|
|
|
|
(2.9909, 4, 0.001, 2.990),
|
|
|
|
(2.9909, 4, 0.005, 2.99),
|
|
|
|
(2.9999, 4, 0.005, 2.995),
|
2020-01-14 14:54:53 +00:00
|
|
|
])
|
2022-08-15 06:51:15 +00:00
|
|
|
def test_amount_to_precision(amount, precision_mode, precision, expected,):
|
2021-11-09 10:31:54 +00:00
|
|
|
"""
|
2020-01-14 14:54:53 +00:00
|
|
|
Test rounds down
|
2021-11-09 10:31:54 +00:00
|
|
|
"""
|
2020-01-12 13:40:58 +00:00
|
|
|
# digits counting mode
|
|
|
|
# DECIMAL_PLACES = 2
|
|
|
|
# SIGNIFICANT_DIGITS = 3
|
|
|
|
# TICK_SIZE = 4
|
2018-07-30 16:49:58 +00:00
|
|
|
|
2022-08-15 06:51:15 +00:00
|
|
|
assert amount_to_precision(amount, precision, precision_mode) == expected
|
2020-01-14 14:54:53 +00:00
|
|
|
|
|
|
|
|
2020-01-14 15:04:39 +00:00
|
|
|
@pytest.mark.parametrize("price,precision_mode,precision,expected", [
|
|
|
|
(2.34559, 2, 4, 2.3456),
|
|
|
|
(2.34559, 2, 5, 2.34559),
|
|
|
|
(2.34559, 2, 3, 2.346),
|
|
|
|
(2.9999, 2, 3, 3.000),
|
|
|
|
(2.9909, 2, 3, 2.991),
|
|
|
|
# Tests for Tick_size
|
|
|
|
(2.34559, 4, 0.0001, 2.3456),
|
|
|
|
(2.34559, 4, 0.00001, 2.34559),
|
|
|
|
(2.34559, 4, 0.001, 2.346),
|
|
|
|
(2.9999, 4, 0.001, 3.000),
|
|
|
|
(2.9909, 4, 0.001, 2.991),
|
2020-01-14 19:16:47 +00:00
|
|
|
(2.9909, 4, 0.005, 2.995),
|
|
|
|
(2.9973, 4, 0.005, 3.0),
|
2020-01-14 15:04:39 +00:00
|
|
|
(2.9977, 4, 0.005, 3.0),
|
2020-01-14 19:16:47 +00:00
|
|
|
(234.43, 4, 0.5, 234.5),
|
|
|
|
(234.53, 4, 0.5, 235.0),
|
|
|
|
(0.891534, 4, 0.0001, 0.8916),
|
2021-10-03 07:48:19 +00:00
|
|
|
(64968.89, 4, 0.01, 64968.89),
|
2022-03-30 05:10:46 +00:00
|
|
|
(0.000000003483, 4, 1e-12, 0.000000003483),
|
2018-07-30 16:49:58 +00:00
|
|
|
|
2020-01-14 14:54:53 +00:00
|
|
|
])
|
2022-08-15 06:51:15 +00:00
|
|
|
def test_price_to_precision(price, precision_mode, precision, expected):
|
2020-01-14 14:54:53 +00:00
|
|
|
# digits counting mode
|
|
|
|
# DECIMAL_PLACES = 2
|
|
|
|
# SIGNIFICANT_DIGITS = 3
|
|
|
|
# TICK_SIZE = 4
|
2018-07-30 16:49:58 +00:00
|
|
|
|
2022-08-15 06:51:15 +00:00
|
|
|
assert price_to_precision(price, precision, precision_mode) == expected
|
2018-07-30 16:49:58 +00:00
|
|
|
|
|
|
|
|
2020-04-15 05:53:31 +00:00
|
|
|
@pytest.mark.parametrize("price,precision_mode,precision,expected", [
|
|
|
|
(2.34559, 2, 4, 0.0001),
|
|
|
|
(2.34559, 2, 5, 0.00001),
|
|
|
|
(2.34559, 2, 3, 0.001),
|
|
|
|
(2.9999, 2, 3, 0.001),
|
|
|
|
(200.0511, 2, 3, 0.001),
|
|
|
|
# Tests for Tick_size
|
|
|
|
(2.34559, 4, 0.0001, 0.0001),
|
|
|
|
(2.34559, 4, 0.00001, 0.00001),
|
|
|
|
(2.34559, 4, 0.0025, 0.0025),
|
|
|
|
(2.9909, 4, 0.0025, 0.0025),
|
|
|
|
(234.43, 4, 0.5, 0.5),
|
|
|
|
(234.43, 4, 0.0025, 0.0025),
|
|
|
|
(234.43, 4, 0.00013, 0.00013),
|
|
|
|
|
|
|
|
])
|
|
|
|
def test_price_get_one_pip(default_conf, mocker, price, precision_mode, precision, expected):
|
|
|
|
markets = PropertyMock(return_value={'ETH/BTC': {'precision': {'price': precision}}})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id="binance")
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.markets', markets)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.precisionMode',
|
|
|
|
PropertyMock(return_value=precision_mode))
|
|
|
|
pair = 'ETH/BTC'
|
|
|
|
assert pytest.approx(exchange.price_get_one_pip(pair, price)) == expected
|
|
|
|
|
|
|
|
|
2022-02-03 06:52:39 +00:00
|
|
|
def test__get_stake_amount_limit(mocker, default_conf) -> None:
|
2021-02-02 18:47:21 +00:00
|
|
|
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id="binance")
|
|
|
|
stoploss = -0.05
|
2021-12-25 13:38:17 +00:00
|
|
|
markets = {'ETH/BTC': {'symbol': 'ETH/BTC'}}
|
2021-02-02 18:47:21 +00:00
|
|
|
|
|
|
|
# no pair found
|
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.exchange.Exchange.markets',
|
|
|
|
PropertyMock(return_value=markets)
|
|
|
|
)
|
|
|
|
with pytest.raises(ValueError, match=r'.*get market information.*'):
|
|
|
|
exchange.get_min_pair_stake_amount('BNB/BTC', 1, stoploss)
|
|
|
|
|
2022-02-03 06:52:39 +00:00
|
|
|
# no cost/amount Min
|
2021-02-02 18:47:21 +00:00
|
|
|
markets["ETH/BTC"]["limits"] = {
|
2022-01-31 09:02:17 +00:00
|
|
|
'cost': {'min': None, 'max': None},
|
|
|
|
'amount': {'min': None, 'max': None},
|
2021-02-02 18:47:21 +00:00
|
|
|
}
|
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.exchange.Exchange.markets',
|
|
|
|
PropertyMock(return_value=markets)
|
|
|
|
)
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 1, stoploss)
|
|
|
|
assert result is None
|
2022-02-04 20:26:15 +00:00
|
|
|
result = exchange.get_max_pair_stake_amount('ETH/BTC', 1)
|
2022-02-03 06:52:39 +00:00
|
|
|
assert result == float('inf')
|
2021-02-02 18:47:21 +00:00
|
|
|
|
2022-02-03 06:52:39 +00:00
|
|
|
# min/max cost is set
|
2021-02-02 18:47:21 +00:00
|
|
|
markets["ETH/BTC"]["limits"] = {
|
2022-02-03 06:52:39 +00:00
|
|
|
'cost': {'min': 2, 'max': 10000},
|
2022-01-31 09:02:17 +00:00
|
|
|
'amount': {'min': None, 'max': None},
|
2021-02-02 18:47:21 +00:00
|
|
|
}
|
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.exchange.Exchange.markets',
|
|
|
|
PropertyMock(return_value=markets)
|
|
|
|
)
|
2022-02-03 06:52:39 +00:00
|
|
|
# min
|
2021-02-02 18:47:21 +00:00
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 1, stoploss)
|
2022-04-11 16:02:02 +00:00
|
|
|
expected_result = 2 * (1 + 0.05) / (1 - abs(stoploss))
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result
|
2021-11-17 13:17:27 +00:00
|
|
|
# With Leverage
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 1, stoploss, 3.0)
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result / 3
|
2022-02-03 06:52:39 +00:00
|
|
|
# max
|
2022-02-04 20:26:15 +00:00
|
|
|
result = exchange.get_max_pair_stake_amount('ETH/BTC', 2)
|
2022-02-03 06:52:39 +00:00
|
|
|
assert result == 10000
|
2021-02-02 18:47:21 +00:00
|
|
|
|
|
|
|
# min amount is set
|
|
|
|
markets["ETH/BTC"]["limits"] = {
|
2022-01-31 09:02:17 +00:00
|
|
|
'cost': {'min': None, 'max': None},
|
2022-02-03 06:52:39 +00:00
|
|
|
'amount': {'min': 2, 'max': 10000},
|
2021-02-02 18:47:21 +00:00
|
|
|
}
|
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.exchange.Exchange.markets',
|
|
|
|
PropertyMock(return_value=markets)
|
|
|
|
)
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, stoploss)
|
2022-04-11 16:02:02 +00:00
|
|
|
expected_result = 2 * 2 * (1 + 0.05) / (1 - abs(stoploss))
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result
|
2021-11-17 13:17:27 +00:00
|
|
|
# With Leverage
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, stoploss, 5.0)
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result / 5
|
2022-02-03 06:52:39 +00:00
|
|
|
# max
|
2022-02-04 20:26:15 +00:00
|
|
|
result = exchange.get_max_pair_stake_amount('ETH/BTC', 2)
|
2022-02-03 06:52:39 +00:00
|
|
|
assert result == 20000
|
2021-02-02 18:47:21 +00:00
|
|
|
|
|
|
|
# min amount and cost are set (cost is minimal)
|
|
|
|
markets["ETH/BTC"]["limits"] = {
|
2022-01-31 09:02:17 +00:00
|
|
|
'cost': {'min': 2, 'max': None},
|
|
|
|
'amount': {'min': 2, 'max': None},
|
2021-02-02 18:47:21 +00:00
|
|
|
}
|
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.exchange.Exchange.markets',
|
|
|
|
PropertyMock(return_value=markets)
|
|
|
|
)
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, stoploss)
|
2022-04-11 16:02:02 +00:00
|
|
|
expected_result = max(2, 2 * 2) * (1 + 0.05) / (1 - abs(stoploss))
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result
|
2021-11-17 13:17:27 +00:00
|
|
|
# With Leverage
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, stoploss, 10)
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result / 10
|
2021-02-02 18:47:21 +00:00
|
|
|
|
|
|
|
# min amount and cost are set (amount is minial)
|
|
|
|
markets["ETH/BTC"]["limits"] = {
|
2022-02-03 06:52:39 +00:00
|
|
|
'cost': {'min': 8, 'max': 10000},
|
|
|
|
'amount': {'min': 2, 'max': 500},
|
2021-02-02 18:47:21 +00:00
|
|
|
}
|
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.exchange.Exchange.markets',
|
|
|
|
PropertyMock(return_value=markets)
|
|
|
|
)
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, stoploss)
|
2022-04-11 16:02:02 +00:00
|
|
|
expected_result = max(8, 2 * 2) * (1 + 0.05) / (1 - abs(stoploss))
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result
|
2021-11-17 13:17:27 +00:00
|
|
|
# With Leverage
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, stoploss, 7.0)
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result / 7.0
|
2022-02-03 06:52:39 +00:00
|
|
|
# Max
|
2022-02-04 20:26:15 +00:00
|
|
|
result = exchange.get_max_pair_stake_amount('ETH/BTC', 2)
|
2022-02-03 06:52:39 +00:00
|
|
|
assert result == 1000
|
2021-03-20 06:21:22 +00:00
|
|
|
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, -0.4)
|
2021-09-19 23:02:09 +00:00
|
|
|
expected_result = max(8, 2 * 2) * 1.5
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result
|
2021-11-17 13:17:27 +00:00
|
|
|
# With Leverage
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, -0.4, 8.0)
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result / 8.0
|
2022-02-03 06:52:39 +00:00
|
|
|
# Max
|
2022-02-04 20:26:15 +00:00
|
|
|
result = exchange.get_max_pair_stake_amount('ETH/BTC', 2)
|
2022-02-03 06:52:39 +00:00
|
|
|
assert result == 1000
|
2021-03-20 06:21:22 +00:00
|
|
|
|
|
|
|
# Really big stoploss
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, -1)
|
2021-09-19 23:02:09 +00:00
|
|
|
expected_result = max(8, 2 * 2) * 1.5
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result
|
2021-11-17 13:17:27 +00:00
|
|
|
# With Leverage
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, -1, 12.0)
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result / 12
|
2022-02-03 06:52:39 +00:00
|
|
|
# Max
|
2022-02-04 20:26:15 +00:00
|
|
|
result = exchange.get_max_pair_stake_amount('ETH/BTC', 2)
|
2022-02-03 06:52:39 +00:00
|
|
|
assert result == 1000
|
2021-02-02 18:47:21 +00:00
|
|
|
|
2022-01-06 09:40:31 +00:00
|
|
|
markets["ETH/BTC"]["contractSize"] = '0.01'
|
2021-12-31 13:00:47 +00:00
|
|
|
default_conf['trading_mode'] = 'futures'
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2021-12-31 13:00:47 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id="binance")
|
2021-12-21 21:45:16 +00:00
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.exchange.Exchange.markets',
|
|
|
|
PropertyMock(return_value=markets)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Contract size 0.01
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, -1)
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == expected_result * 0.01
|
2022-02-03 06:52:39 +00:00
|
|
|
# Max
|
2022-02-04 20:26:15 +00:00
|
|
|
result = exchange.get_max_pair_stake_amount('ETH/BTC', 2)
|
2022-02-03 06:52:39 +00:00
|
|
|
assert result == 10
|
2021-12-21 21:45:16 +00:00
|
|
|
|
2022-01-06 09:40:31 +00:00
|
|
|
markets["ETH/BTC"]["contractSize"] = '10'
|
2021-12-21 21:45:16 +00:00
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.exchange.Exchange.markets',
|
|
|
|
PropertyMock(return_value=markets)
|
|
|
|
)
|
|
|
|
# With Leverage, Contract size 10
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 2, -1, 12.0)
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(result) == (expected_result / 12) * 10.0
|
2022-02-03 06:52:39 +00:00
|
|
|
# Max
|
2022-02-04 20:26:15 +00:00
|
|
|
result = exchange.get_max_pair_stake_amount('ETH/BTC', 2)
|
2022-02-03 06:52:39 +00:00
|
|
|
assert result == 10000
|
2021-12-21 21:45:16 +00:00
|
|
|
|
2021-02-02 18:47:21 +00:00
|
|
|
|
|
|
|
def test_get_min_pair_stake_amount_real_data(mocker, default_conf) -> None:
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id="binance")
|
|
|
|
stoploss = -0.05
|
|
|
|
markets = {'ETH/BTC': {'symbol': 'ETH/BTC'}}
|
|
|
|
|
2022-02-03 06:52:39 +00:00
|
|
|
# ~Real Binance data
|
2021-02-02 18:47:21 +00:00
|
|
|
markets["ETH/BTC"]["limits"] = {
|
2022-02-03 06:52:39 +00:00
|
|
|
'cost': {'min': 0.0001, 'max': 4000},
|
|
|
|
'amount': {'min': 0.001, 'max': 10000},
|
2021-02-02 18:47:21 +00:00
|
|
|
}
|
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.exchange.Exchange.markets',
|
|
|
|
PropertyMock(return_value=markets)
|
|
|
|
)
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 0.020405, stoploss)
|
2022-04-11 16:02:02 +00:00
|
|
|
expected_result = max(0.0001, 0.001 * 0.020405) * (1 + 0.05) / (1 - abs(stoploss))
|
2021-09-19 23:02:09 +00:00
|
|
|
assert round(result, 8) == round(expected_result, 8)
|
2022-02-03 06:52:39 +00:00
|
|
|
# Max
|
2022-02-04 20:26:15 +00:00
|
|
|
result = exchange.get_max_pair_stake_amount('ETH/BTC', 2.0)
|
2022-02-03 06:52:39 +00:00
|
|
|
assert result == 4000
|
|
|
|
|
|
|
|
# Leverage
|
2021-11-17 13:17:27 +00:00
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 0.020405, stoploss, 3.0)
|
2022-04-11 16:02:02 +00:00
|
|
|
assert round(result, 8) == round(expected_result / 3, 8)
|
2021-02-02 18:47:21 +00:00
|
|
|
|
2022-02-03 06:52:39 +00:00
|
|
|
# Contract_size
|
|
|
|
markets["ETH/BTC"]["contractSize"] = 0.1
|
|
|
|
result = exchange.get_min_pair_stake_amount('ETH/BTC', 0.020405, stoploss, 3.0)
|
2022-04-11 16:02:02 +00:00
|
|
|
assert round(result, 8) == round((expected_result / 3), 8)
|
2022-02-03 06:52:39 +00:00
|
|
|
|
|
|
|
# Max
|
2022-02-04 20:26:15 +00:00
|
|
|
result = exchange.get_max_pair_stake_amount('ETH/BTC', 12.0)
|
2022-02-03 06:52:39 +00:00
|
|
|
assert result == 4000
|
|
|
|
|
2021-02-02 18:47:21 +00:00
|
|
|
|
2018-07-28 20:32:10 +00:00
|
|
|
def test_set_sandbox(default_conf, mocker):
|
|
|
|
"""
|
|
|
|
Test working scenario
|
|
|
|
"""
|
|
|
|
api_mock = MagicMock()
|
|
|
|
api_mock.load_markets = MagicMock(return_value={
|
|
|
|
'ETH/BTC': '', 'LTC/BTC': '', 'XRP/BTC': '', 'NEO/BTC': ''
|
|
|
|
})
|
2018-07-29 08:10:55 +00:00
|
|
|
url_mock = PropertyMock(return_value={'test': "api-public.sandbox.gdax.com",
|
|
|
|
'api': 'https://api.gdax.com'})
|
2018-07-28 20:32:10 +00:00
|
|
|
type(api_mock).urls = url_mock
|
2019-03-05 18:46:03 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
2018-07-29 08:02:04 +00:00
|
|
|
liveurl = exchange._api.urls['api']
|
|
|
|
default_conf['exchange']['sandbox'] = True
|
|
|
|
exchange.set_sandbox(exchange._api, default_conf['exchange'], 'Logname')
|
|
|
|
assert exchange._api.urls['api'] != liveurl
|
|
|
|
|
2018-07-29 08:10:55 +00:00
|
|
|
|
2018-07-29 08:02:04 +00:00
|
|
|
def test_set_sandbox_exception(default_conf, mocker):
|
|
|
|
"""
|
|
|
|
Test Fail scenario
|
|
|
|
"""
|
|
|
|
api_mock = MagicMock()
|
|
|
|
api_mock.load_markets = MagicMock(return_value={
|
|
|
|
'ETH/BTC': '', 'LTC/BTC': '', 'XRP/BTC': '', 'NEO/BTC': ''
|
|
|
|
})
|
|
|
|
url_mock = PropertyMock(return_value={'api': 'https://api.gdax.com'})
|
|
|
|
type(api_mock).urls = url_mock
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException, match=r'does not provide a sandbox api'):
|
2019-03-05 18:46:03 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
2018-07-29 08:02:04 +00:00
|
|
|
default_conf['exchange']['sandbox'] = True
|
|
|
|
exchange.set_sandbox(exchange._api, default_conf['exchange'], 'Logname')
|
|
|
|
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2020-06-13 10:34:29 +00:00
|
|
|
def test__load_async_markets(default_conf, mocker, caplog):
|
2020-06-17 06:33:53 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_markets')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2020-06-17 06:33:53 +00:00
|
|
|
exchange = Exchange(default_conf)
|
2020-06-13 10:34:29 +00:00
|
|
|
exchange._api_async.load_markets = get_mock_coro(None)
|
|
|
|
exchange._load_async_markets()
|
|
|
|
assert exchange._api_async.load_markets.call_count == 1
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
|
|
|
|
exchange._api_async.load_markets = Mock(side_effect=ccxt.BaseError("deadbeef"))
|
|
|
|
exchange._load_async_markets()
|
|
|
|
|
|
|
|
assert log_has('Could not load async markets. Reason: deadbeef', caplog)
|
|
|
|
|
|
|
|
|
2018-09-11 17:46:47 +00:00
|
|
|
def test__load_markets(default_conf, mocker, caplog):
|
|
|
|
caplog.set_level(logging.INFO)
|
|
|
|
api_mock = MagicMock()
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.load_markets = MagicMock(side_effect=ccxt.BaseError("SomeError"))
|
2019-03-05 18:46:03 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
2020-06-13 10:34:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2019-03-05 18:46:03 +00:00
|
|
|
Exchange(default_conf)
|
2021-03-20 12:33:49 +00:00
|
|
|
assert log_has('Unable to initialize markets.', caplog)
|
2018-09-11 17:46:47 +00:00
|
|
|
|
|
|
|
expected_return = {'ETH/BTC': 'available'}
|
2019-03-05 18:46:03 +00:00
|
|
|
api_mock = MagicMock()
|
2018-09-11 17:46:47 +00:00
|
|
|
api_mock.load_markets = MagicMock(return_value=expected_return)
|
2021-01-28 18:40:10 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
2018-09-11 17:46:47 +00:00
|
|
|
default_conf['exchange']['pair_whitelist'] = ['ETH/BTC']
|
2021-01-28 18:40:10 +00:00
|
|
|
ex = Exchange(default_conf)
|
|
|
|
|
2018-09-11 17:46:47 +00:00
|
|
|
assert ex.markets == expected_return
|
|
|
|
|
|
|
|
|
2020-06-09 22:39:23 +00:00
|
|
|
def test_reload_markets(default_conf, mocker, caplog):
|
2019-03-10 15:36:25 +00:00
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
initial_markets = {'ETH/BTC': {}}
|
2021-01-28 18:40:10 +00:00
|
|
|
updated_markets = {'ETH/BTC': {}, "LTC/BTC": {}}
|
2019-03-12 16:54:16 +00:00
|
|
|
|
2019-03-10 16:40:54 +00:00
|
|
|
api_mock = MagicMock()
|
2021-01-28 18:40:10 +00:00
|
|
|
api_mock.load_markets = MagicMock(return_value=initial_markets)
|
2019-03-10 15:36:25 +00:00
|
|
|
default_conf['exchange']['markets_refresh_interval'] = 10
|
2019-10-26 08:08:23 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id="binance",
|
|
|
|
mock_markets=False)
|
2020-06-17 05:23:20 +00:00
|
|
|
exchange._load_async_markets = MagicMock()
|
2020-10-12 17:58:04 +00:00
|
|
|
exchange._last_markets_refresh = arrow.utcnow().int_timestamp
|
2019-03-10 15:36:25 +00:00
|
|
|
|
|
|
|
assert exchange.markets == initial_markets
|
|
|
|
|
|
|
|
# less than 10 minutes have passed, no reload
|
2020-06-09 22:39:23 +00:00
|
|
|
exchange.reload_markets()
|
2019-03-10 15:36:25 +00:00
|
|
|
assert exchange.markets == initial_markets
|
2020-06-17 05:23:20 +00:00
|
|
|
assert exchange._load_async_markets.call_count == 0
|
2019-03-10 15:36:25 +00:00
|
|
|
|
2021-01-28 18:40:10 +00:00
|
|
|
api_mock.load_markets = MagicMock(return_value=updated_markets)
|
2019-03-10 15:36:25 +00:00
|
|
|
# more than 10 minutes have passed, reload is executed
|
2020-10-12 17:58:04 +00:00
|
|
|
exchange._last_markets_refresh = arrow.utcnow().int_timestamp - 15 * 60
|
2020-06-09 22:39:23 +00:00
|
|
|
exchange.reload_markets()
|
2019-03-10 15:36:25 +00:00
|
|
|
assert exchange.markets == updated_markets
|
2020-06-17 05:23:20 +00:00
|
|
|
assert exchange._load_async_markets.call_count == 1
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has('Performing scheduled market reload..', caplog)
|
2019-03-10 15:36:25 +00:00
|
|
|
|
|
|
|
|
2020-06-09 22:39:23 +00:00
|
|
|
def test_reload_markets_exception(default_conf, mocker, caplog):
|
2019-04-24 19:56:24 +00:00
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
|
|
|
|
api_mock = MagicMock()
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.load_markets = MagicMock(side_effect=ccxt.NetworkError("LoadError"))
|
2019-04-24 19:56:24 +00:00
|
|
|
default_conf['exchange']['markets_refresh_interval'] = 10
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id="binance")
|
|
|
|
|
|
|
|
# less than 10 minutes have passed, no reload
|
2020-06-09 22:39:23 +00:00
|
|
|
exchange.reload_markets()
|
2019-04-24 19:56:24 +00:00
|
|
|
assert exchange._last_markets_refresh == 0
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has_re(r"Could not reload markets.*", caplog)
|
2019-04-24 19:56:24 +00:00
|
|
|
|
|
|
|
|
2022-02-04 06:20:27 +00:00
|
|
|
@pytest.mark.parametrize("stake_currency", ['ETH', 'BTC', 'USDT'])
|
2021-08-29 07:18:46 +00:00
|
|
|
def test_validate_stakecurrency(default_conf, stake_currency, mocker, caplog):
|
2020-01-11 11:01:34 +00:00
|
|
|
default_conf['stake_currency'] = stake_currency
|
|
|
|
api_mock = MagicMock()
|
2021-01-28 18:40:10 +00:00
|
|
|
type(api_mock).load_markets = MagicMock(return_value={
|
2020-01-11 11:01:34 +00:00
|
|
|
'ETH/BTC': {'quote': 'BTC'}, 'LTC/BTC': {'quote': 'BTC'},
|
|
|
|
'XRP/ETH': {'quote': 'ETH'}, 'NEO/USDT': {'quote': 'USDT'},
|
|
|
|
})
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
2020-06-13 10:34:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2020-01-11 11:01:34 +00:00
|
|
|
Exchange(default_conf)
|
|
|
|
|
|
|
|
|
2021-08-29 07:18:46 +00:00
|
|
|
def test_validate_stakecurrency_error(default_conf, mocker, caplog):
|
2020-01-11 12:14:19 +00:00
|
|
|
default_conf['stake_currency'] = 'XRP'
|
|
|
|
api_mock = MagicMock()
|
2021-01-28 18:40:10 +00:00
|
|
|
type(api_mock).load_markets = MagicMock(return_value={
|
2020-01-11 12:14:19 +00:00
|
|
|
'ETH/BTC': {'quote': 'BTC'}, 'LTC/BTC': {'quote': 'BTC'},
|
|
|
|
'XRP/ETH': {'quote': 'ETH'}, 'NEO/USDT': {'quote': 'USDT'},
|
|
|
|
})
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
2020-06-13 10:34:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
2020-01-11 12:14:19 +00:00
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r'XRP is not available as stake on .*'
|
|
|
|
'Available currencies are: BTC, ETH, USDT'):
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
2021-08-29 07:18:46 +00:00
|
|
|
type(api_mock).load_markets = MagicMock(side_effect=ccxt.NetworkError('No connection.'))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r'Could not load markets, therefore cannot start\. Please.*'):
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
2020-01-11 12:14:19 +00:00
|
|
|
|
2020-01-11 11:01:34 +00:00
|
|
|
def test_get_quote_currencies(default_conf, mocker):
|
|
|
|
ex = get_patched_exchange(mocker, default_conf)
|
|
|
|
|
2022-02-14 23:34:59 +00:00
|
|
|
assert set(ex.get_quote_currencies()) == set(['USD', 'ETH', 'BTC', 'USDT', 'BUSD'])
|
2020-01-11 11:01:34 +00:00
|
|
|
|
|
|
|
|
2020-02-25 06:01:23 +00:00
|
|
|
@pytest.mark.parametrize('pair,expected', [
|
|
|
|
('XRP/BTC', 'BTC'),
|
|
|
|
('LTC/USD', 'USD'),
|
|
|
|
('ETH/USDT', 'USDT'),
|
|
|
|
('XLTCUSDT', 'USDT'),
|
2020-02-26 06:09:54 +00:00
|
|
|
('XRP/NOCURRENCY', ''),
|
2020-02-25 06:01:23 +00:00
|
|
|
])
|
|
|
|
def test_get_pair_quote_currency(default_conf, mocker, pair, expected):
|
|
|
|
ex = get_patched_exchange(mocker, default_conf)
|
|
|
|
assert ex.get_pair_quote_currency(pair) == expected
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize('pair,expected', [
|
|
|
|
('XRP/BTC', 'XRP'),
|
|
|
|
('LTC/USD', 'LTC'),
|
|
|
|
('ETH/USDT', 'ETH'),
|
|
|
|
('XLTCUSDT', 'LTC'),
|
2020-02-26 06:09:54 +00:00
|
|
|
('XRP/NOCURRENCY', ''),
|
2020-02-25 06:01:23 +00:00
|
|
|
])
|
|
|
|
def test_get_pair_base_currency(default_conf, mocker, pair, expected):
|
|
|
|
ex = get_patched_exchange(mocker, default_conf)
|
|
|
|
assert ex.get_pair_base_currency(pair) == expected
|
2020-01-11 11:01:34 +00:00
|
|
|
|
|
|
|
|
2019-03-05 18:46:03 +00:00
|
|
|
def test_validate_pairs(default_conf, mocker): # test exchange.validate_pairs directly
|
2017-12-30 07:12:52 +00:00
|
|
|
api_mock = MagicMock()
|
2021-01-28 18:40:10 +00:00
|
|
|
type(api_mock).load_markets = MagicMock(return_value={
|
2020-02-24 20:22:58 +00:00
|
|
|
'ETH/BTC': {'quote': 'BTC'},
|
|
|
|
'LTC/BTC': {'quote': 'BTC'},
|
|
|
|
'XRP/BTC': {'quote': 'BTC'},
|
|
|
|
'NEO/BTC': {'quote': 'BTC'},
|
2018-04-06 07:57:08 +00:00
|
|
|
})
|
|
|
|
id_mock = PropertyMock(return_value='test_exchange')
|
|
|
|
type(api_mock).id = id_mock
|
|
|
|
|
2018-06-17 18:13:39 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
2020-06-13 10:34:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2018-06-17 18:13:39 +00:00
|
|
|
Exchange(default_conf)
|
2017-12-30 07:12:52 +00:00
|
|
|
|
|
|
|
|
2021-01-14 23:13:11 +00:00
|
|
|
def test_validate_pairs_not_available(default_conf, mocker):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
type(api_mock).markets = PropertyMock(return_value={
|
|
|
|
'XRP/BTC': {'inactive': True, 'base': 'XRP', 'quote': 'BTC'}
|
|
|
|
})
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException, match=r'not available'):
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
|
|
|
|
|
|
|
def test_validate_pairs_exception(default_conf, mocker, caplog):
|
|
|
|
caplog.set_level(logging.INFO)
|
|
|
|
api_mock = MagicMock()
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.name', PropertyMock(return_value='Binance'))
|
|
|
|
|
|
|
|
type(api_mock).markets = PropertyMock(return_value={})
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', api_mock)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2021-01-14 23:13:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException, match=r'Pair ETH/BTC is not available on Binance'):
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.markets', PropertyMock(return_value={}))
|
|
|
|
Exchange(default_conf)
|
|
|
|
assert log_has('Unable to validate pairs (assuming they are correct).', caplog)
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2018-04-09 17:21:35 +00:00
|
|
|
|
2019-08-03 11:11:51 +00:00
|
|
|
def test_validate_pairs_restricted(default_conf, mocker, caplog):
|
|
|
|
api_mock = MagicMock()
|
2021-01-28 18:40:10 +00:00
|
|
|
type(api_mock).load_markets = MagicMock(return_value={
|
2020-02-24 20:22:58 +00:00
|
|
|
'ETH/BTC': {'quote': 'BTC'}, 'LTC/BTC': {'quote': 'BTC'},
|
2021-07-29 04:56:37 +00:00
|
|
|
'XRP/BTC': {'quote': 'BTC', 'info': {'prohibitedIn': ['US']}},
|
2020-02-24 20:22:58 +00:00
|
|
|
'NEO/BTC': {'quote': 'BTC', 'info': 'TestString'}, # info can also be a string ...
|
2019-08-03 11:11:51 +00:00
|
|
|
})
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
2020-06-13 10:34:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2019-08-03 11:11:51 +00:00
|
|
|
|
|
|
|
Exchange(default_conf)
|
2020-05-18 09:40:25 +00:00
|
|
|
assert log_has("Pair XRP/BTC is restricted for some users on this exchange."
|
|
|
|
"Please check if you are impacted by this restriction "
|
|
|
|
"on the exchange and eventually remove XRP/BTC from your whitelist.", caplog)
|
2019-08-03 11:11:51 +00:00
|
|
|
|
|
|
|
|
2020-02-24 20:22:58 +00:00
|
|
|
def test_validate_pairs_stakecompatibility(default_conf, mocker, caplog):
|
|
|
|
api_mock = MagicMock()
|
2021-01-28 18:40:10 +00:00
|
|
|
type(api_mock).load_markets = MagicMock(return_value={
|
2020-02-24 20:22:58 +00:00
|
|
|
'ETH/BTC': {'quote': 'BTC'}, 'LTC/BTC': {'quote': 'BTC'},
|
|
|
|
'XRP/BTC': {'quote': 'BTC'}, 'NEO/BTC': {'quote': 'BTC'},
|
|
|
|
'HELLO-WORLD': {'quote': 'BTC'},
|
|
|
|
})
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
2020-06-13 10:34:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
2020-02-29 13:56:04 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2020-02-29 13:56:04 +00:00
|
|
|
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
|
|
|
|
|
|
|
def test_validate_pairs_stakecompatibility_downloaddata(default_conf, mocker, caplog):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
default_conf['stake_currency'] = ''
|
2021-01-28 18:40:10 +00:00
|
|
|
type(api_mock).load_markets = MagicMock(return_value={
|
2020-02-29 13:56:04 +00:00
|
|
|
'ETH/BTC': {'quote': 'BTC'}, 'LTC/BTC': {'quote': 'BTC'},
|
|
|
|
'XRP/BTC': {'quote': 'BTC'}, 'NEO/BTC': {'quote': 'BTC'},
|
|
|
|
'HELLO-WORLD': {'quote': 'BTC'},
|
|
|
|
})
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
2020-06-13 10:34:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
2020-02-24 20:22:58 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2020-02-24 20:22:58 +00:00
|
|
|
|
|
|
|
Exchange(default_conf)
|
2021-01-28 18:40:10 +00:00
|
|
|
assert type(api_mock).load_markets.call_count == 1
|
2020-02-24 20:22:58 +00:00
|
|
|
|
|
|
|
|
|
|
|
def test_validate_pairs_stakecompatibility_fail(default_conf, mocker, caplog):
|
|
|
|
default_conf['exchange']['pair_whitelist'].append('HELLO-WORLD')
|
|
|
|
api_mock = MagicMock()
|
2021-01-28 18:40:10 +00:00
|
|
|
type(api_mock).load_markets = MagicMock(return_value={
|
2020-02-24 20:22:58 +00:00
|
|
|
'ETH/BTC': {'quote': 'BTC'}, 'LTC/BTC': {'quote': 'BTC'},
|
|
|
|
'XRP/BTC': {'quote': 'BTC'}, 'NEO/BTC': {'quote': 'BTC'},
|
|
|
|
'HELLO-WORLD': {'quote': 'USDT'},
|
|
|
|
})
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
2020-06-13 10:34:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
2020-02-24 20:22:58 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException, match=r"Stake-currency 'BTC' not compatible with.*"):
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
2020-02-25 06:03:11 +00:00
|
|
|
|
2020-01-11 10:36:28 +00:00
|
|
|
@pytest.mark.parametrize("timeframe", [
|
|
|
|
('5m'), ("1m"), ("15m"), ("1h")
|
|
|
|
])
|
|
|
|
def test_validate_timeframes(default_conf, mocker, timeframe):
|
2020-06-01 18:39:01 +00:00
|
|
|
default_conf["timeframe"] = timeframe
|
2018-07-07 12:42:53 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
id_mock = PropertyMock(return_value='test_exchange')
|
|
|
|
type(api_mock).id = id_mock
|
|
|
|
timeframes = PropertyMock(return_value={'1m': '1m',
|
|
|
|
'5m': '5m',
|
|
|
|
'15m': '15m',
|
|
|
|
'1h': '1h'})
|
|
|
|
type(api_mock).timeframes = timeframes
|
|
|
|
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
2018-09-11 17:46:47 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2018-07-07 12:42:53 +00:00
|
|
|
Exchange(default_conf)
|
|
|
|
|
|
|
|
|
|
|
|
def test_validate_timeframes_failed(default_conf, mocker):
|
2020-06-01 18:39:01 +00:00
|
|
|
default_conf["timeframe"] = "3m"
|
2018-07-07 12:42:53 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
id_mock = PropertyMock(return_value='test_exchange')
|
|
|
|
type(api_mock).id = id_mock
|
2020-01-11 10:36:28 +00:00
|
|
|
timeframes = PropertyMock(return_value={'15s': '15s',
|
|
|
|
'1m': '1m',
|
2018-07-07 12:42:53 +00:00
|
|
|
'5m': '5m',
|
|
|
|
'15m': '15m',
|
|
|
|
'1h': '1h'})
|
|
|
|
type(api_mock).timeframes = timeframes
|
|
|
|
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
2018-09-11 17:46:47 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
|
2019-03-05 18:46:03 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
|
2019-09-29 20:08:11 +00:00
|
|
|
with pytest.raises(OperationalException,
|
2020-03-08 10:35:31 +00:00
|
|
|
match=r"Invalid timeframe '3m'. This exchange supports.*"):
|
2018-07-07 12:42:53 +00:00
|
|
|
Exchange(default_conf)
|
2020-06-01 18:39:01 +00:00
|
|
|
default_conf["timeframe"] = "15s"
|
2020-01-11 10:36:28 +00:00
|
|
|
|
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r"Timeframes < 1m are currently not supported by Freqtrade."):
|
|
|
|
Exchange(default_conf)
|
2018-07-07 12:42:53 +00:00
|
|
|
|
|
|
|
|
2019-07-02 22:03:38 +00:00
|
|
|
def test_validate_timeframes_emulated_ohlcv_1(default_conf, mocker):
|
2020-06-01 18:39:01 +00:00
|
|
|
default_conf["timeframe"] = "3m"
|
2019-06-30 18:30:47 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
id_mock = PropertyMock(return_value='test_exchange')
|
|
|
|
type(api_mock).id = id_mock
|
|
|
|
|
|
|
|
# delete timeframes so magicmock does not autocreate it
|
|
|
|
del api_mock.timeframes
|
|
|
|
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2019-06-30 18:30:47 +00:00
|
|
|
with pytest.raises(OperationalException,
|
2019-07-02 22:03:38 +00:00
|
|
|
match=r'The ccxt library does not provide the list of timeframes '
|
2022-04-28 17:43:52 +00:00
|
|
|
r'for the exchange .* and this exchange '
|
2019-07-02 22:03:38 +00:00
|
|
|
r'is therefore not supported. *'):
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
|
|
|
|
|
|
|
def test_validate_timeframes_emulated_ohlcvi_2(default_conf, mocker):
|
2020-06-01 18:39:01 +00:00
|
|
|
default_conf["timeframe"] = "3m"
|
2019-07-02 22:03:38 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
id_mock = PropertyMock(return_value='test_exchange')
|
|
|
|
type(api_mock).id = id_mock
|
|
|
|
|
|
|
|
# delete timeframes so magicmock does not autocreate it
|
|
|
|
del api_mock.timeframes
|
|
|
|
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_markets',
|
|
|
|
MagicMock(return_value={'timeframes': None}))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs', MagicMock())
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2019-07-02 22:03:38 +00:00
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r'The ccxt library does not provide the list of timeframes '
|
2022-04-28 17:43:52 +00:00
|
|
|
r'for the exchange .* and this exchange '
|
2019-07-02 22:03:38 +00:00
|
|
|
r'is therefore not supported. *'):
|
2019-06-30 18:30:47 +00:00
|
|
|
Exchange(default_conf)
|
|
|
|
|
|
|
|
|
2018-07-07 13:30:29 +00:00
|
|
|
def test_validate_timeframes_not_in_config(default_conf, mocker):
|
2022-05-15 13:12:29 +00:00
|
|
|
# TODO: this test does not assert ...
|
2020-06-01 18:39:01 +00:00
|
|
|
del default_conf["timeframe"]
|
2018-07-07 13:30:29 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
id_mock = PropertyMock(return_value='test_exchange')
|
|
|
|
type(api_mock).id = id_mock
|
|
|
|
timeframes = PropertyMock(return_value={'1m': '1m',
|
|
|
|
'5m': '5m',
|
|
|
|
'15m': '15m',
|
|
|
|
'1h': '1h'})
|
|
|
|
type(api_mock).timeframes = timeframes
|
|
|
|
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
2018-09-11 17:46:47 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2022-05-15 13:12:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_required_startup_candles')
|
2018-07-07 13:30:29 +00:00
|
|
|
Exchange(default_conf)
|
|
|
|
|
|
|
|
|
2022-03-18 16:07:12 +00:00
|
|
|
def test_validate_pricing(default_conf, mocker):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
has = {
|
|
|
|
'fetchL2OrderBook': True,
|
|
|
|
'fetchTicker': True,
|
|
|
|
}
|
|
|
|
type(api_mock).has = PropertyMock(return_value=has)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
|
|
|
|
mocker.patch('freqtrade.exchange.exchange.Exchange.validate_trading_mode_and_margin_mode')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.name', 'Binance')
|
|
|
|
ExchangeResolver.load_exchange('binance', default_conf)
|
|
|
|
has.update({'fetchTicker': False})
|
|
|
|
with pytest.raises(OperationalException, match="Ticker pricing not available for .*"):
|
|
|
|
ExchangeResolver.load_exchange('binance', default_conf)
|
|
|
|
|
|
|
|
has.update({'fetchTicker': True})
|
|
|
|
|
2022-03-27 16:03:49 +00:00
|
|
|
default_conf['exit_pricing']['use_order_book'] = True
|
2022-03-18 16:07:12 +00:00
|
|
|
ExchangeResolver.load_exchange('binance', default_conf)
|
|
|
|
has.update({'fetchL2OrderBook': False})
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException, match="Orderbook not available for .*"):
|
|
|
|
ExchangeResolver.load_exchange('binance', default_conf)
|
|
|
|
|
|
|
|
has.update({'fetchL2OrderBook': True})
|
|
|
|
|
|
|
|
# Binance has no tickers on futures
|
|
|
|
default_conf['trading_mode'] = TradingMode.FUTURES
|
|
|
|
default_conf['margin_mode'] = MarginMode.ISOLATED
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException, match="Ticker pricing not available for .*"):
|
|
|
|
ExchangeResolver.load_exchange('binance', default_conf)
|
|
|
|
|
|
|
|
|
|
|
|
def test_validate_ordertypes(default_conf, mocker):
|
2018-11-17 18:54:55 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'createMarketOrder': True})
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2018-11-25 16:22:56 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.name', 'Bittrex')
|
2020-06-13 22:07:00 +00:00
|
|
|
|
2018-11-25 16:22:56 +00:00
|
|
|
default_conf['order_types'] = {
|
2022-03-08 05:59:14 +00:00
|
|
|
'entry': 'limit',
|
|
|
|
'exit': 'limit',
|
2018-11-25 16:22:56 +00:00
|
|
|
'stoploss': 'market',
|
|
|
|
'stoploss_on_exchange': False
|
|
|
|
}
|
2018-11-17 18:54:55 +00:00
|
|
|
Exchange(default_conf)
|
|
|
|
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'createMarketOrder': False})
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
|
2018-11-25 18:09:11 +00:00
|
|
|
default_conf['order_types'] = {
|
2022-03-08 05:59:14 +00:00
|
|
|
'entry': 'limit',
|
|
|
|
'exit': 'limit',
|
2018-11-25 18:09:11 +00:00
|
|
|
'stoploss': 'market',
|
2020-06-13 21:57:13 +00:00
|
|
|
'stoploss_on_exchange': False
|
2018-11-25 18:09:11 +00:00
|
|
|
}
|
2018-11-17 18:54:55 +00:00
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r'Exchange .* does not support market orders.'):
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
2018-11-25 16:22:56 +00:00
|
|
|
default_conf['order_types'] = {
|
2022-03-08 05:59:14 +00:00
|
|
|
'entry': 'limit',
|
|
|
|
'exit': 'limit',
|
2018-11-25 16:22:56 +00:00
|
|
|
'stoploss': 'limit',
|
|
|
|
'stoploss_on_exchange': True
|
|
|
|
}
|
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r'On exchange stoploss is not supported for .*'):
|
|
|
|
Exchange(default_conf)
|
|
|
|
|
2018-11-17 18:54:55 +00:00
|
|
|
|
|
|
|
def test_validate_order_types_not_in_config(default_conf, mocker):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', MagicMock(return_value=api_mock))
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2018-11-17 18:54:55 +00:00
|
|
|
|
|
|
|
conf = copy.deepcopy(default_conf)
|
|
|
|
Exchange(conf)
|
|
|
|
|
|
|
|
|
2019-10-27 09:38:21 +00:00
|
|
|
def test_validate_required_startup_candles(default_conf, mocker, caplog):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.name', PropertyMock(return_value='Binance'))
|
|
|
|
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._init_ccxt', api_mock)
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_timeframes')
|
2020-06-13 10:34:29 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._load_async_markets')
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pairs')
|
2022-03-18 18:26:54 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_pricing')
|
2020-01-11 10:54:11 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
|
2019-10-27 09:38:21 +00:00
|
|
|
|
2019-10-27 09:56:38 +00:00
|
|
|
default_conf['startup_candle_count'] = 20
|
|
|
|
ex = Exchange(default_conf)
|
|
|
|
assert ex
|
2021-11-07 12:10:40 +00:00
|
|
|
# assumption is that the exchange provides 500 candles per call.s
|
|
|
|
assert ex.validate_required_startup_candles(200, '5m') == 1
|
|
|
|
assert ex.validate_required_startup_candles(499, '5m') == 1
|
|
|
|
assert ex.validate_required_startup_candles(600, '5m') == 2
|
|
|
|
assert ex.validate_required_startup_candles(501, '5m') == 2
|
|
|
|
assert ex.validate_required_startup_candles(499, '5m') == 1
|
|
|
|
assert ex.validate_required_startup_candles(1000, '5m') == 3
|
|
|
|
assert ex.validate_required_startup_candles(2499, '5m') == 5
|
|
|
|
assert log_has_re(r'Using 5 calls to get OHLCV. This.*', caplog)
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException, match=r'This strategy requires 2500.*'):
|
|
|
|
ex.validate_required_startup_candles(2500, '5m')
|
|
|
|
|
|
|
|
# Ensure the same also happens on init
|
|
|
|
default_conf['startup_candle_count'] = 6000
|
|
|
|
with pytest.raises(OperationalException, match=r'This strategy requires 6000.*'):
|
2019-10-27 09:38:21 +00:00
|
|
|
Exchange(default_conf)
|
|
|
|
|
2022-05-14 07:10:38 +00:00
|
|
|
# Emulate kraken mode
|
|
|
|
ex._ft_has['ohlcv_has_history'] = False
|
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r'This strategy requires 2500.*, '
|
|
|
|
r'which is more than the amount.*'):
|
|
|
|
ex.validate_required_startup_candles(2500, '5m')
|
|
|
|
|
2019-10-27 09:38:21 +00:00
|
|
|
|
2018-07-30 17:08:33 +00:00
|
|
|
def test_exchange_has(default_conf, mocker):
|
2018-06-28 20:11:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
|
|
|
assert not exchange.exchange_has('ASDFASDF')
|
|
|
|
api_mock = MagicMock()
|
|
|
|
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'deadbeef': True})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
assert exchange.exchange_has("deadbeef")
|
|
|
|
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'deadbeef': False})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
assert not exchange.exchange_has("deadbeef")
|
|
|
|
|
|
|
|
|
2022-03-05 14:53:40 +00:00
|
|
|
@pytest.mark.parametrize("side,leverage", [
|
|
|
|
("buy", 1),
|
|
|
|
("buy", 5),
|
|
|
|
("sell", 1.0),
|
|
|
|
("sell", 5.0),
|
2019-02-22 00:48:35 +00:00
|
|
|
])
|
2019-02-24 19:08:27 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2022-03-05 14:53:40 +00:00
|
|
|
def test_create_dry_run_order(default_conf, mocker, side, exchange_name, leverage):
|
2019-02-22 00:48:35 +00:00
|
|
|
default_conf['dry_run'] = True
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
2019-02-22 00:48:35 +00:00
|
|
|
|
2021-04-10 11:50:56 +00:00
|
|
|
order = exchange.create_dry_run_order(
|
2021-09-19 23:02:09 +00:00
|
|
|
pair='ETH/BTC',
|
|
|
|
ordertype='limit',
|
|
|
|
side=side,
|
|
|
|
amount=1,
|
|
|
|
rate=200,
|
2022-03-05 14:53:40 +00:00
|
|
|
leverage=leverage
|
2021-09-19 23:02:09 +00:00
|
|
|
)
|
2019-02-22 00:48:35 +00:00
|
|
|
assert 'id' in order
|
|
|
|
assert f'dry_run_{side}_' in order["id"]
|
2019-03-08 20:17:21 +00:00
|
|
|
assert order["side"] == side
|
|
|
|
assert order["type"] == "limit"
|
2020-08-13 13:39:29 +00:00
|
|
|
assert order["symbol"] == "ETH/BTC"
|
2021-12-21 21:45:16 +00:00
|
|
|
assert order["amount"] == 1
|
2022-03-05 14:53:40 +00:00
|
|
|
assert order["leverage"] == leverage
|
2022-07-16 11:12:50 +00:00
|
|
|
assert order["cost"] == 1 * 200
|
2019-02-22 00:48:35 +00:00
|
|
|
|
|
|
|
|
2022-05-04 05:52:01 +00:00
|
|
|
@pytest.mark.parametrize('side,is_short,order_reason', [
|
|
|
|
("buy", False, "entry"),
|
|
|
|
("sell", False, "exit"),
|
|
|
|
("buy", True, "exit"),
|
|
|
|
("sell", True, "entry"),
|
|
|
|
])
|
|
|
|
@pytest.mark.parametrize("order_type,price_side,fee", [
|
|
|
|
("limit", "same", 1.0),
|
|
|
|
("limit", "other", 2.0),
|
|
|
|
("market", "same", 2.0),
|
|
|
|
("market", "other", 2.0),
|
|
|
|
])
|
|
|
|
def test_create_dry_run_order_fees(
|
|
|
|
default_conf,
|
|
|
|
mocker,
|
|
|
|
side,
|
|
|
|
order_type,
|
|
|
|
is_short,
|
|
|
|
order_reason,
|
|
|
|
price_side,
|
|
|
|
fee,
|
|
|
|
):
|
|
|
|
mocker.patch(
|
|
|
|
'freqtrade.exchange.Exchange.get_fee',
|
2022-07-16 15:03:45 +00:00
|
|
|
side_effect=lambda symbol, taker_or_maker: 2.0 if taker_or_maker == 'taker' else 1.0
|
2022-05-04 05:52:01 +00:00
|
|
|
)
|
2022-07-16 15:03:45 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._is_dry_limit_order_filled',
|
|
|
|
return_value=price_side == 'other')
|
2022-05-04 05:52:01 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
|
|
|
|
|
|
|
order = exchange.create_dry_run_order(
|
2022-07-16 15:03:45 +00:00
|
|
|
pair='LTC/USDT',
|
2022-05-04 05:52:01 +00:00
|
|
|
ordertype=order_type,
|
|
|
|
side=side,
|
|
|
|
amount=10,
|
|
|
|
rate=2.0,
|
2022-07-16 15:03:45 +00:00
|
|
|
leverage=1.0
|
2022-05-04 05:52:01 +00:00
|
|
|
)
|
2022-07-16 15:03:45 +00:00
|
|
|
if price_side == 'other' or order_type == 'market':
|
|
|
|
assert order['fee']['rate'] == fee
|
|
|
|
return
|
|
|
|
else:
|
|
|
|
assert order['fee'] is None
|
|
|
|
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange._is_dry_limit_order_filled',
|
|
|
|
return_value=price_side != 'other')
|
2022-05-04 05:52:01 +00:00
|
|
|
|
2022-07-16 15:03:45 +00:00
|
|
|
order1 = exchange.fetch_dry_run_order(order['id'])
|
|
|
|
assert order1['fee']['rate'] == fee
|
2022-05-04 05:52:01 +00:00
|
|
|
|
|
|
|
|
2022-11-23 17:17:10 +00:00
|
|
|
@pytest.mark.parametrize("side,price,filled", [
|
|
|
|
# order_book_l2_usd spread:
|
|
|
|
# best ask: 25.566
|
|
|
|
# best bid: 25.563
|
|
|
|
("buy", 25.563, False),
|
|
|
|
("buy", 25.566, True),
|
|
|
|
("sell", 25.566, False),
|
|
|
|
("sell", 25.563, True),
|
2021-06-04 04:44:51 +00:00
|
|
|
])
|
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2022-11-23 17:17:10 +00:00
|
|
|
def test_create_dry_run_order_limit_fill(default_conf, mocker, side, price, filled,
|
2021-06-04 04:44:51 +00:00
|
|
|
exchange_name, order_book_l2_usd):
|
|
|
|
default_conf['dry_run'] = True
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
mocker.patch.multiple('freqtrade.exchange.Exchange',
|
|
|
|
exchange_has=MagicMock(return_value=True),
|
|
|
|
fetch_l2_order_book=order_book_l2_usd,
|
|
|
|
)
|
|
|
|
|
|
|
|
order = exchange.create_dry_run_order(
|
2021-09-19 23:02:09 +00:00
|
|
|
pair='LTC/USDT',
|
|
|
|
ordertype='limit',
|
|
|
|
side=side,
|
|
|
|
amount=1,
|
2022-11-23 17:17:10 +00:00
|
|
|
rate=price,
|
2021-09-19 23:02:09 +00:00
|
|
|
leverage=1.0
|
|
|
|
)
|
2021-06-05 13:22:52 +00:00
|
|
|
assert order_book_l2_usd.call_count == 1
|
2021-06-04 04:44:51 +00:00
|
|
|
assert 'id' in order
|
|
|
|
assert f'dry_run_{side}_' in order["id"]
|
|
|
|
assert order["side"] == side
|
|
|
|
assert order["type"] == "limit"
|
|
|
|
assert order["symbol"] == "LTC/USDT"
|
2022-11-23 17:17:10 +00:00
|
|
|
assert order["average"] == price
|
|
|
|
assert order['status'] == 'open' if not filled else 'closed'
|
2021-06-05 13:22:52 +00:00
|
|
|
order_book_l2_usd.reset_mock()
|
2021-06-04 04:44:51 +00:00
|
|
|
|
2022-11-23 17:17:10 +00:00
|
|
|
# fetch order again...
|
2021-06-04 04:44:51 +00:00
|
|
|
order_closed = exchange.fetch_dry_run_order(order['id'])
|
2022-11-23 17:17:10 +00:00
|
|
|
assert order_book_l2_usd.call_count == (1 if not filled else 0)
|
|
|
|
assert order_closed['status'] == ('open' if not filled else 'closed')
|
|
|
|
assert order_closed['filled'] == (0 if not filled else 1)
|
2021-06-04 04:44:51 +00:00
|
|
|
|
|
|
|
order_book_l2_usd.reset_mock()
|
|
|
|
|
2021-12-02 18:17:00 +00:00
|
|
|
# Empty orderbook test
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_l2_order_book',
|
|
|
|
return_value={'asks': [], 'bids': []})
|
|
|
|
exchange._dry_run_open_orders[order['id']]['status'] = 'open'
|
|
|
|
order_closed = exchange.fetch_dry_run_order(order['id'])
|
|
|
|
|
2021-06-04 04:44:51 +00:00
|
|
|
|
2021-08-11 10:11:29 +00:00
|
|
|
@pytest.mark.parametrize("side,rate,amount,endprice", [
|
|
|
|
# spread is 25.263-25.266
|
|
|
|
("buy", 25.564, 1, 25.566),
|
|
|
|
("buy", 25.564, 100, 25.5672), # Requires interpolation
|
|
|
|
("buy", 25.590, 100, 25.5672), # Price above spread ... average is lower
|
|
|
|
("buy", 25.564, 1000, 25.575), # More than orderbook return
|
|
|
|
("buy", 24.000, 100000, 25.200), # Run into max_slippage of 5%
|
|
|
|
("sell", 25.564, 1, 25.563),
|
|
|
|
("sell", 25.564, 100, 25.5625), # Requires interpolation
|
|
|
|
("sell", 25.510, 100, 25.5625), # price below spread - average is higher
|
|
|
|
("sell", 25.564, 1000, 25.5555), # More than orderbook return
|
|
|
|
("sell", 27, 10000, 25.65), # max-slippage 5%
|
2021-06-04 04:44:51 +00:00
|
|
|
])
|
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2021-08-11 10:11:29 +00:00
|
|
|
def test_create_dry_run_order_market_fill(default_conf, mocker, side, rate, amount, endprice,
|
2021-06-04 04:44:51 +00:00
|
|
|
exchange_name, order_book_l2_usd):
|
|
|
|
default_conf['dry_run'] = True
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
mocker.patch.multiple('freqtrade.exchange.Exchange',
|
|
|
|
exchange_has=MagicMock(return_value=True),
|
|
|
|
fetch_l2_order_book=order_book_l2_usd,
|
|
|
|
)
|
|
|
|
|
|
|
|
order = exchange.create_dry_run_order(
|
2021-09-19 23:02:09 +00:00
|
|
|
pair='LTC/USDT',
|
|
|
|
ordertype='market',
|
|
|
|
side=side,
|
|
|
|
amount=amount,
|
|
|
|
rate=rate,
|
|
|
|
leverage=1.0
|
|
|
|
)
|
2021-06-04 04:44:51 +00:00
|
|
|
assert 'id' in order
|
|
|
|
assert f'dry_run_{side}_' in order["id"]
|
|
|
|
assert order["side"] == side
|
|
|
|
assert order["type"] == "market"
|
|
|
|
assert order["symbol"] == "LTC/USDT"
|
|
|
|
assert order['status'] == 'closed'
|
2022-01-15 14:23:08 +00:00
|
|
|
assert order['filled'] == amount
|
2021-06-04 04:44:51 +00:00
|
|
|
assert round(order["average"], 4) == round(endprice, 4)
|
|
|
|
|
|
|
|
|
2021-09-19 23:02:09 +00:00
|
|
|
@pytest.mark.parametrize("side", ["buy", "sell"])
|
2019-07-14 12:23:23 +00:00
|
|
|
@pytest.mark.parametrize("ordertype,rate,marketprice", [
|
|
|
|
("market", None, None),
|
|
|
|
("market", 200, True),
|
|
|
|
("limit", 200, None),
|
|
|
|
("stop_loss_limit", 200, None)
|
2019-02-22 00:48:35 +00:00
|
|
|
])
|
2019-02-24 19:08:27 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2019-07-14 12:23:23 +00:00
|
|
|
def test_create_order(default_conf, mocker, side, ordertype, rate, marketprice, exchange_name):
|
2019-02-22 00:48:35 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
order_id = 'test_prod_{}_{}'.format(side, randint(0, 10 ** 6))
|
2019-07-14 12:23:23 +00:00
|
|
|
api_mock.options = {} if not marketprice else {"createMarketBuyOrderRequiresPrice": True}
|
2019-02-22 00:48:35 +00:00
|
|
|
api_mock.create_order = MagicMock(return_value={
|
|
|
|
'id': order_id,
|
|
|
|
'info': {
|
|
|
|
'foo': 'bar'
|
2021-12-21 21:45:16 +00:00
|
|
|
},
|
|
|
|
'symbol': 'XLTCUSDT',
|
|
|
|
'amount': 1
|
2019-02-22 00:48:35 +00:00
|
|
|
})
|
|
|
|
default_conf['dry_run'] = False
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2020-01-12 13:55:05 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.amount_to_precision', lambda s, x, y: y)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-09-19 23:02:09 +00:00
|
|
|
exchange._set_leverage = MagicMock()
|
|
|
|
exchange.set_margin_mode = MagicMock()
|
2019-02-22 00:48:35 +00:00
|
|
|
|
|
|
|
order = exchange.create_order(
|
2021-12-21 21:45:16 +00:00
|
|
|
pair='XLTCUSDT',
|
2021-09-19 23:02:09 +00:00
|
|
|
ordertype=ordertype,
|
|
|
|
side=side,
|
|
|
|
amount=1,
|
2022-03-30 05:09:41 +00:00
|
|
|
rate=rate,
|
2021-09-19 23:02:09 +00:00
|
|
|
leverage=1.0
|
|
|
|
)
|
2019-02-22 00:48:35 +00:00
|
|
|
|
|
|
|
assert 'id' in order
|
|
|
|
assert 'info' in order
|
|
|
|
assert order['id'] == order_id
|
2021-12-21 21:45:16 +00:00
|
|
|
assert order['amount'] == 1
|
|
|
|
assert api_mock.create_order.call_args[0][0] == 'XLTCUSDT'
|
2019-02-22 00:48:35 +00:00
|
|
|
assert api_mock.create_order.call_args[0][1] == ordertype
|
|
|
|
assert api_mock.create_order.call_args[0][2] == side
|
|
|
|
assert api_mock.create_order.call_args[0][3] == 1
|
|
|
|
assert api_mock.create_order.call_args[0][4] is rate
|
2021-09-19 23:02:09 +00:00
|
|
|
assert exchange._set_leverage.call_count == 0
|
|
|
|
assert exchange.set_margin_mode.call_count == 0
|
|
|
|
|
2022-02-13 03:59:26 +00:00
|
|
|
api_mock.create_order = MagicMock(return_value={
|
|
|
|
'id': order_id,
|
|
|
|
'info': {
|
|
|
|
'foo': 'bar'
|
|
|
|
},
|
|
|
|
'symbol': 'ADA/USDT:USDT',
|
|
|
|
'amount': 1
|
|
|
|
})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-09-19 23:02:09 +00:00
|
|
|
exchange.trading_mode = TradingMode.FUTURES
|
2022-02-13 03:59:26 +00:00
|
|
|
exchange._set_leverage = MagicMock()
|
|
|
|
exchange.set_margin_mode = MagicMock()
|
2021-09-19 23:02:09 +00:00
|
|
|
order = exchange.create_order(
|
2022-02-13 03:59:26 +00:00
|
|
|
pair='ADA/USDT:USDT',
|
2021-09-19 23:02:09 +00:00
|
|
|
ordertype=ordertype,
|
|
|
|
side=side,
|
|
|
|
amount=1,
|
|
|
|
rate=200,
|
|
|
|
leverage=3.0
|
|
|
|
)
|
|
|
|
|
|
|
|
assert exchange._set_leverage.call_count == 1
|
|
|
|
assert exchange.set_margin_mode.call_count == 1
|
2021-12-21 21:45:16 +00:00
|
|
|
assert order['amount'] == 0.01
|
2019-02-22 00:48:35 +00:00
|
|
|
|
|
|
|
|
2017-12-30 07:12:52 +00:00
|
|
|
def test_buy_dry_run(default_conf, mocker):
|
|
|
|
default_conf['dry_run'] = True
|
2018-06-17 18:13:39 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2021-07-25 01:30:34 +00:00
|
|
|
order = exchange.create_order(pair='ETH/BTC', ordertype='limit', side="buy",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force='gtc')
|
2018-04-06 07:57:08 +00:00
|
|
|
assert 'id' in order
|
|
|
|
assert 'dry_run_buy_' in order['id']
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2018-04-12 16:13:35 +00:00
|
|
|
|
2019-02-24 19:08:27 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_buy_prod(default_conf, mocker, exchange_name):
|
2017-12-30 07:12:52 +00:00
|
|
|
api_mock = MagicMock()
|
2018-04-06 07:57:08 +00:00
|
|
|
order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
|
2018-11-17 12:29:42 +00:00
|
|
|
order_type = 'market'
|
2018-12-09 15:22:21 +00:00
|
|
|
time_in_force = 'gtc'
|
2019-07-14 12:18:30 +00:00
|
|
|
api_mock.options = {}
|
2018-11-15 05:58:24 +00:00
|
|
|
api_mock.create_order = MagicMock(return_value={
|
2018-04-06 07:57:08 +00:00
|
|
|
'id': order_id,
|
2021-12-25 13:38:17 +00:00
|
|
|
'symbol': 'ETH/BTC',
|
2018-04-06 07:57:08 +00:00
|
|
|
'info': {
|
|
|
|
'foo': 'bar'
|
|
|
|
}
|
|
|
|
})
|
2017-12-30 07:12:52 +00:00
|
|
|
default_conf['dry_run'] = False
|
2020-01-12 13:55:05 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.amount_to_precision', lambda s, x, y: y)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2021-07-25 01:30:34 +00:00
|
|
|
order = exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="buy",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force=time_in_force)
|
2018-12-09 15:22:21 +00:00
|
|
|
|
2018-04-06 07:57:08 +00:00
|
|
|
assert 'id' in order
|
|
|
|
assert 'info' in order
|
|
|
|
assert order['id'] == order_id
|
2018-11-17 19:09:05 +00:00
|
|
|
assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
|
2018-11-17 12:29:42 +00:00
|
|
|
assert api_mock.create_order.call_args[0][1] == order_type
|
2018-11-17 19:09:05 +00:00
|
|
|
assert api_mock.create_order.call_args[0][2] == 'buy'
|
|
|
|
assert api_mock.create_order.call_args[0][3] == 1
|
|
|
|
assert api_mock.create_order.call_args[0][4] is None
|
2018-11-17 12:34:23 +00:00
|
|
|
|
2018-11-17 12:29:42 +00:00
|
|
|
api_mock.create_order.reset_mock()
|
2018-11-17 12:34:23 +00:00
|
|
|
order_type = 'limit'
|
2021-07-25 01:30:34 +00:00
|
|
|
order = exchange.create_order(
|
2018-12-09 15:22:21 +00:00
|
|
|
pair='ETH/BTC',
|
|
|
|
ordertype=order_type,
|
2021-07-25 01:30:34 +00:00
|
|
|
side="buy",
|
2018-12-09 15:22:21 +00:00
|
|
|
amount=1,
|
|
|
|
rate=200,
|
2022-02-02 19:15:42 +00:00
|
|
|
leverage=1.0,
|
|
|
|
time_in_force=time_in_force
|
|
|
|
)
|
2018-11-17 19:09:05 +00:00
|
|
|
assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
|
2018-11-17 12:29:42 +00:00
|
|
|
assert api_mock.create_order.call_args[0][1] == order_type
|
2018-11-17 19:09:05 +00:00
|
|
|
assert api_mock.create_order.call_args[0][2] == 'buy'
|
|
|
|
assert api_mock.create_order.call_args[0][3] == 1
|
|
|
|
assert api_mock.create_order.call_args[0][4] == 200
|
2018-04-06 07:57:08 +00:00
|
|
|
|
|
|
|
# test exception handling
|
|
|
|
with pytest.raises(DependencyException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds("Not enough funds"))
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-07-25 01:30:34 +00:00
|
|
|
exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="buy",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force=time_in_force)
|
2018-04-06 07:57:08 +00:00
|
|
|
|
|
|
|
with pytest.raises(DependencyException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-07-25 01:30:34 +00:00
|
|
|
exchange.create_order(pair='ETH/BTC', ordertype='limit', side="buy",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force=time_in_force)
|
2019-08-18 13:48:20 +00:00
|
|
|
|
|
|
|
with pytest.raises(DependencyException):
|
|
|
|
api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-07-25 01:30:34 +00:00
|
|
|
exchange.create_order(pair='ETH/BTC', ordertype='market', side="buy",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force=time_in_force)
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2018-04-21 20:37:27 +00:00
|
|
|
with pytest.raises(TemporaryError):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError("Network disconnect"))
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-07-25 01:30:34 +00:00
|
|
|
exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="buy",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force=time_in_force)
|
2018-04-06 07:57:08 +00:00
|
|
|
|
|
|
|
with pytest.raises(OperationalException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.create_order = MagicMock(side_effect=ccxt.BaseError("Unknown error"))
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-07-25 01:30:34 +00:00
|
|
|
exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="buy",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force=time_in_force)
|
2017-12-30 07:12:52 +00:00
|
|
|
|
|
|
|
|
2019-03-11 19:30:16 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_buy_considers_time_in_force(default_conf, mocker, exchange_name):
|
2018-12-10 18:09:20 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
|
2019-07-14 12:18:30 +00:00
|
|
|
api_mock.options = {}
|
2018-12-10 18:09:20 +00:00
|
|
|
api_mock.create_order = MagicMock(return_value={
|
|
|
|
'id': order_id,
|
2021-12-25 13:38:17 +00:00
|
|
|
'symbol': 'ETH/BTC',
|
2018-12-10 18:09:20 +00:00
|
|
|
'info': {
|
|
|
|
'foo': 'bar'
|
|
|
|
}
|
|
|
|
})
|
|
|
|
default_conf['dry_run'] = False
|
2020-01-12 13:55:05 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.amount_to_precision', lambda s, x, y: y)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
|
2019-03-11 19:30:16 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-12-10 18:09:20 +00:00
|
|
|
|
2019-03-11 19:20:30 +00:00
|
|
|
order_type = 'limit'
|
|
|
|
time_in_force = 'ioc'
|
|
|
|
|
2021-07-25 01:30:34 +00:00
|
|
|
order = exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="buy",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force=time_in_force)
|
2018-12-10 18:09:20 +00:00
|
|
|
|
|
|
|
assert 'id' in order
|
|
|
|
assert 'info' in order
|
|
|
|
assert order['id'] == order_id
|
|
|
|
assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
|
|
|
|
assert api_mock.create_order.call_args[0][1] == order_type
|
|
|
|
assert api_mock.create_order.call_args[0][2] == 'buy'
|
|
|
|
assert api_mock.create_order.call_args[0][3] == 1
|
2019-03-11 19:20:30 +00:00
|
|
|
assert api_mock.create_order.call_args[0][4] == 200
|
2019-03-11 19:30:16 +00:00
|
|
|
assert "timeInForce" in api_mock.create_order.call_args[0][5]
|
2022-08-27 08:24:56 +00:00
|
|
|
assert api_mock.create_order.call_args[0][5]["timeInForce"] == time_in_force.upper()
|
2018-12-10 18:09:20 +00:00
|
|
|
|
2019-03-11 19:20:30 +00:00
|
|
|
order_type = 'market'
|
|
|
|
time_in_force = 'ioc'
|
|
|
|
|
2021-07-25 01:30:34 +00:00
|
|
|
order = exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="buy",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force=time_in_force)
|
2019-03-11 19:20:30 +00:00
|
|
|
|
|
|
|
assert 'id' in order
|
|
|
|
assert 'info' in order
|
|
|
|
assert order['id'] == order_id
|
|
|
|
assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
|
|
|
|
assert api_mock.create_order.call_args[0][1] == order_type
|
|
|
|
assert api_mock.create_order.call_args[0][2] == 'buy'
|
|
|
|
assert api_mock.create_order.call_args[0][3] == 1
|
|
|
|
assert api_mock.create_order.call_args[0][4] is None
|
2019-03-11 19:30:16 +00:00
|
|
|
# Market orders should not send timeInForce!!
|
|
|
|
assert "timeInForce" not in api_mock.create_order.call_args[0][5]
|
2019-03-11 19:20:30 +00:00
|
|
|
|
2018-12-10 18:09:20 +00:00
|
|
|
|
2017-12-30 07:12:52 +00:00
|
|
|
def test_sell_dry_run(default_conf, mocker):
|
|
|
|
default_conf['dry_run'] = True
|
2018-06-17 18:13:39 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2021-07-25 01:30:34 +00:00
|
|
|
order = exchange.create_order(pair='ETH/BTC', ordertype='limit',
|
2022-02-02 19:15:42 +00:00
|
|
|
side="sell", amount=1, rate=200, leverage=1.0)
|
2018-04-06 07:57:08 +00:00
|
|
|
assert 'id' in order
|
|
|
|
assert 'dry_run_sell_' in order['id']
|
2017-12-30 07:12:52 +00:00
|
|
|
|
|
|
|
|
2019-02-24 19:08:27 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_sell_prod(default_conf, mocker, exchange_name):
|
2017-12-30 07:12:52 +00:00
|
|
|
api_mock = MagicMock()
|
2018-04-06 07:57:08 +00:00
|
|
|
order_id = 'test_prod_sell_{}'.format(randint(0, 10 ** 6))
|
2018-11-17 12:29:42 +00:00
|
|
|
order_type = 'market'
|
2019-07-14 12:18:30 +00:00
|
|
|
api_mock.options = {}
|
2018-11-15 05:58:24 +00:00
|
|
|
api_mock.create_order = MagicMock(return_value={
|
2018-04-06 07:57:08 +00:00
|
|
|
'id': order_id,
|
2021-12-25 13:38:17 +00:00
|
|
|
'symbol': 'ETH/BTC',
|
2018-04-06 07:57:08 +00:00
|
|
|
'info': {
|
|
|
|
'foo': 'bar'
|
|
|
|
}
|
|
|
|
})
|
2017-12-30 07:12:52 +00:00
|
|
|
default_conf['dry_run'] = False
|
|
|
|
|
2020-01-12 13:55:05 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.amount_to_precision', lambda s, x, y: y)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-06-17 18:13:39 +00:00
|
|
|
|
2021-07-25 01:30:34 +00:00
|
|
|
order = exchange.create_order(pair='ETH/BTC', ordertype=order_type,
|
2022-02-02 19:15:42 +00:00
|
|
|
side="sell", amount=1, rate=200, leverage=1.0)
|
2019-02-19 20:56:20 +00:00
|
|
|
|
2018-04-06 07:57:08 +00:00
|
|
|
assert 'id' in order
|
|
|
|
assert 'info' in order
|
|
|
|
assert order['id'] == order_id
|
2018-11-17 19:09:05 +00:00
|
|
|
assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
|
2018-11-17 12:29:42 +00:00
|
|
|
assert api_mock.create_order.call_args[0][1] == order_type
|
2018-11-17 19:09:05 +00:00
|
|
|
assert api_mock.create_order.call_args[0][2] == 'sell'
|
|
|
|
assert api_mock.create_order.call_args[0][3] == 1
|
|
|
|
assert api_mock.create_order.call_args[0][4] is None
|
2018-11-17 12:29:42 +00:00
|
|
|
|
|
|
|
api_mock.create_order.reset_mock()
|
2018-11-17 12:34:23 +00:00
|
|
|
order_type = 'limit'
|
2021-07-25 01:30:34 +00:00
|
|
|
order = exchange.create_order(pair='ETH/BTC', ordertype=order_type,
|
2022-02-02 19:15:42 +00:00
|
|
|
side="sell", amount=1, rate=200,
|
|
|
|
leverage=1.0)
|
2018-11-17 19:09:05 +00:00
|
|
|
assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
|
2018-11-17 12:29:42 +00:00
|
|
|
assert api_mock.create_order.call_args[0][1] == order_type
|
2018-11-17 19:09:05 +00:00
|
|
|
assert api_mock.create_order.call_args[0][2] == 'sell'
|
|
|
|
assert api_mock.create_order.call_args[0][3] == 1
|
|
|
|
assert api_mock.create_order.call_args[0][4] == 200
|
2018-04-06 07:57:08 +00:00
|
|
|
|
|
|
|
# test exception handling
|
|
|
|
with pytest.raises(DependencyException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.create_order = MagicMock(side_effect=ccxt.InsufficientFunds("0 balance"))
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2022-02-02 19:15:42 +00:00
|
|
|
exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="sell", amount=1, rate=200,
|
|
|
|
leverage=1.0)
|
2018-04-06 07:57:08 +00:00
|
|
|
|
|
|
|
with pytest.raises(DependencyException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2022-02-02 19:15:42 +00:00
|
|
|
exchange.create_order(pair='ETH/BTC', ordertype='limit', side="sell", amount=1, rate=200,
|
|
|
|
leverage=1.0)
|
2019-08-18 13:45:30 +00:00
|
|
|
|
|
|
|
# Market orders don't require price, so the behaviour is slightly different
|
|
|
|
with pytest.raises(DependencyException):
|
|
|
|
api_mock.create_order = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2022-02-02 19:15:42 +00:00
|
|
|
exchange.create_order(pair='ETH/BTC', ordertype='market', side="sell", amount=1, rate=200,
|
|
|
|
leverage=1.0)
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2018-04-21 20:37:27 +00:00
|
|
|
with pytest.raises(TemporaryError):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.create_order = MagicMock(side_effect=ccxt.NetworkError("No Connection"))
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2022-02-02 19:15:42 +00:00
|
|
|
exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="sell", amount=1, rate=200,
|
|
|
|
leverage=1.0)
|
2018-04-06 07:57:08 +00:00
|
|
|
|
|
|
|
with pytest.raises(OperationalException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.create_order = MagicMock(side_effect=ccxt.BaseError("DeadBeef"))
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2022-02-02 19:15:42 +00:00
|
|
|
exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="sell", amount=1, rate=200,
|
|
|
|
leverage=1.0)
|
2017-12-30 07:12:52 +00:00
|
|
|
|
|
|
|
|
2019-03-11 19:30:16 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_sell_considers_time_in_force(default_conf, mocker, exchange_name):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
order_id = 'test_prod_sell_{}'.format(randint(0, 10 ** 6))
|
|
|
|
api_mock.create_order = MagicMock(return_value={
|
|
|
|
'id': order_id,
|
2021-12-25 13:38:17 +00:00
|
|
|
'symbol': 'ETH/BTC',
|
2019-03-11 19:30:16 +00:00
|
|
|
'info': {
|
|
|
|
'foo': 'bar'
|
|
|
|
}
|
|
|
|
})
|
2019-07-14 12:18:30 +00:00
|
|
|
api_mock.options = {}
|
2019-03-11 19:30:16 +00:00
|
|
|
default_conf['dry_run'] = False
|
2020-01-12 13:55:05 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.amount_to_precision', lambda s, x, y: y)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
|
2019-03-11 19:30:16 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
|
|
|
|
order_type = 'limit'
|
|
|
|
time_in_force = 'ioc'
|
|
|
|
|
2021-07-25 01:30:34 +00:00
|
|
|
order = exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="sell",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force=time_in_force)
|
2019-03-11 19:30:16 +00:00
|
|
|
|
|
|
|
assert 'id' in order
|
|
|
|
assert 'info' in order
|
|
|
|
assert order['id'] == order_id
|
|
|
|
assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
|
|
|
|
assert api_mock.create_order.call_args[0][1] == order_type
|
|
|
|
assert api_mock.create_order.call_args[0][2] == 'sell'
|
|
|
|
assert api_mock.create_order.call_args[0][3] == 1
|
|
|
|
assert api_mock.create_order.call_args[0][4] == 200
|
|
|
|
assert "timeInForce" in api_mock.create_order.call_args[0][5]
|
2022-08-27 08:24:56 +00:00
|
|
|
assert api_mock.create_order.call_args[0][5]["timeInForce"] == time_in_force.upper()
|
2019-03-11 19:30:16 +00:00
|
|
|
|
|
|
|
order_type = 'market'
|
2022-08-27 08:24:56 +00:00
|
|
|
time_in_force = 'IOC'
|
2021-07-25 01:30:34 +00:00
|
|
|
order = exchange.create_order(pair='ETH/BTC', ordertype=order_type, side="sell",
|
2022-02-02 19:15:42 +00:00
|
|
|
amount=1, rate=200, leverage=1.0,
|
|
|
|
time_in_force=time_in_force)
|
2019-03-11 19:30:16 +00:00
|
|
|
|
|
|
|
assert 'id' in order
|
|
|
|
assert 'info' in order
|
|
|
|
assert order['id'] == order_id
|
|
|
|
assert api_mock.create_order.call_args[0][0] == 'ETH/BTC'
|
|
|
|
assert api_mock.create_order.call_args[0][1] == order_type
|
|
|
|
assert api_mock.create_order.call_args[0][2] == 'sell'
|
|
|
|
assert api_mock.create_order.call_args[0][3] == 1
|
|
|
|
assert api_mock.create_order.call_args[0][4] is None
|
|
|
|
# Market orders should not send timeInForce!!
|
|
|
|
assert "timeInForce" not in api_mock.create_order.call_args[0][5]
|
|
|
|
|
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_get_balances_prod(default_conf, mocker, exchange_name):
|
2017-12-30 07:12:52 +00:00
|
|
|
balance_item = {
|
2018-04-06 07:57:08 +00:00
|
|
|
'free': 10.0,
|
|
|
|
'total': 10.0,
|
|
|
|
'used': 0.0
|
2017-12-30 07:12:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
api_mock = MagicMock()
|
2018-04-06 07:57:08 +00:00
|
|
|
api_mock.fetch_balance = MagicMock(return_value={
|
|
|
|
'1ST': balance_item,
|
|
|
|
'2ST': balance_item,
|
|
|
|
'3ST': balance_item
|
|
|
|
})
|
2017-12-30 07:12:52 +00:00
|
|
|
default_conf['dry_run'] = False
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-06-17 18:13:39 +00:00
|
|
|
assert len(exchange.get_balances()) == 3
|
|
|
|
assert exchange.get_balances()['1ST']['free'] == 10.0
|
|
|
|
assert exchange.get_balances()['1ST']['total'] == 10.0
|
|
|
|
assert exchange.get_balances()['1ST']['used'] == 0.0
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
2018-06-28 20:18:38 +00:00
|
|
|
"get_balances", "fetch_balance")
|
2017-12-30 07:12:52 +00:00
|
|
|
|
|
|
|
|
2022-02-23 18:27:40 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_fetch_positions(default_conf, mocker, exchange_name):
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.validate_trading_mode_and_margin_mode')
|
|
|
|
api_mock = MagicMock()
|
|
|
|
api_mock.fetch_positions = MagicMock(return_value=[
|
|
|
|
{'symbol': 'ETH/USDT:USDT', 'leverage': 5},
|
|
|
|
{'symbol': 'XRP/USDT:USDT', 'leverage': 5},
|
|
|
|
])
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
assert exchange.fetch_positions() == []
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
default_conf['trading_mode'] = 'futures'
|
|
|
|
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
res = exchange.fetch_positions()
|
|
|
|
assert len(res) == 2
|
|
|
|
|
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
|
|
|
"fetch_positions", "fetch_positions")
|
|
|
|
|
|
|
|
|
2022-03-26 12:53:36 +00:00
|
|
|
def test_fetch_trading_fees(default_conf, mocker):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
tick = {
|
|
|
|
'1INCH/USDT:USDT': {
|
2022-03-26 14:12:05 +00:00
|
|
|
'info': {'user_id': '',
|
2022-03-26 12:53:36 +00:00
|
|
|
'taker_fee': '0.0018',
|
|
|
|
'maker_fee': '0.0018',
|
|
|
|
'gt_discount': False,
|
|
|
|
'gt_taker_fee': '0',
|
|
|
|
'gt_maker_fee': '0',
|
|
|
|
'loan_fee': '0.18',
|
|
|
|
'point_type': '1',
|
|
|
|
'futures_taker_fee': '0.0005',
|
|
|
|
'futures_maker_fee': '0'},
|
|
|
|
'symbol': '1INCH/USDT:USDT',
|
|
|
|
'maker': 0.0,
|
|
|
|
'taker': 0.0005},
|
|
|
|
'ETH/USDT:USDT': {
|
2022-03-26 14:12:05 +00:00
|
|
|
'info': {'user_id': '',
|
2022-03-26 12:53:36 +00:00
|
|
|
'taker_fee': '0.0018',
|
|
|
|
'maker_fee': '0.0018',
|
|
|
|
'gt_discount': False,
|
|
|
|
'gt_taker_fee': '0',
|
|
|
|
'gt_maker_fee': '0',
|
|
|
|
'loan_fee': '0.18',
|
|
|
|
'point_type': '1',
|
|
|
|
'futures_taker_fee': '0.0005',
|
|
|
|
'futures_maker_fee': '0'},
|
|
|
|
'symbol': 'ETH/USDT:USDT',
|
|
|
|
'maker': 0.0,
|
|
|
|
'taker': 0.0005}
|
|
|
|
}
|
|
|
|
exchange_name = 'gateio'
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
default_conf['trading_mode'] = TradingMode.FUTURES
|
|
|
|
default_conf['margin_mode'] = MarginMode.ISOLATED
|
|
|
|
api_mock.fetch_trading_fees = MagicMock(return_value=tick)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
|
2022-03-26 14:15:16 +00:00
|
|
|
assert '1INCH/USDT:USDT' in exchange._trading_fees
|
|
|
|
assert 'ETH/USDT:USDT' in exchange._trading_fees
|
2022-03-26 12:53:36 +00:00
|
|
|
assert api_mock.fetch_trading_fees.call_count == 1
|
|
|
|
|
|
|
|
api_mock.fetch_trading_fees.reset_mock()
|
|
|
|
|
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
|
|
|
"fetch_trading_fees", "fetch_trading_fees")
|
|
|
|
|
|
|
|
api_mock.fetch_trading_fees = MagicMock(return_value={})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
exchange.fetch_trading_fees()
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
|
|
|
|
assert exchange.fetch_trading_fees() == {}
|
|
|
|
|
|
|
|
|
2022-03-18 06:08:16 +00:00
|
|
|
def test_fetch_bids_asks(default_conf, mocker):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
tick = {'ETH/BTC': {
|
|
|
|
'symbol': 'ETH/BTC',
|
|
|
|
'bid': 0.5,
|
|
|
|
'ask': 1,
|
|
|
|
'last': 42,
|
|
|
|
}, 'BCH/BTC': {
|
|
|
|
'symbol': 'BCH/BTC',
|
|
|
|
'bid': 0.6,
|
|
|
|
'ask': 0.5,
|
|
|
|
'last': 41,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
exchange_name = 'binance'
|
|
|
|
api_mock.fetch_bids_asks = MagicMock(return_value=tick)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
# retrieve original ticker
|
|
|
|
bidsasks = exchange.fetch_bids_asks()
|
|
|
|
|
|
|
|
assert 'ETH/BTC' in bidsasks
|
|
|
|
assert 'BCH/BTC' in bidsasks
|
|
|
|
assert bidsasks['ETH/BTC']['bid'] == 0.5
|
|
|
|
assert bidsasks['ETH/BTC']['ask'] == 1
|
|
|
|
assert bidsasks['BCH/BTC']['bid'] == 0.6
|
|
|
|
assert bidsasks['BCH/BTC']['ask'] == 0.5
|
|
|
|
assert api_mock.fetch_bids_asks.call_count == 1
|
|
|
|
|
|
|
|
api_mock.fetch_bids_asks.reset_mock()
|
|
|
|
|
|
|
|
# Cached ticker should not call api again
|
|
|
|
tickers2 = exchange.fetch_bids_asks(cached=True)
|
|
|
|
assert tickers2 == bidsasks
|
|
|
|
assert api_mock.fetch_bids_asks.call_count == 0
|
|
|
|
tickers2 = exchange.fetch_bids_asks(cached=False)
|
|
|
|
assert api_mock.fetch_bids_asks.call_count == 1
|
|
|
|
|
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
|
|
|
"fetch_bids_asks", "fetch_bids_asks")
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException):
|
|
|
|
api_mock.fetch_bids_asks = MagicMock(side_effect=ccxt.NotSupported("DeadBeef"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
exchange.fetch_bids_asks()
|
|
|
|
|
|
|
|
api_mock.fetch_bids_asks = MagicMock(return_value={})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
exchange.fetch_bids_asks()
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
|
|
|
|
assert exchange.fetch_bids_asks() == {}
|
|
|
|
|
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_get_tickers(default_conf, mocker, exchange_name):
|
2018-06-17 21:30:48 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
tick = {'ETH/BTC': {
|
2019-10-17 20:40:29 +00:00
|
|
|
'symbol': 'ETH/BTC',
|
|
|
|
'bid': 0.5,
|
|
|
|
'ask': 1,
|
|
|
|
'last': 42,
|
|
|
|
}, 'BCH/BTC': {
|
|
|
|
'symbol': 'BCH/BTC',
|
|
|
|
'bid': 0.6,
|
|
|
|
'ask': 0.5,
|
|
|
|
'last': 41,
|
|
|
|
}
|
|
|
|
}
|
2022-10-13 04:58:02 +00:00
|
|
|
mocker.patch('freqtrade.exchange.exchange.Exchange.exchange_has', return_value=True)
|
2018-06-17 21:30:48 +00:00
|
|
|
api_mock.fetch_tickers = MagicMock(return_value=tick)
|
2022-03-18 06:08:16 +00:00
|
|
|
api_mock.fetch_bids_asks = MagicMock(return_value={})
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-06-17 21:30:48 +00:00
|
|
|
# retrieve original ticker
|
|
|
|
tickers = exchange.get_tickers()
|
|
|
|
|
|
|
|
assert 'ETH/BTC' in tickers
|
|
|
|
assert 'BCH/BTC' in tickers
|
|
|
|
assert tickers['ETH/BTC']['bid'] == 0.5
|
|
|
|
assert tickers['ETH/BTC']['ask'] == 1
|
|
|
|
assert tickers['BCH/BTC']['bid'] == 0.6
|
|
|
|
assert tickers['BCH/BTC']['ask'] == 0.5
|
2021-04-13 18:09:22 +00:00
|
|
|
assert api_mock.fetch_tickers.call_count == 1
|
2022-03-18 06:08:16 +00:00
|
|
|
assert api_mock.fetch_bids_asks.call_count == 0
|
2021-04-13 18:09:22 +00:00
|
|
|
|
|
|
|
api_mock.fetch_tickers.reset_mock()
|
|
|
|
|
|
|
|
# Cached ticker should not call api again
|
|
|
|
tickers2 = exchange.get_tickers(cached=True)
|
|
|
|
assert tickers2 == tickers
|
|
|
|
assert api_mock.fetch_tickers.call_count == 0
|
2022-03-18 06:08:16 +00:00
|
|
|
assert api_mock.fetch_bids_asks.call_count == 0
|
2021-04-13 19:54:06 +00:00
|
|
|
tickers2 = exchange.get_tickers(cached=False)
|
|
|
|
assert api_mock.fetch_tickers.call_count == 1
|
2022-03-18 06:08:16 +00:00
|
|
|
assert api_mock.fetch_bids_asks.call_count == 0
|
2018-06-17 21:30:48 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
2018-06-28 20:18:38 +00:00
|
|
|
"get_tickers", "fetch_tickers")
|
2018-06-17 21:30:48 +00:00
|
|
|
|
2018-06-18 17:46:42 +00:00
|
|
|
with pytest.raises(OperationalException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.fetch_tickers = MagicMock(side_effect=ccxt.NotSupported("DeadBeef"))
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-06-18 17:46:42 +00:00
|
|
|
exchange.get_tickers()
|
|
|
|
|
2018-06-17 21:30:48 +00:00
|
|
|
api_mock.fetch_tickers = MagicMock(return_value={})
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-06-17 21:30:48 +00:00
|
|
|
exchange.get_tickers()
|
|
|
|
|
2022-03-18 06:08:16 +00:00
|
|
|
api_mock.fetch_tickers.reset_mock()
|
|
|
|
api_mock.fetch_bids_asks.reset_mock()
|
|
|
|
default_conf['trading_mode'] = TradingMode.FUTURES
|
|
|
|
default_conf['margin_mode'] = MarginMode.ISOLATED
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
|
|
|
|
exchange.get_tickers()
|
|
|
|
assert api_mock.fetch_tickers.call_count == 1
|
|
|
|
assert api_mock.fetch_bids_asks.call_count == (1 if exchange_name == 'binance' else 0)
|
|
|
|
|
2022-10-13 04:58:02 +00:00
|
|
|
api_mock.fetch_tickers.reset_mock()
|
|
|
|
api_mock.fetch_bids_asks.reset_mock()
|
|
|
|
mocker.patch('freqtrade.exchange.exchange.Exchange.exchange_has', return_value=False)
|
|
|
|
assert exchange.get_tickers() == {}
|
|
|
|
|
2018-06-17 21:30:48 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2019-12-18 15:34:30 +00:00
|
|
|
def test_fetch_ticker(default_conf, mocker, exchange_name):
|
2017-12-30 07:12:52 +00:00
|
|
|
api_mock = MagicMock()
|
2018-04-06 07:57:08 +00:00
|
|
|
tick = {
|
|
|
|
'symbol': 'ETH/BTC',
|
|
|
|
'bid': 0.00001098,
|
|
|
|
'ask': 0.00001099,
|
|
|
|
'last': 0.0001,
|
|
|
|
}
|
|
|
|
api_mock.fetch_ticker = MagicMock(return_value=tick)
|
2019-07-03 18:07:26 +00:00
|
|
|
api_mock.markets = {'ETH/BTC': {'active': True}}
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-01-07 20:26:43 +00:00
|
|
|
# retrieve original ticker
|
2019-12-18 15:34:30 +00:00
|
|
|
ticker = exchange.fetch_ticker(pair='ETH/BTC')
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2017-12-30 07:12:52 +00:00
|
|
|
assert ticker['bid'] == 0.00001098
|
|
|
|
assert ticker['ask'] == 0.00001099
|
2018-01-03 16:58:08 +00:00
|
|
|
|
2018-01-07 20:24:17 +00:00
|
|
|
# change the ticker
|
2018-04-06 07:57:08 +00:00
|
|
|
tick = {
|
|
|
|
'symbol': 'ETH/BTC',
|
|
|
|
'bid': 0.5,
|
|
|
|
'ask': 1,
|
|
|
|
'last': 42,
|
|
|
|
}
|
|
|
|
api_mock.fetch_ticker = MagicMock(return_value=tick)
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-01-07 20:24:17 +00:00
|
|
|
|
2018-01-03 16:58:08 +00:00
|
|
|
# if not caching the result we should get the same ticker
|
2018-01-10 06:41:37 +00:00
|
|
|
# if not fetching a new result we should get the cached ticker
|
2019-12-18 15:34:30 +00:00
|
|
|
ticker = exchange.fetch_ticker(pair='ETH/BTC')
|
2018-01-03 16:58:08 +00:00
|
|
|
|
2018-06-06 18:24:47 +00:00
|
|
|
assert api_mock.fetch_ticker.call_count == 1
|
2018-01-07 20:24:17 +00:00
|
|
|
assert ticker['bid'] == 0.5
|
2018-01-03 16:58:08 +00:00
|
|
|
assert ticker['ask'] == 1
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
2019-12-18 15:34:30 +00:00
|
|
|
"fetch_ticker", "fetch_ticker",
|
2020-02-22 10:03:25 +00:00
|
|
|
pair='ETH/BTC')
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2018-06-06 19:24:57 +00:00
|
|
|
api_mock.fetch_ticker = MagicMock(return_value={})
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2020-02-22 10:03:25 +00:00
|
|
|
exchange.fetch_ticker(pair='ETH/BTC')
|
2018-06-06 19:24:57 +00:00
|
|
|
|
2018-10-10 19:28:48 +00:00
|
|
|
with pytest.raises(DependencyException, match=r'Pair XRP/ETH not available'):
|
2020-02-22 10:03:25 +00:00
|
|
|
exchange.fetch_ticker(pair='XRP/ETH')
|
2018-10-10 19:28:48 +00:00
|
|
|
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2021-11-21 07:43:05 +00:00
|
|
|
@pytest.mark.parametrize('candle_type', ['mark', ''])
|
|
|
|
def test_get_historic_ohlcv(default_conf, mocker, caplog, exchange_name, candle_type):
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
2020-03-08 10:35:31 +00:00
|
|
|
ohlcv = [
|
2018-08-14 18:53:58 +00:00
|
|
|
[
|
2020-10-12 17:58:04 +00:00
|
|
|
arrow.utcnow().int_timestamp * 1000, # unix timestamp ms
|
2018-08-14 18:53:58 +00:00
|
|
|
1, # open
|
|
|
|
2, # high
|
|
|
|
3, # low
|
|
|
|
4, # close
|
|
|
|
5, # volume (in quote currency)
|
|
|
|
]
|
|
|
|
]
|
|
|
|
pair = 'ETH/BTC'
|
|
|
|
|
2021-12-04 14:13:06 +00:00
|
|
|
async def mock_candle_hist(pair, timeframe, candle_type, since_ms):
|
2021-11-21 07:43:05 +00:00
|
|
|
return pair, timeframe, candle_type, ohlcv
|
2018-08-14 18:53:58 +00:00
|
|
|
|
2018-08-29 17:56:38 +00:00
|
|
|
exchange._async_get_candle_history = Mock(wraps=mock_candle_hist)
|
2018-08-14 18:53:58 +00:00
|
|
|
# one_call calculation * 1.8 should do 2 calls
|
2020-03-25 14:50:33 +00:00
|
|
|
|
2022-05-14 11:27:36 +00:00
|
|
|
since = 5 * 60 * exchange.ohlcv_candle_limit('5m', CandleType.SPOT) * 1.8
|
2021-11-21 07:43:05 +00:00
|
|
|
ret = exchange.get_historic_ohlcv(
|
|
|
|
pair,
|
|
|
|
"5m",
|
|
|
|
int((arrow.utcnow().int_timestamp - since) * 1000),
|
|
|
|
candle_type=candle_type
|
|
|
|
)
|
2018-08-14 18:53:58 +00:00
|
|
|
|
|
|
|
assert exchange._async_get_candle_history.call_count == 2
|
2020-03-08 10:35:31 +00:00
|
|
|
# Returns twice the above OHLCV data
|
2018-08-14 18:53:58 +00:00
|
|
|
assert len(ret) == 2
|
2021-11-04 19:00:02 +00:00
|
|
|
assert log_has_re(r'Downloaded data for .* with length .*\.', caplog)
|
2018-08-14 18:53:58 +00:00
|
|
|
|
2020-10-23 05:45:11 +00:00
|
|
|
caplog.clear()
|
|
|
|
|
|
|
|
async def mock_get_candle_hist_error(pair, *args, **kwargs):
|
|
|
|
raise TimeoutError()
|
|
|
|
|
|
|
|
exchange._async_get_candle_history = MagicMock(side_effect=mock_get_candle_hist_error)
|
2021-11-21 07:43:05 +00:00
|
|
|
ret = exchange.get_historic_ohlcv(
|
|
|
|
pair,
|
|
|
|
"5m",
|
|
|
|
int((arrow.utcnow().int_timestamp - since) * 1000),
|
|
|
|
candle_type=candle_type
|
|
|
|
)
|
2020-10-23 05:45:11 +00:00
|
|
|
assert log_has_re(r"Async code raised an exception: .*", caplog)
|
|
|
|
|
2018-08-14 18:53:58 +00:00
|
|
|
|
2021-09-16 04:28:10 +00:00
|
|
|
@pytest.mark.asyncio
|
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2021-12-31 12:00:56 +00:00
|
|
|
@pytest.mark.parametrize('candle_type', [CandleType.MARK, CandleType.SPOT])
|
|
|
|
async def test__async_get_historic_ohlcv(default_conf, mocker, caplog, exchange_name, candle_type):
|
2021-09-16 04:28:10 +00:00
|
|
|
ohlcv = [
|
|
|
|
[
|
|
|
|
int((datetime.now(timezone.utc).timestamp() - 1000) * 1000),
|
|
|
|
1, # open
|
|
|
|
2, # high
|
|
|
|
3, # low
|
|
|
|
4, # close
|
|
|
|
5, # volume (in quote currency)
|
|
|
|
]
|
|
|
|
]
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
# Monkey-patch async function
|
|
|
|
exchange._api_async.fetch_ohlcv = get_mock_coro(ohlcv)
|
|
|
|
|
|
|
|
pair = 'ETH/USDT'
|
2021-11-21 07:43:05 +00:00
|
|
|
respair, restf, _, res = await exchange._async_get_historic_ohlcv(
|
2021-12-31 12:00:56 +00:00
|
|
|
pair, "5m", 1500000000000, candle_type=candle_type, is_new_pair=False)
|
2021-11-04 19:00:02 +00:00
|
|
|
assert respair == pair
|
|
|
|
assert restf == '5m'
|
2021-09-16 04:28:10 +00:00
|
|
|
# Call with very old timestamp - causes tons of requests
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count > 200
|
|
|
|
assert res[0] == ohlcv[0]
|
|
|
|
|
2022-04-30 15:24:57 +00:00
|
|
|
exchange._api_async.fetch_ohlcv.reset_mock()
|
|
|
|
end_ts = 1_500_500_000_000
|
|
|
|
start_ts = 1_500_000_000_000
|
|
|
|
respair, restf, _, res = await exchange._async_get_historic_ohlcv(
|
|
|
|
pair, "5m", since_ms=start_ts, candle_type=candle_type, is_new_pair=False,
|
|
|
|
until_ms=end_ts
|
|
|
|
)
|
|
|
|
# Required candles
|
|
|
|
candles = (end_ts - start_ts) / 300_000
|
2022-05-14 11:27:36 +00:00
|
|
|
exp = candles // exchange.ohlcv_candle_limit('5m', CandleType.SPOT) + 1
|
2022-04-30 15:24:57 +00:00
|
|
|
|
|
|
|
# Depending on the exchange, this should be called between 1 and 6 times.
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == exp
|
|
|
|
|
2021-09-16 04:28:10 +00:00
|
|
|
|
2022-01-28 14:52:12 +00:00
|
|
|
@pytest.mark.parametrize('candle_type', [CandleType.FUTURES, CandleType.MARK, CandleType.SPOT])
|
|
|
|
def test_refresh_latest_ohlcv(mocker, default_conf, caplog, candle_type) -> None:
|
2020-03-08 10:35:31 +00:00
|
|
|
ohlcv = [
|
2018-08-16 10:15:09 +00:00
|
|
|
[
|
2022-10-05 05:03:06 +00:00
|
|
|
(arrow.utcnow().shift(minutes=-5).int_timestamp) * 1000, # unix timestamp ms
|
2018-08-16 10:15:09 +00:00
|
|
|
1, # open
|
|
|
|
2, # high
|
|
|
|
3, # low
|
|
|
|
4, # close
|
|
|
|
5, # volume (in quote currency)
|
2018-12-11 18:48:36 +00:00
|
|
|
],
|
|
|
|
[
|
2020-10-12 17:58:04 +00:00
|
|
|
arrow.utcnow().int_timestamp * 1000, # unix timestamp ms
|
2018-12-11 18:48:36 +00:00
|
|
|
3, # open
|
|
|
|
1, # high
|
|
|
|
4, # low
|
|
|
|
6, # close
|
|
|
|
5, # volume (in quote currency)
|
2018-08-16 10:15:09 +00:00
|
|
|
]
|
|
|
|
]
|
|
|
|
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
2020-03-08 10:35:31 +00:00
|
|
|
exchange._api_async.fetch_ohlcv = get_mock_coro(ohlcv)
|
2018-08-16 10:15:09 +00:00
|
|
|
|
2022-01-28 14:52:12 +00:00
|
|
|
pairs = [('IOTA/ETH', '5m', candle_type), ('XRP/ETH', '5m', candle_type)]
|
2018-08-16 10:15:09 +00:00
|
|
|
# empty dicts
|
2018-12-11 18:48:36 +00:00
|
|
|
assert not exchange._klines
|
2021-08-17 04:41:13 +00:00
|
|
|
res = exchange.refresh_latest_ohlcv(pairs, cache=False)
|
2020-12-15 07:22:45 +00:00
|
|
|
# No caching
|
|
|
|
assert not exchange._klines
|
2021-08-17 04:41:13 +00:00
|
|
|
|
|
|
|
assert len(res) == len(pairs)
|
2020-12-15 07:22:45 +00:00
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 2
|
|
|
|
exchange._api_async.fetch_ohlcv.reset_mock()
|
|
|
|
|
2021-11-07 12:10:40 +00:00
|
|
|
exchange.required_candle_call_count = 2
|
2021-08-17 04:41:13 +00:00
|
|
|
res = exchange.refresh_latest_ohlcv(pairs)
|
|
|
|
assert len(res) == len(pairs)
|
2018-08-16 10:15:09 +00:00
|
|
|
|
2020-03-08 10:35:31 +00:00
|
|
|
assert log_has(f'Refreshing candle (OHLCV) data for {len(pairs)} pairs', caplog)
|
2018-12-11 18:48:36 +00:00
|
|
|
assert exchange._klines
|
2021-11-07 12:10:40 +00:00
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 4
|
|
|
|
exchange._api_async.fetch_ohlcv.reset_mock()
|
2018-08-16 10:15:09 +00:00
|
|
|
for pair in pairs:
|
2018-12-11 18:48:36 +00:00
|
|
|
assert isinstance(exchange.klines(pair), DataFrame)
|
|
|
|
assert len(exchange.klines(pair)) > 0
|
2018-08-16 10:15:09 +00:00
|
|
|
|
2018-12-22 18:03:42 +00:00
|
|
|
# klines function should return a different object on each call
|
|
|
|
# if copy is "True"
|
|
|
|
assert exchange.klines(pair) is not exchange.klines(pair)
|
|
|
|
assert exchange.klines(pair) is not exchange.klines(pair, copy=True)
|
|
|
|
assert exchange.klines(pair, copy=True) is not exchange.klines(pair, copy=True)
|
|
|
|
assert exchange.klines(pair, copy=False) is exchange.klines(pair, copy=False)
|
|
|
|
|
2018-12-10 19:22:21 +00:00
|
|
|
# test caching
|
2022-01-28 14:52:12 +00:00
|
|
|
res = exchange.refresh_latest_ohlcv(
|
|
|
|
[('IOTA/ETH', '5m', candle_type), ('XRP/ETH', '5m', candle_type)])
|
2021-08-17 04:41:13 +00:00
|
|
|
assert len(res) == len(pairs)
|
2018-12-10 19:22:21 +00:00
|
|
|
|
2021-11-07 12:10:40 +00:00
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 0
|
2022-01-28 14:52:12 +00:00
|
|
|
assert log_has(f"Using cached candle (OHLCV) data for {pairs[0][0]}, "
|
|
|
|
f"{pairs[0][1]}, {candle_type} ...",
|
2019-08-11 18:17:39 +00:00
|
|
|
caplog)
|
2022-10-05 05:08:40 +00:00
|
|
|
caplog.clear()
|
2022-10-06 04:41:56 +00:00
|
|
|
# Reset refresh times - must do 2 call per pair as cache is expired
|
2022-10-05 05:08:40 +00:00
|
|
|
exchange._pairs_last_refresh_time = {}
|
|
|
|
res = exchange.refresh_latest_ohlcv(
|
|
|
|
[('IOTA/ETH', '5m', candle_type), ('XRP/ETH', '5m', candle_type)])
|
|
|
|
assert len(res) == len(pairs)
|
|
|
|
|
2022-10-06 04:41:56 +00:00
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 4
|
2022-10-05 05:08:40 +00:00
|
|
|
|
|
|
|
# cache - but disabled caching
|
|
|
|
exchange._api_async.fetch_ohlcv.reset_mock()
|
|
|
|
exchange.required_candle_call_count = 1
|
|
|
|
|
2022-01-28 14:52:12 +00:00
|
|
|
pairlist = [
|
|
|
|
('IOTA/ETH', '5m', candle_type),
|
|
|
|
('XRP/ETH', '5m', candle_type),
|
|
|
|
('XRP/ETH', '1d', candle_type)]
|
|
|
|
res = exchange.refresh_latest_ohlcv(pairlist, cache=False)
|
2021-11-23 16:43:37 +00:00
|
|
|
assert len(res) == 3
|
2021-11-27 18:30:49 +00:00
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 3
|
|
|
|
|
|
|
|
# Test the same again, should NOT return from cache!
|
|
|
|
exchange._api_async.fetch_ohlcv.reset_mock()
|
2022-01-28 14:52:12 +00:00
|
|
|
res = exchange.refresh_latest_ohlcv(pairlist, cache=False)
|
2021-11-27 18:30:49 +00:00
|
|
|
assert len(res) == 3
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 3
|
2022-03-11 16:59:57 +00:00
|
|
|
exchange._api_async.fetch_ohlcv.reset_mock()
|
|
|
|
caplog.clear()
|
2022-10-05 05:03:06 +00:00
|
|
|
|
2022-03-11 16:59:57 +00:00
|
|
|
# Call with invalid timeframe
|
2022-03-13 14:38:12 +00:00
|
|
|
res = exchange.refresh_latest_ohlcv([('IOTA/ETH', '3m', candle_type)], cache=False)
|
2022-03-13 15:13:38 +00:00
|
|
|
if candle_type != CandleType.MARK:
|
|
|
|
assert not res
|
|
|
|
assert len(res) == 0
|
|
|
|
assert log_has_re(r'Cannot download \(IOTA\/ETH, 3m\).*', caplog)
|
|
|
|
else:
|
|
|
|
assert len(res) == 1
|
2018-08-16 10:15:09 +00:00
|
|
|
|
|
|
|
|
2022-10-05 17:39:28 +00:00
|
|
|
@pytest.mark.parametrize('candle_type', [CandleType.FUTURES, CandleType.MARK, CandleType.SPOT])
|
|
|
|
def test_refresh_latest_ohlcv_cache(mocker, default_conf, candle_type, time_machine) -> None:
|
|
|
|
start = datetime(2021, 8, 1, 0, 0, 0, 0, tzinfo=timezone.utc)
|
|
|
|
ohlcv = generate_test_data_raw('1h', 100, start.strftime('%Y-%m-%d'))
|
|
|
|
time_machine.move_to(start + timedelta(hours=99, minutes=30))
|
|
|
|
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
2022-10-19 09:57:05 +00:00
|
|
|
mocker.patch("freqtrade.exchange.Exchange.ohlcv_candle_limit", return_value=100)
|
|
|
|
assert exchange._startup_candle_count == 0
|
|
|
|
|
2022-10-05 17:39:28 +00:00
|
|
|
exchange._api_async.fetch_ohlcv = get_mock_coro(ohlcv)
|
|
|
|
pair1 = ('IOTA/ETH', '1h', candle_type)
|
|
|
|
pair2 = ('XRP/ETH', '1h', candle_type)
|
|
|
|
pairs = [pair1, pair2]
|
|
|
|
|
|
|
|
# No caching
|
|
|
|
assert not exchange._klines
|
|
|
|
res = exchange.refresh_latest_ohlcv(pairs, cache=False)
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 2
|
|
|
|
assert len(res) == 2
|
|
|
|
assert len(res[pair1]) == 99
|
|
|
|
assert len(res[pair2]) == 99
|
|
|
|
assert not exchange._klines
|
|
|
|
exchange._api_async.fetch_ohlcv.reset_mock()
|
|
|
|
|
|
|
|
# With caching
|
|
|
|
res = exchange.refresh_latest_ohlcv(pairs)
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 2
|
|
|
|
assert len(res) == 2
|
|
|
|
assert len(res[pair1]) == 99
|
|
|
|
assert len(res[pair2]) == 99
|
|
|
|
assert exchange._klines
|
|
|
|
assert exchange._pairs_last_refresh_time[pair1] == ohlcv[-1][0] // 1000
|
|
|
|
exchange._api_async.fetch_ohlcv.reset_mock()
|
|
|
|
|
|
|
|
# Returned from cache
|
|
|
|
res = exchange.refresh_latest_ohlcv(pairs)
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 0
|
|
|
|
assert len(res) == 2
|
|
|
|
assert len(res[pair1]) == 99
|
|
|
|
assert len(res[pair2]) == 99
|
|
|
|
assert exchange._pairs_last_refresh_time[pair1] == ohlcv[-1][0] // 1000
|
|
|
|
|
|
|
|
# Move time 1 candle further but result didn't change yet
|
|
|
|
time_machine.move_to(start + timedelta(hours=101))
|
|
|
|
res = exchange.refresh_latest_ohlcv(pairs)
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 2
|
|
|
|
assert len(res) == 2
|
|
|
|
assert len(res[pair1]) == 99
|
|
|
|
assert len(res[pair2]) == 99
|
2022-10-19 09:57:05 +00:00
|
|
|
assert res[pair2].at[0, 'open']
|
2022-10-05 17:39:28 +00:00
|
|
|
assert exchange._pairs_last_refresh_time[pair1] == ohlcv[-1][0] // 1000
|
|
|
|
refresh_pior = exchange._pairs_last_refresh_time[pair1]
|
|
|
|
|
2022-10-19 09:57:05 +00:00
|
|
|
# New candle on exchange - return 100 candles - but skip one candle so we actually get 2 candles
|
|
|
|
# in one go
|
|
|
|
new_startdate = (start + timedelta(hours=2)).strftime('%Y-%m-%d %H:%M')
|
|
|
|
# mocker.patch("freqtrade.exchange.Exchange.ohlcv_candle_limit", return_value=100)
|
|
|
|
ohlcv = generate_test_data_raw('1h', 100, new_startdate)
|
2022-10-05 17:39:28 +00:00
|
|
|
exchange._api_async.fetch_ohlcv = get_mock_coro(ohlcv)
|
|
|
|
res = exchange.refresh_latest_ohlcv(pairs)
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 2
|
|
|
|
assert len(res) == 2
|
|
|
|
assert len(res[pair1]) == 100
|
|
|
|
assert len(res[pair2]) == 100
|
2022-10-19 09:57:05 +00:00
|
|
|
# Verify index starts at 0
|
|
|
|
assert res[pair2].at[0, 'open']
|
2022-10-05 17:39:28 +00:00
|
|
|
assert refresh_pior != exchange._pairs_last_refresh_time[pair1]
|
|
|
|
|
|
|
|
assert exchange._pairs_last_refresh_time[pair1] == ohlcv[-1][0] // 1000
|
|
|
|
assert exchange._pairs_last_refresh_time[pair2] == ohlcv[-1][0] // 1000
|
|
|
|
exchange._api_async.fetch_ohlcv.reset_mock()
|
|
|
|
|
2022-10-19 09:57:05 +00:00
|
|
|
# Retry same call - from cache
|
2022-10-05 17:39:28 +00:00
|
|
|
res = exchange.refresh_latest_ohlcv(pairs)
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 0
|
|
|
|
assert len(res) == 2
|
|
|
|
assert len(res[pair1]) == 100
|
|
|
|
assert len(res[pair2]) == 100
|
2022-10-19 09:57:05 +00:00
|
|
|
assert res[pair2].at[0, 'open']
|
2022-10-05 17:39:28 +00:00
|
|
|
|
2022-10-06 14:43:45 +00:00
|
|
|
# Move to distant future (so a 1 call would cause a hole in the data)
|
|
|
|
time_machine.move_to(start + timedelta(hours=2000))
|
|
|
|
ohlcv = generate_test_data_raw('1h', 100, start + timedelta(hours=1900))
|
|
|
|
exchange._api_async.fetch_ohlcv = get_mock_coro(ohlcv)
|
|
|
|
res = exchange.refresh_latest_ohlcv(pairs)
|
|
|
|
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 2
|
|
|
|
assert len(res) == 2
|
|
|
|
# Cache eviction - new data.
|
|
|
|
assert len(res[pair1]) == 99
|
|
|
|
assert len(res[pair2]) == 99
|
2022-10-19 09:57:05 +00:00
|
|
|
assert res[pair2].at[0, 'open']
|
2022-10-06 14:43:45 +00:00
|
|
|
|
2022-10-05 17:39:28 +00:00
|
|
|
|
2018-08-01 19:19:49 +00:00
|
|
|
@pytest.mark.asyncio
|
2019-02-24 19:08:27 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
async def test__async_get_candle_history(default_conf, mocker, caplog, exchange_name):
|
2020-03-08 10:35:31 +00:00
|
|
|
ohlcv = [
|
2018-08-01 19:19:49 +00:00
|
|
|
[
|
2020-10-12 17:58:04 +00:00
|
|
|
arrow.utcnow().int_timestamp * 1000, # unix timestamp ms
|
2018-08-01 19:19:49 +00:00
|
|
|
1, # open
|
|
|
|
2, # high
|
|
|
|
3, # low
|
|
|
|
4, # close
|
|
|
|
5, # volume (in quote currency)
|
|
|
|
]
|
|
|
|
]
|
|
|
|
|
2018-08-14 18:33:03 +00:00
|
|
|
caplog.set_level(logging.DEBUG)
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
2018-08-01 19:19:49 +00:00
|
|
|
# Monkey-patch async function
|
2020-03-08 10:35:31 +00:00
|
|
|
exchange._api_async.fetch_ohlcv = get_mock_coro(ohlcv)
|
2018-08-01 19:19:49 +00:00
|
|
|
|
|
|
|
pair = 'ETH/BTC'
|
2021-12-03 15:44:05 +00:00
|
|
|
res = await exchange._async_get_candle_history(pair, "5m", CandleType.SPOT)
|
2018-08-01 19:19:49 +00:00
|
|
|
assert type(res) is tuple
|
2021-11-21 07:43:05 +00:00
|
|
|
assert len(res) == 4
|
2018-08-01 19:19:49 +00:00
|
|
|
assert res[0] == pair
|
2018-12-29 18:30:47 +00:00
|
|
|
assert res[1] == "5m"
|
2021-12-03 15:44:05 +00:00
|
|
|
assert res[2] == CandleType.SPOT
|
2021-11-21 07:43:05 +00:00
|
|
|
assert res[3] == ohlcv
|
2018-08-14 18:33:03 +00:00
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 1
|
2020-03-08 10:35:31 +00:00
|
|
|
assert not log_has(f"Using cached candle (OHLCV) data for {pair} ...", caplog)
|
2018-08-14 18:33:03 +00:00
|
|
|
|
|
|
|
# exchange = Exchange(default_conf)
|
2018-08-01 19:19:49 +00:00
|
|
|
await async_ccxt_exception(mocker, default_conf, MagicMock(),
|
2018-08-14 18:33:03 +00:00
|
|
|
"_async_get_candle_history", "fetch_ohlcv",
|
2021-12-03 15:44:05 +00:00
|
|
|
pair='ABCD/BTC', timeframe=default_conf['timeframe'],
|
|
|
|
candle_type=CandleType.SPOT)
|
2018-08-14 18:35:12 +00:00
|
|
|
|
|
|
|
api_mock = MagicMock()
|
2020-03-08 10:35:31 +00:00
|
|
|
with pytest.raises(OperationalException,
|
|
|
|
match=r'Could not fetch historical candle \(OHLCV\) data.*'):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.BaseError("Unknown error"))
|
2019-02-24 19:08:27 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-12-03 15:44:05 +00:00
|
|
|
await exchange._async_get_candle_history(pair, "5m", CandleType.SPOT,
|
2020-10-12 17:58:04 +00:00
|
|
|
(arrow.utcnow().int_timestamp - 2000) * 1000)
|
2018-08-01 19:19:49 +00:00
|
|
|
|
2019-08-29 11:13:41 +00:00
|
|
|
with pytest.raises(OperationalException, match=r'Exchange.* does not support fetching '
|
2020-03-08 10:35:31 +00:00
|
|
|
r'historical candle \(OHLCV\) data\..*'):
|
2019-08-29 11:13:41 +00:00
|
|
|
api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.NotSupported("Not supported"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-12-03 15:44:05 +00:00
|
|
|
await exchange._async_get_candle_history(pair, "5m", CandleType.SPOT,
|
2020-10-12 17:58:04 +00:00
|
|
|
(arrow.utcnow().int_timestamp - 2000) * 1000)
|
2019-08-29 11:13:41 +00:00
|
|
|
|
2018-08-01 19:19:49 +00:00
|
|
|
|
2021-12-25 21:32:22 +00:00
|
|
|
@pytest.mark.asyncio
|
|
|
|
async def test__async_kucoin_get_candle_history(default_conf, mocker, caplog):
|
2022-05-26 16:05:40 +00:00
|
|
|
from freqtrade.exchange.common import _reset_logging_mixin
|
|
|
|
_reset_logging_mixin()
|
2021-12-25 21:32:22 +00:00
|
|
|
caplog.set_level(logging.INFO)
|
|
|
|
api_mock = MagicMock()
|
2021-12-27 15:39:47 +00:00
|
|
|
api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.DDoSProtection(
|
|
|
|
"kucoin GET https://openapi-v2.kucoin.com/api/v1/market/candles?"
|
|
|
|
"symbol=ETH-BTC&type=5min&startAt=1640268735&endAt=1640418735"
|
|
|
|
"429 Too Many Requests" '{"code":"429000","msg":"Too Many Requests"}'))
|
2022-04-02 17:33:20 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id="KuCoin")
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.name', PropertyMock(return_value='KuCoin'))
|
2021-12-25 21:32:22 +00:00
|
|
|
|
2021-12-27 15:39:47 +00:00
|
|
|
msg = "Kucoin 429 error, avoid triggering DDosProtection backoff delay"
|
2021-12-27 16:14:59 +00:00
|
|
|
assert not num_log_has_re(msg, caplog)
|
2021-12-25 21:32:22 +00:00
|
|
|
|
|
|
|
for _ in range(3):
|
|
|
|
with pytest.raises(DDosProtection, match=r'429 Too Many Requests'):
|
|
|
|
await exchange._async_get_candle_history(
|
2022-10-09 08:55:38 +00:00
|
|
|
"ETH/BTC", "5m", CandleType.SPOT,
|
|
|
|
since_ms=(arrow.utcnow().int_timestamp - 2000) * 1000, count=3)
|
2021-12-27 16:14:59 +00:00
|
|
|
assert num_log_has_re(msg, caplog) == 3
|
|
|
|
|
|
|
|
caplog.clear()
|
|
|
|
# Test regular non-kucoin message
|
|
|
|
api_mock.fetch_ohlcv = MagicMock(side_effect=ccxt.DDoSProtection(
|
|
|
|
"kucoin GET https://openapi-v2.kucoin.com/api/v1/market/candles?"
|
|
|
|
"symbol=ETH-BTC&type=5min&startAt=1640268735&endAt=1640418735"
|
|
|
|
"429 Too Many Requests" '{"code":"2222222","msg":"Too Many Requests"}'))
|
|
|
|
|
|
|
|
msg = r'_async_get_candle_history\(\) returned exception: .*'
|
|
|
|
msg2 = r'Applying DDosProtection backoff delay: .*'
|
|
|
|
with patch('freqtrade.exchange.common.asyncio.sleep', get_mock_coro(None)):
|
|
|
|
for _ in range(3):
|
|
|
|
with pytest.raises(DDosProtection, match=r'429 Too Many Requests'):
|
|
|
|
await exchange._async_get_candle_history(
|
2022-10-09 08:55:38 +00:00
|
|
|
"ETH/BTC", "5m", CandleType.SPOT,
|
|
|
|
(arrow.utcnow().int_timestamp - 2000) * 1000, count=3)
|
2021-12-27 16:14:59 +00:00
|
|
|
# Expect the "returned exception" message 12 times (4 retries * 3 (loop))
|
|
|
|
assert num_log_has_re(msg, caplog) == 12
|
|
|
|
assert num_log_has_re(msg2, caplog) == 9
|
2021-12-25 21:32:22 +00:00
|
|
|
|
|
|
|
|
2018-09-02 17:15:23 +00:00
|
|
|
@pytest.mark.asyncio
|
|
|
|
async def test__async_get_candle_history_empty(default_conf, mocker, caplog):
|
|
|
|
""" Test empty exchange result """
|
2020-03-08 10:35:31 +00:00
|
|
|
ohlcv = []
|
2018-09-02 17:15:23 +00:00
|
|
|
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
|
|
|
# Monkey-patch async function
|
|
|
|
exchange._api_async.fetch_ohlcv = get_mock_coro([])
|
|
|
|
|
|
|
|
exchange = Exchange(default_conf)
|
|
|
|
pair = 'ETH/BTC'
|
2021-12-03 15:44:05 +00:00
|
|
|
res = await exchange._async_get_candle_history(pair, "5m", CandleType.SPOT)
|
2018-09-02 17:15:23 +00:00
|
|
|
assert type(res) is tuple
|
2021-11-21 07:43:05 +00:00
|
|
|
assert len(res) == 4
|
2018-09-02 17:15:23 +00:00
|
|
|
assert res[0] == pair
|
2018-12-29 18:30:47 +00:00
|
|
|
assert res[1] == "5m"
|
2021-12-04 14:13:06 +00:00
|
|
|
assert res[2] == CandleType.SPOT
|
2021-11-21 07:43:05 +00:00
|
|
|
assert res[3] == ohlcv
|
2018-09-02 17:15:23 +00:00
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 1
|
|
|
|
|
|
|
|
|
2019-01-22 06:38:15 +00:00
|
|
|
def test_refresh_latest_ohlcv_inv_result(default_conf, mocker, caplog):
|
2019-01-19 19:03:04 +00:00
|
|
|
|
|
|
|
async def mock_get_candle_hist(pair, *args, **kwargs):
|
|
|
|
if pair == 'ETH/BTC':
|
|
|
|
return [[]]
|
|
|
|
else:
|
|
|
|
raise TypeError()
|
|
|
|
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
|
|
|
|
|
|
|
# Monkey-patch async function with empty result
|
|
|
|
exchange._api_async.fetch_ohlcv = MagicMock(side_effect=mock_get_candle_hist)
|
|
|
|
|
2021-11-21 07:43:05 +00:00
|
|
|
pairs = [("ETH/BTC", "5m", ''), ("XRP/BTC", "5m", '')]
|
2019-01-22 06:38:15 +00:00
|
|
|
res = exchange.refresh_latest_ohlcv(pairs)
|
|
|
|
assert exchange._klines
|
|
|
|
assert exchange._api_async.fetch_ohlcv.call_count == 2
|
|
|
|
|
2020-12-15 07:22:45 +00:00
|
|
|
assert type(res) is dict
|
|
|
|
assert len(res) == 1
|
2019-01-22 18:17:21 +00:00
|
|
|
# Test that each is in list at least once as order is not guaranteed
|
2019-08-11 18:17:39 +00:00
|
|
|
assert log_has("Error loading ETH/BTC. Result was [[]].", caplog)
|
2021-11-30 05:58:32 +00:00
|
|
|
assert log_has("Async code raised an exception: TypeError()", caplog)
|
2019-01-19 19:03:04 +00:00
|
|
|
|
|
|
|
|
2020-10-13 18:02:47 +00:00
|
|
|
def test_get_next_limit_in_list():
|
|
|
|
limit_range = [5, 10, 20, 50, 100, 500, 1000]
|
|
|
|
assert Exchange.get_next_limit_in_list(1, limit_range) == 5
|
|
|
|
assert Exchange.get_next_limit_in_list(5, limit_range) == 5
|
|
|
|
assert Exchange.get_next_limit_in_list(6, limit_range) == 10
|
|
|
|
assert Exchange.get_next_limit_in_list(9, limit_range) == 10
|
|
|
|
assert Exchange.get_next_limit_in_list(10, limit_range) == 10
|
|
|
|
assert Exchange.get_next_limit_in_list(11, limit_range) == 20
|
|
|
|
assert Exchange.get_next_limit_in_list(19, limit_range) == 20
|
|
|
|
assert Exchange.get_next_limit_in_list(21, limit_range) == 50
|
|
|
|
assert Exchange.get_next_limit_in_list(51, limit_range) == 100
|
|
|
|
assert Exchange.get_next_limit_in_list(1000, limit_range) == 1000
|
2020-10-13 18:38:02 +00:00
|
|
|
# Going over the limit ...
|
|
|
|
assert Exchange.get_next_limit_in_list(1001, limit_range) == 1000
|
|
|
|
assert Exchange.get_next_limit_in_list(2000, limit_range) == 1000
|
2021-04-13 10:28:07 +00:00
|
|
|
# Without required range
|
|
|
|
assert Exchange.get_next_limit_in_list(2000, limit_range, False) is None
|
|
|
|
assert Exchange.get_next_limit_in_list(15, limit_range, False) == 20
|
2020-10-13 18:02:47 +00:00
|
|
|
|
|
|
|
assert Exchange.get_next_limit_in_list(21, None) == 21
|
|
|
|
assert Exchange.get_next_limit_in_list(100, None) == 100
|
|
|
|
assert Exchange.get_next_limit_in_list(1000, None) == 1000
|
|
|
|
|
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2020-05-26 18:27:35 +00:00
|
|
|
def test_fetch_l2_order_book(default_conf, mocker, order_book_l2, exchange_name):
|
2019-02-24 18:59:45 +00:00
|
|
|
default_conf['exchange']['name'] = exchange_name
|
2018-08-25 11:17:07 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
|
|
|
|
api_mock.fetch_l2_order_book = order_book_l2
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2020-05-26 18:27:35 +00:00
|
|
|
order_book = exchange.fetch_l2_order_book(pair='ETH/BTC', limit=10)
|
2018-08-05 04:41:06 +00:00
|
|
|
assert 'bids' in order_book
|
|
|
|
assert 'asks' in order_book
|
2018-08-25 11:17:07 +00:00
|
|
|
assert len(order_book['bids']) == 10
|
|
|
|
assert len(order_book['asks']) == 10
|
2020-10-13 18:02:47 +00:00
|
|
|
assert api_mock.fetch_l2_order_book.call_args_list[0][0][0] == 'ETH/BTC'
|
|
|
|
|
2020-10-13 18:29:51 +00:00
|
|
|
for val in [1, 5, 10, 12, 20, 50, 100]:
|
2020-10-13 18:02:47 +00:00
|
|
|
api_mock.fetch_l2_order_book.reset_mock()
|
|
|
|
|
|
|
|
order_book = exchange.fetch_l2_order_book(pair='ETH/BTC', limit=val)
|
|
|
|
assert api_mock.fetch_l2_order_book.call_args_list[0][0][0] == 'ETH/BTC'
|
|
|
|
# Not all exchanges support all limits for orderbook
|
2022-08-21 16:07:41 +00:00
|
|
|
if (not exchange.get_option('l2_limit_range')
|
|
|
|
or val in exchange.get_option('l2_limit_range')):
|
2020-10-13 18:02:47 +00:00
|
|
|
assert api_mock.fetch_l2_order_book.call_args_list[0][0][1] == val
|
|
|
|
else:
|
2022-08-21 15:48:13 +00:00
|
|
|
next_limit = exchange.get_next_limit_in_list(val, exchange.get_option('l2_limit_range'))
|
2020-10-13 18:02:47 +00:00
|
|
|
assert api_mock.fetch_l2_order_book.call_args_list[0][0][1] == next_limit
|
2018-08-05 04:41:06 +00:00
|
|
|
|
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2020-05-26 18:27:35 +00:00
|
|
|
def test_fetch_l2_order_book_exception(default_conf, mocker, exchange_name):
|
2018-08-05 14:41:58 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
with pytest.raises(OperationalException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.fetch_l2_order_book = MagicMock(side_effect=ccxt.NotSupported("Not supported"))
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2020-05-26 18:27:35 +00:00
|
|
|
exchange.fetch_l2_order_book(pair='ETH/BTC', limit=50)
|
2018-08-05 14:41:58 +00:00
|
|
|
with pytest.raises(TemporaryError):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.fetch_l2_order_book = MagicMock(side_effect=ccxt.NetworkError("DeadBeef"))
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2020-05-26 18:27:35 +00:00
|
|
|
exchange.fetch_l2_order_book(pair='ETH/BTC', limit=50)
|
2018-08-05 14:41:58 +00:00
|
|
|
with pytest.raises(OperationalException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.fetch_l2_order_book = MagicMock(side_effect=ccxt.BaseError("DeadBeef"))
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2020-05-26 18:27:35 +00:00
|
|
|
exchange.fetch_l2_order_book(pair='ETH/BTC', limit=50)
|
2018-08-05 14:41:58 +00:00
|
|
|
|
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
@pytest.mark.parametrize("side,ask,bid,last,last_ab,expected", get_entry_rate_data)
|
2022-03-28 17:16:12 +00:00
|
|
|
def test_get_entry_rate(mocker, default_conf, caplog, side, ask, bid,
|
|
|
|
last, last_ab, expected) -> None:
|
2021-06-02 09:30:19 +00:00
|
|
|
caplog.set_level(logging.DEBUG)
|
2021-10-07 04:51:29 +00:00
|
|
|
if last_ab is None:
|
2022-03-28 17:48:45 +00:00
|
|
|
del default_conf['entry_pricing']['price_last_balance']
|
2021-10-07 04:51:29 +00:00
|
|
|
else:
|
2022-03-28 17:48:45 +00:00
|
|
|
default_conf['entry_pricing']['price_last_balance'] = last_ab
|
2022-03-27 16:03:49 +00:00
|
|
|
default_conf['entry_pricing']['price_side'] = side
|
2021-06-02 09:30:19 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_ticker',
|
|
|
|
return_value={'ask': ask, 'last': last, 'bid': bid})
|
|
|
|
|
2022-03-28 17:30:14 +00:00
|
|
|
assert exchange.get_rate('ETH/BTC', side="entry", is_short=False, refresh=True) == expected
|
2022-03-28 17:16:12 +00:00
|
|
|
assert not log_has("Using cached entry rate for ETH/BTC.", caplog)
|
2021-06-02 09:30:19 +00:00
|
|
|
|
2022-03-28 17:30:14 +00:00
|
|
|
assert exchange.get_rate('ETH/BTC', side="entry", is_short=False, refresh=False) == expected
|
2022-03-28 17:16:12 +00:00
|
|
|
assert log_has("Using cached entry rate for ETH/BTC.", caplog)
|
2021-06-02 09:30:19 +00:00
|
|
|
# Running a 2nd time with Refresh on!
|
|
|
|
caplog.clear()
|
2022-03-28 17:30:14 +00:00
|
|
|
assert exchange.get_rate('ETH/BTC', side="entry", is_short=False, refresh=True) == expected
|
2022-03-28 17:16:12 +00:00
|
|
|
assert not log_has("Using cached entry rate for ETH/BTC.", caplog)
|
2021-06-02 09:30:19 +00:00
|
|
|
|
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
@pytest.mark.parametrize('side,ask,bid,last,last_ab,expected', get_sell_rate_data)
|
2022-03-28 17:16:12 +00:00
|
|
|
def test_get_exit_rate(default_conf, mocker, caplog, side, bid, ask,
|
2021-06-02 09:39:18 +00:00
|
|
|
last, last_ab, expected) -> None:
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
|
2022-03-27 16:03:49 +00:00
|
|
|
default_conf['exit_pricing']['price_side'] = side
|
2021-10-07 05:15:09 +00:00
|
|
|
if last_ab is not None:
|
2022-03-28 17:48:45 +00:00
|
|
|
default_conf['exit_pricing']['price_last_balance'] = last_ab
|
2021-06-02 09:39:18 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_ticker',
|
|
|
|
return_value={'ask': ask, 'bid': bid, 'last': last})
|
|
|
|
pair = "ETH/BTC"
|
|
|
|
|
|
|
|
# Test regular mode
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
2022-03-28 17:30:14 +00:00
|
|
|
rate = exchange.get_rate(pair, side="exit", is_short=False, refresh=True)
|
|
|
|
assert not log_has("Using cached exit rate for ETH/BTC.", caplog)
|
2021-06-02 09:39:18 +00:00
|
|
|
assert isinstance(rate, float)
|
|
|
|
assert rate == expected
|
|
|
|
# Use caching
|
2022-03-28 17:30:14 +00:00
|
|
|
rate = exchange.get_rate(pair, side="exit", is_short=False, refresh=False)
|
2021-06-02 09:39:18 +00:00
|
|
|
assert rate == expected
|
2022-03-28 17:30:14 +00:00
|
|
|
assert log_has("Using cached exit rate for ETH/BTC.", caplog)
|
2021-06-02 09:39:18 +00:00
|
|
|
|
|
|
|
|
2022-03-28 17:16:12 +00:00
|
|
|
@pytest.mark.parametrize("entry,is_short,side,ask,bid,last,last_ab,expected", [
|
|
|
|
('entry', False, 'ask', None, 4, 4, 0, 4), # ask not available
|
|
|
|
('entry', False, 'ask', None, None, 4, 0, 4), # ask not available
|
|
|
|
('entry', False, 'bid', 6, None, 4, 0, 5), # bid not available
|
|
|
|
('entry', False, 'bid', None, None, 4, 0, 5), # No rate available
|
|
|
|
('exit', False, 'ask', None, 4, 4, 0, 4), # ask not available
|
|
|
|
('exit', False, 'ask', None, None, 4, 0, 4), # ask not available
|
|
|
|
('exit', False, 'bid', 6, None, 4, 0, 5), # bid not available
|
|
|
|
('exit', False, 'bid', None, None, 4, 0, 5), # bid not available
|
2021-08-25 05:13:09 +00:00
|
|
|
])
|
2022-03-28 17:16:12 +00:00
|
|
|
def test_get_ticker_rate_error(mocker, entry, default_conf, caplog, side, is_short, ask, bid,
|
2021-08-25 05:13:09 +00:00
|
|
|
last, last_ab, expected) -> None:
|
|
|
|
caplog.set_level(logging.DEBUG)
|
2022-03-28 17:48:45 +00:00
|
|
|
default_conf['entry_pricing']['price_last_balance'] = last_ab
|
2022-03-27 16:03:49 +00:00
|
|
|
default_conf['entry_pricing']['price_side'] = side
|
|
|
|
default_conf['exit_pricing']['price_side'] = side
|
2022-03-28 17:48:45 +00:00
|
|
|
default_conf['exit_pricing']['price_last_balance'] = last_ab
|
2021-08-25 05:13:09 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_ticker',
|
|
|
|
return_value={'ask': ask, 'last': last, 'bid': bid})
|
|
|
|
|
|
|
|
with pytest.raises(PricingError):
|
2022-03-28 17:16:12 +00:00
|
|
|
exchange.get_rate('ETH/BTC', refresh=True, side=entry, is_short=is_short)
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize('is_short,side,expected', [
|
2022-07-31 12:19:04 +00:00
|
|
|
(False, 'bid', 0.043936), # Value from order_book_l2 fixture - bids side
|
|
|
|
(False, 'ask', 0.043949), # Value from order_book_l2 fixture - asks side
|
|
|
|
(False, 'other', 0.043936), # Value from order_book_l2 fixture - bids side
|
|
|
|
(False, 'same', 0.043949), # Value from order_book_l2 fixture - asks side
|
|
|
|
(True, 'bid', 0.043936), # Value from order_book_l2 fixture - bids side
|
|
|
|
(True, 'ask', 0.043949), # Value from order_book_l2 fixture - asks side
|
|
|
|
(True, 'other', 0.043949), # Value from order_book_l2 fixture - asks side
|
|
|
|
(True, 'same', 0.043936), # Value from order_book_l2 fixture - bids side
|
2021-06-02 09:39:18 +00:00
|
|
|
])
|
2022-03-28 17:16:12 +00:00
|
|
|
def test_get_exit_rate_orderbook(
|
|
|
|
default_conf, mocker, caplog, is_short, side, expected, order_book_l2):
|
2021-06-02 09:39:18 +00:00
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
# Test orderbook mode
|
2022-03-27 16:03:49 +00:00
|
|
|
default_conf['exit_pricing']['price_side'] = side
|
|
|
|
default_conf['exit_pricing']['use_order_book'] = True
|
|
|
|
default_conf['exit_pricing']['order_book_top'] = 1
|
2021-06-02 09:39:18 +00:00
|
|
|
pair = "ETH/BTC"
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_l2_order_book', order_book_l2)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
2022-03-28 17:16:12 +00:00
|
|
|
rate = exchange.get_rate(pair, refresh=True, side="exit", is_short=is_short)
|
|
|
|
assert not log_has("Using cached exit rate for ETH/BTC.", caplog)
|
2021-06-02 09:39:18 +00:00
|
|
|
assert isinstance(rate, float)
|
|
|
|
assert rate == expected
|
2022-03-28 17:16:12 +00:00
|
|
|
rate = exchange.get_rate(pair, refresh=False, side="exit", is_short=is_short)
|
2021-06-02 09:39:18 +00:00
|
|
|
assert rate == expected
|
2022-03-28 17:16:12 +00:00
|
|
|
assert log_has("Using cached exit rate for ETH/BTC.", caplog)
|
2021-06-02 09:39:18 +00:00
|
|
|
|
|
|
|
|
2022-03-28 17:16:12 +00:00
|
|
|
def test_get_exit_rate_orderbook_exception(default_conf, mocker, caplog):
|
2021-06-02 09:39:18 +00:00
|
|
|
# Test orderbook mode
|
2022-03-27 16:03:49 +00:00
|
|
|
default_conf['exit_pricing']['price_side'] = 'ask'
|
|
|
|
default_conf['exit_pricing']['use_order_book'] = True
|
|
|
|
default_conf['exit_pricing']['order_book_top'] = 1
|
2021-06-02 09:39:18 +00:00
|
|
|
pair = "ETH/BTC"
|
|
|
|
# Test What happens if the exchange returns an empty orderbook.
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_l2_order_book',
|
|
|
|
return_value={'bids': [[]], 'asks': [[]]})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
|
|
|
with pytest.raises(PricingError):
|
2022-03-28 17:16:12 +00:00
|
|
|
exchange.get_rate(pair, refresh=True, side="exit", is_short=False)
|
2022-07-31 12:19:04 +00:00
|
|
|
assert log_has_re(rf"{pair} - Exit Price at location 1 from orderbook "
|
|
|
|
rf"could not be determined\..*",
|
2021-06-25 18:51:45 +00:00
|
|
|
caplog)
|
2021-06-02 09:39:18 +00:00
|
|
|
|
|
|
|
|
2022-03-28 17:16:12 +00:00
|
|
|
@pytest.mark.parametrize('is_short', [True, False])
|
|
|
|
def test_get_exit_rate_exception(default_conf, mocker, is_short):
|
2021-06-02 09:39:18 +00:00
|
|
|
# Ticker on one side can be empty in certain circumstances.
|
2022-03-27 16:03:49 +00:00
|
|
|
default_conf['exit_pricing']['price_side'] = 'ask'
|
2021-06-02 09:39:18 +00:00
|
|
|
pair = "ETH/BTC"
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_ticker',
|
|
|
|
return_value={'ask': None, 'bid': 0.12, 'last': None})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
2022-03-28 17:16:12 +00:00
|
|
|
with pytest.raises(PricingError, match=r"Exit-Rate for ETH/BTC was empty."):
|
|
|
|
exchange.get_rate(pair, refresh=True, side="exit", is_short=is_short)
|
2021-06-02 09:39:18 +00:00
|
|
|
|
2022-03-27 16:03:49 +00:00
|
|
|
exchange._config['exit_pricing']['price_side'] = 'bid'
|
2022-03-28 17:16:12 +00:00
|
|
|
assert exchange.get_rate(pair, refresh=True, side="exit", is_short=is_short) == 0.12
|
2021-06-02 09:39:18 +00:00
|
|
|
# Reverse sides
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_ticker',
|
|
|
|
return_value={'ask': 0.13, 'bid': None, 'last': None})
|
2022-03-28 17:16:12 +00:00
|
|
|
with pytest.raises(PricingError, match=r"Exit-Rate for ETH/BTC was empty."):
|
|
|
|
exchange.get_rate(pair, refresh=True, side="exit", is_short=is_short)
|
2021-06-02 09:39:18 +00:00
|
|
|
|
2022-03-27 16:03:49 +00:00
|
|
|
exchange._config['exit_pricing']['price_side'] = 'ask'
|
2022-03-28 17:16:12 +00:00
|
|
|
assert exchange.get_rate(pair, refresh=True, side="exit", is_short=is_short) == 0.13
|
2021-06-02 09:39:18 +00:00
|
|
|
|
|
|
|
|
2022-07-31 12:19:04 +00:00
|
|
|
@pytest.mark.parametrize("side,ask,bid,last,last_ab,expected", get_entry_rate_data)
|
|
|
|
@pytest.mark.parametrize("side2", ['bid', 'ask'])
|
|
|
|
@pytest.mark.parametrize("use_order_book", [True, False])
|
|
|
|
def test_get_rates_testing_buy(mocker, default_conf, caplog, side, ask, bid,
|
|
|
|
last, last_ab, expected,
|
|
|
|
side2, use_order_book, order_book_l2) -> None:
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
if last_ab is None:
|
|
|
|
del default_conf['entry_pricing']['price_last_balance']
|
|
|
|
else:
|
|
|
|
default_conf['entry_pricing']['price_last_balance'] = last_ab
|
|
|
|
default_conf['entry_pricing']['price_side'] = side
|
|
|
|
default_conf['exit_pricing']['price_side'] = side2
|
|
|
|
default_conf['exit_pricing']['use_order_book'] = use_order_book
|
|
|
|
api_mock = MagicMock()
|
|
|
|
api_mock.fetch_l2_order_book = order_book_l2
|
|
|
|
api_mock.fetch_ticker = MagicMock(
|
|
|
|
return_value={'ask': ask, 'last': last, 'bid': bid})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
|
|
|
|
assert exchange.get_rates('ETH/BTC', refresh=True, is_short=False)[0] == expected
|
|
|
|
assert not log_has("Using cached buy rate for ETH/BTC.", caplog)
|
|
|
|
|
|
|
|
api_mock.fetch_l2_order_book.reset_mock()
|
|
|
|
api_mock.fetch_ticker.reset_mock()
|
|
|
|
assert exchange.get_rates('ETH/BTC', refresh=False, is_short=False)[0] == expected
|
|
|
|
assert log_has("Using cached buy rate for ETH/BTC.", caplog)
|
|
|
|
assert api_mock.fetch_l2_order_book.call_count == 0
|
|
|
|
assert api_mock.fetch_ticker.call_count == 0
|
|
|
|
# Running a 2nd time with Refresh on!
|
|
|
|
caplog.clear()
|
|
|
|
|
|
|
|
assert exchange.get_rates('ETH/BTC', refresh=True, is_short=False)[0] == expected
|
|
|
|
assert not log_has("Using cached buy rate for ETH/BTC.", caplog)
|
|
|
|
|
|
|
|
assert api_mock.fetch_l2_order_book.call_count == int(use_order_book)
|
|
|
|
assert api_mock.fetch_ticker.call_count == 1
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize('side,ask,bid,last,last_ab,expected', get_sell_rate_data)
|
|
|
|
@pytest.mark.parametrize("side2", ['bid', 'ask'])
|
|
|
|
@pytest.mark.parametrize("use_order_book", [True, False])
|
|
|
|
def test_get_rates_testing_sell(default_conf, mocker, caplog, side, bid, ask,
|
|
|
|
last, last_ab, expected,
|
|
|
|
side2, use_order_book, order_book_l2) -> None:
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
|
|
|
|
default_conf['exit_pricing']['price_side'] = side
|
|
|
|
if last_ab is not None:
|
|
|
|
default_conf['exit_pricing']['price_last_balance'] = last_ab
|
|
|
|
|
|
|
|
default_conf['entry_pricing']['price_side'] = side2
|
|
|
|
default_conf['entry_pricing']['use_order_book'] = use_order_book
|
|
|
|
api_mock = MagicMock()
|
|
|
|
api_mock.fetch_l2_order_book = order_book_l2
|
|
|
|
api_mock.fetch_ticker = MagicMock(
|
|
|
|
return_value={'ask': ask, 'last': last, 'bid': bid})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
|
|
|
|
pair = "ETH/BTC"
|
|
|
|
|
|
|
|
# Test regular mode
|
|
|
|
rate = exchange.get_rates(pair, refresh=True, is_short=False)[1]
|
|
|
|
assert not log_has("Using cached sell rate for ETH/BTC.", caplog)
|
|
|
|
assert isinstance(rate, float)
|
|
|
|
assert rate == expected
|
|
|
|
# Use caching
|
|
|
|
api_mock.fetch_l2_order_book.reset_mock()
|
|
|
|
api_mock.fetch_ticker.reset_mock()
|
|
|
|
|
|
|
|
rate = exchange.get_rates(pair, refresh=False, is_short=False)[1]
|
|
|
|
assert rate == expected
|
|
|
|
assert log_has("Using cached sell rate for ETH/BTC.", caplog)
|
|
|
|
|
|
|
|
assert api_mock.fetch_l2_order_book.call_count == 0
|
|
|
|
assert api_mock.fetch_ticker.call_count == 0
|
|
|
|
|
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2018-11-25 13:48:15 +00:00
|
|
|
@pytest.mark.asyncio
|
2019-02-24 18:59:45 +00:00
|
|
|
async def test___async_get_candle_history_sort(default_conf, mocker, exchange_name):
|
2018-11-25 14:00:50 +00:00
|
|
|
def sort_data(data, key):
|
|
|
|
return sorted(data, key=key)
|
2018-06-01 06:45:35 +00:00
|
|
|
|
|
|
|
# GDAX use-case (real data from GDAX)
|
2020-03-08 10:35:31 +00:00
|
|
|
# This OHLCV data is ordered DESC (newest first, oldest last)
|
|
|
|
ohlcv = [
|
2018-06-01 06:45:35 +00:00
|
|
|
[1527833100000, 0.07666, 0.07671, 0.07666, 0.07668, 16.65244264],
|
|
|
|
[1527832800000, 0.07662, 0.07666, 0.07662, 0.07666, 1.30051526],
|
|
|
|
[1527832500000, 0.07656, 0.07661, 0.07656, 0.07661, 12.034778840000001],
|
|
|
|
[1527832200000, 0.07658, 0.07658, 0.07655, 0.07656, 0.59780186],
|
|
|
|
[1527831900000, 0.07658, 0.07658, 0.07658, 0.07658, 1.76278136],
|
|
|
|
[1527831600000, 0.07658, 0.07658, 0.07658, 0.07658, 2.22646521],
|
|
|
|
[1527831300000, 0.07655, 0.07657, 0.07655, 0.07657, 1.1753],
|
|
|
|
[1527831000000, 0.07654, 0.07654, 0.07651, 0.07651, 0.8073060299999999],
|
|
|
|
[1527830700000, 0.07652, 0.07652, 0.07651, 0.07652, 10.04822687],
|
|
|
|
[1527830400000, 0.07649, 0.07651, 0.07649, 0.07651, 2.5734867]
|
|
|
|
]
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
2020-03-08 10:35:31 +00:00
|
|
|
exchange._api_async.fetch_ohlcv = get_mock_coro(ohlcv)
|
2019-02-21 05:59:52 +00:00
|
|
|
sort_mock = mocker.patch('freqtrade.exchange.exchange.sorted', MagicMock(side_effect=sort_data))
|
2020-03-08 10:35:31 +00:00
|
|
|
# Test the OHLCV data sort
|
2021-12-03 15:44:05 +00:00
|
|
|
res = await exchange._async_get_candle_history(
|
|
|
|
'ETH/BTC', default_conf['timeframe'], CandleType.SPOT)
|
2018-11-25 13:48:15 +00:00
|
|
|
assert res[0] == 'ETH/BTC'
|
2021-11-21 07:43:05 +00:00
|
|
|
res_ohlcv = res[3]
|
2018-11-25 14:00:50 +00:00
|
|
|
|
|
|
|
assert sort_mock.call_count == 1
|
2020-03-08 10:35:31 +00:00
|
|
|
assert res_ohlcv[0][0] == 1527830400000
|
|
|
|
assert res_ohlcv[0][1] == 0.07649
|
|
|
|
assert res_ohlcv[0][2] == 0.07651
|
|
|
|
assert res_ohlcv[0][3] == 0.07649
|
|
|
|
assert res_ohlcv[0][4] == 0.07651
|
|
|
|
assert res_ohlcv[0][5] == 2.5734867
|
|
|
|
|
|
|
|
assert res_ohlcv[9][0] == 1527833100000
|
|
|
|
assert res_ohlcv[9][1] == 0.07666
|
|
|
|
assert res_ohlcv[9][2] == 0.07671
|
|
|
|
assert res_ohlcv[9][3] == 0.07666
|
|
|
|
assert res_ohlcv[9][4] == 0.07668
|
|
|
|
assert res_ohlcv[9][5] == 16.65244264
|
2018-06-01 06:45:35 +00:00
|
|
|
|
|
|
|
# Bittrex use-case (real data from Bittrex)
|
2020-03-08 10:35:31 +00:00
|
|
|
# This OHLCV data is ordered ASC (oldest first, newest last)
|
|
|
|
ohlcv = [
|
2018-06-01 06:45:35 +00:00
|
|
|
[1527827700000, 0.07659999, 0.0766, 0.07627, 0.07657998, 1.85216924],
|
|
|
|
[1527828000000, 0.07657995, 0.07657995, 0.0763, 0.0763, 26.04051037],
|
|
|
|
[1527828300000, 0.0763, 0.07659998, 0.0763, 0.0764, 10.36434124],
|
|
|
|
[1527828600000, 0.0764, 0.0766, 0.0764, 0.0766, 5.71044773],
|
|
|
|
[1527828900000, 0.0764, 0.07666998, 0.0764, 0.07666998, 47.48888565],
|
|
|
|
[1527829200000, 0.0765, 0.07672999, 0.0765, 0.07672999, 3.37640326],
|
|
|
|
[1527829500000, 0.0766, 0.07675, 0.0765, 0.07675, 8.36203831],
|
|
|
|
[1527829800000, 0.07675, 0.07677999, 0.07620002, 0.076695, 119.22963884],
|
|
|
|
[1527830100000, 0.076695, 0.07671, 0.07624171, 0.07671, 1.80689244],
|
|
|
|
[1527830400000, 0.07671, 0.07674399, 0.07629216, 0.07655213, 2.31452783]
|
|
|
|
]
|
2020-03-08 10:35:31 +00:00
|
|
|
exchange._api_async.fetch_ohlcv = get_mock_coro(ohlcv)
|
2018-11-25 14:00:50 +00:00
|
|
|
# Reset sort mock
|
|
|
|
sort_mock = mocker.patch('freqtrade.exchange.sorted', MagicMock(side_effect=sort_data))
|
2020-03-08 10:35:31 +00:00
|
|
|
# Test the OHLCV data sort
|
2021-12-03 15:44:05 +00:00
|
|
|
res = await exchange._async_get_candle_history(
|
|
|
|
'ETH/BTC', default_conf['timeframe'], CandleType.SPOT)
|
2018-11-25 13:48:15 +00:00
|
|
|
assert res[0] == 'ETH/BTC'
|
2020-06-01 18:33:26 +00:00
|
|
|
assert res[1] == default_conf['timeframe']
|
2021-11-21 07:43:05 +00:00
|
|
|
res_ohlcv = res[3]
|
2018-11-25 14:00:50 +00:00
|
|
|
# Sorted not called again - data is already in order
|
|
|
|
assert sort_mock.call_count == 0
|
2020-03-08 10:35:31 +00:00
|
|
|
assert res_ohlcv[0][0] == 1527827700000
|
|
|
|
assert res_ohlcv[0][1] == 0.07659999
|
|
|
|
assert res_ohlcv[0][2] == 0.0766
|
|
|
|
assert res_ohlcv[0][3] == 0.07627
|
|
|
|
assert res_ohlcv[0][4] == 0.07657998
|
|
|
|
assert res_ohlcv[0][5] == 1.85216924
|
|
|
|
|
|
|
|
assert res_ohlcv[9][0] == 1527830400000
|
|
|
|
assert res_ohlcv[9][1] == 0.07671
|
|
|
|
assert res_ohlcv[9][2] == 0.07674399
|
|
|
|
assert res_ohlcv[9][3] == 0.07629216
|
|
|
|
assert res_ohlcv[9][4] == 0.07655213
|
|
|
|
assert res_ohlcv[9][5] == 2.31452783
|
2018-06-01 06:45:35 +00:00
|
|
|
|
|
|
|
|
2019-08-29 14:33:56 +00:00
|
|
|
@pytest.mark.asyncio
|
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
async def test__async_fetch_trades(default_conf, mocker, caplog, exchange_name,
|
2020-04-01 04:53:58 +00:00
|
|
|
fetch_trades_result):
|
2019-08-29 14:33:56 +00:00
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
# Monkey-patch async function
|
2020-04-01 04:53:58 +00:00
|
|
|
exchange._api_async.fetch_trades = get_mock_coro(fetch_trades_result)
|
2019-08-29 14:33:56 +00:00
|
|
|
|
|
|
|
pair = 'ETH/BTC'
|
|
|
|
res = await exchange._async_fetch_trades(pair, since=None, params=None)
|
|
|
|
assert type(res) is list
|
2020-04-01 04:53:58 +00:00
|
|
|
assert isinstance(res[0], list)
|
|
|
|
assert isinstance(res[1], list)
|
2019-08-29 14:33:56 +00:00
|
|
|
|
|
|
|
assert exchange._api_async.fetch_trades.call_count == 1
|
|
|
|
assert exchange._api_async.fetch_trades.call_args[0][0] == pair
|
|
|
|
assert exchange._api_async.fetch_trades.call_args[1]['limit'] == 1000
|
|
|
|
|
|
|
|
assert log_has_re(f"Fetching trades for pair {pair}, since .*", caplog)
|
|
|
|
caplog.clear()
|
|
|
|
exchange._api_async.fetch_trades.reset_mock()
|
|
|
|
res = await exchange._async_fetch_trades(pair, since=None, params={'from': '123'})
|
|
|
|
assert exchange._api_async.fetch_trades.call_count == 1
|
|
|
|
assert exchange._api_async.fetch_trades.call_args[0][0] == pair
|
|
|
|
assert exchange._api_async.fetch_trades.call_args[1]['limit'] == 1000
|
|
|
|
assert exchange._api_async.fetch_trades.call_args[1]['params'] == {'from': '123'}
|
|
|
|
assert log_has_re(f"Fetching trades for pair {pair}, params: .*", caplog)
|
|
|
|
|
|
|
|
exchange = Exchange(default_conf)
|
|
|
|
await async_ccxt_exception(mocker, default_conf, MagicMock(),
|
|
|
|
"_async_fetch_trades", "fetch_trades",
|
|
|
|
pair='ABCD/BTC', since=None)
|
|
|
|
|
|
|
|
api_mock = MagicMock()
|
|
|
|
with pytest.raises(OperationalException, match=r'Could not fetch trade data*'):
|
|
|
|
api_mock.fetch_trades = MagicMock(side_effect=ccxt.BaseError("Unknown error"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2020-10-12 17:58:04 +00:00
|
|
|
await exchange._async_fetch_trades(pair, since=(arrow.utcnow().int_timestamp - 2000) * 1000)
|
2019-08-29 14:33:56 +00:00
|
|
|
|
|
|
|
with pytest.raises(OperationalException, match=r'Exchange.* does not support fetching '
|
|
|
|
r'historical trade data\..*'):
|
|
|
|
api_mock.fetch_trades = MagicMock(side_effect=ccxt.NotSupported("Not supported"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2020-10-12 17:58:04 +00:00
|
|
|
await exchange._async_fetch_trades(pair, since=(arrow.utcnow().int_timestamp - 2000) * 1000)
|
2019-08-29 14:33:56 +00:00
|
|
|
|
|
|
|
|
2021-12-21 21:45:16 +00:00
|
|
|
@pytest.mark.asyncio
|
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
async def test__async_fetch_trades_contract_size(default_conf, mocker, caplog, exchange_name,
|
|
|
|
fetch_trades_result):
|
|
|
|
caplog.set_level(logging.DEBUG)
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2021-12-21 21:45:16 +00:00
|
|
|
default_conf['trading_mode'] = 'futures'
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
# Monkey-patch async function
|
|
|
|
exchange._api_async.fetch_trades = get_mock_coro([
|
|
|
|
{'info': {'a': 126181333,
|
|
|
|
'p': '0.01952600',
|
|
|
|
'q': '0.01200000',
|
|
|
|
'f': 138604158,
|
|
|
|
'l': 138604158,
|
|
|
|
'T': 1565798399872,
|
|
|
|
'm': True,
|
|
|
|
'M': True},
|
|
|
|
'timestamp': 1565798399872,
|
|
|
|
'datetime': '2019-08-14T15:59:59.872Z',
|
|
|
|
'symbol': 'ETH/USDT:USDT',
|
|
|
|
'id': '126181383',
|
|
|
|
'order': None,
|
|
|
|
'type': None,
|
|
|
|
'takerOrMaker': None,
|
|
|
|
'side': 'sell',
|
|
|
|
'price': 2.0,
|
|
|
|
'amount': 30.0,
|
|
|
|
'cost': 60.0,
|
|
|
|
'fee': None}]
|
|
|
|
)
|
|
|
|
|
|
|
|
pair = 'ETH/USDT:USDT'
|
|
|
|
res = await exchange._async_fetch_trades(pair, since=None, params=None)
|
|
|
|
assert res[0][5] == 300
|
|
|
|
|
|
|
|
|
2019-09-28 09:17:02 +00:00
|
|
|
@pytest.mark.asyncio
|
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2021-01-07 19:06:26 +00:00
|
|
|
async def test__async_get_trade_history_id(default_conf, mocker, exchange_name,
|
|
|
|
fetch_trades_result):
|
2019-09-28 09:17:02 +00:00
|
|
|
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
2019-09-28 11:35:25 +00:00
|
|
|
pagination_arg = exchange._trades_pagination_arg
|
|
|
|
|
|
|
|
async def mock_get_trade_hist(pair, *args, **kwargs):
|
|
|
|
if 'since' in kwargs:
|
|
|
|
# Return first 3
|
2021-01-07 19:06:26 +00:00
|
|
|
return fetch_trades_result[:-2]
|
|
|
|
elif kwargs.get('params', {}).get(pagination_arg) == fetch_trades_result[-3]['id']:
|
2019-09-28 11:35:25 +00:00
|
|
|
# Return 2
|
2021-01-07 19:06:26 +00:00
|
|
|
return fetch_trades_result[-3:-1]
|
2019-09-28 11:35:25 +00:00
|
|
|
else:
|
|
|
|
# Return last 2
|
2021-01-07 19:06:26 +00:00
|
|
|
return fetch_trades_result[-2:]
|
2019-09-28 09:17:02 +00:00
|
|
|
# Monkey-patch async function
|
2021-01-07 19:06:26 +00:00
|
|
|
exchange._api_async.fetch_trades = MagicMock(side_effect=mock_get_trade_hist)
|
2019-09-28 11:35:25 +00:00
|
|
|
|
2019-09-28 09:17:02 +00:00
|
|
|
pair = 'ETH/BTC'
|
2021-01-07 19:06:26 +00:00
|
|
|
ret = await exchange._async_get_trade_history_id(pair,
|
|
|
|
since=fetch_trades_result[0]['timestamp'],
|
|
|
|
until=fetch_trades_result[-1]['timestamp'] - 1)
|
2019-09-28 11:35:25 +00:00
|
|
|
assert type(ret) is tuple
|
|
|
|
assert ret[0] == pair
|
|
|
|
assert type(ret[1]) is list
|
2021-01-07 19:06:26 +00:00
|
|
|
assert len(ret[1]) == len(fetch_trades_result)
|
|
|
|
assert exchange._api_async.fetch_trades.call_count == 3
|
|
|
|
fetch_trades_cal = exchange._api_async.fetch_trades.call_args_list
|
2019-09-28 11:35:25 +00:00
|
|
|
# first call (using since, not fromId)
|
|
|
|
assert fetch_trades_cal[0][0][0] == pair
|
2021-01-07 19:06:26 +00:00
|
|
|
assert fetch_trades_cal[0][1]['since'] == fetch_trades_result[0]['timestamp']
|
2019-09-28 11:35:25 +00:00
|
|
|
|
|
|
|
# 2nd call
|
|
|
|
assert fetch_trades_cal[1][0][0] == pair
|
|
|
|
assert 'params' in fetch_trades_cal[1][1]
|
|
|
|
assert exchange._ft_has['trades_pagination_arg'] in fetch_trades_cal[1][1]['params']
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
async def test__async_get_trade_history_time(default_conf, mocker, caplog, exchange_name,
|
2021-01-07 19:03:34 +00:00
|
|
|
fetch_trades_result):
|
2019-09-28 11:35:25 +00:00
|
|
|
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
|
|
|
|
async def mock_get_trade_hist(pair, *args, **kwargs):
|
2021-01-07 19:03:34 +00:00
|
|
|
if kwargs['since'] == fetch_trades_result[0]['timestamp']:
|
|
|
|
return fetch_trades_result[:-1]
|
2019-09-28 11:35:25 +00:00
|
|
|
else:
|
2021-01-07 19:03:34 +00:00
|
|
|
return fetch_trades_result[-1:]
|
2019-09-28 11:35:25 +00:00
|
|
|
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
# Monkey-patch async function
|
2021-01-07 19:03:34 +00:00
|
|
|
exchange._api_async.fetch_trades = MagicMock(side_effect=mock_get_trade_hist)
|
2019-09-28 11:35:25 +00:00
|
|
|
pair = 'ETH/BTC'
|
2022-04-11 16:02:02 +00:00
|
|
|
ret = await exchange._async_get_trade_history_time(
|
|
|
|
pair,
|
|
|
|
since=fetch_trades_result[0]['timestamp'],
|
|
|
|
until=fetch_trades_result[-1]['timestamp'] - 1)
|
2019-09-28 09:17:02 +00:00
|
|
|
assert type(ret) is tuple
|
|
|
|
assert ret[0] == pair
|
|
|
|
assert type(ret[1]) is list
|
2021-01-07 19:03:34 +00:00
|
|
|
assert len(ret[1]) == len(fetch_trades_result)
|
|
|
|
assert exchange._api_async.fetch_trades.call_count == 2
|
|
|
|
fetch_trades_cal = exchange._api_async.fetch_trades.call_args_list
|
2019-09-28 09:17:02 +00:00
|
|
|
# first call (using since, not fromId)
|
2019-09-28 11:35:25 +00:00
|
|
|
assert fetch_trades_cal[0][0][0] == pair
|
2021-01-07 19:03:34 +00:00
|
|
|
assert fetch_trades_cal[0][1]['since'] == fetch_trades_result[0]['timestamp']
|
2019-09-28 09:17:02 +00:00
|
|
|
|
|
|
|
# 2nd call
|
2019-09-28 11:35:25 +00:00
|
|
|
assert fetch_trades_cal[1][0][0] == pair
|
2021-01-07 19:03:34 +00:00
|
|
|
assert fetch_trades_cal[1][1]['since'] == fetch_trades_result[-2]['timestamp']
|
2019-09-28 11:35:25 +00:00
|
|
|
assert log_has_re(r"Stopping because until was reached.*", caplog)
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
async def test__async_get_trade_history_time_empty(default_conf, mocker, caplog, exchange_name,
|
|
|
|
trades_history):
|
|
|
|
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
|
|
|
|
async def mock_get_trade_hist(pair, *args, **kwargs):
|
2020-04-01 04:53:58 +00:00
|
|
|
if kwargs['since'] == trades_history[0][0]:
|
2019-09-28 11:35:25 +00:00
|
|
|
return trades_history[:-1]
|
|
|
|
else:
|
|
|
|
return []
|
|
|
|
|
|
|
|
caplog.set_level(logging.DEBUG)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
# Monkey-patch async function
|
|
|
|
exchange._async_fetch_trades = MagicMock(side_effect=mock_get_trade_hist)
|
|
|
|
pair = 'ETH/BTC'
|
2020-04-01 04:53:58 +00:00
|
|
|
ret = await exchange._async_get_trade_history_time(pair, since=trades_history[0][0],
|
2022-04-11 16:02:02 +00:00
|
|
|
until=trades_history[-1][0] - 1)
|
2019-09-28 11:35:25 +00:00
|
|
|
assert type(ret) is tuple
|
|
|
|
assert ret[0] == pair
|
|
|
|
assert type(ret[1]) is list
|
|
|
|
assert len(ret[1]) == len(trades_history) - 1
|
|
|
|
assert exchange._async_fetch_trades.call_count == 2
|
|
|
|
fetch_trades_cal = exchange._async_fetch_trades.call_args_list
|
|
|
|
# first call (using since, not fromId)
|
|
|
|
assert fetch_trades_cal[0][0][0] == pair
|
2020-04-01 04:53:58 +00:00
|
|
|
assert fetch_trades_cal[0][1]['since'] == trades_history[0][0]
|
2019-09-28 09:17:02 +00:00
|
|
|
|
|
|
|
|
2019-08-30 04:51:21 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_get_historic_trades(default_conf, mocker, caplog, exchange_name, trades_history):
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
|
|
|
|
pair = 'ETH/BTC'
|
|
|
|
|
|
|
|
exchange._async_get_trade_history_id = get_mock_coro((pair, trades_history))
|
|
|
|
exchange._async_get_trade_history_time = get_mock_coro((pair, trades_history))
|
2020-04-01 04:53:58 +00:00
|
|
|
ret = exchange.get_historic_trades(pair, since=trades_history[0][0],
|
|
|
|
until=trades_history[-1][0])
|
2019-08-30 04:51:21 +00:00
|
|
|
|
|
|
|
# Depending on the exchange, one or the other method should be called
|
|
|
|
assert sum([exchange._async_get_trade_history_id.call_count,
|
|
|
|
exchange._async_get_trade_history_time.call_count]) == 1
|
|
|
|
|
|
|
|
assert len(ret) == 2
|
|
|
|
assert ret[0] == pair
|
2019-09-28 11:35:25 +00:00
|
|
|
assert len(ret[1]) == len(trades_history)
|
2019-08-30 04:51:21 +00:00
|
|
|
|
|
|
|
|
2019-09-28 08:45:16 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_get_historic_trades_notsupported(default_conf, mocker, caplog, exchange_name,
|
|
|
|
trades_history):
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=False)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
|
|
|
|
pair = 'ETH/BTC'
|
|
|
|
|
|
|
|
with pytest.raises(OperationalException,
|
2021-08-16 18:02:25 +00:00
|
|
|
match="This exchange does not support downloading Trades."):
|
2020-04-01 04:53:58 +00:00
|
|
|
exchange.get_historic_trades(pair, since=trades_history[0][0],
|
|
|
|
until=trades_history[-1][0])
|
2019-09-28 08:45:16 +00:00
|
|
|
|
|
|
|
|
2022-05-20 04:26:16 +00:00
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_cancel_order_dry_run(default_conf, mocker, exchange_name):
|
2017-12-30 07:12:52 +00:00
|
|
|
default_conf['dry_run'] = True
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
2021-06-05 13:22:52 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange._is_dry_limit_order_filled', return_value=True)
|
2020-04-18 04:55:25 +00:00
|
|
|
assert exchange.cancel_order(order_id='123', pair='TKN/BTC') == {}
|
2020-03-25 16:01:45 +00:00
|
|
|
assert exchange.cancel_stoploss_order(order_id='123', pair='TKN/BTC') == {}
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2022-02-04 00:28:08 +00:00
|
|
|
order = exchange.create_order(
|
|
|
|
pair='ETH/BTC',
|
|
|
|
ordertype='limit',
|
|
|
|
side='buy',
|
|
|
|
amount=5,
|
|
|
|
rate=0.55,
|
|
|
|
time_in_force='gtc',
|
2022-02-04 10:54:16 +00:00
|
|
|
leverage=1.0,
|
2022-02-04 00:28:08 +00:00
|
|
|
)
|
2020-08-29 08:07:02 +00:00
|
|
|
|
|
|
|
cancel_order = exchange.cancel_order(order_id=order['id'], pair='ETH/BTC')
|
|
|
|
assert order['id'] == cancel_order['id']
|
|
|
|
assert order['amount'] == cancel_order['amount']
|
2020-09-06 13:27:16 +00:00
|
|
|
assert order['symbol'] == cancel_order['symbol']
|
2020-08-29 08:07:02 +00:00
|
|
|
assert cancel_order['status'] == 'canceled'
|
|
|
|
|
2017-12-30 07:12:52 +00:00
|
|
|
|
2020-03-24 16:15:47 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
@pytest.mark.parametrize("order,result", [
|
|
|
|
({'status': 'closed', 'filled': 10}, False),
|
|
|
|
({'status': 'closed', 'filled': 0.0}, True),
|
|
|
|
({'status': 'canceled', 'filled': 0.0}, True),
|
|
|
|
({'status': 'canceled', 'filled': 10.0}, False),
|
2020-04-14 17:20:47 +00:00
|
|
|
({'status': 'unknown', 'filled': 10.0}, False),
|
|
|
|
({'result': 'testest123'}, False),
|
2021-07-18 03:58:54 +00:00
|
|
|
])
|
2020-03-24 16:15:47 +00:00
|
|
|
def test_check_order_canceled_empty(mocker, default_conf, exchange_name, order, result):
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
assert exchange.check_order_canceled_empty(order) == result
|
|
|
|
|
|
|
|
|
2020-04-17 05:18:46 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
@pytest.mark.parametrize("order,result", [
|
|
|
|
({'status': 'closed', 'amount': 10, 'fee': {}}, True),
|
|
|
|
({'status': 'closed', 'amount': 0.0, 'fee': {}}, True),
|
|
|
|
({'status': 'canceled', 'amount': 0.0, 'fee': {}}, True),
|
|
|
|
({'status': 'canceled', 'amount': 10.0}, False),
|
|
|
|
({'amount': 10.0, 'fee': {}}, False),
|
|
|
|
({'result': 'testest123'}, False),
|
|
|
|
('hello_world', False),
|
2022-07-25 15:47:28 +00:00
|
|
|
({'status': 'canceled', 'amount': None, 'fee': None}, False),
|
|
|
|
({'status': 'canceled', 'filled': None, 'amount': None, 'fee': None}, False),
|
|
|
|
|
2020-04-17 05:18:46 +00:00
|
|
|
])
|
|
|
|
def test_is_cancel_order_result_suitable(mocker, default_conf, exchange_name, order, result):
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
assert exchange.is_cancel_order_result_suitable(order) == result
|
|
|
|
|
2020-04-17 15:53:18 +00:00
|
|
|
|
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
@pytest.mark.parametrize("corder,call_corder,call_forder", [
|
|
|
|
({'status': 'closed', 'amount': 10, 'fee': {}}, 1, 0),
|
|
|
|
({'amount': 10, 'fee': {}}, 1, 1),
|
|
|
|
])
|
|
|
|
def test_cancel_order_with_result(default_conf, mocker, exchange_name, corder,
|
|
|
|
call_corder, call_forder):
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
api_mock = MagicMock()
|
|
|
|
api_mock.cancel_order = MagicMock(return_value=corder)
|
|
|
|
api_mock.fetch_order = MagicMock(return_value={})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
res = exchange.cancel_order_with_result('1234', 'ETH/BTC', 1234)
|
|
|
|
assert isinstance(res, dict)
|
|
|
|
assert api_mock.cancel_order.call_count == call_corder
|
|
|
|
assert api_mock.fetch_order.call_count == call_forder
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_cancel_order_with_result_error(default_conf, mocker, exchange_name, caplog):
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
api_mock = MagicMock()
|
|
|
|
api_mock.cancel_order = MagicMock(side_effect=ccxt.InvalidOrder("Did not find order"))
|
|
|
|
api_mock.fetch_order = MagicMock(side_effect=ccxt.InvalidOrder("Did not find order"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
|
|
|
|
res = exchange.cancel_order_with_result('1234', 'ETH/BTC', 1541)
|
|
|
|
assert isinstance(res, dict)
|
2020-08-01 13:59:50 +00:00
|
|
|
assert log_has("Could not cancel order 1234 for ETH/BTC.", caplog)
|
2020-04-17 15:53:18 +00:00
|
|
|
assert log_has("Could not fetch cancelled order 1234.", caplog)
|
|
|
|
assert res['amount'] == 1541
|
|
|
|
|
|
|
|
|
2018-01-10 06:41:37 +00:00
|
|
|
# Ensure that if not dry_run, we should call API
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2021-12-25 13:38:17 +00:00
|
|
|
def test_cancel_order(default_conf, mocker, exchange_name):
|
2018-01-10 06:41:37 +00:00
|
|
|
default_conf['dry_run'] = False
|
|
|
|
api_mock = MagicMock()
|
2021-12-25 13:38:17 +00:00
|
|
|
api_mock.cancel_order = MagicMock(return_value={'id': '123'})
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-12-25 13:38:17 +00:00
|
|
|
assert exchange.cancel_order(order_id='_', pair='TKN/BTC') == {'id': '123'}
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2019-04-02 16:45:18 +00:00
|
|
|
with pytest.raises(InvalidOrderException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.cancel_order = MagicMock(side_effect=ccxt.InvalidOrder("Did not find order"))
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-12-25 13:38:17 +00:00
|
|
|
exchange.cancel_order(order_id='_', pair='TKN/BTC')
|
2019-04-02 16:45:18 +00:00
|
|
|
assert api_mock.cancel_order.call_count == 1
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
2018-06-28 20:18:38 +00:00
|
|
|
"cancel_order", "cancel_order",
|
2021-12-25 13:38:17 +00:00
|
|
|
order_id='_', pair='TKN/BTC')
|
2018-01-10 06:41:37 +00:00
|
|
|
|
|
|
|
|
2020-03-25 16:01:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_cancel_stoploss_order(default_conf, mocker, exchange_name):
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
api_mock = MagicMock()
|
2021-02-08 18:37:24 +00:00
|
|
|
api_mock.cancel_order = MagicMock(return_value={'id': '123'})
|
2020-03-25 16:01:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-02-08 18:37:24 +00:00
|
|
|
assert exchange.cancel_stoploss_order(order_id='_', pair='TKN/BTC') == {'id': '123'}
|
2020-03-25 16:01:45 +00:00
|
|
|
|
|
|
|
with pytest.raises(InvalidOrderException):
|
|
|
|
api_mock.cancel_order = MagicMock(side_effect=ccxt.InvalidOrder("Did not find order"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
exchange.cancel_stoploss_order(order_id='_', pair='TKN/BTC')
|
|
|
|
assert api_mock.cancel_order.call_count == 1
|
|
|
|
|
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
|
|
|
"cancel_stoploss_order", "cancel_order",
|
|
|
|
order_id='_', pair='TKN/BTC')
|
|
|
|
|
|
|
|
|
2021-05-16 12:31:53 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_cancel_stoploss_order_with_result(default_conf, mocker, exchange_name):
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_stoploss_order', return_value={'for': 123})
|
2022-03-18 07:18:17 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Gateio.fetch_stoploss_order', return_value={'for': 123})
|
2021-05-16 12:31:53 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
|
2022-03-18 07:18:17 +00:00
|
|
|
res = {'fee': {}, 'status': 'canceled', 'amount': 1234}
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.cancel_stoploss_order', return_value=res)
|
|
|
|
mocker.patch('freqtrade.exchange.Gateio.cancel_stoploss_order', return_value=res)
|
2021-05-16 12:31:53 +00:00
|
|
|
co = exchange.cancel_stoploss_order_with_result(order_id='_', pair='TKN/BTC', amount=555)
|
2022-03-18 07:18:17 +00:00
|
|
|
assert co == res
|
2021-05-16 12:31:53 +00:00
|
|
|
|
2022-03-18 07:18:17 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.cancel_stoploss_order', return_value='canceled')
|
|
|
|
mocker.patch('freqtrade.exchange.Gateio.cancel_stoploss_order', return_value='canceled')
|
2021-05-16 12:31:53 +00:00
|
|
|
# Fall back to fetch_stoploss_order
|
|
|
|
co = exchange.cancel_stoploss_order_with_result(order_id='_', pair='TKN/BTC', amount=555)
|
|
|
|
assert co == {'for': 123}
|
|
|
|
|
2022-03-18 07:18:17 +00:00
|
|
|
exc = InvalidOrderException("")
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_stoploss_order', side_effect=exc)
|
|
|
|
mocker.patch('freqtrade.exchange.Gateio.fetch_stoploss_order', side_effect=exc)
|
2021-05-16 12:31:53 +00:00
|
|
|
co = exchange.cancel_stoploss_order_with_result(order_id='_', pair='TKN/BTC', amount=555)
|
|
|
|
assert co['amount'] == 555
|
|
|
|
assert co == {'fee': {}, 'status': 'canceled', 'amount': 555, 'info': {}}
|
|
|
|
|
|
|
|
with pytest.raises(InvalidOrderException):
|
2022-03-18 07:18:17 +00:00
|
|
|
exc = InvalidOrderException("Did not find order")
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.cancel_stoploss_order', side_effect=exc)
|
|
|
|
mocker.patch('freqtrade.exchange.Gateio.cancel_stoploss_order', side_effect=exc)
|
2021-05-16 12:31:53 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
exchange.cancel_stoploss_order_with_result(order_id='_', pair='TKN/BTC', amount=123)
|
|
|
|
|
|
|
|
|
2022-05-20 04:26:16 +00:00
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2021-12-25 13:38:17 +00:00
|
|
|
def test_fetch_order(default_conf, mocker, exchange_name, caplog):
|
2018-01-10 06:41:37 +00:00
|
|
|
default_conf['dry_run'] = True
|
2021-06-10 18:09:25 +00:00
|
|
|
default_conf['exchange']['log_responses'] = True
|
2018-01-10 06:41:37 +00:00
|
|
|
order = MagicMock()
|
|
|
|
order.myid = 123
|
2021-12-25 13:38:17 +00:00
|
|
|
order.symbol = 'TKN/BTC'
|
2021-12-21 21:45:16 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
2018-06-18 20:09:46 +00:00
|
|
|
exchange._dry_run_open_orders['X'] = order
|
2020-06-28 14:27:35 +00:00
|
|
|
assert exchange.fetch_order('X', 'TKN/BTC').myid == 123
|
2018-01-10 06:41:37 +00:00
|
|
|
|
2019-08-18 17:38:23 +00:00
|
|
|
with pytest.raises(InvalidOrderException, match=r'Tried to get an invalid dry-run-order.*'):
|
2020-06-28 14:27:35 +00:00
|
|
|
exchange.fetch_order('Y', 'TKN/BTC')
|
2019-08-18 17:38:23 +00:00
|
|
|
|
2018-01-10 06:41:37 +00:00
|
|
|
default_conf['dry_run'] = False
|
|
|
|
api_mock = MagicMock()
|
2021-12-25 13:38:17 +00:00
|
|
|
api_mock.fetch_order = MagicMock(return_value={'id': '123', 'amount': 2, 'symbol': 'TKN/BTC'})
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-12-21 21:45:16 +00:00
|
|
|
assert exchange.fetch_order(
|
2021-12-25 13:38:17 +00:00
|
|
|
'X', 'TKN/BTC') == {'id': '123', 'amount': 2, 'symbol': 'TKN/BTC'}
|
2021-12-21 21:45:16 +00:00
|
|
|
assert log_has(
|
2021-12-25 13:38:17 +00:00
|
|
|
("API fetch_order: {\'id\': \'123\', \'amount\': 2, \'symbol\': \'TKN/BTC\'}"
|
2021-12-21 21:45:16 +00:00
|
|
|
),
|
|
|
|
caplog
|
|
|
|
)
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2019-04-05 17:46:43 +00:00
|
|
|
with pytest.raises(InvalidOrderException):
|
2019-07-22 18:57:40 +00:00
|
|
|
api_mock.fetch_order = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2020-06-28 14:27:35 +00:00
|
|
|
exchange.fetch_order(order_id='_', pair='TKN/BTC')
|
2019-04-05 17:46:43 +00:00
|
|
|
assert api_mock.fetch_order.call_count == 1
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2020-06-28 17:45:42 +00:00
|
|
|
api_mock.fetch_order = MagicMock(side_effect=ccxt.OrderNotFound("Order not found"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
with patch('freqtrade.exchange.common.time.sleep') as tm:
|
|
|
|
with pytest.raises(InvalidOrderException):
|
|
|
|
exchange.fetch_order(order_id='_', pair='TKN/BTC')
|
|
|
|
# Ensure backoff is called
|
|
|
|
assert tm.call_args_list[0][0][0] == 1
|
|
|
|
assert tm.call_args_list[1][0][0] == 2
|
2020-08-22 15:35:42 +00:00
|
|
|
if API_FETCH_ORDER_RETRY_COUNT > 2:
|
|
|
|
assert tm.call_args_list[2][0][0] == 5
|
|
|
|
if API_FETCH_ORDER_RETRY_COUNT > 3:
|
|
|
|
assert tm.call_args_list[3][0][0] == 10
|
|
|
|
assert api_mock.fetch_order.call_count == API_FETCH_ORDER_RETRY_COUNT + 1
|
2020-06-28 17:45:42 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
2020-08-22 15:35:42 +00:00
|
|
|
'fetch_order', 'fetch_order', retries=API_FETCH_ORDER_RETRY_COUNT + 1,
|
2018-06-28 20:18:38 +00:00
|
|
|
order_id='_', pair='TKN/BTC')
|
2018-01-10 06:41:37 +00:00
|
|
|
|
|
|
|
|
2022-05-20 04:26:16 +00:00
|
|
|
@pytest.mark.usefixtures("init_persistence")
|
2020-03-25 16:01:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2020-06-28 14:30:24 +00:00
|
|
|
def test_fetch_stoploss_order(default_conf, mocker, exchange_name):
|
2020-03-25 16:01:45 +00:00
|
|
|
default_conf['dry_run'] = True
|
|
|
|
order = MagicMock()
|
|
|
|
order.myid = 123
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
exchange._dry_run_open_orders['X'] = order
|
2020-06-28 14:30:24 +00:00
|
|
|
assert exchange.fetch_stoploss_order('X', 'TKN/BTC').myid == 123
|
2020-03-25 16:01:45 +00:00
|
|
|
|
|
|
|
with pytest.raises(InvalidOrderException, match=r'Tried to get an invalid dry-run-order.*'):
|
2020-06-28 14:30:24 +00:00
|
|
|
exchange.fetch_stoploss_order('Y', 'TKN/BTC')
|
2020-03-25 16:01:45 +00:00
|
|
|
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
api_mock = MagicMock()
|
2021-12-25 13:38:17 +00:00
|
|
|
api_mock.fetch_order = MagicMock(return_value={'id': '123', 'symbol': 'TKN/BTC'})
|
2020-03-25 16:01:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-12-25 13:38:17 +00:00
|
|
|
assert exchange.fetch_stoploss_order('X', 'TKN/BTC') == {'id': '123', 'symbol': 'TKN/BTC'}
|
2020-03-25 16:01:45 +00:00
|
|
|
|
|
|
|
with pytest.raises(InvalidOrderException):
|
|
|
|
api_mock.fetch_order = MagicMock(side_effect=ccxt.InvalidOrder("Order not found"))
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2020-06-28 14:30:24 +00:00
|
|
|
exchange.fetch_stoploss_order(order_id='_', pair='TKN/BTC')
|
2020-03-25 16:01:45 +00:00
|
|
|
assert api_mock.fetch_order.call_count == 1
|
|
|
|
|
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
2020-06-28 14:30:24 +00:00
|
|
|
'fetch_stoploss_order', 'fetch_order',
|
2020-08-22 15:35:42 +00:00
|
|
|
retries=API_FETCH_ORDER_RETRY_COUNT + 1,
|
2020-03-25 16:01:45 +00:00
|
|
|
order_id='_', pair='TKN/BTC')
|
|
|
|
|
2020-06-01 09:24:23 +00:00
|
|
|
|
2020-08-22 07:24:14 +00:00
|
|
|
def test_fetch_order_or_stoploss_order(default_conf, mocker):
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id='binance')
|
|
|
|
fetch_order_mock = MagicMock()
|
|
|
|
fetch_stoploss_order_mock = MagicMock()
|
|
|
|
mocker.patch.multiple('freqtrade.exchange.Exchange',
|
|
|
|
fetch_order=fetch_order_mock,
|
|
|
|
fetch_stoploss_order=fetch_stoploss_order_mock,
|
|
|
|
)
|
|
|
|
|
|
|
|
exchange.fetch_order_or_stoploss_order('1234', 'ETH/BTC', False)
|
|
|
|
assert fetch_order_mock.call_count == 1
|
|
|
|
assert fetch_order_mock.call_args_list[0][0][0] == '1234'
|
|
|
|
assert fetch_order_mock.call_args_list[0][0][1] == 'ETH/BTC'
|
|
|
|
assert fetch_stoploss_order_mock.call_count == 0
|
|
|
|
|
|
|
|
fetch_order_mock.reset_mock()
|
|
|
|
fetch_stoploss_order_mock.reset_mock()
|
|
|
|
|
|
|
|
exchange.fetch_order_or_stoploss_order('1234', 'ETH/BTC', True)
|
|
|
|
assert fetch_order_mock.call_count == 0
|
|
|
|
assert fetch_stoploss_order_mock.call_count == 1
|
|
|
|
assert fetch_stoploss_order_mock.call_args_list[0][0][0] == '1234'
|
|
|
|
assert fetch_stoploss_order_mock.call_args_list[0][0][1] == 'ETH/BTC'
|
|
|
|
|
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2019-09-10 21:18:07 +00:00
|
|
|
def test_name(default_conf, mocker, exchange_name):
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
assert exchange.name == exchange_name.title()
|
|
|
|
assert exchange.id == exchange_name
|
2018-04-06 07:57:08 +00:00
|
|
|
|
|
|
|
|
2021-12-21 21:45:16 +00:00
|
|
|
@pytest.mark.parametrize("trading_mode,amount", [
|
|
|
|
('spot', 0.2340606),
|
2022-01-02 12:11:29 +00:00
|
|
|
('futures', 2.340606),
|
2021-12-21 21:45:16 +00:00
|
|
|
])
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
2021-12-21 21:45:16 +00:00
|
|
|
def test_get_trades_for_order(default_conf, mocker, exchange_name, trading_mode, amount):
|
2018-06-17 21:22:28 +00:00
|
|
|
order_id = 'ABCD-ABCD'
|
2019-11-08 05:55:07 +00:00
|
|
|
since = datetime(2018, 5, 5, 0, 0, 0)
|
2018-06-17 21:22:28 +00:00
|
|
|
default_conf["dry_run"] = False
|
2021-12-21 21:45:16 +00:00
|
|
|
default_conf["trading_mode"] = trading_mode
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf["margin_mode"] = 'isolated'
|
2018-06-17 21:22:28 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
|
|
|
|
api_mock = MagicMock()
|
|
|
|
|
|
|
|
api_mock.fetch_my_trades = MagicMock(return_value=[{'id': 'TTR67E-3PFBD-76IISV',
|
|
|
|
'order': 'ABCD-ABCD',
|
|
|
|
'info': {'pair': 'XLTCZBTC',
|
|
|
|
'time': 1519860024.4388,
|
|
|
|
'type': 'buy',
|
|
|
|
'ordertype': 'limit',
|
|
|
|
'price': '20.00000',
|
|
|
|
'cost': '38.62000',
|
|
|
|
'fee': '0.06179',
|
|
|
|
'vol': '5',
|
|
|
|
'id': 'ABCD-ABCD'},
|
|
|
|
'timestamp': 1519860024438,
|
|
|
|
'datetime': '2018-02-28T23:20:24.438Z',
|
2021-12-21 21:45:16 +00:00
|
|
|
'symbol': 'ETH/USDT:USDT',
|
2018-06-17 21:22:28 +00:00
|
|
|
'type': 'limit',
|
|
|
|
'side': 'buy',
|
|
|
|
'price': 165.0,
|
|
|
|
'amount': 0.2340606,
|
|
|
|
'fee': {'cost': 0.06179, 'currency': 'BTC'}
|
|
|
|
}])
|
2021-12-21 21:45:16 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2018-06-17 21:22:28 +00:00
|
|
|
|
2021-12-21 21:45:16 +00:00
|
|
|
orders = exchange.get_trades_for_order(order_id, 'ETH/USDT:USDT', since)
|
2018-06-17 21:22:28 +00:00
|
|
|
assert len(orders) == 1
|
|
|
|
assert orders[0]['price'] == 165
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(orders[0]['amount']) == amount
|
2019-08-06 18:09:09 +00:00
|
|
|
assert api_mock.fetch_my_trades.call_count == 1
|
|
|
|
# since argument should be
|
|
|
|
assert isinstance(api_mock.fetch_my_trades.call_args[0][1], int)
|
2021-12-21 21:45:16 +00:00
|
|
|
assert api_mock.fetch_my_trades.call_args[0][0] == 'ETH/USDT:USDT'
|
2019-08-06 18:09:09 +00:00
|
|
|
# Same test twice, hardcoded number and doing the same calculation
|
2019-08-06 18:23:32 +00:00
|
|
|
assert api_mock.fetch_my_trades.call_args[0][1] == 1525478395000
|
2019-11-08 05:55:07 +00:00
|
|
|
assert api_mock.fetch_my_trades.call_args[0][1] == int(since.replace(
|
|
|
|
tzinfo=timezone.utc).timestamp() - 5) * 1000
|
2018-06-17 21:22:28 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
2018-06-28 20:18:38 +00:00
|
|
|
'get_trades_for_order', 'fetch_my_trades',
|
2021-12-21 21:45:16 +00:00
|
|
|
order_id=order_id, pair='ETH/USDT:USDT', since=since)
|
2018-06-17 21:22:28 +00:00
|
|
|
|
2018-06-28 19:51:59 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=False))
|
2021-12-21 21:45:16 +00:00
|
|
|
assert exchange.get_trades_for_order(order_id, 'ETH/USDT:USDT', since) == []
|
2018-06-28 19:51:59 +00:00
|
|
|
|
2018-06-17 21:22:28 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_get_fee(default_conf, mocker, exchange_name):
|
2018-01-10 06:41:37 +00:00
|
|
|
api_mock = MagicMock()
|
2018-04-06 07:57:08 +00:00
|
|
|
api_mock.calculate_fee = MagicMock(return_value={
|
|
|
|
'type': 'taker',
|
|
|
|
'currency': 'BTC',
|
|
|
|
'rate': 0.025,
|
|
|
|
'cost': 0.05
|
|
|
|
})
|
2019-02-24 18:59:45 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2021-03-14 18:37:30 +00:00
|
|
|
exchange._config.pop('fee', None)
|
2018-06-17 18:13:39 +00:00
|
|
|
|
2019-12-14 12:22:42 +00:00
|
|
|
assert exchange.get_fee('ETH/BTC') == 0.025
|
2021-03-14 18:37:30 +00:00
|
|
|
assert api_mock.calculate_fee.call_count == 1
|
2018-04-16 17:43:13 +00:00
|
|
|
|
2019-02-24 18:59:45 +00:00
|
|
|
ccxt_exceptionhandlers(mocker, default_conf, api_mock, exchange_name,
|
2019-12-14 12:22:42 +00:00
|
|
|
'get_fee', 'calculate_fee', symbol="ETH/BTC")
|
2018-11-22 16:41:01 +00:00
|
|
|
|
2021-03-14 18:37:30 +00:00
|
|
|
api_mock.calculate_fee.reset_mock()
|
|
|
|
exchange._config['fee'] = 0.001
|
|
|
|
|
|
|
|
assert exchange.get_fee('ETH/BTC') == 0.001
|
|
|
|
assert api_mock.calculate_fee.call_count == 0
|
|
|
|
|
2018-11-22 18:38:20 +00:00
|
|
|
|
2020-01-19 13:39:51 +00:00
|
|
|
def test_stoploss_order_unsupported_exchange(default_conf, mocker):
|
2020-12-20 18:38:12 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id='bittrex')
|
2020-01-19 13:39:51 +00:00
|
|
|
with pytest.raises(OperationalException, match=r"stoploss is not implemented .*"):
|
2021-09-19 23:02:09 +00:00
|
|
|
exchange.stoploss(
|
|
|
|
pair='ETH/BTC',
|
|
|
|
amount=1,
|
|
|
|
stop_price=220,
|
|
|
|
order_types={},
|
|
|
|
side="sell",
|
|
|
|
leverage=1.0
|
|
|
|
)
|
2018-11-30 19:13:50 +00:00
|
|
|
|
2020-01-19 18:54:30 +00:00
|
|
|
with pytest.raises(OperationalException, match=r"stoploss is not implemented .*"):
|
2021-09-19 23:02:09 +00:00
|
|
|
exchange.stoploss_adjust(1, {}, side="sell")
|
2020-01-19 18:54:30 +00:00
|
|
|
|
2018-11-24 17:08:11 +00:00
|
|
|
|
2019-06-09 12:05:36 +00:00
|
|
|
def test_merge_ft_has_dict(default_conf, mocker):
|
2019-07-03 18:20:12 +00:00
|
|
|
mocker.patch.multiple('freqtrade.exchange.Exchange',
|
|
|
|
_init_ccxt=MagicMock(return_value=MagicMock()),
|
2020-06-13 10:34:29 +00:00
|
|
|
_load_async_markets=MagicMock(),
|
2019-07-03 18:20:12 +00:00
|
|
|
validate_pairs=MagicMock(),
|
2020-01-11 10:54:11 +00:00
|
|
|
validate_timeframes=MagicMock(),
|
2022-03-18 18:26:54 +00:00
|
|
|
validate_stakecurrency=MagicMock(),
|
|
|
|
validate_pricing=MagicMock(),
|
2020-01-11 10:54:11 +00:00
|
|
|
)
|
2019-06-09 12:05:36 +00:00
|
|
|
ex = Exchange(default_conf)
|
|
|
|
assert ex._ft_has == Exchange._ft_has_default
|
|
|
|
|
|
|
|
ex = Kraken(default_conf)
|
2019-08-15 14:49:54 +00:00
|
|
|
assert ex._ft_has != Exchange._ft_has_default
|
2022-08-21 15:48:13 +00:00
|
|
|
assert ex.get_option('trades_pagination') == 'id'
|
|
|
|
assert ex.get_option('trades_pagination_arg') == 'since'
|
2019-06-09 12:05:36 +00:00
|
|
|
|
|
|
|
# Binance defines different values
|
|
|
|
ex = Binance(default_conf)
|
|
|
|
assert ex._ft_has != Exchange._ft_has_default
|
2022-08-21 15:48:13 +00:00
|
|
|
assert ex.get_option('stoploss_on_exchange')
|
2022-08-27 08:24:56 +00:00
|
|
|
assert ex.get_option('order_time_in_force') == ['GTC', 'FOK', 'IOC']
|
2022-08-21 15:48:13 +00:00
|
|
|
assert ex.get_option('trades_pagination') == 'id'
|
|
|
|
assert ex.get_option('trades_pagination_arg') == 'fromId'
|
2019-06-09 12:05:36 +00:00
|
|
|
|
|
|
|
conf = copy.deepcopy(default_conf)
|
|
|
|
conf['exchange']['_ft_has_params'] = {"DeadBeef": 20,
|
|
|
|
"stoploss_on_exchange": False}
|
|
|
|
# Use settings from configuration (overriding stoploss_on_exchange)
|
|
|
|
ex = Binance(conf)
|
|
|
|
assert ex._ft_has != Exchange._ft_has_default
|
|
|
|
assert not ex._ft_has['stoploss_on_exchange']
|
|
|
|
assert ex._ft_has['DeadBeef'] == 20
|
2019-07-03 18:20:12 +00:00
|
|
|
|
|
|
|
|
|
|
|
def test_get_valid_pair_combination(default_conf, mocker, markets):
|
|
|
|
mocker.patch.multiple('freqtrade.exchange.Exchange',
|
|
|
|
_init_ccxt=MagicMock(return_value=MagicMock()),
|
2020-06-13 10:34:29 +00:00
|
|
|
_load_async_markets=MagicMock(),
|
2019-07-03 18:20:12 +00:00
|
|
|
validate_pairs=MagicMock(),
|
|
|
|
validate_timeframes=MagicMock(),
|
2022-03-18 18:26:54 +00:00
|
|
|
validate_pricing=MagicMock(),
|
2019-07-03 18:20:12 +00:00
|
|
|
markets=PropertyMock(return_value=markets))
|
|
|
|
ex = Exchange(default_conf)
|
|
|
|
|
|
|
|
assert ex.get_valid_pair_combination("ETH", "BTC") == "ETH/BTC"
|
|
|
|
assert ex.get_valid_pair_combination("BTC", "ETH") == "ETH/BTC"
|
|
|
|
with pytest.raises(DependencyException, match=r"Could not combine.* to get a valid pair."):
|
|
|
|
ex.get_valid_pair_combination("NOPAIR", "ETH")
|
2019-08-12 13:43:10 +00:00
|
|
|
|
|
|
|
|
2019-10-17 20:40:29 +00:00
|
|
|
@pytest.mark.parametrize(
|
2021-11-01 08:12:39 +00:00
|
|
|
"base_currencies,quote_currencies,tradable_only,active_only,spot_only,"
|
2022-02-14 15:24:42 +00:00
|
|
|
"futures_only,expected_keys,test_comment", [
|
2019-10-17 20:40:29 +00:00
|
|
|
# Testing markets (in conftest.py):
|
|
|
|
# 'BLK/BTC': 'active': True
|
|
|
|
# 'BTT/BTC': 'active': True
|
|
|
|
# 'ETH/BTC': 'active': True
|
|
|
|
# 'ETH/USDT': 'active': True
|
|
|
|
# 'LTC/BTC': 'active': False
|
2020-02-24 20:50:27 +00:00
|
|
|
# 'LTC/ETH': 'active': True
|
2019-10-17 20:40:29 +00:00
|
|
|
# 'LTC/USD': 'active': True
|
|
|
|
# 'LTC/USDT': 'active': True
|
|
|
|
# 'NEO/BTC': 'active': False
|
|
|
|
# 'TKN/BTC': 'active' not set
|
|
|
|
# 'XLTCUSDT': 'active': True, not a pair
|
|
|
|
# 'XRP/BTC': 'active': False
|
2021-11-01 08:12:39 +00:00
|
|
|
([], [], False, False, False, False,
|
2022-02-15 06:42:40 +00:00
|
|
|
['BLK/BTC', 'BTT/BTC', 'ETH/BTC', 'ETH/USDT', 'LTC/BTC', 'LTC/ETH', 'LTC/USD', 'LTC/USDT',
|
|
|
|
'NEO/BTC', 'TKN/BTC', 'XLTCUSDT', 'XRP/BTC', 'ADA/USDT:USDT',
|
|
|
|
'ETH/USDT:USDT'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'all markets'),
|
2021-11-01 08:12:39 +00:00
|
|
|
([], [], False, False, True, False,
|
|
|
|
['BLK/BTC', 'BTT/BTC', 'ETH/BTC', 'ETH/USDT', 'LTC/BTC', 'LTC/ETH', 'LTC/USD',
|
2022-02-14 15:40:01 +00:00
|
|
|
'LTC/USDT', 'NEO/BTC', 'TKN/BTC', 'XRP/BTC'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'all markets, only spot pairs'),
|
2021-11-01 08:12:39 +00:00
|
|
|
([], [], False, True, False, False,
|
2020-02-24 20:50:27 +00:00
|
|
|
['BLK/BTC', 'ETH/BTC', 'ETH/USDT', 'LTC/BTC', 'LTC/ETH', 'LTC/USD', 'NEO/BTC',
|
2022-02-15 06:42:40 +00:00
|
|
|
'TKN/BTC', 'XLTCUSDT', 'XRP/BTC', 'ADA/USDT:USDT', 'ETH/USDT:USDT'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'active markets'),
|
2021-11-01 08:12:39 +00:00
|
|
|
([], [], True, False, False, False,
|
2020-02-24 20:50:27 +00:00
|
|
|
['BLK/BTC', 'BTT/BTC', 'ETH/BTC', 'ETH/USDT', 'LTC/BTC', 'LTC/ETH', 'LTC/USD',
|
2022-02-14 15:40:01 +00:00
|
|
|
'LTC/USDT', 'NEO/BTC', 'TKN/BTC', 'XRP/BTC'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'all pairs'),
|
2021-11-01 08:12:39 +00:00
|
|
|
([], [], True, True, False, False,
|
2020-02-24 20:50:27 +00:00
|
|
|
['BLK/BTC', 'ETH/BTC', 'ETH/USDT', 'LTC/BTC', 'LTC/ETH', 'LTC/USD', 'NEO/BTC',
|
2022-02-14 15:40:01 +00:00
|
|
|
'TKN/BTC', 'XRP/BTC'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'active pairs'),
|
2021-11-01 08:12:39 +00:00
|
|
|
(['ETH', 'LTC'], [], False, False, False, False,
|
2022-02-15 06:42:40 +00:00
|
|
|
['ETH/BTC', 'ETH/USDT', 'LTC/BTC', 'LTC/ETH', 'LTC/USD', 'LTC/USDT', 'XLTCUSDT',
|
|
|
|
'ETH/USDT:USDT'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'all markets, base=ETH, LTC'),
|
2021-11-01 08:12:39 +00:00
|
|
|
(['LTC'], [], False, False, False, False,
|
2022-02-14 15:24:42 +00:00
|
|
|
['LTC/BTC', 'LTC/ETH', 'LTC/USD', 'LTC/USDT', 'XLTCUSDT'],
|
|
|
|
'all markets, base=LTC'),
|
2021-11-01 08:12:39 +00:00
|
|
|
(['LTC'], [], False, False, True, False,
|
2022-02-14 15:40:01 +00:00
|
|
|
['LTC/BTC', 'LTC/ETH', 'LTC/USD', 'LTC/USDT'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'spot markets, base=LTC'),
|
2021-11-01 08:12:39 +00:00
|
|
|
([], ['USDT'], False, False, False, False,
|
2022-02-15 06:42:40 +00:00
|
|
|
['ETH/USDT', 'LTC/USDT', 'XLTCUSDT', 'ADA/USDT:USDT', 'ETH/USDT:USDT'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'all markets, quote=USDT'),
|
2021-11-01 08:12:39 +00:00
|
|
|
([], ['USDT'], False, False, False, True,
|
2022-02-15 06:42:40 +00:00
|
|
|
['ADA/USDT:USDT', 'ETH/USDT:USDT'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'Futures markets, quote=USDT'),
|
2021-11-01 08:12:39 +00:00
|
|
|
([], ['USDT', 'USD'], False, False, False, False,
|
2022-02-15 06:42:40 +00:00
|
|
|
['ETH/USDT', 'LTC/USD', 'LTC/USDT', 'XLTCUSDT', 'ADA/USDT:USDT', 'ETH/USDT:USDT'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'all markets, quote=USDT, USD'),
|
2021-11-01 08:12:39 +00:00
|
|
|
([], ['USDT', 'USD'], False, False, True, False,
|
2022-02-14 15:40:01 +00:00
|
|
|
['ETH/USDT', 'LTC/USD', 'LTC/USDT'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'spot markets, quote=USDT, USD'),
|
2021-11-01 08:12:39 +00:00
|
|
|
(['LTC'], ['USDT'], False, False, False, False,
|
2022-02-14 15:24:42 +00:00
|
|
|
['LTC/USDT', 'XLTCUSDT'],
|
|
|
|
'all markets, base=LTC, quote=USDT'),
|
2021-11-01 08:12:39 +00:00
|
|
|
(['LTC'], ['USDT'], True, False, False, False,
|
2022-02-14 15:40:01 +00:00
|
|
|
['LTC/USDT'],
|
2022-02-14 15:24:42 +00:00
|
|
|
'all pairs, base=LTC, quote=USDT'),
|
2021-11-01 08:12:39 +00:00
|
|
|
(['LTC'], ['USDT', 'NONEXISTENT'], False, False, False, False,
|
2022-02-14 15:24:42 +00:00
|
|
|
['LTC/USDT', 'XLTCUSDT'],
|
|
|
|
'all markets, base=LTC, quote=USDT, NONEXISTENT'),
|
2021-11-01 08:12:39 +00:00
|
|
|
(['LTC'], ['NONEXISTENT'], False, False, False, False,
|
2022-02-14 15:24:42 +00:00
|
|
|
[],
|
|
|
|
'all markets, base=LTC, quote=NONEXISTENT'),
|
2019-10-17 20:40:29 +00:00
|
|
|
])
|
2021-09-29 07:15:05 +00:00
|
|
|
def test_get_markets(default_conf, mocker, markets_static,
|
2021-11-01 08:12:39 +00:00
|
|
|
base_currencies, quote_currencies, tradable_only, active_only,
|
2022-02-14 15:24:42 +00:00
|
|
|
spot_only, futures_only, expected_keys,
|
|
|
|
test_comment # Here for debugging purposes (Not used within method)
|
|
|
|
):
|
2019-10-17 19:45:20 +00:00
|
|
|
mocker.patch.multiple('freqtrade.exchange.Exchange',
|
|
|
|
_init_ccxt=MagicMock(return_value=MagicMock()),
|
2020-06-13 10:34:29 +00:00
|
|
|
_load_async_markets=MagicMock(),
|
2019-10-17 19:45:20 +00:00
|
|
|
validate_pairs=MagicMock(),
|
|
|
|
validate_timeframes=MagicMock(),
|
2022-03-18 18:26:54 +00:00
|
|
|
validate_pricing=MagicMock(),
|
2021-09-29 07:15:05 +00:00
|
|
|
markets=PropertyMock(return_value=markets_static))
|
2019-10-17 19:45:20 +00:00
|
|
|
ex = Exchange(default_conf)
|
2021-11-01 08:12:39 +00:00
|
|
|
pairs = ex.get_markets(base_currencies,
|
|
|
|
quote_currencies,
|
|
|
|
tradable_only=tradable_only,
|
|
|
|
spot_only=spot_only,
|
|
|
|
futures_only=futures_only,
|
|
|
|
active_only=active_only)
|
2019-10-17 19:45:20 +00:00
|
|
|
assert sorted(pairs.keys()) == sorted(expected_keys)
|
|
|
|
|
|
|
|
|
2020-06-28 09:56:29 +00:00
|
|
|
def test_get_markets_error(default_conf, mocker):
|
|
|
|
ex = get_patched_exchange(mocker, default_conf)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.markets', PropertyMock(return_value=None))
|
|
|
|
with pytest.raises(OperationalException, match="Markets were not loaded."):
|
|
|
|
ex.get_markets('LTC', 'USDT', True, False)
|
|
|
|
|
|
|
|
|
2021-02-14 09:38:49 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", EXCHANGES)
|
|
|
|
def test_ohlcv_candle_limit(default_conf, mocker, exchange_name):
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
timeframes = ('1m', '5m', '1h')
|
|
|
|
expected = exchange._ft_has['ohlcv_candle_limit']
|
|
|
|
for timeframe in timeframes:
|
|
|
|
if 'ohlcv_candle_limit_per_timeframe' in exchange._ft_has:
|
|
|
|
expected = exchange._ft_has['ohlcv_candle_limit_per_timeframe'][timeframe]
|
|
|
|
# This should only run for bittrex
|
|
|
|
assert exchange_name == 'bittrex'
|
2022-05-14 11:27:36 +00:00
|
|
|
assert exchange.ohlcv_candle_limit(timeframe, CandleType.SPOT) == expected
|
2021-02-14 09:38:49 +00:00
|
|
|
|
|
|
|
|
2019-08-12 13:43:10 +00:00
|
|
|
def test_timeframe_to_minutes():
|
|
|
|
assert timeframe_to_minutes("5m") == 5
|
|
|
|
assert timeframe_to_minutes("10m") == 10
|
|
|
|
assert timeframe_to_minutes("1h") == 60
|
|
|
|
assert timeframe_to_minutes("1d") == 1440
|
|
|
|
|
|
|
|
|
|
|
|
def test_timeframe_to_seconds():
|
|
|
|
assert timeframe_to_seconds("5m") == 300
|
|
|
|
assert timeframe_to_seconds("10m") == 600
|
|
|
|
assert timeframe_to_seconds("1h") == 3600
|
|
|
|
assert timeframe_to_seconds("1d") == 86400
|
|
|
|
|
|
|
|
|
|
|
|
def test_timeframe_to_msecs():
|
|
|
|
assert timeframe_to_msecs("5m") == 300000
|
|
|
|
assert timeframe_to_msecs("10m") == 600000
|
|
|
|
assert timeframe_to_msecs("1h") == 3600000
|
|
|
|
assert timeframe_to_msecs("1d") == 86400000
|
2019-08-12 14:07:19 +00:00
|
|
|
|
|
|
|
|
2019-08-12 14:11:43 +00:00
|
|
|
def test_timeframe_to_prev_date():
|
|
|
|
# 2019-08-12 13:22:08
|
|
|
|
date = datetime.fromtimestamp(1565616128, tz=timezone.utc)
|
|
|
|
|
2019-08-12 14:17:06 +00:00
|
|
|
tf_list = [
|
|
|
|
# 5m -> 2019-08-12 13:20:00
|
|
|
|
("5m", datetime(2019, 8, 12, 13, 20, 0, tzinfo=timezone.utc)),
|
|
|
|
# 10m -> 2019-08-12 13:20:00
|
|
|
|
("10m", datetime(2019, 8, 12, 13, 20, 0, tzinfo=timezone.utc)),
|
|
|
|
# 1h -> 2019-08-12 13:00:00
|
|
|
|
("1h", datetime(2019, 8, 12, 13, 00, 0, tzinfo=timezone.utc)),
|
|
|
|
# 2h -> 2019-08-12 12:00:00
|
|
|
|
("2h", datetime(2019, 8, 12, 12, 00, 0, tzinfo=timezone.utc)),
|
|
|
|
# 4h -> 2019-08-12 12:00:00
|
|
|
|
("4h", datetime(2019, 8, 12, 12, 00, 0, tzinfo=timezone.utc)),
|
|
|
|
# 1d -> 2019-08-12 00:00:00
|
|
|
|
("1d", datetime(2019, 8, 12, 00, 00, 0, tzinfo=timezone.utc)),
|
|
|
|
]
|
|
|
|
for interval, result in tf_list:
|
|
|
|
assert timeframe_to_prev_date(interval, date) == result
|
2019-08-12 14:11:43 +00:00
|
|
|
|
2019-08-12 18:37:11 +00:00
|
|
|
date = datetime.now(tz=timezone.utc)
|
2019-08-25 08:53:56 +00:00
|
|
|
assert timeframe_to_prev_date("5m") < date
|
2021-02-09 19:03:03 +00:00
|
|
|
# Does not round
|
|
|
|
time = datetime(2019, 8, 12, 13, 20, 0, tzinfo=timezone.utc)
|
|
|
|
assert timeframe_to_prev_date('5m', time) == time
|
2021-11-14 18:53:08 +00:00
|
|
|
time = datetime(2019, 8, 12, 13, 0, 0, tzinfo=timezone.utc)
|
|
|
|
assert timeframe_to_prev_date('1h', time) == time
|
2019-08-12 18:37:11 +00:00
|
|
|
|
2019-08-12 14:11:43 +00:00
|
|
|
|
2019-08-12 14:07:19 +00:00
|
|
|
def test_timeframe_to_next_date():
|
|
|
|
# 2019-08-12 13:22:08
|
|
|
|
date = datetime.fromtimestamp(1565616128, tz=timezone.utc)
|
2019-08-12 14:17:06 +00:00
|
|
|
tf_list = [
|
|
|
|
# 5m -> 2019-08-12 13:25:00
|
|
|
|
("5m", datetime(2019, 8, 12, 13, 25, 0, tzinfo=timezone.utc)),
|
|
|
|
# 10m -> 2019-08-12 13:30:00
|
|
|
|
("10m", datetime(2019, 8, 12, 13, 30, 0, tzinfo=timezone.utc)),
|
|
|
|
# 1h -> 2019-08-12 14:00:00
|
|
|
|
("1h", datetime(2019, 8, 12, 14, 00, 0, tzinfo=timezone.utc)),
|
|
|
|
# 2h -> 2019-08-12 14:00:00
|
|
|
|
("2h", datetime(2019, 8, 12, 14, 00, 0, tzinfo=timezone.utc)),
|
|
|
|
# 4h -> 2019-08-12 14:00:00
|
|
|
|
("4h", datetime(2019, 8, 12, 16, 00, 0, tzinfo=timezone.utc)),
|
|
|
|
# 1d -> 2019-08-13 00:00:00
|
|
|
|
("1d", datetime(2019, 8, 13, 0, 0, 0, tzinfo=timezone.utc)),
|
|
|
|
]
|
2019-08-12 14:07:19 +00:00
|
|
|
|
2019-08-12 14:17:06 +00:00
|
|
|
for interval, result in tf_list:
|
|
|
|
assert timeframe_to_next_date(interval, date) == result
|
2019-08-12 18:37:11 +00:00
|
|
|
|
|
|
|
date = datetime.now(tz=timezone.utc)
|
2019-08-25 08:53:56 +00:00
|
|
|
assert timeframe_to_next_date("5m") > date
|
2019-10-17 15:19:50 +00:00
|
|
|
|
2020-10-25 09:13:54 +00:00
|
|
|
date = datetime(2019, 8, 12, 13, 30, 0, tzinfo=timezone.utc)
|
|
|
|
assert timeframe_to_next_date("5m", date) == date + timedelta(minutes=5)
|
|
|
|
|
2019-10-17 15:19:50 +00:00
|
|
|
|
2022-05-14 17:30:42 +00:00
|
|
|
def test_date_minus_candles():
|
|
|
|
|
|
|
|
date = datetime(2019, 8, 12, 13, 25, 0, tzinfo=timezone.utc)
|
|
|
|
|
|
|
|
assert date_minus_candles("5m", 3, date) == date - timedelta(minutes=15)
|
|
|
|
assert date_minus_candles("5m", 5, date) == date - timedelta(minutes=25)
|
|
|
|
assert date_minus_candles("1m", 6, date) == date - timedelta(minutes=6)
|
|
|
|
assert date_minus_candles("1h", 3, date) == date - timedelta(hours=3, minutes=25)
|
|
|
|
assert date_minus_candles("1h", 3) == timeframe_to_prev_date('1h') - timedelta(hours=3)
|
|
|
|
|
|
|
|
|
2021-11-01 08:33:55 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
"market_symbol,base,quote,exchange,spot,margin,futures,trademode,add_dict,expected_result",
|
|
|
|
[
|
|
|
|
("BTC/USDT", 'BTC', 'USDT', "binance", True, False, False, 'spot', {}, True),
|
|
|
|
("USDT/BTC", 'USDT', 'BTC', "binance", True, False, False, 'spot', {}, True),
|
|
|
|
# No seperating /
|
|
|
|
("BTCUSDT", 'BTC', 'USDT', "binance", True, False, False, 'spot', {}, True),
|
|
|
|
("BTCUSDT", None, "USDT", "binance", True, False, False, 'spot', {}, False),
|
|
|
|
("USDT/BTC", "BTC", None, "binance", True, False, False, 'spot', {}, False),
|
|
|
|
("BTCUSDT", "BTC", None, "binance", True, False, False, 'spot', {}, False),
|
|
|
|
("BTC/USDT", "BTC", "USDT", "binance", True, False, False, 'spot', {}, True),
|
|
|
|
# Futures mode, spot pair
|
|
|
|
("BTC/USDT", "BTC", "USDT", "binance", True, False, False, 'futures', {}, False),
|
|
|
|
("BTC/USDT", "BTC", "USDT", "binance", True, False, False, 'margin', {}, False),
|
|
|
|
("BTC/USDT", "BTC", "USDT", "binance", True, True, True, 'margin', {}, True),
|
|
|
|
("BTC/USDT", "BTC", "USDT", "binance", False, True, False, 'margin', {}, True),
|
|
|
|
# Futures mode, futures pair
|
|
|
|
("BTC/USDT", "BTC", "USDT", "binance", False, False, True, 'futures', {}, True),
|
|
|
|
# Futures market
|
|
|
|
("BTC/UNK", "BTC", 'UNK', "binance", False, False, True, 'spot', {}, False),
|
|
|
|
("BTC/EUR", 'BTC', 'EUR', "kraken", True, False, False, 'spot', {"darkpool": False}, True),
|
|
|
|
("EUR/BTC", 'EUR', 'BTC', "kraken", True, False, False, 'spot', {"darkpool": False}, True),
|
|
|
|
# no darkpools
|
|
|
|
("BTC/EUR", 'BTC', 'EUR', "kraken", True, False, False, 'spot',
|
|
|
|
{"darkpool": True}, False),
|
|
|
|
# no darkpools
|
|
|
|
("BTC/EUR.d", 'BTC', 'EUR', "kraken", True, False, False, 'spot',
|
|
|
|
{"darkpool": True}, False),
|
2022-02-11 16:02:04 +00:00
|
|
|
("BTC/USDT:USDT", 'BTC', 'USD', "okx", False, False, True, 'spot', {}, False),
|
|
|
|
("BTC/USDT:USDT", 'BTC', 'USD', "okx", False, False, True, 'margin', {}, False),
|
|
|
|
("BTC/USDT:USDT", 'BTC', 'USD', "okx", False, False, True, 'futures', {}, True),
|
2021-11-01 08:46:35 +00:00
|
|
|
])
|
2021-11-01 08:33:55 +00:00
|
|
|
def test_market_is_tradable(
|
|
|
|
mocker, default_conf, market_symbol, base,
|
|
|
|
quote, spot, margin, futures, trademode, add_dict, exchange, expected_result
|
2021-11-21 07:43:05 +00:00
|
|
|
) -> None:
|
2021-11-01 08:33:55 +00:00
|
|
|
default_conf['trading_mode'] = trademode
|
2022-02-01 18:53:38 +00:00
|
|
|
mocker.patch('freqtrade.exchange.exchange.Exchange.validate_trading_mode_and_margin_mode')
|
2020-06-02 18:30:31 +00:00
|
|
|
ex = get_patched_exchange(mocker, default_conf, id=exchange)
|
|
|
|
market = {
|
|
|
|
'symbol': market_symbol,
|
|
|
|
'base': base,
|
|
|
|
'quote': quote,
|
2021-11-01 08:12:39 +00:00
|
|
|
'spot': spot,
|
2021-11-01 08:33:55 +00:00
|
|
|
'future': futures,
|
2021-11-15 18:43:43 +00:00
|
|
|
'swap': futures,
|
2021-11-01 08:33:55 +00:00
|
|
|
'margin': margin,
|
2022-02-14 23:34:59 +00:00
|
|
|
'linear': True,
|
2020-06-02 18:30:31 +00:00
|
|
|
**(add_dict),
|
|
|
|
}
|
|
|
|
assert ex.market_is_tradable(market) == expected_result
|
2019-10-17 16:24:39 +00:00
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("market,expected_result", [
|
|
|
|
({'symbol': 'ETH/BTC', 'active': True}, True),
|
|
|
|
({'symbol': 'ETH/BTC', 'active': False}, False),
|
|
|
|
({'symbol': 'ETH/BTC', }, True),
|
|
|
|
])
|
|
|
|
def test_market_is_active(market, expected_result) -> None:
|
|
|
|
assert market_is_active(market) == expected_result
|
2020-04-30 18:05:27 +00:00
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("order,expected", [
|
|
|
|
([{'fee'}], False),
|
|
|
|
({'fee': None}, False),
|
|
|
|
({'fee': {'currency': 'ETH/BTC'}}, False),
|
|
|
|
({'fee': {'currency': 'ETH/BTC', 'cost': None}}, False),
|
|
|
|
({'fee': {'currency': 'ETH/BTC', 'cost': 0.01}}, True),
|
|
|
|
])
|
|
|
|
def test_order_has_fee(order, expected) -> None:
|
|
|
|
assert Exchange.order_has_fee(order) == expected
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("order,expected", [
|
2020-05-01 13:17:52 +00:00
|
|
|
({'symbol': 'ETH/BTC', 'fee': {'currency': 'ETH', 'cost': 0.43}},
|
|
|
|
(0.43, 'ETH', 0.01)),
|
|
|
|
({'symbol': 'ETH/USDT', 'fee': {'currency': 'USDT', 'cost': 0.01}},
|
|
|
|
(0.01, 'USDT', 0.01)),
|
|
|
|
({'symbol': 'BTC/USDT', 'fee': {'currency': 'USDT', 'cost': 0.34, 'rate': 0.01}},
|
|
|
|
(0.34, 'USDT', 0.01)),
|
2020-04-30 18:05:27 +00:00
|
|
|
])
|
2020-05-01 13:17:52 +00:00
|
|
|
def test_extract_cost_curr_rate(mocker, default_conf, order, expected) -> None:
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.calculate_fee_rate', MagicMock(return_value=0.01))
|
|
|
|
ex = get_patched_exchange(mocker, default_conf)
|
2022-07-06 17:15:55 +00:00
|
|
|
assert ex.extract_cost_curr_rate(order['fee'], order['symbol'], cost=20, amount=1) == expected
|
2020-05-01 13:17:52 +00:00
|
|
|
|
|
|
|
|
2021-12-11 14:26:08 +00:00
|
|
|
@pytest.mark.parametrize("order,unknown_fee_rate,expected", [
|
2020-05-01 13:17:52 +00:00
|
|
|
# Using base-currency
|
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.05,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'ETH', 'cost': 0.004, 'rate': None}}, None, 0.1),
|
2020-05-01 13:17:52 +00:00
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.05, 'cost': 0.05,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'ETH', 'cost': 0.004, 'rate': None}}, None, 0.08),
|
2020-05-01 13:17:52 +00:00
|
|
|
# Using quote currency
|
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.05,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'BTC', 'cost': 0.005}}, None, 0.1),
|
2020-05-01 13:17:52 +00:00
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.05,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'BTC', 'cost': 0.002, 'rate': None}}, None, 0.04),
|
2020-05-01 13:17:52 +00:00
|
|
|
# Using foreign currency
|
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.05,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'NEO', 'cost': 0.0012}}, None, 0.001944),
|
2020-05-01 13:17:52 +00:00
|
|
|
({'symbol': 'ETH/BTC', 'amount': 2.21, 'cost': 0.02992561,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'NEO', 'cost': 0.00027452}}, None, 0.00074305),
|
2020-05-01 13:17:52 +00:00
|
|
|
# Rate included in return - return as is
|
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.05,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'USDT', 'cost': 0.34, 'rate': 0.01}}, None, 0.01),
|
2020-05-01 13:17:52 +00:00
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.05,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'USDT', 'cost': 0.34, 'rate': 0.005}}, None, 0.005),
|
2020-06-02 18:54:14 +00:00
|
|
|
# 0.1% filled - no costs (kraken - #3431)
|
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.0,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'BTC', 'cost': 0.0, 'rate': None}}, None, None),
|
2020-06-02 18:54:14 +00:00
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.0,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'ETH', 'cost': 0.0, 'rate': None}}, None, 0.0),
|
2020-06-02 18:54:14 +00:00
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.0,
|
2021-12-11 14:26:08 +00:00
|
|
|
'fee': {'currency': 'NEO', 'cost': 0.0, 'rate': None}}, None, None),
|
|
|
|
# Invalid pair combination - POINT/BTC is not a pair
|
|
|
|
({'symbol': 'POINT/BTC', 'amount': 0.04, 'cost': 0.5,
|
|
|
|
'fee': {'currency': 'POINT', 'cost': 2.0, 'rate': None}}, None, None),
|
|
|
|
({'symbol': 'POINT/BTC', 'amount': 0.04, 'cost': 0.5,
|
|
|
|
'fee': {'currency': 'POINT', 'cost': 2.0, 'rate': None}}, 1, 4.0),
|
|
|
|
({'symbol': 'POINT/BTC', 'amount': 0.04, 'cost': 0.5,
|
|
|
|
'fee': {'currency': 'POINT', 'cost': 2.0, 'rate': None}}, 2, 8.0),
|
2022-07-09 06:24:29 +00:00
|
|
|
# Missing currency
|
|
|
|
({'symbol': 'ETH/BTC', 'amount': 0.04, 'cost': 0.05,
|
|
|
|
'fee': {'currency': None, 'cost': 0.005}}, None, None),
|
2020-05-01 13:17:52 +00:00
|
|
|
])
|
2021-12-11 14:26:08 +00:00
|
|
|
def test_calculate_fee_rate(mocker, default_conf, order, expected, unknown_fee_rate) -> None:
|
2020-05-01 13:17:52 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.fetch_ticker', return_value={'last': 0.081})
|
2021-12-11 14:26:08 +00:00
|
|
|
if unknown_fee_rate:
|
|
|
|
default_conf['exchange']['unknown_fee_rate'] = unknown_fee_rate
|
2020-05-01 13:17:52 +00:00
|
|
|
|
|
|
|
ex = get_patched_exchange(mocker, default_conf)
|
2021-12-11 14:26:08 +00:00
|
|
|
|
2022-07-06 17:15:55 +00:00
|
|
|
assert ex.calculate_fee_rate(order['fee'], order['symbol'],
|
|
|
|
cost=order['cost'], amount=order['amount']) == expected
|
2020-06-28 14:18:39 +00:00
|
|
|
|
|
|
|
|
2020-06-28 17:40:33 +00:00
|
|
|
@pytest.mark.parametrize('retrycount,max_retries,expected', [
|
|
|
|
(0, 3, 10),
|
|
|
|
(1, 3, 5),
|
|
|
|
(2, 3, 2),
|
|
|
|
(3, 3, 1),
|
|
|
|
(0, 1, 2),
|
|
|
|
(1, 1, 1),
|
2020-08-02 08:18:19 +00:00
|
|
|
(0, 4, 17),
|
|
|
|
(1, 4, 10),
|
|
|
|
(2, 4, 5),
|
|
|
|
(3, 4, 2),
|
|
|
|
(4, 4, 1),
|
|
|
|
(0, 5, 26),
|
|
|
|
(1, 5, 17),
|
|
|
|
(2, 5, 10),
|
|
|
|
(3, 5, 5),
|
|
|
|
(4, 5, 2),
|
|
|
|
(5, 5, 1),
|
2020-06-28 14:18:39 +00:00
|
|
|
])
|
2020-06-28 17:40:33 +00:00
|
|
|
def test_calculate_backoff(retrycount, max_retries, expected):
|
|
|
|
assert calculate_backoff(retrycount, max_retries) == expected
|
2021-09-02 02:34:01 +00:00
|
|
|
|
|
|
|
|
2022-11-14 18:40:57 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", ['binance'])
|
2021-11-08 07:50:50 +00:00
|
|
|
def test__get_funding_fees_from_exchange(default_conf, mocker, exchange_name):
|
2021-09-08 19:46:52 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
api_mock.fetch_funding_history = MagicMock(return_value=[
|
|
|
|
{
|
2021-10-11 10:14:59 +00:00
|
|
|
'amount': 0.14542,
|
2021-09-08 19:46:52 +00:00
|
|
|
'code': 'USDT',
|
|
|
|
'datetime': '2021-09-01T08:00:01.000Z',
|
|
|
|
'id': '485478',
|
|
|
|
'info': {'asset': 'USDT',
|
2021-10-11 10:14:59 +00:00
|
|
|
'income': '0.14542',
|
2021-09-08 19:46:52 +00:00
|
|
|
'incomeType': 'FUNDING_FEE',
|
|
|
|
'info': 'FUNDING_FEE',
|
|
|
|
'symbol': 'XRPUSDT',
|
2021-10-11 10:14:59 +00:00
|
|
|
'time': '1630382001000',
|
2021-09-08 19:46:52 +00:00
|
|
|
'tradeId': '',
|
2021-10-11 10:14:59 +00:00
|
|
|
'tranId': '993203'},
|
2021-09-08 19:46:52 +00:00
|
|
|
'symbol': 'XRP/USDT',
|
2021-10-11 10:14:59 +00:00
|
|
|
'timestamp': 1630382001000
|
2021-09-08 19:46:52 +00:00
|
|
|
},
|
|
|
|
{
|
2021-10-11 10:14:59 +00:00
|
|
|
'amount': -0.14642,
|
2021-09-08 19:46:52 +00:00
|
|
|
'code': 'USDT',
|
|
|
|
'datetime': '2021-09-01T16:00:01.000Z',
|
|
|
|
'id': '485479',
|
|
|
|
'info': {'asset': 'USDT',
|
2021-10-11 10:14:59 +00:00
|
|
|
'income': '-0.14642',
|
2021-09-08 19:46:52 +00:00
|
|
|
'incomeType': 'FUNDING_FEE',
|
|
|
|
'info': 'FUNDING_FEE',
|
|
|
|
'symbol': 'XRPUSDT',
|
2021-10-11 10:14:59 +00:00
|
|
|
'time': '1630314001000',
|
2021-09-08 19:46:52 +00:00
|
|
|
'tradeId': '',
|
2021-10-11 10:14:59 +00:00
|
|
|
'tranId': '993204'},
|
2021-09-08 19:46:52 +00:00
|
|
|
'symbol': 'XRP/USDT',
|
2021-10-11 10:14:59 +00:00
|
|
|
'timestamp': 1630314001000
|
2021-09-08 19:46:52 +00:00
|
|
|
}
|
|
|
|
])
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'fetchFundingHistory': True})
|
|
|
|
|
|
|
|
# mocker.patch('freqtrade.exchange.Exchange.get_funding_fees', lambda pair, since: y)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
date_time = datetime.strptime("2021-09-01T00:00:01.000Z", '%Y-%m-%dT%H:%M:%S.%fZ')
|
2021-09-19 08:26:59 +00:00
|
|
|
unix_time = int(date_time.timestamp())
|
2021-09-08 19:46:52 +00:00
|
|
|
expected_fees = -0.001 # 0.14542341 + -0.14642341
|
2021-11-08 07:50:50 +00:00
|
|
|
fees_from_datetime = exchange._get_funding_fees_from_exchange(
|
2021-09-08 19:46:52 +00:00
|
|
|
pair='XRP/USDT',
|
|
|
|
since=date_time
|
|
|
|
)
|
2021-11-08 07:50:50 +00:00
|
|
|
fees_from_unix_time = exchange._get_funding_fees_from_exchange(
|
2021-09-08 19:46:52 +00:00
|
|
|
pair='XRP/USDT',
|
|
|
|
since=unix_time
|
|
|
|
)
|
|
|
|
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(expected_fees) == fees_from_datetime
|
|
|
|
assert pytest.approx(expected_fees) == fees_from_unix_time
|
2021-09-08 19:46:52 +00:00
|
|
|
|
|
|
|
ccxt_exceptionhandlers(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
api_mock,
|
|
|
|
exchange_name,
|
2021-11-08 07:50:50 +00:00
|
|
|
"_get_funding_fees_from_exchange",
|
2021-09-08 19:46:52 +00:00
|
|
|
"fetch_funding_history",
|
|
|
|
pair="XRP/USDT",
|
|
|
|
since=unix_time
|
|
|
|
)
|
2021-09-19 23:02:09 +00:00
|
|
|
|
|
|
|
|
2022-11-14 18:40:57 +00:00
|
|
|
@pytest.mark.parametrize('exchange', ['binance', 'kraken'])
|
2021-11-17 13:17:27 +00:00
|
|
|
@pytest.mark.parametrize('stake_amount,leverage,min_stake_with_lev', [
|
|
|
|
(9.0, 3.0, 3.0),
|
|
|
|
(20.0, 5.0, 4.0),
|
|
|
|
(100.0, 100.0, 1.0)
|
|
|
|
])
|
|
|
|
def test_get_stake_amount_considering_leverage(
|
|
|
|
exchange,
|
|
|
|
stake_amount,
|
|
|
|
leverage,
|
|
|
|
min_stake_with_lev,
|
|
|
|
mocker,
|
|
|
|
default_conf
|
|
|
|
):
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange)
|
|
|
|
assert exchange._get_stake_amount_considering_leverage(
|
|
|
|
stake_amount, leverage) == min_stake_with_lev
|
|
|
|
|
|
|
|
|
2021-09-19 23:02:09 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name,trading_mode", [
|
|
|
|
("binance", TradingMode.FUTURES),
|
|
|
|
])
|
|
|
|
def test__set_leverage(mocker, default_conf, exchange_name, trading_mode):
|
|
|
|
|
|
|
|
api_mock = MagicMock()
|
|
|
|
api_mock.set_leverage = MagicMock()
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'setLeverage': True})
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
|
|
|
|
ccxt_exceptionhandlers(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
api_mock,
|
|
|
|
exchange_name,
|
|
|
|
"_set_leverage",
|
|
|
|
"set_leverage",
|
|
|
|
pair="XRP/USDT",
|
|
|
|
leverage=5.0,
|
|
|
|
trading_mode=trading_mode
|
|
|
|
)
|
|
|
|
|
|
|
|
|
2022-02-01 18:53:38 +00:00
|
|
|
@pytest.mark.parametrize("margin_mode", [
|
|
|
|
(MarginMode.CROSS),
|
|
|
|
(MarginMode.ISOLATED)
|
2021-09-19 23:02:09 +00:00
|
|
|
])
|
2022-02-01 18:53:38 +00:00
|
|
|
def test_set_margin_mode(mocker, default_conf, margin_mode):
|
2021-09-19 23:02:09 +00:00
|
|
|
|
|
|
|
api_mock = MagicMock()
|
|
|
|
api_mock.set_margin_mode = MagicMock()
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'setMarginMode': True})
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
|
|
|
|
ccxt_exceptionhandlers(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
api_mock,
|
|
|
|
"binance",
|
|
|
|
"set_margin_mode",
|
|
|
|
"set_margin_mode",
|
|
|
|
pair="XRP/USDT",
|
2022-02-01 18:53:38 +00:00
|
|
|
margin_mode=margin_mode
|
2021-09-19 23:02:09 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
|
2022-02-01 18:53:38 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name, trading_mode, margin_mode, exception_thrown", [
|
2021-09-19 23:02:09 +00:00
|
|
|
("binance", TradingMode.SPOT, None, False),
|
2022-02-01 18:53:38 +00:00
|
|
|
("binance", TradingMode.MARGIN, MarginMode.ISOLATED, True),
|
2021-09-19 23:02:09 +00:00
|
|
|
("kraken", TradingMode.SPOT, None, False),
|
2022-02-01 18:53:38 +00:00
|
|
|
("kraken", TradingMode.MARGIN, MarginMode.ISOLATED, True),
|
|
|
|
("kraken", TradingMode.FUTURES, MarginMode.ISOLATED, True),
|
2021-09-19 23:02:09 +00:00
|
|
|
("bittrex", TradingMode.SPOT, None, False),
|
2022-02-01 18:53:38 +00:00
|
|
|
("bittrex", TradingMode.MARGIN, MarginMode.CROSS, True),
|
|
|
|
("bittrex", TradingMode.MARGIN, MarginMode.ISOLATED, True),
|
|
|
|
("bittrex", TradingMode.FUTURES, MarginMode.CROSS, True),
|
|
|
|
("bittrex", TradingMode.FUTURES, MarginMode.ISOLATED, True),
|
|
|
|
("gateio", TradingMode.MARGIN, MarginMode.ISOLATED, True),
|
2022-02-11 16:02:04 +00:00
|
|
|
("okx", TradingMode.SPOT, None, False),
|
|
|
|
("okx", TradingMode.MARGIN, MarginMode.CROSS, True),
|
|
|
|
("okx", TradingMode.MARGIN, MarginMode.ISOLATED, True),
|
|
|
|
("okx", TradingMode.FUTURES, MarginMode.CROSS, True),
|
2021-09-19 23:02:09 +00:00
|
|
|
|
2022-02-01 18:53:38 +00:00
|
|
|
("binance", TradingMode.FUTURES, MarginMode.ISOLATED, False),
|
2022-02-16 10:52:26 +00:00
|
|
|
("gateio", TradingMode.FUTURES, MarginMode.ISOLATED, False),
|
2022-02-13 03:59:26 +00:00
|
|
|
("okx", TradingMode.FUTURES, MarginMode.ISOLATED, False),
|
2022-01-14 12:58:32 +00:00
|
|
|
|
|
|
|
# * Remove once implemented
|
2022-02-01 18:53:38 +00:00
|
|
|
("binance", TradingMode.MARGIN, MarginMode.CROSS, True),
|
|
|
|
("binance", TradingMode.FUTURES, MarginMode.CROSS, True),
|
|
|
|
("kraken", TradingMode.MARGIN, MarginMode.CROSS, True),
|
|
|
|
("kraken", TradingMode.FUTURES, MarginMode.CROSS, True),
|
|
|
|
("gateio", TradingMode.MARGIN, MarginMode.CROSS, True),
|
|
|
|
("gateio", TradingMode.FUTURES, MarginMode.CROSS, True),
|
2021-09-19 23:02:09 +00:00
|
|
|
|
2022-01-14 12:58:32 +00:00
|
|
|
# * Uncomment once implemented
|
2022-02-01 18:53:38 +00:00
|
|
|
# ("binance", TradingMode.MARGIN, MarginMode.CROSS, False),
|
|
|
|
# ("binance", TradingMode.FUTURES, MarginMode.CROSS, False),
|
|
|
|
# ("kraken", TradingMode.MARGIN, MarginMode.CROSS, False),
|
|
|
|
# ("kraken", TradingMode.FUTURES, MarginMode.CROSS, False),
|
|
|
|
# ("gateio", TradingMode.MARGIN, MarginMode.CROSS, False),
|
|
|
|
# ("gateio", TradingMode.FUTURES, MarginMode.CROSS, False),
|
2021-09-19 23:02:09 +00:00
|
|
|
])
|
2022-02-01 18:53:38 +00:00
|
|
|
def test_validate_trading_mode_and_margin_mode(
|
2021-09-19 23:02:09 +00:00
|
|
|
default_conf,
|
|
|
|
mocker,
|
|
|
|
exchange_name,
|
|
|
|
trading_mode,
|
2022-02-01 18:53:38 +00:00
|
|
|
margin_mode,
|
2021-09-19 23:02:09 +00:00
|
|
|
exception_thrown
|
|
|
|
):
|
|
|
|
exchange = get_patched_exchange(
|
|
|
|
mocker, default_conf, id=exchange_name, mock_supported_modes=False)
|
|
|
|
if (exception_thrown):
|
|
|
|
with pytest.raises(OperationalException):
|
2022-02-01 18:53:38 +00:00
|
|
|
exchange.validate_trading_mode_and_margin_mode(trading_mode, margin_mode)
|
2021-09-19 23:02:09 +00:00
|
|
|
else:
|
2022-02-01 18:53:38 +00:00
|
|
|
exchange.validate_trading_mode_and_margin_mode(trading_mode, margin_mode)
|
2021-10-20 11:33:09 +00:00
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("exchange_name,trading_mode,ccxt_config", [
|
|
|
|
("binance", "spot", {}),
|
|
|
|
("binance", "margin", {"options": {"defaultType": "margin"}}),
|
|
|
|
("binance", "futures", {"options": {"defaultType": "future"}}),
|
2022-05-27 08:18:04 +00:00
|
|
|
("bybit", "spot", {"options": {"defaultType": "spot"}}),
|
2021-11-13 22:32:43 +00:00
|
|
|
("bybit", "futures", {"options": {"defaultType": "linear"}}),
|
2021-10-23 19:48:18 +00:00
|
|
|
("gateio", "futures", {"options": {"defaultType": "swap"}}),
|
2021-11-13 22:32:43 +00:00
|
|
|
("hitbtc", "futures", {"options": {"defaultType": "swap"}}),
|
|
|
|
("kraken", "futures", {"options": {"defaultType": "swap"}}),
|
|
|
|
("kucoin", "futures", {"options": {"defaultType": "swap"}}),
|
2022-02-11 16:02:04 +00:00
|
|
|
("okx", "futures", {"options": {"defaultType": "swap"}}),
|
2021-10-20 11:33:09 +00:00
|
|
|
])
|
|
|
|
def test__ccxt_config(
|
|
|
|
default_conf,
|
|
|
|
mocker,
|
|
|
|
exchange_name,
|
|
|
|
trading_mode,
|
|
|
|
ccxt_config
|
|
|
|
):
|
|
|
|
default_conf['trading_mode'] = trading_mode
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2021-10-20 11:33:09 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
|
|
|
assert exchange._ccxt_config == ccxt_config
|
2021-10-17 13:06:55 +00:00
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize('pair,nominal_value,max_lev', [
|
|
|
|
("ETH/BTC", 0.0, 2.0),
|
|
|
|
("TKN/BTC", 100.0, 5.0),
|
|
|
|
("BLK/BTC", 173.31, 3.0),
|
|
|
|
("LTC/BTC", 0.0, 1.0),
|
|
|
|
("TKN/USDT", 210.30, 1.0),
|
|
|
|
])
|
2022-02-13 03:59:26 +00:00
|
|
|
def test_get_max_leverage_from_margin(default_conf, mocker, pair, nominal_value, max_lev):
|
|
|
|
default_conf['trading_mode'] = 'margin'
|
2022-02-07 07:33:42 +00:00
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2022-02-07 12:27:20 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'fetchLeverageTiers': False})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id="gateio")
|
2021-10-17 13:06:55 +00:00
|
|
|
assert exchange.get_max_leverage(pair, nominal_value) == max_lev
|
2021-09-26 10:11:35 +00:00
|
|
|
|
|
|
|
|
2021-11-06 23:12:48 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
'size,funding_rate,mark_price,time_in_ratio,funding_fee,kraken_fee', [
|
|
|
|
(10, 0.0001, 2.0, 1.0, 0.002, 0.002),
|
|
|
|
(10, 0.0002, 2.0, 0.01, 0.004, 0.00004),
|
|
|
|
(10, 0.0002, 2.5, None, 0.005, None),
|
|
|
|
])
|
2022-01-17 18:39:58 +00:00
|
|
|
def test_calculate_funding_fees(
|
2021-10-31 10:40:23 +00:00
|
|
|
default_conf,
|
|
|
|
mocker,
|
2021-11-06 23:12:48 +00:00
|
|
|
size,
|
2021-10-31 10:40:23 +00:00
|
|
|
funding_rate,
|
|
|
|
mark_price,
|
2021-11-06 23:12:48 +00:00
|
|
|
funding_fee,
|
|
|
|
kraken_fee,
|
|
|
|
time_in_ratio
|
2021-10-31 10:40:23 +00:00
|
|
|
):
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
2021-11-06 23:12:48 +00:00
|
|
|
kraken = get_patched_exchange(mocker, default_conf, id="kraken")
|
2022-01-08 10:27:04 +00:00
|
|
|
prior_date = timeframe_to_prev_date('1h', datetime.now(timezone.utc) - timedelta(hours=1))
|
|
|
|
trade_date = timeframe_to_prev_date('1h', datetime.now(timezone.utc))
|
|
|
|
funding_rates = DataFrame([
|
|
|
|
{'date': prior_date, 'open': funding_rate}, # Line not used.
|
|
|
|
{'date': trade_date, 'open': funding_rate},
|
2022-01-31 09:02:17 +00:00
|
|
|
])
|
2022-01-08 10:27:04 +00:00
|
|
|
mark_rates = DataFrame([
|
|
|
|
{'date': prior_date, 'open': mark_price},
|
|
|
|
{'date': trade_date, 'open': mark_price},
|
2022-01-31 09:02:17 +00:00
|
|
|
])
|
2022-01-17 18:39:58 +00:00
|
|
|
df = exchange.combine_funding_and_mark(funding_rates, mark_rates)
|
2022-01-08 10:27:04 +00:00
|
|
|
|
2022-01-17 18:26:03 +00:00
|
|
|
assert exchange.calculate_funding_fees(
|
2022-01-17 18:39:58 +00:00
|
|
|
df,
|
2022-01-08 10:27:04 +00:00
|
|
|
amount=size,
|
2022-01-17 18:59:33 +00:00
|
|
|
is_short=True,
|
2022-01-08 10:27:04 +00:00
|
|
|
open_date=trade_date,
|
|
|
|
close_date=trade_date,
|
|
|
|
time_in_ratio=time_in_ratio,
|
|
|
|
) == funding_fee
|
2021-11-06 23:12:48 +00:00
|
|
|
|
|
|
|
if (kraken_fee is None):
|
|
|
|
with pytest.raises(OperationalException):
|
2022-01-17 18:26:03 +00:00
|
|
|
kraken.calculate_funding_fees(
|
2022-01-17 18:39:58 +00:00
|
|
|
df,
|
2022-01-08 10:27:04 +00:00
|
|
|
amount=size,
|
2022-01-17 18:59:33 +00:00
|
|
|
is_short=True,
|
2022-01-08 10:27:04 +00:00
|
|
|
open_date=trade_date,
|
|
|
|
close_date=trade_date,
|
|
|
|
time_in_ratio=time_in_ratio,
|
|
|
|
)
|
|
|
|
|
2021-11-06 23:12:48 +00:00
|
|
|
else:
|
2022-01-17 18:26:03 +00:00
|
|
|
assert kraken.calculate_funding_fees(
|
2022-01-17 18:39:58 +00:00
|
|
|
df,
|
2022-01-08 10:27:04 +00:00
|
|
|
amount=size,
|
2022-01-17 18:59:33 +00:00
|
|
|
is_short=True,
|
2022-01-08 10:27:04 +00:00
|
|
|
open_date=trade_date,
|
|
|
|
close_date=trade_date,
|
|
|
|
time_in_ratio=time_in_ratio,
|
|
|
|
) == kraken_fee
|
2021-10-31 10:40:23 +00:00
|
|
|
|
|
|
|
|
2022-05-21 07:03:30 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
'mark_price,funding_rate,futures_funding_rate', [
|
|
|
|
(1000, 0.001, None),
|
|
|
|
(1000, 0.001, 0.01),
|
|
|
|
(1000, 0.001, 0.0),
|
|
|
|
(1000, 0.001, -0.01),
|
|
|
|
])
|
|
|
|
def test_combine_funding_and_mark(
|
|
|
|
default_conf,
|
|
|
|
mocker,
|
|
|
|
funding_rate,
|
|
|
|
mark_price,
|
|
|
|
futures_funding_rate,
|
|
|
|
):
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
|
|
|
prior2_date = timeframe_to_prev_date('1h', datetime.now(timezone.utc) - timedelta(hours=2))
|
|
|
|
prior_date = timeframe_to_prev_date('1h', datetime.now(timezone.utc) - timedelta(hours=1))
|
|
|
|
trade_date = timeframe_to_prev_date('1h', datetime.now(timezone.utc))
|
|
|
|
funding_rates = DataFrame([
|
|
|
|
{'date': prior2_date, 'open': funding_rate},
|
|
|
|
{'date': prior_date, 'open': funding_rate},
|
|
|
|
{'date': trade_date, 'open': funding_rate},
|
|
|
|
])
|
|
|
|
mark_rates = DataFrame([
|
|
|
|
{'date': prior2_date, 'open': mark_price},
|
|
|
|
{'date': prior_date, 'open': mark_price},
|
|
|
|
{'date': trade_date, 'open': mark_price},
|
|
|
|
])
|
|
|
|
|
|
|
|
df = exchange.combine_funding_and_mark(funding_rates, mark_rates, futures_funding_rate)
|
|
|
|
assert 'open_mark' in df.columns
|
|
|
|
assert 'open_fund' in df.columns
|
|
|
|
assert len(df) == 3
|
|
|
|
|
|
|
|
funding_rates = DataFrame([
|
|
|
|
{'date': trade_date, 'open': funding_rate},
|
|
|
|
])
|
|
|
|
mark_rates = DataFrame([
|
|
|
|
{'date': prior2_date, 'open': mark_price},
|
|
|
|
{'date': prior_date, 'open': mark_price},
|
|
|
|
{'date': trade_date, 'open': mark_price},
|
|
|
|
])
|
|
|
|
df = exchange.combine_funding_and_mark(funding_rates, mark_rates, futures_funding_rate)
|
|
|
|
|
|
|
|
if futures_funding_rate is not None:
|
|
|
|
assert len(df) == 3
|
|
|
|
assert df.iloc[0]['open_fund'] == futures_funding_rate
|
|
|
|
assert df.iloc[1]['open_fund'] == futures_funding_rate
|
|
|
|
assert df.iloc[2]['open_fund'] == funding_rate
|
|
|
|
else:
|
|
|
|
assert len(df) == 1
|
|
|
|
|
|
|
|
# Empty funding rates
|
|
|
|
funding_rates = DataFrame([], columns=['date', 'open'])
|
|
|
|
df = exchange.combine_funding_and_mark(funding_rates, mark_rates, futures_funding_rate)
|
|
|
|
if futures_funding_rate is not None:
|
|
|
|
assert len(df) == 3
|
|
|
|
assert df.iloc[0]['open_fund'] == futures_funding_rate
|
|
|
|
assert df.iloc[1]['open_fund'] == futures_funding_rate
|
|
|
|
assert df.iloc[2]['open_fund'] == futures_funding_rate
|
|
|
|
else:
|
|
|
|
assert len(df) == 0
|
|
|
|
|
|
|
|
|
2021-11-13 10:45:23 +00:00
|
|
|
@pytest.mark.parametrize('exchange,rate_start,rate_end,d1,d2,amount,expected_fees', [
|
2022-03-21 11:01:18 +00:00
|
|
|
('binance', 0, 2, "2021-09-01 01:00:00", "2021-09-01 04:00:00", 30.0, 0.0),
|
2022-03-21 18:30:24 +00:00
|
|
|
('binance', 0, 2, "2021-09-01 00:00:00", "2021-09-01 08:00:00", 30.0, -0.00091409999),
|
|
|
|
('binance', 0, 2, "2021-09-01 00:00:15", "2021-09-01 08:00:00", 30.0, -0.0002493),
|
2021-11-13 10:45:23 +00:00
|
|
|
('binance', 1, 2, "2021-09-01 01:00:14", "2021-09-01 08:00:00", 30.0, -0.0002493),
|
|
|
|
('binance', 1, 2, "2021-09-01 00:00:16", "2021-09-01 08:00:00", 30.0, -0.0002493),
|
2022-03-21 18:30:24 +00:00
|
|
|
('binance', 0, 1, "2021-09-01 00:00:00", "2021-09-01 07:59:59", 30.0, -0.00066479999),
|
|
|
|
('binance', 0, 2, "2021-09-01 00:00:00", "2021-09-01 12:00:00", 30.0, -0.00091409999),
|
|
|
|
('binance', 0, 2, "2021-09-01 00:00:01", "2021-09-01 08:00:00", 30.0, -0.0002493),
|
2021-11-08 07:50:50 +00:00
|
|
|
# TODO: Uncoment once _calculate_funding_fees can pas time_in_ratio to exchange._get_funding_fee
|
2021-11-07 03:45:35 +00:00
|
|
|
# ('kraken', "2021-09-01 00:00:00", "2021-09-01 08:00:00", 30.0, -0.0014937),
|
|
|
|
# ('kraken', "2021-09-01 00:00:15", "2021-09-01 08:00:00", 30.0, -0.0008289),
|
|
|
|
# ('kraken', "2021-09-01 01:00:14", "2021-09-01 08:00:00", 30.0, -0.0008289),
|
|
|
|
# ('kraken', "2021-09-01 00:00:00", "2021-09-01 07:59:59", 30.0, -0.0012443999999999999),
|
|
|
|
# ('kraken', "2021-09-01 00:00:00", "2021-09-01 12:00:00", 30.0, 0.0045759),
|
|
|
|
# ('kraken', "2021-09-01 00:00:01", "2021-09-01 08:00:00", 30.0, -0.0008289),
|
2022-03-21 11:01:18 +00:00
|
|
|
('gateio', 0, 2, "2021-09-01 00:10:00", "2021-09-01 04:00:00", 30.0, 0.0),
|
2022-03-21 18:30:24 +00:00
|
|
|
('gateio', 0, 2, "2021-09-01 00:00:00", "2021-09-01 08:00:00", 30.0, -0.0009140999),
|
|
|
|
('gateio', 0, 2, "2021-09-01 00:00:00", "2021-09-01 12:00:00", 30.0, -0.0009140999),
|
2021-11-13 10:45:23 +00:00
|
|
|
('gateio', 1, 2, "2021-09-01 00:00:01", "2021-09-01 08:00:00", 30.0, -0.0002493),
|
2022-03-21 18:30:24 +00:00
|
|
|
('binance', 0, 2, "2021-09-01 00:00:00", "2021-09-01 08:00:00", 50.0, -0.0015235),
|
2021-11-08 07:50:50 +00:00
|
|
|
# TODO: Uncoment once _calculate_funding_fees can pas time_in_ratio to exchange._get_funding_fee
|
2021-11-07 03:45:35 +00:00
|
|
|
# ('kraken', "2021-09-01 00:00:00", "2021-09-01 08:00:00", 50.0, -0.0024895),
|
2021-11-01 12:28:03 +00:00
|
|
|
])
|
2022-01-08 10:01:14 +00:00
|
|
|
def test__fetch_and_calculate_funding_fees(
|
2021-11-01 12:28:03 +00:00
|
|
|
mocker,
|
|
|
|
default_conf,
|
2021-11-13 10:45:23 +00:00
|
|
|
funding_rate_history_hourly,
|
|
|
|
funding_rate_history_octohourly,
|
|
|
|
rate_start,
|
|
|
|
rate_end,
|
2021-11-01 12:28:03 +00:00
|
|
|
mark_ohlcv,
|
|
|
|
exchange,
|
|
|
|
d1,
|
|
|
|
d2,
|
|
|
|
amount,
|
|
|
|
expected_fees
|
|
|
|
):
|
2022-01-14 11:49:46 +00:00
|
|
|
"""
|
|
|
|
nominal_value = mark_price * size
|
|
|
|
funding_fee = nominal_value * funding_rate
|
|
|
|
size: 30
|
|
|
|
time: 0, mark: 2.77, nominal_value: 83.1, fundRate: -0.000008, fundFee: -0.0006648
|
|
|
|
time: 1, mark: 2.73, nominal_value: 81.9, fundRate: -0.000004, fundFee: -0.0003276
|
|
|
|
time: 2, mark: 2.74, nominal_value: 82.2, fundRate: 0.000012, fundFee: 0.0009864
|
|
|
|
time: 3, mark: 2.76, nominal_value: 82.8, fundRate: -0.000003, fundFee: -0.0002484
|
|
|
|
time: 4, mark: 2.76, nominal_value: 82.8, fundRate: -0.000007, fundFee: -0.0005796
|
|
|
|
time: 5, mark: 2.77, nominal_value: 83.1, fundRate: 0.000003, fundFee: 0.0002493
|
|
|
|
time: 6, mark: 2.78, nominal_value: 83.4, fundRate: 0.000019, fundFee: 0.0015846
|
|
|
|
time: 7, mark: 2.78, nominal_value: 83.4, fundRate: 0.000003, fundFee: 0.0002502
|
|
|
|
time: 8, mark: 2.77, nominal_value: 83.1, fundRate: -0.000003, fundFee: -0.0002493
|
|
|
|
time: 9, mark: 2.77, nominal_value: 83.1, fundRate: 0, fundFee: 0.0
|
|
|
|
time: 10, mark: 2.84, nominal_value: 85.2, fundRate: 0.000013, fundFee: 0.0011076
|
|
|
|
time: 11, mark: 2.81, nominal_value: 84.3, fundRate: 0.000077, fundFee: 0.0064911
|
|
|
|
time: 12, mark: 2.81, nominal_value: 84.3, fundRate: 0.000072, fundFee: 0.0060696
|
|
|
|
time: 13, mark: 2.82, nominal_value: 84.6, fundRate: 0.000097, fundFee: 0.0082062
|
|
|
|
|
|
|
|
size: 50
|
|
|
|
time: 0, mark: 2.77, nominal_value: 138.5, fundRate: -0.000008, fundFee: -0.001108
|
|
|
|
time: 1, mark: 2.73, nominal_value: 136.5, fundRate: -0.000004, fundFee: -0.000546
|
|
|
|
time: 2, mark: 2.74, nominal_value: 137.0, fundRate: 0.000012, fundFee: 0.001644
|
|
|
|
time: 3, mark: 2.76, nominal_value: 138.0, fundRate: -0.000003, fundFee: -0.000414
|
|
|
|
time: 4, mark: 2.76, nominal_value: 138.0, fundRate: -0.000007, fundFee: -0.000966
|
|
|
|
time: 5, mark: 2.77, nominal_value: 138.5, fundRate: 0.000003, fundFee: 0.0004155
|
|
|
|
time: 6, mark: 2.78, nominal_value: 139.0, fundRate: 0.000019, fundFee: 0.002641
|
|
|
|
time: 7, mark: 2.78, nominal_value: 139.0, fundRate: 0.000003, fundFee: 0.000417
|
|
|
|
time: 8, mark: 2.77, nominal_value: 138.5, fundRate: -0.000003, fundFee: -0.0004155
|
|
|
|
time: 9, mark: 2.77, nominal_value: 138.5, fundRate: 0, fundFee: 0.0
|
|
|
|
time: 10, mark: 2.84, nominal_value: 142.0, fundRate: 0.000013, fundFee: 0.001846
|
|
|
|
time: 11, mark: 2.81, nominal_value: 140.5, fundRate: 0.000077, fundFee: 0.0108185
|
|
|
|
time: 12, mark: 2.81, nominal_value: 140.5, fundRate: 0.000072, fundFee: 0.010116
|
|
|
|
time: 13, mark: 2.82, nominal_value: 141.0, fundRate: 0.000097, fundFee: 0.013677
|
|
|
|
"""
|
2021-11-01 12:28:03 +00:00
|
|
|
d1 = datetime.strptime(f"{d1} +0000", '%Y-%m-%d %H:%M:%S %z')
|
|
|
|
d2 = datetime.strptime(f"{d2} +0000", '%Y-%m-%d %H:%M:%S %z')
|
2021-11-13 10:45:23 +00:00
|
|
|
funding_rate_history = {
|
|
|
|
'binance': funding_rate_history_octohourly,
|
|
|
|
'gateio': funding_rate_history_octohourly,
|
|
|
|
}[exchange][rate_start:rate_end]
|
2021-11-01 12:28:03 +00:00
|
|
|
api_mock = MagicMock()
|
2021-12-10 18:50:58 +00:00
|
|
|
api_mock.fetch_funding_rate_history = get_mock_coro(return_value=funding_rate_history)
|
|
|
|
api_mock.fetch_ohlcv = get_mock_coro(return_value=mark_ohlcv)
|
2021-11-01 12:28:03 +00:00
|
|
|
type(api_mock).has = PropertyMock(return_value={'fetchOHLCV': True})
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'fetchFundingRateHistory': True})
|
|
|
|
|
2022-09-08 05:24:57 +00:00
|
|
|
ex = get_patched_exchange(mocker, default_conf, api_mock, id=exchange)
|
2022-03-13 14:38:12 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.timeframes', PropertyMock(
|
2022-03-21 11:01:18 +00:00
|
|
|
return_value=['1h', '4h', '8h']))
|
2022-09-08 05:24:57 +00:00
|
|
|
funding_fees = ex._fetch_and_calculate_funding_fees(
|
2022-01-22 10:37:28 +00:00
|
|
|
pair='ADA/USDT', amount=amount, is_short=True, open_date=d1, close_date=d2)
|
2021-12-11 08:49:48 +00:00
|
|
|
assert pytest.approx(funding_fees) == expected_fees
|
2022-01-22 10:37:28 +00:00
|
|
|
# Fees for Longs are inverted
|
2022-09-08 05:24:57 +00:00
|
|
|
funding_fees = ex._fetch_and_calculate_funding_fees(
|
2022-01-22 10:37:28 +00:00
|
|
|
pair='ADA/USDT', amount=amount, is_short=False, open_date=d1, close_date=d2)
|
|
|
|
assert pytest.approx(funding_fees) == -expected_fees
|
2021-11-01 12:28:03 +00:00
|
|
|
|
2022-09-08 05:24:57 +00:00
|
|
|
# Return empty "refresh_latest"
|
|
|
|
mocker.patch("freqtrade.exchange.Exchange.refresh_latest_ohlcv", return_value={})
|
|
|
|
ex = get_patched_exchange(mocker, default_conf, api_mock, id=exchange)
|
|
|
|
with pytest.raises(ExchangeError, match="Could not find funding rates."):
|
|
|
|
ex._fetch_and_calculate_funding_fees(
|
|
|
|
pair='ADA/USDT', amount=amount, is_short=False, open_date=d1, close_date=d2)
|
|
|
|
|
2021-11-01 12:28:03 +00:00
|
|
|
|
2021-12-19 06:56:34 +00:00
|
|
|
@pytest.mark.parametrize('exchange,expected_fees', [
|
2021-11-13 10:45:23 +00:00
|
|
|
('binance', -0.0009140999999999999),
|
|
|
|
('gateio', -0.0009140999999999999),
|
2021-11-01 13:52:40 +00:00
|
|
|
])
|
2022-01-08 10:01:14 +00:00
|
|
|
def test__fetch_and_calculate_funding_fees_datetime_called(
|
2021-11-01 12:28:03 +00:00
|
|
|
mocker,
|
|
|
|
default_conf,
|
2021-11-13 10:45:23 +00:00
|
|
|
funding_rate_history_octohourly,
|
2021-11-01 13:52:40 +00:00
|
|
|
mark_ohlcv,
|
2021-11-13 10:45:23 +00:00
|
|
|
exchange,
|
2021-11-01 13:52:40 +00:00
|
|
|
time_machine,
|
2021-11-13 10:45:23 +00:00
|
|
|
expected_fees
|
2021-11-01 12:28:03 +00:00
|
|
|
):
|
|
|
|
api_mock = MagicMock()
|
2021-12-10 18:50:58 +00:00
|
|
|
api_mock.fetch_ohlcv = get_mock_coro(return_value=mark_ohlcv)
|
2021-12-10 18:52:48 +00:00
|
|
|
api_mock.fetch_funding_rate_history = get_mock_coro(
|
|
|
|
return_value=funding_rate_history_octohourly)
|
2021-11-01 12:28:03 +00:00
|
|
|
type(api_mock).has = PropertyMock(return_value={'fetchOHLCV': True})
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'fetchFundingRateHistory': True})
|
2022-03-13 14:38:12 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.timeframes', PropertyMock(return_value=['4h', '8h']))
|
2021-11-13 10:45:23 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange)
|
2021-11-01 13:52:40 +00:00
|
|
|
d1 = datetime.strptime("2021-09-01 00:00:00 +0000", '%Y-%m-%d %H:%M:%S %z')
|
|
|
|
|
|
|
|
time_machine.move_to("2021-09-01 08:00:00 +00:00")
|
2022-01-17 18:59:33 +00:00
|
|
|
funding_fees = exchange._fetch_and_calculate_funding_fees('ADA/USDT', 30.0, True, d1)
|
2021-11-13 10:45:23 +00:00
|
|
|
assert funding_fees == expected_fees
|
2022-02-02 18:42:13 +00:00
|
|
|
funding_fees = exchange._fetch_and_calculate_funding_fees('ADA/USDT', 30.0, False, d1)
|
|
|
|
assert funding_fees == 0 - expected_fees
|
2021-12-19 06:56:34 +00:00
|
|
|
|
|
|
|
|
2021-12-21 21:45:16 +00:00
|
|
|
@pytest.mark.parametrize('pair,expected_size,trading_mode', [
|
|
|
|
('XLTCUSDT', 1, 'spot'),
|
|
|
|
('LTC/USD', 1, 'futures'),
|
|
|
|
('XLTCUSDT', 0.01, 'futures'),
|
2022-10-17 09:54:58 +00:00
|
|
|
('ETH/USDT:USDT', 10, 'futures'),
|
|
|
|
('TORN/USDT:USDT', None, 'futures'), # Don't fail for unavailable pairs.
|
2021-12-21 21:45:16 +00:00
|
|
|
])
|
2022-10-17 09:54:58 +00:00
|
|
|
def test__get_contract_size(mocker, default_conf, pair, expected_size, trading_mode):
|
2021-12-21 21:45:16 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
default_conf['trading_mode'] = trading_mode
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2022-02-13 03:59:26 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
2021-12-31 10:50:55 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.markets', {
|
|
|
|
'LTC/USD': {
|
|
|
|
'symbol': 'LTC/USD',
|
|
|
|
'contractSize': None,
|
|
|
|
},
|
|
|
|
'XLTCUSDT': {
|
|
|
|
'symbol': 'XLTCUSDT',
|
2022-01-06 09:40:31 +00:00
|
|
|
'contractSize': '0.01',
|
2021-12-31 10:50:55 +00:00
|
|
|
},
|
|
|
|
'ETH/USDT:USDT': {
|
|
|
|
'symbol': 'ETH/USDT:USDT',
|
2022-01-06 09:40:31 +00:00
|
|
|
'contractSize': '10',
|
2021-12-31 10:50:55 +00:00
|
|
|
}
|
|
|
|
})
|
2022-08-22 18:28:33 +00:00
|
|
|
size = exchange.get_contract_size(pair)
|
2021-12-21 21:45:16 +00:00
|
|
|
assert expected_size == size
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize('pair,contract_size,trading_mode', [
|
|
|
|
('XLTCUSDT', 1, 'spot'),
|
|
|
|
('LTC/USD', 1, 'futures'),
|
2022-02-13 03:59:26 +00:00
|
|
|
('ADA/USDT:USDT', 0.01, 'futures'),
|
2021-12-21 21:45:16 +00:00
|
|
|
('LTC/ETH', 1, 'futures'),
|
|
|
|
('ETH/USDT:USDT', 10, 'futures'),
|
|
|
|
])
|
|
|
|
def test__order_contracts_to_amount(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
markets,
|
|
|
|
pair,
|
|
|
|
contract_size,
|
|
|
|
trading_mode,
|
|
|
|
):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
default_conf['trading_mode'] = trading_mode
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2021-12-21 21:45:16 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.markets', markets)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
2021-12-19 06:56:34 +00:00
|
|
|
|
2021-12-21 21:45:16 +00:00
|
|
|
orders = [
|
|
|
|
{
|
|
|
|
'id': '123456320',
|
|
|
|
'clientOrderId': '12345632018',
|
|
|
|
'timestamp': 1640124992000,
|
|
|
|
'datetime': 'Tue 21 Dec 2021 22:16:32 UTC',
|
|
|
|
'lastTradeTimestamp': 1640124911000,
|
|
|
|
'status': 'active',
|
|
|
|
'symbol': pair,
|
|
|
|
'type': 'limit',
|
|
|
|
'timeInForce': 'gtc',
|
|
|
|
'postOnly': None,
|
|
|
|
'side': 'buy',
|
|
|
|
'price': 2.0,
|
|
|
|
'stopPrice': None,
|
|
|
|
'average': None,
|
|
|
|
'amount': 30.0,
|
|
|
|
'cost': 60.0,
|
|
|
|
'filled': None,
|
|
|
|
'remaining': 30.0,
|
2022-05-03 16:03:45 +00:00
|
|
|
'fee': {
|
|
|
|
'currency': 'USDT',
|
|
|
|
'cost': 0.06,
|
|
|
|
},
|
2021-12-21 21:45:16 +00:00
|
|
|
'fees': [{
|
|
|
|
'currency': 'USDT',
|
|
|
|
'cost': 0.06,
|
|
|
|
}],
|
|
|
|
'trades': None,
|
|
|
|
'info': {},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
'id': '123456380',
|
|
|
|
'clientOrderId': '12345638203',
|
|
|
|
'timestamp': 1640124992000,
|
|
|
|
'datetime': 'Tue 21 Dec 2021 22:16:32 UTC',
|
|
|
|
'lastTradeTimestamp': 1640124911000,
|
|
|
|
'status': 'active',
|
|
|
|
'symbol': pair,
|
|
|
|
'type': 'limit',
|
|
|
|
'timeInForce': 'gtc',
|
|
|
|
'postOnly': None,
|
|
|
|
'side': 'sell',
|
|
|
|
'price': 2.2,
|
|
|
|
'stopPrice': None,
|
|
|
|
'average': None,
|
|
|
|
'amount': 40.0,
|
|
|
|
'cost': 80.0,
|
|
|
|
'filled': None,
|
|
|
|
'remaining': 40.0,
|
2022-05-03 16:03:45 +00:00
|
|
|
'fee': {
|
|
|
|
'currency': 'USDT',
|
|
|
|
'cost': 0.08,
|
|
|
|
},
|
2021-12-21 21:45:16 +00:00
|
|
|
'fees': [{
|
|
|
|
'currency': 'USDT',
|
|
|
|
'cost': 0.08,
|
|
|
|
}],
|
|
|
|
'trades': None,
|
|
|
|
'info': {},
|
|
|
|
},
|
2022-03-25 17:09:18 +00:00
|
|
|
{
|
|
|
|
# Realistic stoploss order on gateio.
|
|
|
|
'id': '123456380',
|
|
|
|
'clientOrderId': '12345638203',
|
|
|
|
'timestamp': None,
|
|
|
|
'datetime': None,
|
|
|
|
'lastTradeTimestamp': None,
|
|
|
|
'status': None,
|
|
|
|
'symbol': None,
|
|
|
|
'type': None,
|
|
|
|
'timeInForce': None,
|
|
|
|
'postOnly': None,
|
|
|
|
'side': None,
|
|
|
|
'price': None,
|
|
|
|
'stopPrice': None,
|
|
|
|
'average': None,
|
|
|
|
'amount': None,
|
|
|
|
'cost': None,
|
|
|
|
'filled': None,
|
|
|
|
'remaining': None,
|
|
|
|
'fee': None,
|
|
|
|
'fees': [],
|
|
|
|
'trades': None,
|
|
|
|
'info': {},
|
|
|
|
},
|
2021-12-21 21:45:16 +00:00
|
|
|
]
|
2022-05-03 16:03:45 +00:00
|
|
|
order1_bef = orders[0]
|
|
|
|
order2_bef = orders[1]
|
|
|
|
order1 = exchange._order_contracts_to_amount(deepcopy(order1_bef))
|
|
|
|
order2 = exchange._order_contracts_to_amount(deepcopy(order2_bef))
|
|
|
|
assert order1['amount'] == order1_bef['amount'] * contract_size
|
|
|
|
assert order1['cost'] == order1_bef['cost'] * contract_size
|
|
|
|
|
|
|
|
assert order2['amount'] == order2_bef['amount'] * contract_size
|
|
|
|
assert order2['cost'] == order2_bef['cost'] * contract_size
|
2021-12-19 06:56:34 +00:00
|
|
|
|
2022-05-03 16:03:45 +00:00
|
|
|
# Don't fail
|
2022-03-25 17:09:18 +00:00
|
|
|
exchange._order_contracts_to_amount(orders[2])
|
2021-12-19 06:56:34 +00:00
|
|
|
|
|
|
|
|
2021-12-21 21:45:16 +00:00
|
|
|
@pytest.mark.parametrize('pair,contract_size,trading_mode', [
|
|
|
|
('XLTCUSDT', 1, 'spot'),
|
|
|
|
('LTC/USD', 1, 'futures'),
|
2022-02-13 03:59:26 +00:00
|
|
|
('ADA/USDT:USDT', 0.01, 'futures'),
|
2021-12-21 21:45:16 +00:00
|
|
|
('LTC/ETH', 1, 'futures'),
|
|
|
|
('ETH/USDT:USDT', 10, 'futures'),
|
|
|
|
])
|
|
|
|
def test__trades_contracts_to_amount(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
markets,
|
|
|
|
pair,
|
|
|
|
contract_size,
|
|
|
|
trading_mode,
|
|
|
|
):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
default_conf['trading_mode'] = trading_mode
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2021-12-21 21:45:16 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.markets', markets)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
2021-12-19 06:56:34 +00:00
|
|
|
|
2021-12-21 21:45:16 +00:00
|
|
|
trades = [
|
|
|
|
{
|
|
|
|
'symbol': pair,
|
|
|
|
'amount': 30.0,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
'symbol': pair,
|
|
|
|
'amount': 40.0,
|
|
|
|
}
|
|
|
|
]
|
2021-12-19 06:56:34 +00:00
|
|
|
|
2021-12-21 21:45:16 +00:00
|
|
|
new_amount_trades = exchange._trades_contracts_to_amount(trades)
|
|
|
|
assert new_amount_trades[0]['amount'] == 30.0 * contract_size
|
|
|
|
assert new_amount_trades[1]['amount'] == 40.0 * contract_size
|
2021-12-19 06:56:34 +00:00
|
|
|
|
|
|
|
|
2021-12-21 21:45:16 +00:00
|
|
|
@pytest.mark.parametrize('pair,param_amount,param_size', [
|
2022-02-13 03:59:26 +00:00
|
|
|
('ADA/USDT:USDT', 40, 4000),
|
2021-12-21 21:45:16 +00:00
|
|
|
('LTC/ETH', 30, 30),
|
2021-12-31 11:28:25 +00:00
|
|
|
('LTC/USD', 30, 30),
|
2021-12-21 21:45:16 +00:00
|
|
|
('ETH/USDT:USDT', 10, 1),
|
|
|
|
])
|
|
|
|
def test__amount_to_contracts(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
pair,
|
|
|
|
param_amount,
|
|
|
|
param_size
|
|
|
|
):
|
|
|
|
api_mock = MagicMock()
|
2021-12-31 11:28:25 +00:00
|
|
|
default_conf['trading_mode'] = 'spot'
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2022-02-13 03:59:26 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
2021-12-31 11:28:25 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.markets', {
|
|
|
|
'LTC/USD': {
|
|
|
|
'symbol': 'LTC/USD',
|
|
|
|
'contractSize': None,
|
|
|
|
},
|
|
|
|
'XLTCUSDT': {
|
|
|
|
'symbol': 'XLTCUSDT',
|
2022-01-06 09:40:31 +00:00
|
|
|
'contractSize': '0.01',
|
2021-12-31 11:28:25 +00:00
|
|
|
},
|
|
|
|
'LTC/ETH': {
|
|
|
|
'symbol': 'LTC/ETH',
|
|
|
|
},
|
|
|
|
'ETH/USDT:USDT': {
|
|
|
|
'symbol': 'ETH/USDT:USDT',
|
2022-01-06 09:40:31 +00:00
|
|
|
'contractSize': '10',
|
2021-12-31 11:28:25 +00:00
|
|
|
}
|
|
|
|
})
|
|
|
|
result_size = exchange._amount_to_contracts(pair, param_amount)
|
|
|
|
assert result_size == param_amount
|
|
|
|
result_amount = exchange._contracts_to_amount(pair, param_size)
|
|
|
|
assert result_amount == param_size
|
|
|
|
|
|
|
|
default_conf['trading_mode'] = 'futures'
|
2021-12-21 21:45:16 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
result_size = exchange._amount_to_contracts(pair, param_amount)
|
|
|
|
assert result_size == param_size
|
|
|
|
result_amount = exchange._contracts_to_amount(pair, param_size)
|
|
|
|
assert result_amount == param_amount
|
2022-01-23 02:03:38 +00:00
|
|
|
|
|
|
|
|
2022-09-07 04:55:22 +00:00
|
|
|
@pytest.mark.parametrize('pair,amount,expected_spot,expected_fut', [
|
|
|
|
# Contract size of 0.01
|
|
|
|
('ADA/USDT:USDT', 40, 40, 40),
|
|
|
|
('ADA/USDT:USDT', 10.4445555, 10.4, 10.444),
|
|
|
|
('LTC/ETH', 30, 30, 30),
|
|
|
|
('LTC/USD', 30, 30, 30),
|
2022-09-24 12:51:58 +00:00
|
|
|
('ADA/USDT:USDT', 1.17, 1.1, 1.17),
|
2022-09-07 04:55:22 +00:00
|
|
|
# contract size of 10
|
|
|
|
('ETH/USDT:USDT', 10.111, 10.1, 10),
|
|
|
|
('ETH/USDT:USDT', 10.188, 10.1, 10),
|
|
|
|
('ETH/USDT:USDT', 10.988, 10.9, 10),
|
|
|
|
])
|
|
|
|
def test_amount_to_contract_precision(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
pair,
|
|
|
|
amount,
|
|
|
|
expected_spot,
|
|
|
|
expected_fut,
|
|
|
|
):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
default_conf['trading_mode'] = 'spot'
|
|
|
|
default_conf['margin_mode'] = 'isolated'
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
|
|
|
|
result_size = exchange.amount_to_contract_precision(pair, amount)
|
|
|
|
assert result_size == expected_spot
|
|
|
|
|
|
|
|
default_conf['trading_mode'] = 'futures'
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
result_size = exchange.amount_to_contract_precision(pair, amount)
|
|
|
|
assert result_size == expected_fut
|
|
|
|
|
|
|
|
|
2022-09-24 13:25:04 +00:00
|
|
|
@pytest.mark.parametrize('amount,precision,precision_mode,contract_size,expected', [
|
|
|
|
(1.17, 1.0, 4, 0.01, 1.17), # Tick size
|
|
|
|
(1.17, 1.0, 2, 0.01, 1.17), #
|
|
|
|
(1.16, 1.0, 4, 0.01, 1.16), #
|
|
|
|
(1.16, 1.0, 2, 0.01, 1.16), #
|
|
|
|
(1.13, 1.0, 2, 0.01, 1.13), #
|
|
|
|
(10.988, 1.0, 2, 10, 10),
|
|
|
|
(10.988, 1.0, 4, 10, 10),
|
|
|
|
])
|
|
|
|
def test_amount_to_contract_precision2(amount, precision, precision_mode, contract_size, expected):
|
|
|
|
res = amount_to_contract_precision(amount, precision, precision_mode, contract_size)
|
|
|
|
assert pytest.approx(res) == expected
|
|
|
|
|
|
|
|
|
2022-02-01 18:53:38 +00:00
|
|
|
@pytest.mark.parametrize('exchange_name,open_rate,is_short,trading_mode,margin_mode', [
|
2022-01-23 02:03:38 +00:00
|
|
|
# Bittrex
|
2022-01-31 19:49:06 +00:00
|
|
|
('bittrex', 2.0, False, 'spot', None),
|
|
|
|
('bittrex', 2.0, False, 'spot', 'cross'),
|
|
|
|
('bittrex', 2.0, True, 'spot', 'isolated'),
|
2022-01-23 02:03:38 +00:00
|
|
|
# Binance
|
2022-01-31 19:49:06 +00:00
|
|
|
('binance', 2.0, False, 'spot', None),
|
|
|
|
('binance', 2.0, False, 'spot', 'cross'),
|
|
|
|
('binance', 2.0, True, 'spot', 'isolated'),
|
2022-01-23 02:03:38 +00:00
|
|
|
])
|
|
|
|
def test_liquidation_price_is_none(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
exchange_name,
|
|
|
|
open_rate,
|
|
|
|
is_short,
|
|
|
|
trading_mode,
|
2022-02-01 18:53:38 +00:00
|
|
|
margin_mode
|
2022-01-23 02:03:38 +00:00
|
|
|
):
|
2022-01-29 08:06:56 +00:00
|
|
|
default_conf['trading_mode'] = trading_mode
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf['margin_mode'] = margin_mode
|
2022-01-23 02:03:38 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
2022-08-29 04:45:00 +00:00
|
|
|
assert exchange.get_liquidation_price(
|
2022-01-30 00:47:17 +00:00
|
|
|
pair='DOGE/USDT',
|
2022-01-29 08:06:56 +00:00
|
|
|
open_rate=open_rate,
|
|
|
|
is_short=is_short,
|
2022-08-26 18:04:36 +00:00
|
|
|
amount=71200.81144,
|
|
|
|
stake_amount=open_rate * 71200.81144,
|
2022-01-29 08:06:56 +00:00
|
|
|
wallet_balance=-56354.57,
|
|
|
|
mm_ex_1=0.10,
|
|
|
|
upnl_ex_1=0.0
|
2022-01-23 02:03:38 +00:00
|
|
|
) is None
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize(
|
2022-02-01 18:53:38 +00:00
|
|
|
'exchange_name, is_short, trading_mode, margin_mode, wallet_balance, '
|
2022-08-26 18:04:36 +00:00
|
|
|
'mm_ex_1, upnl_ex_1, maintenance_amt, amount, open_rate, '
|
2022-01-23 02:03:38 +00:00
|
|
|
'mm_ratio, expected',
|
|
|
|
[
|
2022-01-31 19:49:06 +00:00
|
|
|
("binance", False, 'futures', 'isolated', 1535443.01, 0.0,
|
2022-01-23 02:03:38 +00:00
|
|
|
0.0, 135365.00, 3683.979, 1456.84, 0.10, 1114.78),
|
2022-01-31 19:49:06 +00:00
|
|
|
("binance", False, 'futures', 'isolated', 1535443.01, 0.0,
|
2022-01-23 02:03:38 +00:00
|
|
|
0.0, 16300.000, 109.488, 32481.980, 0.025, 18778.73),
|
2022-01-31 19:49:06 +00:00
|
|
|
("binance", False, 'futures', 'cross', 1535443.01, 71200.81144,
|
2022-01-23 02:03:38 +00:00
|
|
|
-56354.57, 135365.00, 3683.979, 1456.84, 0.10, 1153.26),
|
2022-01-31 19:49:06 +00:00
|
|
|
("binance", False, 'futures', 'cross', 1535443.01, 356512.508,
|
2022-01-23 02:03:38 +00:00
|
|
|
-448192.89, 16300.000, 109.488, 32481.980, 0.025, 26316.89)
|
|
|
|
])
|
|
|
|
def test_liquidation_price(
|
2022-01-31 19:49:06 +00:00
|
|
|
mocker, default_conf, exchange_name, open_rate, is_short, trading_mode,
|
2022-08-26 18:04:36 +00:00
|
|
|
margin_mode, wallet_balance, mm_ex_1, upnl_ex_1, maintenance_amt, amount, mm_ratio, expected
|
2022-01-23 02:03:38 +00:00
|
|
|
):
|
2022-01-29 08:06:56 +00:00
|
|
|
default_conf['trading_mode'] = trading_mode
|
2022-02-01 18:53:38 +00:00
|
|
|
default_conf['margin_mode'] = margin_mode
|
2022-02-11 09:48:09 +00:00
|
|
|
default_conf['liquidation_buffer'] = 0.0
|
2022-01-23 02:03:38 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id=exchange_name)
|
2022-01-30 00:47:17 +00:00
|
|
|
exchange.get_maintenance_ratio_and_amt = MagicMock(return_value=(mm_ratio, maintenance_amt))
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(round(exchange.get_liquidation_price(
|
2022-01-30 00:47:17 +00:00
|
|
|
pair='DOGE/USDT',
|
2022-01-23 02:03:38 +00:00
|
|
|
open_rate=open_rate,
|
|
|
|
is_short=is_short,
|
|
|
|
wallet_balance=wallet_balance,
|
|
|
|
mm_ex_1=mm_ex_1,
|
|
|
|
upnl_ex_1=upnl_ex_1,
|
2022-08-26 18:04:36 +00:00
|
|
|
amount=amount,
|
|
|
|
stake_amount=open_rate * amount,
|
2022-08-31 08:18:28 +00:00
|
|
|
), 2)) == expected
|
2022-01-29 09:22:08 +00:00
|
|
|
|
|
|
|
|
2022-02-02 02:24:06 +00:00
|
|
|
def test_get_max_pair_stake_amount(
|
2022-01-29 09:22:08 +00:00
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
):
|
|
|
|
api_mock = MagicMock()
|
2022-02-03 07:38:14 +00:00
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2022-01-31 09:57:47 +00:00
|
|
|
default_conf['trading_mode'] = 'futures'
|
2022-01-29 09:22:08 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
markets = {
|
2022-01-31 09:57:47 +00:00
|
|
|
'XRP/USDT:USDT': {
|
2022-01-29 09:22:08 +00:00
|
|
|
'limits': {
|
|
|
|
'amount': {
|
|
|
|
'min': 0.001,
|
|
|
|
'max': 10000
|
|
|
|
},
|
|
|
|
'cost': {
|
|
|
|
'min': 5,
|
|
|
|
'max': None
|
|
|
|
},
|
|
|
|
},
|
|
|
|
'contractSize': None,
|
|
|
|
'spot': False,
|
|
|
|
},
|
2022-01-31 09:57:47 +00:00
|
|
|
'LTC/USDT:USDT': {
|
2022-01-29 09:22:08 +00:00
|
|
|
'limits': {
|
|
|
|
'amount': {
|
|
|
|
'min': 0.001,
|
|
|
|
'max': None
|
|
|
|
},
|
|
|
|
'cost': {
|
|
|
|
'min': 5,
|
|
|
|
'max': None
|
|
|
|
},
|
2022-01-31 09:57:47 +00:00
|
|
|
},
|
|
|
|
'contractSize': 0.01,
|
|
|
|
'spot': False,
|
|
|
|
},
|
|
|
|
'ETH/USDT:USDT': {
|
|
|
|
'limits': {
|
|
|
|
'amount': {
|
2022-01-31 08:31:44 +00:00
|
|
|
'min': 0.001,
|
2022-01-31 09:57:47 +00:00
|
|
|
'max': 10000
|
|
|
|
},
|
|
|
|
'cost': {
|
|
|
|
'min': 5,
|
|
|
|
'max': 30000,
|
2022-01-31 08:31:44 +00:00
|
|
|
},
|
2022-01-29 09:22:08 +00:00
|
|
|
},
|
|
|
|
'contractSize': 0.01,
|
|
|
|
'spot': False,
|
|
|
|
},
|
2022-01-31 09:57:47 +00:00
|
|
|
'BTC/USDT': {
|
2022-01-29 09:22:08 +00:00
|
|
|
'limits': {
|
|
|
|
'amount': {
|
|
|
|
'min': 0.001,
|
|
|
|
'max': 10000
|
|
|
|
},
|
|
|
|
'cost': {
|
|
|
|
'min': 5,
|
|
|
|
'max': None
|
|
|
|
},
|
2022-01-31 09:57:47 +00:00
|
|
|
},
|
|
|
|
'contractSize': 0.01,
|
|
|
|
'spot': True,
|
|
|
|
},
|
|
|
|
'ADA/USDT': {
|
|
|
|
'limits': {
|
|
|
|
'amount': {
|
2022-01-31 08:31:44 +00:00
|
|
|
'min': 0.001,
|
2022-01-31 09:57:47 +00:00
|
|
|
'max': 10000
|
|
|
|
},
|
|
|
|
'cost': {
|
|
|
|
'min': 5,
|
|
|
|
'max': 500,
|
2022-01-31 08:31:44 +00:00
|
|
|
},
|
2022-01-29 09:22:08 +00:00
|
|
|
},
|
|
|
|
'contractSize': 0.01,
|
2022-01-31 09:57:47 +00:00
|
|
|
'spot': True,
|
2022-01-29 09:22:08 +00:00
|
|
|
},
|
2022-01-31 09:57:47 +00:00
|
|
|
'DOGE/USDT:USDT': {
|
2022-01-29 09:22:08 +00:00
|
|
|
'limits': {
|
|
|
|
'amount': {
|
|
|
|
'min': 0.001,
|
|
|
|
'max': 10000
|
|
|
|
},
|
|
|
|
'cost': {
|
|
|
|
'min': 5,
|
2022-01-31 09:57:47 +00:00
|
|
|
'max': 500
|
2022-01-29 09:22:08 +00:00
|
|
|
},
|
2022-01-31 09:57:47 +00:00
|
|
|
},
|
|
|
|
'contractSize': None,
|
|
|
|
'spot': False,
|
|
|
|
},
|
|
|
|
'LUNA/USDT:USDT': {
|
|
|
|
'limits': {
|
|
|
|
'amount': {
|
2022-01-31 08:31:44 +00:00
|
|
|
'min': 0.001,
|
2022-01-31 09:57:47 +00:00
|
|
|
'max': 10000
|
|
|
|
},
|
|
|
|
'cost': {
|
|
|
|
'min': 5,
|
|
|
|
'max': 500
|
2022-01-31 08:31:44 +00:00
|
|
|
},
|
2022-01-29 09:22:08 +00:00
|
|
|
},
|
|
|
|
'contractSize': 0.01,
|
2022-01-31 09:57:47 +00:00
|
|
|
'spot': False,
|
|
|
|
},
|
2022-01-29 09:22:08 +00:00
|
|
|
}
|
2022-01-31 09:57:47 +00:00
|
|
|
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.markets', markets)
|
2022-02-04 20:26:15 +00:00
|
|
|
assert exchange.get_max_pair_stake_amount('XRP/USDT:USDT', 2.0) == 20000
|
2022-02-07 10:57:39 +00:00
|
|
|
assert exchange.get_max_pair_stake_amount('XRP/USDT:USDT', 2.0, 5) == 4000
|
2022-02-04 20:26:15 +00:00
|
|
|
assert exchange.get_max_pair_stake_amount('LTC/USDT:USDT', 2.0) == float('inf')
|
|
|
|
assert exchange.get_max_pair_stake_amount('ETH/USDT:USDT', 2.0) == 200
|
|
|
|
assert exchange.get_max_pair_stake_amount('DOGE/USDT:USDT', 2.0) == 500
|
|
|
|
assert exchange.get_max_pair_stake_amount('LUNA/USDT:USDT', 2.0) == 5.0
|
2022-01-31 09:57:47 +00:00
|
|
|
|
|
|
|
default_conf['trading_mode'] = 'spot'
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
2022-01-31 08:31:44 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.markets', markets)
|
2022-02-04 20:26:15 +00:00
|
|
|
assert exchange.get_max_pair_stake_amount('BTC/USDT', 2.0) == 20000
|
|
|
|
assert exchange.get_max_pair_stake_amount('ADA/USDT', 2.0) == 500
|
2022-02-07 11:03:10 +00:00
|
|
|
|
|
|
|
|
2022-02-16 11:26:52 +00:00
|
|
|
@pytest.mark.parametrize('exchange_name', EXCHANGES)
|
|
|
|
def test_load_leverage_tiers(mocker, default_conf, leverage_tiers, exchange_name):
|
2022-02-07 12:27:20 +00:00
|
|
|
api_mock = MagicMock()
|
2022-02-07 13:09:29 +00:00
|
|
|
api_mock.fetch_leverage_tiers = MagicMock()
|
2022-02-07 12:27:20 +00:00
|
|
|
type(api_mock).has = PropertyMock(return_value={'fetchLeverageTiers': True})
|
|
|
|
default_conf['dry_run'] = False
|
2022-02-16 11:26:52 +00:00
|
|
|
mocker.patch('freqtrade.exchange.exchange.Exchange.validate_trading_mode_and_margin_mode')
|
2022-02-16 10:37:11 +00:00
|
|
|
|
2022-02-16 11:26:52 +00:00
|
|
|
api_mock.fetch_leverage_tiers = MagicMock(return_value={
|
|
|
|
'ADA/USDT:USDT': [
|
|
|
|
{
|
|
|
|
'tier': 1,
|
2022-04-17 03:47:44 +00:00
|
|
|
'minNotional': 0,
|
|
|
|
'maxNotional': 500,
|
2022-02-16 15:04:43 +00:00
|
|
|
'maintenanceMarginRate': 0.02,
|
2022-02-16 11:26:52 +00:00
|
|
|
'maxLeverage': 75,
|
|
|
|
'info': {
|
|
|
|
'baseMaxLoan': '',
|
|
|
|
'imr': '0.013',
|
|
|
|
'instId': '',
|
|
|
|
'maxLever': '75',
|
|
|
|
'maxSz': '500',
|
|
|
|
'minSz': '0',
|
|
|
|
'mmr': '0.01',
|
|
|
|
'optMgnFactor': '0',
|
|
|
|
'quoteMaxLoan': '',
|
|
|
|
'tier': '1',
|
|
|
|
'uly': 'ADA-USDT'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
]
|
|
|
|
})
|
2022-02-16 10:37:11 +00:00
|
|
|
|
|
|
|
# SPOT
|
2022-02-16 11:26:52 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2022-02-16 10:37:11 +00:00
|
|
|
assert exchange.load_leverage_tiers() == {}
|
|
|
|
|
2022-02-07 13:09:29 +00:00
|
|
|
default_conf['trading_mode'] = 'futures'
|
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2022-02-16 11:44:11 +00:00
|
|
|
|
|
|
|
if exchange_name != 'binance':
|
|
|
|
# FUTURES has.fetchLeverageTiers == False
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'fetchLeverageTiers': False})
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
assert exchange.load_leverage_tiers() == {}
|
2022-02-16 10:52:26 +00:00
|
|
|
|
|
|
|
# FUTURES regular
|
|
|
|
type(api_mock).has = PropertyMock(return_value={'fetchLeverageTiers': True})
|
2022-02-16 11:26:52 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
2022-02-16 10:37:11 +00:00
|
|
|
assert exchange.load_leverage_tiers() == {
|
2022-02-16 10:52:26 +00:00
|
|
|
'ADA/USDT:USDT': [
|
|
|
|
{
|
|
|
|
'tier': 1,
|
2022-04-17 03:47:44 +00:00
|
|
|
'minNotional': 0,
|
|
|
|
'maxNotional': 500,
|
2022-02-16 15:04:43 +00:00
|
|
|
'maintenanceMarginRate': 0.02,
|
2022-02-16 10:52:26 +00:00
|
|
|
'maxLeverage': 75,
|
|
|
|
'info': {
|
|
|
|
'baseMaxLoan': '',
|
|
|
|
'imr': '0.013',
|
|
|
|
'instId': '',
|
|
|
|
'maxLever': '75',
|
|
|
|
'maxSz': '500',
|
|
|
|
'minSz': '0',
|
|
|
|
'mmr': '0.01',
|
|
|
|
'optMgnFactor': '0',
|
|
|
|
'quoteMaxLoan': '',
|
|
|
|
'tier': '1',
|
|
|
|
'uly': 'ADA-USDT'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
]
|
|
|
|
}
|
2022-02-07 12:27:20 +00:00
|
|
|
|
|
|
|
ccxt_exceptionhandlers(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
api_mock,
|
2022-02-16 11:26:52 +00:00
|
|
|
exchange_name,
|
2022-02-07 13:09:29 +00:00
|
|
|
"load_leverage_tiers",
|
|
|
|
"fetch_leverage_tiers",
|
2022-02-07 12:27:20 +00:00
|
|
|
)
|
2022-02-07 11:03:10 +00:00
|
|
|
|
|
|
|
|
2022-08-20 12:03:47 +00:00
|
|
|
@pytest.mark.asyncio
|
|
|
|
@pytest.mark.parametrize('exchange_name', EXCHANGES)
|
|
|
|
async def test_get_market_leverage_tiers(mocker, default_conf, exchange_name):
|
|
|
|
default_conf['exchange']['name'] = exchange_name
|
|
|
|
await async_ccxt_exception(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
MagicMock(),
|
|
|
|
"get_market_leverage_tiers",
|
|
|
|
"fetch_market_leverage_tiers",
|
|
|
|
symbol='BTC/USDT:USDT'
|
|
|
|
)
|
|
|
|
|
|
|
|
|
2022-02-07 13:09:29 +00:00
|
|
|
def test_parse_leverage_tier(mocker, default_conf):
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf)
|
|
|
|
|
|
|
|
tier = {
|
|
|
|
"tier": 1,
|
2022-04-17 03:47:44 +00:00
|
|
|
"minNotional": 0,
|
|
|
|
"maxNotional": 100000,
|
2022-02-16 15:04:43 +00:00
|
|
|
"maintenanceMarginRate": 0.025,
|
2022-02-07 13:09:29 +00:00
|
|
|
"maxLeverage": 20,
|
|
|
|
"info": {
|
|
|
|
"bracket": "1",
|
|
|
|
"initialLeverage": "20",
|
2022-04-17 03:47:44 +00:00
|
|
|
"maxNotional": "100000",
|
|
|
|
"minNotional": "0",
|
2022-02-07 13:09:29 +00:00
|
|
|
"maintMarginRatio": "0.025",
|
|
|
|
"cum": "0.0"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert exchange.parse_leverage_tier(tier) == {
|
2022-08-26 17:34:51 +00:00
|
|
|
"minNotional": 0,
|
|
|
|
"maxNotional": 100000,
|
|
|
|
"maintenanceMarginRate": 0.025,
|
|
|
|
"maxLeverage": 20,
|
2022-02-07 13:09:29 +00:00
|
|
|
"maintAmt": 0.0,
|
|
|
|
}
|
|
|
|
|
|
|
|
tier2 = {
|
|
|
|
'tier': 1,
|
2022-04-17 03:47:44 +00:00
|
|
|
'minNotional': 0,
|
|
|
|
'maxNotional': 2000,
|
2022-02-16 15:04:43 +00:00
|
|
|
'maintenanceMarginRate': 0.01,
|
2022-02-07 13:09:29 +00:00
|
|
|
'maxLeverage': 75,
|
|
|
|
'info': {
|
|
|
|
'baseMaxLoan': '',
|
|
|
|
'imr': '0.013',
|
|
|
|
'instId': '',
|
|
|
|
'maxLever': '75',
|
|
|
|
'maxSz': '2000',
|
|
|
|
'minSz': '0',
|
|
|
|
'mmr': '0.01',
|
|
|
|
'optMgnFactor': '0',
|
|
|
|
'quoteMaxLoan': '',
|
|
|
|
'tier': '1',
|
|
|
|
'uly': 'SHIB-USDT'
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert exchange.parse_leverage_tier(tier2) == {
|
2022-08-26 17:34:51 +00:00
|
|
|
'minNotional': 0,
|
|
|
|
'maxNotional': 2000,
|
|
|
|
'maintenanceMarginRate': 0.01,
|
|
|
|
'maxLeverage': 75,
|
2022-02-07 13:09:29 +00:00
|
|
|
"maintAmt": None,
|
|
|
|
}
|
2022-02-07 11:03:10 +00:00
|
|
|
|
|
|
|
|
2022-02-10 11:04:29 +00:00
|
|
|
def test_get_maintenance_ratio_and_amt_exceptions(mocker, default_conf, leverage_tiers):
|
2022-02-07 11:03:10 +00:00
|
|
|
api_mock = MagicMock()
|
|
|
|
default_conf['trading_mode'] = 'futures'
|
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2022-02-13 12:00:38 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
|
2022-02-07 11:03:10 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
2022-02-10 12:10:15 +00:00
|
|
|
|
|
|
|
exchange._leverage_tiers = leverage_tiers
|
|
|
|
with pytest.raises(
|
|
|
|
OperationalException,
|
|
|
|
match='nominal value can not be lower than 0',
|
|
|
|
):
|
|
|
|
exchange.get_maintenance_ratio_and_amt('1000SHIB/USDT', -1)
|
2022-02-10 11:04:29 +00:00
|
|
|
|
|
|
|
exchange._leverage_tiers = {}
|
|
|
|
|
|
|
|
with pytest.raises(
|
|
|
|
InvalidOrderException,
|
2022-02-10 12:10:15 +00:00
|
|
|
match="Maintenance margin rate for 1000SHIB/USDT is unavailable for",
|
2022-02-10 11:04:29 +00:00
|
|
|
):
|
2022-02-10 12:10:15 +00:00
|
|
|
exchange.get_maintenance_ratio_and_amt('1000SHIB/USDT', 10000)
|
2022-02-10 11:04:29 +00:00
|
|
|
|
|
|
|
|
2022-02-16 10:05:27 +00:00
|
|
|
@pytest.mark.parametrize('pair,value,mmr,maintAmt', [
|
2022-02-10 11:04:29 +00:00
|
|
|
('ADA/BUSD', 500, 0.025, 0.0),
|
|
|
|
('ADA/BUSD', 20000000, 0.5, 1527500.0),
|
|
|
|
('ZEC/USDT', 500, 0.01, 0.0),
|
|
|
|
('ZEC/USDT', 20000000, 0.5, 654500.0),
|
|
|
|
])
|
|
|
|
def test_get_maintenance_ratio_and_amt(
|
|
|
|
mocker,
|
|
|
|
default_conf,
|
|
|
|
leverage_tiers,
|
|
|
|
pair,
|
|
|
|
value,
|
|
|
|
mmr,
|
|
|
|
maintAmt
|
|
|
|
):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
default_conf['trading_mode'] = 'futures'
|
|
|
|
default_conf['margin_mode'] = 'isolated'
|
2022-02-13 12:00:38 +00:00
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
|
2022-02-10 11:04:29 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
2022-02-14 23:34:59 +00:00
|
|
|
exchange._leverage_tiers = leverage_tiers
|
2022-02-10 11:04:29 +00:00
|
|
|
exchange.get_maintenance_ratio_and_amt(pair, value) == (mmr, maintAmt)
|
2022-02-13 03:59:26 +00:00
|
|
|
|
|
|
|
|
|
|
|
def test_get_max_leverage_futures(default_conf, mocker, leverage_tiers):
|
|
|
|
|
|
|
|
# Test Spot
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id="binance")
|
|
|
|
assert exchange.get_max_leverage("BNB/USDT", 100.0) == 1.0
|
|
|
|
|
|
|
|
# Test Futures
|
|
|
|
default_conf['trading_mode'] = 'futures'
|
|
|
|
default_conf['margin_mode'] = 'isolated'
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, id="binance")
|
|
|
|
|
|
|
|
exchange._leverage_tiers = leverage_tiers
|
|
|
|
|
|
|
|
assert exchange.get_max_leverage("BNB/BUSD", 1.0) == 20.0
|
|
|
|
assert exchange.get_max_leverage("BNB/USDT", 100.0) == 75.0
|
|
|
|
assert exchange.get_max_leverage("BTC/USDT", 170.30) == 125.0
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(exchange.get_max_leverage("BNB/BUSD", 99999.9)) == 5.000005
|
|
|
|
assert pytest.approx(exchange.get_max_leverage("BNB/USDT", 1500)) == 33.333333333333333
|
2022-02-13 03:59:26 +00:00
|
|
|
assert exchange.get_max_leverage("BTC/USDT", 300000000) == 2.0
|
|
|
|
assert exchange.get_max_leverage("BTC/USDT", 600000000) == 1.0 # Last tier
|
|
|
|
|
|
|
|
assert exchange.get_max_leverage("SPONGE/USDT", 200) == 1.0 # Pair not in leverage_tiers
|
|
|
|
assert exchange.get_max_leverage("BTC/USDT", 0.0) == 125.0 # No stake amount
|
|
|
|
with pytest.raises(
|
|
|
|
InvalidOrderException,
|
|
|
|
match=r'Amount 1000000000.01 too high for BTC/USDT'
|
|
|
|
):
|
|
|
|
exchange.get_max_leverage("BTC/USDT", 1000000000.01)
|
2022-02-16 16:00:06 +00:00
|
|
|
|
|
|
|
|
2022-11-14 18:40:57 +00:00
|
|
|
@pytest.mark.parametrize("exchange_name", ['bittrex', 'binance', 'kraken', 'gateio', 'okx'])
|
2022-02-16 16:00:06 +00:00
|
|
|
def test__get_params(mocker, default_conf, exchange_name):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.exchange_has', return_value=True)
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
exchange._params = {'test': True}
|
|
|
|
|
|
|
|
params1 = {'test': True}
|
|
|
|
params2 = {
|
|
|
|
'test': True,
|
2022-08-27 08:24:56 +00:00
|
|
|
'timeInForce': 'IOC',
|
2022-02-16 16:00:06 +00:00
|
|
|
'reduceOnly': True,
|
|
|
|
}
|
|
|
|
|
|
|
|
if exchange_name == 'kraken':
|
|
|
|
params2['leverage'] = 3.0
|
|
|
|
|
|
|
|
if exchange_name == 'okx':
|
|
|
|
params2['tdMode'] = 'isolated'
|
2022-05-07 08:56:13 +00:00
|
|
|
params2['posSide'] = 'net'
|
2022-02-16 16:00:06 +00:00
|
|
|
|
|
|
|
assert exchange._get_params(
|
2022-05-07 08:56:13 +00:00
|
|
|
side="buy",
|
2022-02-16 16:00:06 +00:00
|
|
|
ordertype='market',
|
|
|
|
reduceOnly=False,
|
2022-08-27 08:24:56 +00:00
|
|
|
time_in_force='GTC',
|
2022-02-16 16:00:06 +00:00
|
|
|
leverage=1.0,
|
|
|
|
) == params1
|
|
|
|
|
|
|
|
assert exchange._get_params(
|
2022-05-07 08:56:13 +00:00
|
|
|
side="buy",
|
2022-02-16 16:00:06 +00:00
|
|
|
ordertype='market',
|
|
|
|
reduceOnly=False,
|
2022-08-27 08:24:56 +00:00
|
|
|
time_in_force='IOC',
|
2022-02-16 16:00:06 +00:00
|
|
|
leverage=1.0,
|
|
|
|
) == params1
|
|
|
|
|
|
|
|
assert exchange._get_params(
|
2022-05-07 08:56:13 +00:00
|
|
|
side="buy",
|
2022-02-16 16:00:06 +00:00
|
|
|
ordertype='limit',
|
|
|
|
reduceOnly=False,
|
2022-08-27 08:24:56 +00:00
|
|
|
time_in_force='GTC',
|
2022-02-16 16:00:06 +00:00
|
|
|
leverage=1.0,
|
|
|
|
) == params1
|
|
|
|
|
|
|
|
default_conf['trading_mode'] = 'futures'
|
|
|
|
default_conf['margin_mode'] = 'isolated'
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock, id=exchange_name)
|
|
|
|
exchange._params = {'test': True}
|
|
|
|
|
|
|
|
assert exchange._get_params(
|
2022-05-07 08:56:13 +00:00
|
|
|
side="buy",
|
2022-02-16 16:00:06 +00:00
|
|
|
ordertype='limit',
|
|
|
|
reduceOnly=True,
|
2022-08-27 08:24:56 +00:00
|
|
|
time_in_force='IOC',
|
2022-02-16 16:00:06 +00:00
|
|
|
leverage=3.0,
|
|
|
|
) == params2
|
2022-02-28 18:27:48 +00:00
|
|
|
|
|
|
|
|
2022-08-29 04:45:00 +00:00
|
|
|
def test_get_liquidation_price1(mocker, default_conf):
|
|
|
|
|
|
|
|
api_mock = MagicMock()
|
|
|
|
positions = [
|
|
|
|
{
|
|
|
|
'info': {},
|
|
|
|
'symbol': 'NEAR/USDT:USDT',
|
|
|
|
'timestamp': 1642164737148,
|
|
|
|
'datetime': '2022-01-14T12:52:17.148Z',
|
|
|
|
'initialMargin': 1.51072,
|
|
|
|
'initialMarginPercentage': 0.1,
|
|
|
|
'maintenanceMargin': 0.38916147,
|
|
|
|
'maintenanceMarginPercentage': 0.025,
|
|
|
|
'entryPrice': 18.884,
|
|
|
|
'notional': 15.1072,
|
|
|
|
'leverage': 9.97,
|
|
|
|
'unrealizedPnl': 0.0048,
|
|
|
|
'contracts': 8,
|
|
|
|
'contractSize': 0.1,
|
|
|
|
'marginRatio': None,
|
|
|
|
'liquidationPrice': 17.47,
|
|
|
|
'markPrice': 18.89,
|
|
|
|
'margin_mode': 1.52549075,
|
|
|
|
'marginType': 'isolated',
|
|
|
|
'side': 'buy',
|
|
|
|
'percentage': 0.003177292946409658
|
|
|
|
}
|
|
|
|
]
|
|
|
|
api_mock.fetch_positions = MagicMock(return_value=positions)
|
|
|
|
mocker.patch.multiple(
|
|
|
|
'freqtrade.exchange.Exchange',
|
|
|
|
exchange_has=MagicMock(return_value=True),
|
|
|
|
)
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
default_conf['trading_mode'] = 'futures'
|
|
|
|
default_conf['margin_mode'] = 'isolated'
|
|
|
|
default_conf['liquidation_buffer'] = 0.0
|
|
|
|
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
liq_price = exchange.get_liquidation_price(
|
|
|
|
pair='NEAR/USDT:USDT',
|
|
|
|
open_rate=18.884,
|
|
|
|
is_short=False,
|
|
|
|
amount=0.8,
|
|
|
|
stake_amount=18.884 * 0.8,
|
2022-09-01 04:49:51 +00:00
|
|
|
wallet_balance=18.884 * 0.8,
|
2022-08-29 04:45:00 +00:00
|
|
|
)
|
|
|
|
assert liq_price == 17.47
|
|
|
|
|
|
|
|
default_conf['liquidation_buffer'] = 0.05
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
liq_price = exchange.get_liquidation_price(
|
|
|
|
pair='NEAR/USDT:USDT',
|
|
|
|
open_rate=18.884,
|
|
|
|
is_short=False,
|
|
|
|
amount=0.8,
|
|
|
|
stake_amount=18.884 * 0.8,
|
2022-09-01 04:49:51 +00:00
|
|
|
wallet_balance=18.884 * 0.8,
|
2022-08-29 04:45:00 +00:00
|
|
|
)
|
|
|
|
assert liq_price == 17.540699999999998
|
|
|
|
|
2022-08-29 04:59:00 +00:00
|
|
|
api_mock.fetch_positions = MagicMock(return_value=[])
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
liq_price = exchange.get_liquidation_price(
|
|
|
|
pair='NEAR/USDT:USDT',
|
|
|
|
open_rate=18.884,
|
|
|
|
is_short=False,
|
|
|
|
amount=0.8,
|
|
|
|
stake_amount=18.884 * 0.8,
|
2022-09-01 04:49:51 +00:00
|
|
|
wallet_balance=18.884 * 0.8,
|
2022-08-29 04:59:00 +00:00
|
|
|
)
|
|
|
|
assert liq_price is None
|
|
|
|
default_conf['trading_mode'] = 'margin'
|
|
|
|
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
|
|
|
with pytest.raises(OperationalException, match=r'.*does not support .* margin'):
|
|
|
|
exchange.get_liquidation_price(
|
|
|
|
pair='NEAR/USDT:USDT',
|
|
|
|
open_rate=18.884,
|
|
|
|
is_short=False,
|
|
|
|
amount=0.8,
|
|
|
|
stake_amount=18.884 * 0.8,
|
2022-09-01 04:49:51 +00:00
|
|
|
wallet_balance=18.884 * 0.8,
|
2022-08-29 04:59:00 +00:00
|
|
|
)
|
|
|
|
|
2022-08-29 04:45:00 +00:00
|
|
|
|
2022-08-29 19:51:10 +00:00
|
|
|
@pytest.mark.parametrize('liquidation_buffer', [0.0, 0.05])
|
2022-02-28 18:27:48 +00:00
|
|
|
@pytest.mark.parametrize(
|
|
|
|
"is_short,trading_mode,exchange_name,margin_mode,leverage,open_rate,amount,expected_liq", [
|
|
|
|
(False, 'spot', 'binance', '', 5.0, 10.0, 1.0, None),
|
|
|
|
(True, 'spot', 'binance', '', 5.0, 10.0, 1.0, None),
|
|
|
|
(False, 'spot', 'gateio', '', 5.0, 10.0, 1.0, None),
|
|
|
|
(True, 'spot', 'gateio', '', 5.0, 10.0, 1.0, None),
|
|
|
|
(False, 'spot', 'okx', '', 5.0, 10.0, 1.0, None),
|
|
|
|
(True, 'spot', 'okx', '', 5.0, 10.0, 1.0, None),
|
|
|
|
# Binance, short
|
|
|
|
(True, 'futures', 'binance', 'isolated', 5.0, 10.0, 1.0, 11.89108910891089),
|
|
|
|
(True, 'futures', 'binance', 'isolated', 3.0, 10.0, 1.0, 13.211221122079207),
|
|
|
|
(True, 'futures', 'binance', 'isolated', 5.0, 8.0, 1.0, 9.514851485148514),
|
2022-08-29 19:04:09 +00:00
|
|
|
(True, 'futures', 'binance', 'isolated', 5.0, 10.0, 0.6, 11.897689768976898),
|
2022-02-28 18:27:48 +00:00
|
|
|
# Binance, long
|
|
|
|
(False, 'futures', 'binance', 'isolated', 5, 10, 1.0, 8.070707070707071),
|
|
|
|
(False, 'futures', 'binance', 'isolated', 5, 8, 1.0, 6.454545454545454),
|
2022-08-29 19:04:09 +00:00
|
|
|
(False, 'futures', 'binance', 'isolated', 3, 10, 1.0, 6.723905723905723),
|
|
|
|
(False, 'futures', 'binance', 'isolated', 5, 10, 0.6, 8.063973063973064),
|
2022-02-28 18:27:48 +00:00
|
|
|
# Gateio/okx, short
|
2022-08-29 19:51:10 +00:00
|
|
|
(True, 'futures', 'gateio', 'isolated', 5, 10, 1.0, 11.87413417771621),
|
|
|
|
(True, 'futures', 'gateio', 'isolated', 5, 10, 2.0, 11.87413417771621),
|
|
|
|
(True, 'futures', 'gateio', 'isolated', 3, 10, 1.0, 13.193482419684678),
|
|
|
|
(True, 'futures', 'gateio', 'isolated', 5, 8, 1.0, 9.499307342172967),
|
|
|
|
(True, 'futures', 'okx', 'isolated', 3, 10, 1.0, 13.193482419684678),
|
2022-02-28 18:27:48 +00:00
|
|
|
# Gateio/okx, long
|
2022-08-29 19:51:10 +00:00
|
|
|
(False, 'futures', 'gateio', 'isolated', 5.0, 10.0, 1.0, 8.085708510208207),
|
|
|
|
(False, 'futures', 'gateio', 'isolated', 3.0, 10.0, 1.0, 6.738090425173506),
|
|
|
|
(False, 'futures', 'okx', 'isolated', 3.0, 10.0, 1.0, 6.738090425173506),
|
2022-02-28 18:27:48 +00:00
|
|
|
]
|
|
|
|
)
|
2022-02-28 18:45:15 +00:00
|
|
|
def test_get_liquidation_price(
|
2022-02-28 18:27:48 +00:00
|
|
|
mocker,
|
|
|
|
default_conf_usdt,
|
|
|
|
is_short,
|
|
|
|
trading_mode,
|
|
|
|
exchange_name,
|
|
|
|
margin_mode,
|
|
|
|
leverage,
|
|
|
|
open_rate,
|
|
|
|
amount,
|
|
|
|
expected_liq,
|
|
|
|
liquidation_buffer,
|
|
|
|
):
|
|
|
|
"""
|
|
|
|
position = 0.2 * 5
|
|
|
|
wb: wallet balance (stake_amount if isolated)
|
|
|
|
cum_b: maintenance amount
|
|
|
|
side_1: -1 if is_short else 1
|
|
|
|
ep1: entry price
|
|
|
|
mmr_b: maintenance margin ratio
|
|
|
|
|
|
|
|
Binance, Short
|
|
|
|
leverage = 5, open_rate = 10, amount = 1.0
|
|
|
|
((wb + cum_b) - (side_1 * position * ep1)) / ((position * mmr_b) - (side_1 * position))
|
|
|
|
((2 + 0.01) - ((-1) * 1 * 10)) / ((1 * 0.01) - ((-1) * 1)) = 11.89108910891089
|
|
|
|
leverage = 3, open_rate = 10, amount = 1.0
|
|
|
|
((3.3333333333 + 0.01) - ((-1) * 1.0 * 10)) / ((1.0 * 0.01) - ((-1) * 1.0)) = 13.2112211220
|
|
|
|
leverage = 5, open_rate = 8, amount = 1.0
|
|
|
|
((1.6 + 0.01) - ((-1) * 1 * 8)) / ((1 * 0.01) - ((-1) * 1)) = 9.514851485148514
|
|
|
|
leverage = 5, open_rate = 10, amount = 0.6
|
|
|
|
((1.6 + 0.01) - ((-1) * 0.6 * 10)) / ((0.6 * 0.01) - ((-1) * 0.6)) = 12.557755775577558
|
|
|
|
|
|
|
|
Binance, Long
|
|
|
|
leverage = 5, open_rate = 10, amount = 1.0
|
|
|
|
((wb + cum_b) - (side_1 * position * ep1)) / ((position * mmr_b) - (side_1 * position))
|
|
|
|
((2 + 0.01) - (1 * 1 * 10)) / ((1 * 0.01) - (1 * 1)) = 8.070707070707071
|
|
|
|
leverage = 5, open_rate = 8, amount = 1.0
|
|
|
|
((1.6 + 0.01) - (1 * 1 * 8)) / ((1 * 0.01) - (1 * 1)) = 6.454545454545454
|
|
|
|
leverage = 3, open_rate = 10, amount = 1.0
|
|
|
|
((2 + 0.01) - (1 * 0.6 * 10)) / ((0.6 * 0.01) - (1 * 0.6)) = 6.717171717171718
|
|
|
|
leverage = 5, open_rate = 10, amount = 0.6
|
|
|
|
((1.6 + 0.01) - (1 * 0.6 * 10)) / ((0.6 * 0.01) - (1 * 0.6)) = 7.39057239057239
|
|
|
|
|
|
|
|
Gateio/Okx, Short
|
|
|
|
leverage = 5, open_rate = 10, amount = 1.0
|
|
|
|
(open_rate + (wallet_balance / position)) / (1 + (mm_ratio + taker_fee_rate))
|
|
|
|
(10 + (2 / 1.0)) / (1 + (0.01 + 0.0006)) = 11.87413417771621
|
|
|
|
leverage = 5, open_rate = 10, amount = 2.0
|
|
|
|
(10 + (4 / 2.0)) / (1 + (0.01 + 0.0006)) = 11.87413417771621
|
|
|
|
leverage = 3, open_rate = 10, amount = 1.0
|
|
|
|
(10 + (3.3333333333333 / 1.0)) / (1 - (0.01 + 0.0006)) = 13.476180850346978
|
|
|
|
leverage = 5, open_rate = 8, amount = 1.0
|
|
|
|
(8 + (1.6 / 1.0)) / (1 + (0.01 + 0.0006)) = 9.499307342172967
|
|
|
|
|
|
|
|
Gateio/Okx, Long
|
|
|
|
leverage = 5, open_rate = 10, amount = 1.0
|
|
|
|
(open_rate - (wallet_balance / position)) / (1 - (mm_ratio + taker_fee_rate))
|
|
|
|
(10 - (2 / 1)) / (1 - (0.01 + 0.0006)) = 8.085708510208207
|
|
|
|
leverage = 5, open_rate = 10, amount = 2.0
|
|
|
|
(10 - (4 / 2.0)) / (1 + (0.01 + 0.0006)) = 7.916089451810806
|
|
|
|
leverage = 3, open_rate = 10, amount = 1.0
|
|
|
|
(10 - (3.333333333333333333 / 1.0)) / (1 - (0.01 + 0.0006)) = 6.738090425173506
|
|
|
|
leverage = 5, open_rate = 8, amount = 1.0
|
|
|
|
(8 - (1.6 / 1.0)) / (1 + (0.01 + 0.0006)) = 6.332871561448645
|
|
|
|
"""
|
|
|
|
default_conf_usdt['liquidation_buffer'] = liquidation_buffer
|
|
|
|
default_conf_usdt['trading_mode'] = trading_mode
|
|
|
|
default_conf_usdt['exchange']['name'] = exchange_name
|
|
|
|
default_conf_usdt['margin_mode'] = margin_mode
|
|
|
|
mocker.patch('freqtrade.exchange.Gateio.validate_ordertypes')
|
2022-08-29 19:51:10 +00:00
|
|
|
exchange = get_patched_exchange(mocker, default_conf_usdt, id=exchange_name)
|
2022-02-28 18:27:48 +00:00
|
|
|
|
|
|
|
exchange.get_maintenance_ratio_and_amt = MagicMock(return_value=(0.01, 0.01))
|
|
|
|
exchange.name = exchange_name
|
|
|
|
# default_conf_usdt.update({
|
|
|
|
# "dry_run": False,
|
|
|
|
# })
|
2022-02-28 18:45:15 +00:00
|
|
|
liq = exchange.get_liquidation_price(
|
2022-02-28 18:27:48 +00:00
|
|
|
pair='ETH/USDT:USDT',
|
|
|
|
open_rate=open_rate,
|
|
|
|
amount=amount,
|
2022-08-29 19:51:10 +00:00
|
|
|
stake_amount=amount * open_rate / leverage,
|
|
|
|
wallet_balance=amount * open_rate / leverage,
|
2022-08-29 04:45:00 +00:00
|
|
|
# leverage=leverage,
|
2022-02-28 18:27:48 +00:00
|
|
|
is_short=is_short,
|
|
|
|
)
|
|
|
|
if expected_liq is None:
|
|
|
|
assert liq is None
|
|
|
|
else:
|
|
|
|
buffer_amount = liquidation_buffer * abs(open_rate - expected_liq)
|
|
|
|
expected_liq = expected_liq - buffer_amount if is_short else expected_liq + buffer_amount
|
2022-08-31 08:18:28 +00:00
|
|
|
assert pytest.approx(expected_liq) == liq
|
2022-03-25 13:21:31 +00:00
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize('contract_size,order_amount', [
|
|
|
|
(10, 10),
|
|
|
|
(0.01, 10000),
|
|
|
|
])
|
|
|
|
def test_stoploss_contract_size(mocker, default_conf, contract_size, order_amount):
|
|
|
|
api_mock = MagicMock()
|
|
|
|
order_id = 'test_prod_buy_{}'.format(randint(0, 10 ** 6))
|
|
|
|
|
|
|
|
api_mock.create_order = MagicMock(return_value={
|
|
|
|
'id': order_id,
|
|
|
|
'info': {
|
|
|
|
'foo': 'bar'
|
|
|
|
},
|
|
|
|
'amount': order_amount,
|
|
|
|
'cost': order_amount,
|
|
|
|
'filled': order_amount,
|
|
|
|
'remaining': order_amount,
|
|
|
|
'symbol': 'ETH/BTC',
|
|
|
|
})
|
|
|
|
default_conf['dry_run'] = False
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.amount_to_precision', lambda s, x, y: y)
|
|
|
|
mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
|
|
|
|
|
|
|
|
exchange = get_patched_exchange(mocker, default_conf, api_mock)
|
2022-08-22 18:28:33 +00:00
|
|
|
exchange.get_contract_size = MagicMock(return_value=contract_size)
|
2022-03-25 13:21:31 +00:00
|
|
|
|
|
|
|
api_mock.create_order.reset_mock()
|
|
|
|
order = exchange.stoploss(
|
|
|
|
pair='ETH/BTC',
|
|
|
|
amount=100,
|
|
|
|
stop_price=220,
|
|
|
|
order_types={},
|
|
|
|
side='buy',
|
|
|
|
leverage=1.0
|
|
|
|
)
|
|
|
|
|
|
|
|
assert api_mock.create_order.call_args_list[0][1]['amount'] == order_amount
|
|
|
|
assert order['amount'] == 100
|
|
|
|
assert order['cost'] == 100
|
|
|
|
assert order['filled'] == 100
|
|
|
|
assert order['remaining'] == 100
|