# pragma pylint: disable=missing-docstring,C0103,protected-access import logging import time from copy import deepcopy from datetime import timedelta from unittest.mock import MagicMock, PropertyMock import pandas as pd import pytest import time_machine from freqtrade.constants import AVAILABLE_PAIRLISTS from freqtrade.data.dataprovider import DataProvider from freqtrade.enums import CandleType, RunMode from freqtrade.exceptions import OperationalException from freqtrade.persistence import LocalTrade, Trade from freqtrade.plugins.pairlist.pairlist_helpers import dynamic_expand_pairlist, expand_pairlist from freqtrade.plugins.pairlistmanager import PairListManager from freqtrade.resolvers import PairListResolver from freqtrade.util import dt_now, dt_utc from tests.conftest import ( EXMS, create_mock_trades_usdt, generate_test_data, get_patched_exchange, get_patched_freqtradebot, log_has, log_has_re, num_log_has, ) # Exclude RemotePairList from tests. # It has a mandatory parameter, and requires special handling, which happens in test_remotepairlist. TESTABLE_PAIRLISTS = [p for p in AVAILABLE_PAIRLISTS if p not in ["RemotePairList"]] @pytest.fixture(scope="function") def whitelist_conf(default_conf): default_conf["runmode"] = "dry_run" default_conf["stake_currency"] = "BTC" default_conf["exchange"]["pair_whitelist"] = [ "ETH/BTC", "TKN/BTC", "TRST/BTC", "SWT/BTC", "BCC/BTC", "HOT/BTC", ] default_conf["exchange"]["pair_blacklist"] = ["BLK/BTC"] default_conf["pairlists"] = [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", }, ] default_conf.update( { "external_message_consumer": { "enabled": True, "producers": [], } } ) return default_conf @pytest.fixture(scope="function") def whitelist_conf_2(default_conf): default_conf["runmode"] = "dry_run" default_conf["stake_currency"] = "BTC" default_conf["exchange"]["pair_whitelist"] = [ "ETH/BTC", "TKN/BTC", "BLK/BTC", "LTC/BTC", "BTT/BTC", "HOT/BTC", "FUEL/BTC", "XRP/BTC", ] default_conf["exchange"]["pair_blacklist"] = ["BLK/BTC"] default_conf["pairlists"] = [ # { "method": "StaticPairList"}, { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "refresh_period": 0, }, ] return default_conf @pytest.fixture(scope="function") def whitelist_conf_agefilter(default_conf): default_conf["runmode"] = "dry_run" default_conf["stake_currency"] = "BTC" default_conf["exchange"]["pair_whitelist"] = [ "ETH/BTC", "TKN/BTC", "BLK/BTC", "LTC/BTC", "BTT/BTC", "HOT/BTC", "FUEL/BTC", "XRP/BTC", ] default_conf["exchange"]["pair_blacklist"] = ["BLK/BTC"] default_conf["pairlists"] = [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "refresh_period": -1, }, {"method": "AgeFilter", "min_days_listed": 2, "max_days_listed": 100}, ] return default_conf @pytest.fixture(scope="function") def static_pl_conf(whitelist_conf): whitelist_conf["pairlists"] = [ { "method": "StaticPairList", }, ] return whitelist_conf def test_log_cached(mocker, static_pl_conf, markets, tickers): mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, ) freqtrade = get_patched_freqtradebot(mocker, static_pl_conf) logmock = MagicMock() # Assign starting whitelist pl = freqtrade.pairlists._pairlist_handlers[0] pl.log_once("Hello world", logmock) assert logmock.call_count == 1 pl.log_once("Hello world", logmock) assert logmock.call_count == 1 assert pl._log_cache.currsize == 1 assert ("Hello world",) in pl._log_cache._Cache__data pl.log_once("Hello world2", logmock) assert logmock.call_count == 2 assert pl._log_cache.currsize == 2 def test_load_pairlist_noexist(mocker, markets, default_conf): freqtrade = get_patched_freqtradebot(mocker, default_conf) mocker.patch(f"{EXMS}.markets", PropertyMock(return_value=markets)) plm = PairListManager(freqtrade.exchange, default_conf, MagicMock()) with pytest.raises( OperationalException, match=r"Impossible to load Pairlist 'NonexistingPairList'. " r"This class does not exist or contains Python code errors.", ): PairListResolver.load_pairlist( "NonexistingPairList", freqtrade.exchange, plm, default_conf, {}, 1 ) def test_load_pairlist_verify_multi(mocker, markets_static, default_conf): freqtrade = get_patched_freqtradebot(mocker, default_conf) mocker.patch(f"{EXMS}.markets", PropertyMock(return_value=markets_static)) plm = PairListManager(freqtrade.exchange, default_conf, MagicMock()) # Call different versions one after the other, should always consider what was passed in # and have no side-effects (therefore the same check multiple times) assert plm.verify_whitelist(["ETH/BTC", "XRP/BTC"], print) == ["ETH/BTC", "XRP/BTC"] assert plm.verify_whitelist(["ETH/BTC", "XRP/BTC", "BUUU/BTC"], print) == ["ETH/BTC", "XRP/BTC"] assert plm.verify_whitelist(["XRP/BTC", "BUUU/BTC"], print) == ["XRP/BTC"] assert plm.verify_whitelist(["ETH/BTC", "XRP/BTC"], print) == ["ETH/BTC", "XRP/BTC"] assert plm.verify_whitelist(["ETH/USDT", "XRP/USDT"], print) == ["ETH/USDT"] assert plm.verify_whitelist(["ETH/BTC", "XRP/BTC"], print) == ["ETH/BTC", "XRP/BTC"] def test_refresh_market_pair_not_in_whitelist(mocker, markets, static_pl_conf): freqtrade = get_patched_freqtradebot(mocker, static_pl_conf) mocker.patch(f"{EXMS}.markets", PropertyMock(return_value=markets)) freqtrade.pairlists.refresh_pairlist() # List ordered by BaseVolume whitelist = ["ETH/BTC", "TKN/BTC"] # Ensure all except those in whitelist are removed assert set(whitelist) == set(freqtrade.pairlists.whitelist) # Ensure config dict hasn't been changed assert ( static_pl_conf["exchange"]["pair_whitelist"] == freqtrade.config["exchange"]["pair_whitelist"] ) def test_refresh_static_pairlist(mocker, markets, static_pl_conf): freqtrade = get_patched_freqtradebot(mocker, static_pl_conf) mocker.patch.multiple( EXMS, exchange_has=MagicMock(return_value=True), markets=PropertyMock(return_value=markets), ) freqtrade.pairlists.refresh_pairlist() # List ordered by BaseVolume whitelist = ["ETH/BTC", "TKN/BTC"] # Ensure all except those in whitelist are removed assert set(whitelist) == set(freqtrade.pairlists.whitelist) assert static_pl_conf["exchange"]["pair_blacklist"] == freqtrade.pairlists.blacklist @pytest.mark.parametrize( "pairs,expected", [ ( ["NOEXIST/BTC", r"\+WHAT/BTC"], ["ETH/BTC", "TKN/BTC", "TRST/BTC", "NOEXIST/BTC", "SWT/BTC", "BCC/BTC", "HOT/BTC"], ), ( ["NOEXIST/BTC", r"*/BTC"], # This is an invalid regex [], ), ], ) def test_refresh_static_pairlist_noexist(mocker, markets, static_pl_conf, pairs, expected, caplog): static_pl_conf["pairlists"][0]["allow_inactive"] = True static_pl_conf["exchange"]["pair_whitelist"] += pairs freqtrade = get_patched_freqtradebot(mocker, static_pl_conf) mocker.patch.multiple( EXMS, exchange_has=MagicMock(return_value=True), markets=PropertyMock(return_value=markets), ) freqtrade.pairlists.refresh_pairlist() # Ensure all except those in whitelist are removed assert set(expected) == set(freqtrade.pairlists.whitelist) assert static_pl_conf["exchange"]["pair_blacklist"] == freqtrade.pairlists.blacklist if not expected: assert log_has_re(r"Pair whitelist contains an invalid Wildcard: Wildcard error.*", caplog) def test_invalid_blacklist(mocker, markets, static_pl_conf, caplog): static_pl_conf["exchange"]["pair_blacklist"] = ["*/BTC"] freqtrade = get_patched_freqtradebot(mocker, static_pl_conf) mocker.patch.multiple( EXMS, exchange_has=MagicMock(return_value=True), markets=PropertyMock(return_value=markets), ) freqtrade.pairlists.refresh_pairlist() whitelist = [] # Ensure all except those in whitelist are removed assert set(whitelist) == set(freqtrade.pairlists.whitelist) assert static_pl_conf["exchange"]["pair_blacklist"] == freqtrade.pairlists.blacklist log_has_re(r"Pair blacklist contains an invalid Wildcard.*", caplog) def test_remove_logs_for_pairs_already_in_blacklist(mocker, markets, static_pl_conf, caplog): logger = logging.getLogger(__name__) freqtrade = get_patched_freqtradebot(mocker, static_pl_conf) mocker.patch.multiple( EXMS, exchange_has=MagicMock(return_value=True), markets=PropertyMock(return_value=markets), ) freqtrade.pairlists.refresh_pairlist() whitelist = ["ETH/BTC", "TKN/BTC"] caplog.clear() caplog.set_level(logging.INFO) # Ensure all except those in whitelist are removed. assert set(whitelist) == set(freqtrade.pairlists.whitelist) assert static_pl_conf["exchange"]["pair_blacklist"] == freqtrade.pairlists.blacklist # Ensure that log message wasn't generated. assert not log_has("Pair BLK/BTC in your blacklist. Removing it from whitelist...", caplog) for _ in range(3): new_whitelist = freqtrade.pairlists.verify_blacklist( [*whitelist, "BLK/BTC"], logger.warning ) # Ensure that the pair is removed from the white list, and properly logged. assert set(whitelist) == set(new_whitelist) assert num_log_has("Pair BLK/BTC in your blacklist. Removing it from whitelist...", caplog) == 1 def test_refresh_pairlist_dynamic(mocker, shitcoinmarkets, tickers, whitelist_conf): mocker.patch.multiple( EXMS, get_tickers=tickers, exchange_has=MagicMock(return_value=True), ) freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) # Remock markets with shitcoinmarkets since get_patched_freqtradebot uses the markets fixture mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=shitcoinmarkets), ) # argument: use the whitelist dynamically by exchange-volume whitelist = ["ETH/BTC", "TKN/BTC", "LTC/BTC", "XRP/BTC", "HOT/BTC"] freqtrade.pairlists.refresh_pairlist() assert whitelist == freqtrade.pairlists.whitelist whitelist_conf["pairlists"] = [{"method": "VolumePairList"}] with pytest.raises( OperationalException, match=r"`number_assets` not specified. Please check your configuration " r'for "pairlist.config.number_assets"', ): PairListManager(freqtrade.exchange, whitelist_conf, MagicMock()) def test_refresh_pairlist_dynamic_2(mocker, shitcoinmarkets, tickers, whitelist_conf_2): tickers_dict = tickers() mocker.patch.multiple( EXMS, exchange_has=MagicMock(return_value=True), ) # Remove caching of ticker data to emulate changing volume by the time of second call mocker.patch.multiple( "freqtrade.plugins.pairlistmanager.PairListManager", _get_cached_tickers=MagicMock(return_value=tickers_dict), ) freqtrade = get_patched_freqtradebot(mocker, whitelist_conf_2) # Remock markets with shitcoinmarkets since get_patched_freqtradebot uses the markets fixture mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=shitcoinmarkets), ) whitelist = ["ETH/BTC", "TKN/BTC", "LTC/BTC", "XRP/BTC", "HOT/BTC"] freqtrade.pairlists.refresh_pairlist() assert whitelist == freqtrade.pairlists.whitelist # Delay to allow 0 TTL cache to expire... time.sleep(1) whitelist = ["FUEL/BTC", "ETH/BTC", "TKN/BTC", "LTC/BTC", "XRP/BTC"] tickers_dict["FUEL/BTC"]["quoteVolume"] = 10000.0 freqtrade.pairlists.refresh_pairlist() assert whitelist == freqtrade.pairlists.whitelist def test_VolumePairList_refresh_empty(mocker, markets_empty, whitelist_conf): mocker.patch.multiple( EXMS, exchange_has=MagicMock(return_value=True), ) freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) mocker.patch(f"{EXMS}.markets", PropertyMock(return_value=markets_empty)) # argument: use the whitelist dynamically by exchange-volume whitelist = [] whitelist_conf["exchange"]["pair_whitelist"] = [] freqtrade.pairlists.refresh_pairlist() pairslist = whitelist_conf["exchange"]["pair_whitelist"] assert set(whitelist) == set(pairslist) @pytest.mark.parametrize( "pairlists,base_currency,whitelist_result", [ # VolumePairList only ( [{"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}], "BTC", ["ETH/BTC", "TKN/BTC", "LTC/BTC", "XRP/BTC", "HOT/BTC"], ), ( [{"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}], "USDT", ["ETH/USDT", "NANO/USDT", "ADAHALF/USDT", "ADADOUBLE/USDT"], ), # No pair for ETH, VolumePairList ([{"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}], "ETH", []), # No pair for ETH, StaticPairList ([{"method": "StaticPairList"}], "ETH", []), # No pair for ETH, all handlers ( [ {"method": "StaticPairList"}, {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "AgeFilter", "min_days_listed": 2, "max_days_listed": None}, {"method": "PrecisionFilter"}, {"method": "PriceFilter", "low_price_ratio": 0.03}, {"method": "SpreadFilter", "max_spread_ratio": 0.005}, {"method": "ShuffleFilter"}, {"method": "PerformanceFilter"}, ], "ETH", [], ), # AgeFilter and VolumePairList (require 2 days only, all should pass age test) ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "AgeFilter", "min_days_listed": 2, "max_days_listed": 100}, ], "BTC", ["ETH/BTC", "TKN/BTC", "LTC/BTC", "XRP/BTC", "HOT/BTC"], ), # AgeFilter and VolumePairList (require 10 days, all should fail age test) ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "AgeFilter", "min_days_listed": 10, "max_days_listed": None}, ], "BTC", [], ), # AgeFilter and VolumePairList (all pair listed > 2, all should fail age test) ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "AgeFilter", "min_days_listed": 1, "max_days_listed": 2}, ], "BTC", [], ), # AgeFilter and VolumePairList LTC/BTC has 6 candles - removes all ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "AgeFilter", "min_days_listed": 4, "max_days_listed": 5}, ], "BTC", [], ), # AgeFilter and VolumePairList LTC/BTC has 6 candles - passes ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "AgeFilter", "min_days_listed": 4, "max_days_listed": 10}, ], "BTC", ["LTC/BTC"], ), # Precisionfilter and quote volume ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "PrecisionFilter"}, ], "BTC", ["ETH/BTC", "TKN/BTC", "LTC/BTC", "XRP/BTC"], ), ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "PrecisionFilter"}, ], "USDT", ["ETH/USDT", "NANO/USDT"], ), # PriceFilter and VolumePairList ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "PriceFilter", "low_price_ratio": 0.03}, ], "BTC", ["ETH/BTC", "TKN/BTC", "LTC/BTC", "XRP/BTC"], ), # PriceFilter and VolumePairList ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "PriceFilter", "low_price_ratio": 0.03}, ], "USDT", ["ETH/USDT", "NANO/USDT"], ), # Hot is removed by precision_filter, Fuel by low_price_ratio, Ripple by min_price. ( [ {"method": "VolumePairList", "number_assets": 6, "sort_key": "quoteVolume"}, {"method": "PrecisionFilter"}, {"method": "PriceFilter", "low_price_ratio": 0.02, "min_price": 0.01}, ], "BTC", ["ETH/BTC", "TKN/BTC", "LTC/BTC"], ), # Hot is removed by precision_filter, Fuel by low_price_ratio, Ethereum by max_price. ( [ {"method": "VolumePairList", "number_assets": 6, "sort_key": "quoteVolume"}, {"method": "PrecisionFilter"}, {"method": "PriceFilter", "low_price_ratio": 0.02, "max_price": 0.05}, ], "BTC", ["TKN/BTC", "LTC/BTC", "XRP/BTC"], ), # HOT and XRP are removed because below 1250 quoteVolume ( [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "min_value": 1250, } ], "BTC", ["ETH/BTC", "TKN/BTC", "LTC/BTC"], ), # HOT, XRP and FUEL whitelisted because they are below 1300 quoteVolume. ( [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "max_value": 1300, } ], "BTC", ["XRP/BTC", "HOT/BTC", "FUEL/BTC"], ), # HOT, XRP whitelisted because they are between 100 and 1300 quoteVolume. ( [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "min_value": 100, "max_value": 1300, } ], "BTC", ["XRP/BTC", "HOT/BTC"], ), # StaticPairlist only ([{"method": "StaticPairList"}], "BTC", ["ETH/BTC", "TKN/BTC", "HOT/BTC"]), # Static Pairlist before VolumePairList - sorting changes # SpreadFilter ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "SpreadFilter", "max_spread_ratio": 0.005}, ], "USDT", ["ETH/USDT"], ), # ShuffleFilter ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "ShuffleFilter", "seed": 77}, ], "USDT", ["ADADOUBLE/USDT", "ETH/USDT", "NANO/USDT", "ADAHALF/USDT"], ), # ShuffleFilter, other seed ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "ShuffleFilter", "seed": 42}, ], "USDT", ["ADAHALF/USDT", "NANO/USDT", "ADADOUBLE/USDT", "ETH/USDT"], ), # ShuffleFilter, no seed ( [ {"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume"}, {"method": "ShuffleFilter"}, ], "USDT", 4, ), # whitelist_result is integer -- check only length of randomized pairlist # AgeFilter only ( [{"method": "AgeFilter", "min_days_listed": 2}], "BTC", "filter_at_the_beginning", ), # OperationalException expected # PrecisionFilter after StaticPairList ( [{"method": "StaticPairList"}, {"method": "PrecisionFilter"}], "BTC", ["ETH/BTC", "TKN/BTC"], ), # PrecisionFilter only ( [{"method": "PrecisionFilter"}], "BTC", "filter_at_the_beginning", ), # OperationalException expected # PriceFilter after StaticPairList ( [ {"method": "StaticPairList"}, { "method": "PriceFilter", "low_price_ratio": 0.02, "min_price": 0.000001, "max_price": 0.1, }, ], "BTC", ["ETH/BTC", "TKN/BTC"], ), # PriceFilter only ( [{"method": "PriceFilter", "low_price_ratio": 0.02}], "BTC", "filter_at_the_beginning", ), # OperationalException expected # ShuffleFilter after StaticPairList ( [{"method": "StaticPairList"}, {"method": "ShuffleFilter", "seed": 42}], "BTC", ["TKN/BTC", "ETH/BTC", "HOT/BTC"], ), # ShuffleFilter only ( [{"method": "ShuffleFilter", "seed": 42}], "BTC", "filter_at_the_beginning", ), # OperationalException expected # PerformanceFilter after StaticPairList ( [{"method": "StaticPairList"}, {"method": "PerformanceFilter"}], "BTC", ["ETH/BTC", "TKN/BTC", "HOT/BTC"], ), # PerformanceFilter only ( [{"method": "PerformanceFilter"}], "BTC", "filter_at_the_beginning", ), # OperationalException expected # SpreadFilter after StaticPairList ( [{"method": "StaticPairList"}, {"method": "SpreadFilter", "max_spread_ratio": 0.005}], "BTC", ["ETH/BTC", "TKN/BTC"], ), # SpreadFilter only ( [{"method": "SpreadFilter", "max_spread_ratio": 0.005}], "BTC", "filter_at_the_beginning", ), # OperationalException expected # Static Pairlist after VolumePairList, on a non-first position (appends pairs) ( [ {"method": "VolumePairList", "number_assets": 2, "sort_key": "quoteVolume"}, {"method": "StaticPairList"}, ], "BTC", ["ETH/BTC", "TKN/BTC", "TRST/BTC", "SWT/BTC", "BCC/BTC", "HOT/BTC"], ), ( [ {"method": "VolumePairList", "number_assets": 20, "sort_key": "quoteVolume"}, {"method": "PriceFilter", "low_price_ratio": 0.02}, ], "USDT", ["ETH/USDT", "NANO/USDT"], ), ( [ {"method": "VolumePairList", "number_assets": 20, "sort_key": "quoteVolume"}, {"method": "PriceFilter", "max_value": 0.000001}, ], "USDT", ["NANO/USDT"], ), ( [ {"method": "StaticPairList"}, { "method": "RangeStabilityFilter", "lookback_days": 10, "min_rate_of_change": 0.01, "refresh_period": 1440, }, ], "BTC", ["ETH/BTC", "TKN/BTC", "HOT/BTC"], ), ( [ {"method": "StaticPairList"}, { "method": "RangeStabilityFilter", "lookback_days": 10, "max_rate_of_change": 0.01, "refresh_period": 1440, }, ], "BTC", [], ), # All removed because of max_rate_of_change being 0.017 ( [ {"method": "StaticPairList"}, { "method": "RangeStabilityFilter", "lookback_days": 10, "min_rate_of_change": 0.018, "max_rate_of_change": 0.02, "refresh_period": 1440, }, ], "BTC", [], ), # All removed - limits are above the highest change_rate ( [ {"method": "StaticPairList"}, { "method": "VolatilityFilter", "lookback_days": 3, "min_volatility": 0.002, "max_volatility": 0.004, "refresh_period": 1440, }, ], "BTC", ["ETH/BTC", "TKN/BTC"], ), # VolumePairList with no offset = unchanged pairlist ( [ {"method": "VolumePairList", "number_assets": 20, "sort_key": "quoteVolume"}, {"method": "OffsetFilter", "offset": 0, "number_assets": 0}, ], "USDT", ["ETH/USDT", "NANO/USDT", "ADAHALF/USDT", "ADADOUBLE/USDT"], ), # VolumePairList with offset = 2 ( [ {"method": "VolumePairList", "number_assets": 20, "sort_key": "quoteVolume"}, {"method": "OffsetFilter", "offset": 2}, ], "USDT", ["ADAHALF/USDT", "ADADOUBLE/USDT"], ), # VolumePairList with offset and limit ( [ {"method": "VolumePairList", "number_assets": 20, "sort_key": "quoteVolume"}, {"method": "OffsetFilter", "offset": 1, "number_assets": 2}, ], "USDT", ["NANO/USDT", "ADAHALF/USDT"], ), # VolumePairList with higher offset, than total pairlist ( [ {"method": "VolumePairList", "number_assets": 20, "sort_key": "quoteVolume"}, {"method": "OffsetFilter", "offset": 100}, ], "USDT", [], ), ], ) def test_VolumePairList_whitelist_gen( mocker, whitelist_conf, shitcoinmarkets, tickers, ohlcv_history, pairlists, base_currency, whitelist_result, caplog, ) -> None: whitelist_conf["runmode"] = "util_exchange" whitelist_conf["pairlists"] = pairlists whitelist_conf["stake_currency"] = base_currency ohlcv_history_high_vola = ohlcv_history.copy() ohlcv_history_high_vola.loc[ohlcv_history_high_vola.index == 1, "close"] = 0.00090 ohlcv_data = { ("ETH/BTC", "1d", CandleType.SPOT): ohlcv_history, ("TKN/BTC", "1d", CandleType.SPOT): ohlcv_history, ("LTC/BTC", "1d", CandleType.SPOT): pd.concat([ohlcv_history, ohlcv_history]), ("XRP/BTC", "1d", CandleType.SPOT): ohlcv_history, ("HOT/BTC", "1d", CandleType.SPOT): ohlcv_history_high_vola, } mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) mocker.patch.multiple( EXMS, get_tickers=tickers, markets=PropertyMock(return_value=shitcoinmarkets) ) mocker.patch.multiple( EXMS, refresh_latest_ohlcv=MagicMock(return_value=ohlcv_data), ) # Provide for PerformanceFilter's dependency mocker.patch.multiple( "freqtrade.persistence.Trade", get_overall_performance=MagicMock(return_value=[]) ) # Set whitelist_result to None if pairlist is invalid and should produce exception if whitelist_result == "filter_at_the_beginning": with pytest.raises( OperationalException, match=r"This Pairlist Handler should not be used at the first position " r"in the list of Pairlist Handlers.", ): freqtrade.pairlists.refresh_pairlist() else: freqtrade.pairlists.refresh_pairlist() whitelist = freqtrade.pairlists.whitelist assert isinstance(whitelist, list) # Verify length of pairlist matches (used for ShuffleFilter without seed) if isinstance(whitelist_result, list): assert whitelist == whitelist_result else: assert len(whitelist) == whitelist_result for pairlist in pairlists: if ( pairlist["method"] == "AgeFilter" and pairlist["min_days_listed"] and len(ohlcv_history) < pairlist["min_days_listed"] ): assert log_has_re( r"^Removed .* from whitelist, because age .* is less than " r".* day.*", caplog ) if ( pairlist["method"] == "AgeFilter" and pairlist["max_days_listed"] and len(ohlcv_history) > pairlist["max_days_listed"] ): assert log_has_re( r"^Removed .* from whitelist, because age .* is less than " r".* day.* or more than .* day", caplog, ) if pairlist["method"] == "PrecisionFilter" and whitelist_result: assert log_has_re( r"^Removed .* from whitelist, because stop price .* " r"would be <= stop limit.*", caplog, ) if pairlist["method"] == "PriceFilter" and whitelist_result: assert ( log_has_re(r"^Removed .* from whitelist, because 1 unit is .*%$", caplog) or log_has_re( r"^Removed .* from whitelist, " r"because last price < .*%$", caplog ) or log_has_re( r"^Removed .* from whitelist, " r"because last price > .*%$", caplog ) or log_has_re( r"^Removed .* from whitelist, " r"because min value change of .*", caplog ) or log_has_re( r"^Removed .* from whitelist, because ticker\['last'\] " r"is empty.*", caplog, ) ) if pairlist["method"] == "VolumePairList": logmsg = ( "DEPRECATED: using any key other than quoteVolume for " "VolumePairList is deprecated." ) if pairlist["sort_key"] != "quoteVolume": assert log_has(logmsg, caplog) else: assert not log_has(logmsg, caplog) if pairlist["method"] == "VolatilityFilter": assert log_has_re(r"^Removed .* from whitelist, because volatility.*$", caplog) @pytest.mark.parametrize( "pairlists,base_currency,exchange,volumefilter_result", [ # default refresh of 1800 to small for daily candle lookback ( [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "lookback_days": 1, } ], "BTC", "binance", "default_refresh_too_short", ), # OperationalException expected # ambiguous configuration with lookback days and period ( [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "lookback_days": 1, "lookback_period": 1, } ], "BTC", "binance", "lookback_days_and_period", ), # OperationalException expected # negative lookback period ( [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "lookback_timeframe": "1d", "lookback_period": -1, } ], "BTC", "binance", "lookback_period_negative", ), # OperationalException expected # lookback range exceedes exchange limit ( [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "lookback_timeframe": "1m", "lookback_period": 2000, "refresh_period": 3600, } ], "BTC", "binance", "lookback_exceeds_exchange_request_size", ), # OperationalException expected # expecting pairs as given ( [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "lookback_timeframe": "1d", "lookback_period": 1, "refresh_period": 86400, } ], "BTC", "binance", ["LTC/BTC", "ETH/BTC", "TKN/BTC", "XRP/BTC", "HOT/BTC"], ), # expecting pairs as input, because 1h candles are not available ( [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "lookback_timeframe": "1h", "lookback_period": 2, "refresh_period": 3600, } ], "BTC", "binance", ["ETH/BTC", "LTC/BTC", "NEO/BTC", "TKN/BTC", "XRP/BTC"], ), # TKN/BTC is removed because it doesn't have enough candles ( [ { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "lookback_timeframe": "1d", "lookback_period": 6, "refresh_period": 86400, } ], "BTC", "binance", ["LTC/BTC", "XRP/BTC", "ETH/BTC", "HOT/BTC", "NEO/BTC"], ), # VolumePairlist in range mode as filter. # TKN/BTC is removed because it doesn't have enough candles ( [ {"method": "VolumePairList", "number_assets": 5}, { "method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", "lookback_timeframe": "1d", "lookback_period": 2, "refresh_period": 86400, }, ], "BTC", "binance", ["LTC/BTC", "XRP/BTC", "ETH/BTC", "TKN/BTC", "HOT/BTC"], ), # ftx data is already in Quote currency, therefore won't require conversion # ([{"method": "VolumePairList", "number_assets": 5, "sort_key": "quoteVolume", # "lookback_timeframe": "1d", "lookback_period": 1, "refresh_period": 86400}], # "BTC", "ftx", ['HOT/BTC', 'LTC/BTC', 'ETH/BTC', 'TKN/BTC', 'XRP/BTC']), ], ) def test_VolumePairList_range( mocker, whitelist_conf, shitcoinmarkets, tickers, ohlcv_history, pairlists, base_currency, exchange, volumefilter_result, time_machine, ) -> None: whitelist_conf["pairlists"] = pairlists whitelist_conf["stake_currency"] = base_currency whitelist_conf["exchange"]["name"] = exchange # Ensure we have 6 candles ohlcv_history_long = pd.concat([ohlcv_history, ohlcv_history]) ohlcv_history_high_vola = ohlcv_history_long.copy() ohlcv_history_high_vola.loc[ohlcv_history_high_vola.index == 1, "close"] = 0.00090 # create candles for medium overall volume with last candle high volume ohlcv_history_medium_volume = ohlcv_history_long.copy() ohlcv_history_medium_volume.loc[ohlcv_history_medium_volume.index == 2, "volume"] = 5 # create candles for high volume with all candles high volume, but very low price. ohlcv_history_high_volume = ohlcv_history_long.copy() ohlcv_history_high_volume["volume"] = 10 ohlcv_history_high_volume["low"] = ohlcv_history_high_volume.loc[:, "low"] * 0.01 ohlcv_history_high_volume["high"] = ohlcv_history_high_volume.loc[:, "high"] * 0.01 ohlcv_history_high_volume["close"] = ohlcv_history_high_volume.loc[:, "close"] * 0.01 ohlcv_data = { ("ETH/BTC", "1d", CandleType.SPOT): ohlcv_history_long, ("TKN/BTC", "1d", CandleType.SPOT): ohlcv_history, ("LTC/BTC", "1d", CandleType.SPOT): ohlcv_history_medium_volume, ("XRP/BTC", "1d", CandleType.SPOT): ohlcv_history_high_vola, ("HOT/BTC", "1d", CandleType.SPOT): ohlcv_history_high_volume, } mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) if volumefilter_result == "default_refresh_too_short": with pytest.raises( OperationalException, match=r"Refresh period of [0-9]+ seconds is smaller than one timeframe " r"of [0-9]+.*\. Please adjust refresh_period to at least [0-9]+ " r"and restart the bot\.", ): freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) return elif volumefilter_result == "lookback_days_and_period": with pytest.raises( OperationalException, match=r"Ambiguous configuration: lookback_days and lookback_period both " r"set in pairlist config\..*", ): freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) elif volumefilter_result == "lookback_period_negative": with pytest.raises( OperationalException, match=r"VolumeFilter requires lookback_period to be >= 0" ): freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) elif volumefilter_result == "lookback_exceeds_exchange_request_size": with pytest.raises( OperationalException, match=r"VolumeFilter requires lookback_period to not exceed " r"exchange max request size \([0-9]+\)", ): freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) else: freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) mocker.patch.multiple( EXMS, get_tickers=tickers, markets=PropertyMock(return_value=shitcoinmarkets) ) start_dt = dt_now() time_machine.move_to(start_dt) # remove ohlcv when looback_timeframe != 1d # to enforce fallback to ticker data if "lookback_timeframe" in pairlists[0]: if pairlists[0]["lookback_timeframe"] != "1d": ohlcv_data = {} ohclv_mock = mocker.patch(f"{EXMS}.refresh_latest_ohlcv", return_value=ohlcv_data) freqtrade.pairlists.refresh_pairlist() whitelist = freqtrade.pairlists.whitelist assert ohclv_mock.call_count == 1 assert isinstance(whitelist, list) assert whitelist == volumefilter_result # Test caching ohclv_mock.reset_mock() freqtrade.pairlists.refresh_pairlist() # in "filter" mode, caching is disabled. assert ohclv_mock.call_count == 0 whitelist = freqtrade.pairlists.whitelist assert whitelist == volumefilter_result time_machine.move_to(start_dt + timedelta(days=2)) ohclv_mock.reset_mock() freqtrade.pairlists.refresh_pairlist() assert ohclv_mock.call_count == 1 whitelist = freqtrade.pairlists.whitelist assert whitelist == volumefilter_result def test_PrecisionFilter_error(mocker, whitelist_conf) -> None: whitelist_conf["pairlists"] = [{"method": "StaticPairList"}, {"method": "PrecisionFilter"}] del whitelist_conf["stoploss"] mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) with pytest.raises( OperationalException, match=r"PrecisionFilter can only work with stoploss defined\..*" ): PairListManager(MagicMock, whitelist_conf, MagicMock()) def test_PerformanceFilter_error(mocker, whitelist_conf, caplog) -> None: whitelist_conf["pairlists"] = [{"method": "StaticPairList"}, {"method": "PerformanceFilter"}] if hasattr(Trade, "session"): del Trade.session mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) exchange = get_patched_exchange(mocker, whitelist_conf) pm = PairListManager(exchange, whitelist_conf, MagicMock()) pm.refresh_pairlist() assert log_has("PerformanceFilter is not available in this mode.", caplog) def test_VolatilityFilter_error(mocker, whitelist_conf) -> None: volatility_filter = {"method": "VolatilityFilter", "lookback_days": -1} whitelist_conf["pairlists"] = [{"method": "StaticPairList"}, volatility_filter] mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) exchange_mock = MagicMock() exchange_mock.ohlcv_candle_limit = MagicMock(return_value=1000) with pytest.raises( OperationalException, match=r"VolatilityFilter requires lookback_days to be >= 1*" ): PairListManager(exchange_mock, whitelist_conf, MagicMock()) volatility_filter = {"method": "VolatilityFilter", "lookback_days": 2000} whitelist_conf["pairlists"] = [{"method": "StaticPairList"}, volatility_filter] with pytest.raises( OperationalException, match=r"VolatilityFilter requires lookback_days to not exceed exchange max", ): PairListManager(exchange_mock, whitelist_conf, MagicMock()) volatility_filter = {"method": "VolatilityFilter", "sort_direction": "Random"} whitelist_conf["pairlists"] = [{"method": "StaticPairList"}, volatility_filter] with pytest.raises( OperationalException, match=r"VolatilityFilter requires sort_direction to be either " r"None .*'asc'.*'desc'", ): PairListManager(exchange_mock, whitelist_conf, MagicMock()) @pytest.mark.parametrize( "pairlist,expected_pairlist", [ ( {"method": "VolatilityFilter", "sort_direction": "asc"}, ["XRP/BTC", "ETH/BTC", "LTC/BTC", "TKN/BTC"], ), ( {"method": "VolatilityFilter", "sort_direction": "desc"}, ["TKN/BTC", "LTC/BTC", "ETH/BTC", "XRP/BTC"], ), ( {"method": "VolatilityFilter", "sort_direction": "desc", "min_volatility": 0.4}, ["TKN/BTC", "LTC/BTC", "ETH/BTC"], ), ( {"method": "VolatilityFilter", "sort_direction": "asc", "min_volatility": 0.4}, ["ETH/BTC", "LTC/BTC", "TKN/BTC"], ), ( {"method": "VolatilityFilter", "sort_direction": "desc", "max_volatility": 0.5}, ["LTC/BTC", "ETH/BTC", "XRP/BTC"], ), ( {"method": "VolatilityFilter", "sort_direction": "asc", "max_volatility": 0.5}, ["XRP/BTC", "ETH/BTC", "LTC/BTC"], ), ( {"method": "RangeStabilityFilter", "sort_direction": "asc"}, ["ETH/BTC", "XRP/BTC", "LTC/BTC", "TKN/BTC"], ), ( {"method": "RangeStabilityFilter", "sort_direction": "desc"}, ["TKN/BTC", "LTC/BTC", "XRP/BTC", "ETH/BTC"], ), ( {"method": "RangeStabilityFilter", "sort_direction": "asc", "min_rate_of_change": 0.4}, ["XRP/BTC", "LTC/BTC", "TKN/BTC"], ), ( {"method": "RangeStabilityFilter", "sort_direction": "desc", "min_rate_of_change": 0.4}, ["TKN/BTC", "LTC/BTC", "XRP/BTC"], ), ], ) def test_VolatilityFilter_RangeStabilityFilter_sort( mocker, whitelist_conf, tickers, time_machine, pairlist, expected_pairlist ) -> None: whitelist_conf["pairlists"] = [{"method": "VolumePairList", "number_assets": 10}, pairlist] df1 = generate_test_data("1d", 10, "2022-01-05 00:00:00+00:00", random_seed=42) df2 = generate_test_data("1d", 10, "2022-01-05 00:00:00+00:00", random_seed=2) df3 = generate_test_data("1d", 10, "2022-01-05 00:00:00+00:00", random_seed=3) df4 = generate_test_data("1d", 10, "2022-01-05 00:00:00+00:00", random_seed=4) df5 = generate_test_data("1d", 10, "2022-01-05 00:00:00+00:00", random_seed=5) df6 = generate_test_data("1d", 10, "2022-01-05 00:00:00+00:00", random_seed=6) assert not df1.equals(df2) time_machine.move_to("2022-01-15 00:00:00+00:00") ohlcv_data = { ("ETH/BTC", "1d", CandleType.SPOT): df1, ("TKN/BTC", "1d", CandleType.SPOT): df2, ("LTC/BTC", "1d", CandleType.SPOT): df3, ("XRP/BTC", "1d", CandleType.SPOT): df4, ("HOT/BTC", "1d", CandleType.SPOT): df5, ("BLK/BTC", "1d", CandleType.SPOT): df6, } ohlcv_mock = MagicMock(return_value=ohlcv_data) mocker.patch.multiple( EXMS, exchange_has=MagicMock(return_value=True), refresh_latest_ohlcv=ohlcv_mock, get_tickers=tickers, ) exchange = get_patched_exchange(mocker, whitelist_conf) exchange.ohlcv_candle_limit = MagicMock(return_value=1000) plm = PairListManager(exchange, whitelist_conf, MagicMock()) assert exchange.ohlcv_candle_limit.call_count == 2 plm.refresh_pairlist() assert ohlcv_mock.call_count == 1 assert exchange.ohlcv_candle_limit.call_count == 2 assert plm.whitelist == expected_pairlist plm.refresh_pairlist() assert exchange.ohlcv_candle_limit.call_count == 2 assert ohlcv_mock.call_count == 1 def test_ShuffleFilter_init(mocker, whitelist_conf, caplog) -> None: whitelist_conf["pairlists"] = [ {"method": "StaticPairList"}, {"method": "ShuffleFilter", "seed": 43}, ] whitelist_conf["runmode"] = RunMode.BACKTEST exchange = get_patched_exchange(mocker, whitelist_conf) plm = PairListManager(exchange, whitelist_conf) assert log_has("Backtesting mode detected, applying seed value: 43", caplog) plm.refresh_pairlist() pl1 = deepcopy(plm.whitelist) plm.refresh_pairlist() assert plm.whitelist != pl1 assert set(plm.whitelist) == set(pl1) caplog.clear() whitelist_conf["runmode"] = RunMode.DRY_RUN plm = PairListManager(exchange, whitelist_conf) assert not log_has("Backtesting mode detected, applying seed value: 42", caplog) assert log_has("Live mode detected, not applying seed.", caplog) with time_machine.travel("2021-09-01 05:01:00 +00:00") as t: plm.refresh_pairlist() pl1 = deepcopy(plm.whitelist) plm.refresh_pairlist() assert plm.whitelist == pl1 target = plm._pairlist_handlers[1]._random shuffle_mock = mocker.patch.object(target, "shuffle", wraps=target.shuffle) t.shift(timedelta(minutes=10)) plm.refresh_pairlist() assert shuffle_mock.call_count == 1 assert set(plm.whitelist) == set(pl1) @pytest.mark.usefixtures("init_persistence") def test_PerformanceFilter_lookback(mocker, default_conf_usdt, fee, caplog) -> None: default_conf_usdt["exchange"]["pair_whitelist"].extend(["ADA/USDT", "XRP/USDT", "ETC/USDT"]) default_conf_usdt["pairlists"] = [ {"method": "StaticPairList"}, {"method": "PerformanceFilter", "minutes": 60, "min_profit": 0.01}, ] mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) exchange = get_patched_exchange(mocker, default_conf_usdt) pm = PairListManager(exchange, default_conf_usdt) pm.refresh_pairlist() assert pm.whitelist == ["ETH/USDT", "XRP/USDT", "NEO/USDT", "TKN/USDT"] with time_machine.travel("2021-09-01 05:00:00 +00:00") as t: create_mock_trades_usdt(fee) pm.refresh_pairlist() assert pm.whitelist == ["XRP/USDT", "NEO/USDT"] assert log_has_re(r"Removing pair .* since .* is below .*", caplog) # Move to "outside" of lookback window, so original sorting is restored. t.move_to("2021-09-01 07:00:00 +00:00") pm.refresh_pairlist() assert pm.whitelist == ["ETH/USDT", "XRP/USDT", "NEO/USDT", "TKN/USDT"] @pytest.mark.usefixtures("init_persistence") def test_PerformanceFilter_keep_mid_order(mocker, default_conf_usdt, fee, caplog) -> None: default_conf_usdt["exchange"]["pair_whitelist"].extend(["ADA/USDT", "ETC/USDT"]) default_conf_usdt["pairlists"] = [ {"method": "StaticPairList", "allow_inactive": True}, { "method": "PerformanceFilter", "minutes": 60, }, ] mocker.patch(f"{EXMS}.exchange_has", return_value=True) exchange = get_patched_exchange(mocker, default_conf_usdt) pm = PairListManager(exchange, default_conf_usdt) pm.refresh_pairlist() assert pm.whitelist == [ "ETH/USDT", "LTC/USDT", "XRP/USDT", "NEO/USDT", "TKN/USDT", "ADA/USDT", "ETC/USDT", ] with time_machine.travel("2021-09-01 05:00:00 +00:00") as t: create_mock_trades_usdt(fee) pm.refresh_pairlist() assert pm.whitelist == [ "XRP/USDT", "NEO/USDT", "ETH/USDT", "LTC/USDT", "TKN/USDT", "ADA/USDT", "ETC/USDT", ] # assert log_has_re(r'Removing pair .* since .* is below .*', caplog) # Move to "outside" of lookback window, so original sorting is restored. t.move_to("2021-09-01 07:00:00 +00:00") pm.refresh_pairlist() assert pm.whitelist == [ "ETH/USDT", "LTC/USDT", "XRP/USDT", "NEO/USDT", "TKN/USDT", "ADA/USDT", "ETC/USDT", ] def test_gen_pair_whitelist_not_supported(mocker, default_conf, tickers) -> None: default_conf["pairlists"] = [{"method": "VolumePairList", "number_assets": 10}] mocker.patch.multiple( EXMS, get_tickers=tickers, exchange_has=MagicMock(return_value=False), ) with pytest.raises( OperationalException, match=r"Exchange .* does not support dynamic whitelist.*" ): get_patched_freqtradebot(mocker, default_conf) def test_pair_whitelist_not_supported_Spread(mocker, default_conf, tickers) -> None: default_conf["pairlists"] = [{"method": "StaticPairList"}, {"method": "SpreadFilter"}] mocker.patch.multiple( EXMS, get_tickers=tickers, exchange_has=MagicMock(return_value=False), ) with pytest.raises( OperationalException, match=r"Exchange .* does not support fetchTickers, .*" ): get_patched_freqtradebot(mocker, default_conf) mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) mocker.patch(f"{EXMS}.get_option", MagicMock(return_value=False)) with pytest.raises(OperationalException, match=r".*requires exchange to have bid/ask data"): get_patched_freqtradebot(mocker, default_conf) @pytest.mark.parametrize("pairlist", TESTABLE_PAIRLISTS) def test_pairlist_class(mocker, whitelist_conf, markets, pairlist): whitelist_conf["pairlists"][0]["method"] = pairlist mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True) ) freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) assert freqtrade.pairlists.name_list == [pairlist] assert pairlist in str(freqtrade.pairlists.short_desc()) assert isinstance(freqtrade.pairlists.whitelist, list) assert isinstance(freqtrade.pairlists.blacklist, list) @pytest.mark.parametrize("pairlist", TESTABLE_PAIRLISTS) @pytest.mark.parametrize( "whitelist,log_message", [ (["ETH/BTC", "TKN/BTC"], ""), # TRX/ETH not in markets (["ETH/BTC", "TKN/BTC", "TRX/ETH"], "is not compatible with exchange"), # wrong stake (["ETH/BTC", "TKN/BTC", "ETH/USDT"], "is not compatible with your stake currency"), # BCH/BTC not available (["ETH/BTC", "TKN/BTC", "BCH/BTC"], "is not compatible with exchange"), # BTT/BTC is inactive (["ETH/BTC", "TKN/BTC", "BTT/BTC"], "Market is not active"), # XLTCUSDT is not a valid pair (["ETH/BTC", "TKN/BTC", "XLTCUSDT"], "is not tradable with Freqtrade"), ], ) def test__whitelist_for_active_markets( mocker, whitelist_conf, markets, pairlist, whitelist, caplog, log_message, tickers ): whitelist_conf["pairlists"][0]["method"] = pairlist mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, ) freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) caplog.clear() # Assign starting whitelist pairlist_handler = freqtrade.pairlists._pairlist_handlers[0] new_whitelist = pairlist_handler._whitelist_for_active_markets(whitelist) assert set(new_whitelist) == set(["ETH/BTC", "TKN/BTC"]) assert log_message in caplog.text @pytest.mark.parametrize("pairlist", TESTABLE_PAIRLISTS) def test__whitelist_for_active_markets_empty(mocker, whitelist_conf, pairlist, tickers): whitelist_conf["pairlists"][0]["method"] = pairlist mocker.patch(f"{EXMS}.exchange_has", return_value=True) freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) mocker.patch.multiple(EXMS, markets=PropertyMock(return_value=None), get_tickers=tickers) # Assign starting whitelist pairlist_handler = freqtrade.pairlists._pairlist_handlers[0] with pytest.raises(OperationalException, match=r"Markets not loaded.*"): pairlist_handler._whitelist_for_active_markets(["ETH/BTC"]) def test_volumepairlist_invalid_sortvalue(mocker, whitelist_conf): whitelist_conf["pairlists"][0].update({"sort_key": "asdf"}) mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) with pytest.raises(OperationalException, match=r"key asdf not in .*"): get_patched_freqtradebot(mocker, whitelist_conf) def test_volumepairlist_caching(mocker, markets, whitelist_conf, tickers): mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, ) freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) assert len(freqtrade.pairlists._pairlist_handlers[0]._pair_cache) == 0 assert tickers.call_count == 0 freqtrade.pairlists.refresh_pairlist() assert tickers.call_count == 1 assert len(freqtrade.pairlists._pairlist_handlers[0]._pair_cache) == 1 freqtrade.pairlists.refresh_pairlist() assert tickers.call_count == 1 def test_agefilter_min_days_listed_too_small(mocker, default_conf, markets, tickers): default_conf["pairlists"] = [ {"method": "VolumePairList", "number_assets": 10}, {"method": "AgeFilter", "min_days_listed": -1}, ] mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, ) with pytest.raises( OperationalException, match=r"AgeFilter requires min_days_listed to be >= 1" ): get_patched_freqtradebot(mocker, default_conf) def test_agefilter_max_days_lower_than_min_days(mocker, default_conf, markets, tickers): default_conf["pairlists"] = [ {"method": "VolumePairList", "number_assets": 10}, {"method": "AgeFilter", "min_days_listed": 3, "max_days_listed": 2}, ] mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, ) with pytest.raises( OperationalException, match=r"AgeFilter max_days_listed <= min_days_listed not permitted" ): get_patched_freqtradebot(mocker, default_conf) def test_agefilter_min_days_listed_too_large(mocker, default_conf, markets, tickers): default_conf["pairlists"] = [ {"method": "VolumePairList", "number_assets": 10}, {"method": "AgeFilter", "min_days_listed": 99999}, ] mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, ) with pytest.raises( OperationalException, match=r"AgeFilter requires min_days_listed to not exceed " r"exchange max request size \([0-9]+\)", ): get_patched_freqtradebot(mocker, default_conf) def test_agefilter_caching(mocker, markets, whitelist_conf_agefilter, tickers, ohlcv_history): with time_machine.travel("2021-09-01 05:00:00 +00:00") as t: ohlcv_data = { ("ETH/BTC", "1d", CandleType.SPOT): ohlcv_history, ("TKN/BTC", "1d", CandleType.SPOT): ohlcv_history, ("LTC/BTC", "1d", CandleType.SPOT): ohlcv_history, } mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, refresh_latest_ohlcv=MagicMock(return_value=ohlcv_data), ) freqtrade = get_patched_freqtradebot(mocker, whitelist_conf_agefilter) assert freqtrade.exchange.refresh_latest_ohlcv.call_count == 0 freqtrade.pairlists.refresh_pairlist() assert len(freqtrade.pairlists.whitelist) == 3 assert freqtrade.exchange.refresh_latest_ohlcv.call_count > 0 freqtrade.pairlists.refresh_pairlist() assert len(freqtrade.pairlists.whitelist) == 3 # Call to XRP/BTC cached assert freqtrade.exchange.refresh_latest_ohlcv.call_count == 2 ohlcv_data = { ("ETH/BTC", "1d", CandleType.SPOT): ohlcv_history, ("TKN/BTC", "1d", CandleType.SPOT): ohlcv_history, ("LTC/BTC", "1d", CandleType.SPOT): ohlcv_history, ("XRP/BTC", "1d", CandleType.SPOT): ohlcv_history.iloc[[0]], } mocker.patch(f"{EXMS}.refresh_latest_ohlcv", return_value=ohlcv_data) freqtrade.pairlists.refresh_pairlist() assert len(freqtrade.pairlists.whitelist) == 3 assert freqtrade.exchange.refresh_latest_ohlcv.call_count == 1 # Move to next day t.move_to("2021-09-02 01:00:00 +00:00") mocker.patch(f"{EXMS}.refresh_latest_ohlcv", return_value=ohlcv_data) freqtrade.pairlists.refresh_pairlist() assert len(freqtrade.pairlists.whitelist) == 3 assert freqtrade.exchange.refresh_latest_ohlcv.call_count == 1 # Move another day with fresh mocks (now the pair is old enough) t.move_to("2021-09-03 01:00:00 +00:00") # Called once for XRP/BTC ohlcv_data = { ("ETH/BTC", "1d", CandleType.SPOT): ohlcv_history, ("TKN/BTC", "1d", CandleType.SPOT): ohlcv_history, ("LTC/BTC", "1d", CandleType.SPOT): ohlcv_history, ("XRP/BTC", "1d", CandleType.SPOT): ohlcv_history, } mocker.patch(f"{EXMS}.refresh_latest_ohlcv", return_value=ohlcv_data) freqtrade.pairlists.refresh_pairlist() assert len(freqtrade.pairlists.whitelist) == 4 # Called once (only for XRP/BTC) assert freqtrade.exchange.refresh_latest_ohlcv.call_count == 1 def test_OffsetFilter_error(mocker, whitelist_conf) -> None: whitelist_conf["pairlists"] = [ {"method": "StaticPairList"}, {"method": "OffsetFilter", "offset": -1}, ] mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) with pytest.raises(OperationalException, match=r"OffsetFilter requires offset to be >= 0"): PairListManager(MagicMock, whitelist_conf) def test_rangestabilityfilter_checks(mocker, default_conf, markets, tickers): default_conf["pairlists"] = [ {"method": "VolumePairList", "number_assets": 10}, {"method": "RangeStabilityFilter", "lookback_days": 99999}, ] mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, ) with pytest.raises( OperationalException, match=r"RangeStabilityFilter requires lookback_days to not exceed " r"exchange max request size \([0-9]+\)", ): get_patched_freqtradebot(mocker, default_conf) default_conf["pairlists"] = [ {"method": "VolumePairList", "number_assets": 10}, {"method": "RangeStabilityFilter", "lookback_days": 0}, ] with pytest.raises( OperationalException, match="RangeStabilityFilter requires lookback_days to be >= 1" ): get_patched_freqtradebot(mocker, default_conf) default_conf["pairlists"] = [ {"method": "VolumePairList", "number_assets": 10}, {"method": "RangeStabilityFilter", "sort_direction": "something"}, ] with pytest.raises( OperationalException, match=r"RangeStabilityFilter requires sort_direction to be either None\.*", ): get_patched_freqtradebot(mocker, default_conf) @pytest.mark.parametrize( "min_rate_of_change,max_rate_of_change,expected_length", [ (0.01, 0.99, 5), (0.05, 0.0, 0), # Setting min rate_of_change to 5% removes all pairs from the whitelist. ], ) def test_rangestabilityfilter_caching( mocker, markets, default_conf, tickers, ohlcv_history, min_rate_of_change, max_rate_of_change, expected_length, ): default_conf["pairlists"] = [ {"method": "VolumePairList", "number_assets": 10}, { "method": "RangeStabilityFilter", "lookback_days": 2, "min_rate_of_change": min_rate_of_change, "max_rate_of_change": max_rate_of_change, }, ] mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, ) ohlcv_data = { ("ETH/BTC", "1d", CandleType.SPOT): ohlcv_history, ("TKN/BTC", "1d", CandleType.SPOT): ohlcv_history, ("LTC/BTC", "1d", CandleType.SPOT): ohlcv_history, ("XRP/BTC", "1d", CandleType.SPOT): ohlcv_history, ("HOT/BTC", "1d", CandleType.SPOT): ohlcv_history, ("BLK/BTC", "1d", CandleType.SPOT): ohlcv_history, } mocker.patch.multiple( EXMS, refresh_latest_ohlcv=MagicMock(return_value=ohlcv_data), ) freqtrade = get_patched_freqtradebot(mocker, default_conf) assert freqtrade.exchange.refresh_latest_ohlcv.call_count == 0 freqtrade.pairlists.refresh_pairlist() assert len(freqtrade.pairlists.whitelist) == expected_length assert freqtrade.exchange.refresh_latest_ohlcv.call_count > 0 previous_call_count = freqtrade.exchange.refresh_latest_ohlcv.call_count freqtrade.pairlists.refresh_pairlist() assert len(freqtrade.pairlists.whitelist) == expected_length # Should not have increased since first call. assert freqtrade.exchange.refresh_latest_ohlcv.call_count == previous_call_count def test_spreadfilter_invalid_data(mocker, default_conf, markets, tickers, caplog): default_conf["pairlists"] = [ {"method": "VolumePairList", "number_assets": 10}, {"method": "SpreadFilter", "max_spread_ratio": 0.1}, ] mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, ) ftbot = get_patched_freqtradebot(mocker, default_conf) ftbot.pairlists.refresh_pairlist() assert len(ftbot.pairlists.whitelist) == 5 tickers.return_value["ETH/BTC"]["ask"] = 0.0 del tickers.return_value["TKN/BTC"] del tickers.return_value["LTC/BTC"] mocker.patch.multiple(EXMS, get_tickers=tickers) ftbot.pairlists.refresh_pairlist() assert log_has_re(r"Removed .* invalid ticker data.*", caplog) assert len(ftbot.pairlists.whitelist) == 2 @pytest.mark.parametrize( "pairlistconfig,desc_expected,exception_expected", [ ( { "method": "PriceFilter", "low_price_ratio": 0.001, "min_price": 0.00000010, "max_price": 1.0, }, "[{'PriceFilter': 'PriceFilter - Filtering pairs priced below " "0.1% or below 0.00000010 or above 1.00000000.'}]", None, ), ( {"method": "PriceFilter", "low_price_ratio": 0.001, "min_price": 0.00000010}, "[{'PriceFilter': 'PriceFilter - Filtering pairs priced below 0.1% " "or below 0.00000010.'}]", None, ), ( {"method": "PriceFilter", "low_price_ratio": 0.001, "max_price": 1.00010000}, "[{'PriceFilter': 'PriceFilter - Filtering pairs priced below 0.1% " "or above 1.00010000.'}]", None, ), ( {"method": "PriceFilter", "min_price": 0.00002000}, "[{'PriceFilter': 'PriceFilter - Filtering pairs priced below 0.00002000.'}]", None, ), ( {"method": "PriceFilter", "max_value": 0.00002000}, "[{'PriceFilter': 'PriceFilter - Filtering pairs priced Value above 0.00002000.'}]", None, ), ( {"method": "PriceFilter"}, "[{'PriceFilter': 'PriceFilter - No price filters configured.'}]", None, ), ( {"method": "PriceFilter", "low_price_ratio": -0.001}, None, "PriceFilter requires low_price_ratio to be >= 0", ), # OperationalException expected ( {"method": "PriceFilter", "min_price": -0.00000010}, None, "PriceFilter requires min_price to be >= 0", ), # OperationalException expected ( {"method": "PriceFilter", "max_price": -1.00010000}, None, "PriceFilter requires max_price to be >= 0", ), # OperationalException expected ( {"method": "PriceFilter", "max_value": -1.00010000}, None, "PriceFilter requires max_value to be >= 0", ), # OperationalException expected ( {"method": "DelistFilter", "max_days_from_now": -1}, None, "DelistFilter requires max_days_from_now to be >= 0", ), # ConfigurationError expected ( {"method": "DelistFilter", "max_days_from_now": 1}, "[{'DelistFilter': 'DelistFilter - Filtering pairs that will be delisted in the " "next 1 days.'}]", None, ), # ConfigurationError expected ( {"method": "RangeStabilityFilter", "lookback_days": 10, "min_rate_of_change": 0.01}, "[{'RangeStabilityFilter': 'RangeStabilityFilter - Filtering pairs with rate " "of change below 0.01 over the last days.'}]", None, ), ( { "method": "RangeStabilityFilter", "lookback_days": 10, "min_rate_of_change": 0.01, "max_rate_of_change": 0.99, }, "[{'RangeStabilityFilter': 'RangeStabilityFilter - Filtering pairs with rate " "of change below 0.01 and above 0.99 over the last days.'}]", None, ), ( {"method": "OffsetFilter", "offset": 5, "number_assets": 10}, "[{'OffsetFilter': 'OffsetFilter - Taking 10 Pairs, starting from 5.'}]", None, ), ( {"method": "ProducerPairList"}, "[{'ProducerPairList': 'ProducerPairList - default'}]", None, ), ( { "method": "RemotePairList", "number_assets": 10, "pairlist_url": "https://example.com", }, "[{'RemotePairList': 'RemotePairList - 10 pairs from RemotePairlist.'}]", None, ), ], ) def test_pricefilter_desc( mocker, whitelist_conf, markets, pairlistconfig, desc_expected, exception_expected ): mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True) ) whitelist_conf["pairlists"] = [pairlistconfig] if desc_expected is not None: freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) short_desc = str(freqtrade.pairlists.short_desc()) assert short_desc == desc_expected else: # OperationalException expected with pytest.raises(OperationalException, match=exception_expected): freqtrade = get_patched_freqtradebot(mocker, whitelist_conf) def test_pairlistmanager_no_pairlist(mocker, whitelist_conf): mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) whitelist_conf["pairlists"] = [] with pytest.raises(OperationalException, match=r"\[\] should be non-empty"): get_patched_freqtradebot(mocker, whitelist_conf) del whitelist_conf["pairlists"] with pytest.raises(OperationalException, match=r"'pairlists' is a required property"): get_patched_freqtradebot(mocker, whitelist_conf) @pytest.mark.parametrize( "pairlists,pair_allowlist,overall_performance,allowlist_result", [ # No trades yet ( [{"method": "StaticPairList"}, {"method": "PerformanceFilter"}], ["ETH/BTC", "TKN/BTC", "LTC/BTC"], [], ["ETH/BTC", "TKN/BTC", "LTC/BTC"], ), # Happy path: Descending order, all values filled ( [{"method": "StaticPairList"}, {"method": "PerformanceFilter"}], ["ETH/BTC", "TKN/BTC"], [ {"pair": "TKN/BTC", "profit_ratio": 0.05, "count": 3}, {"pair": "ETH/BTC", "profit_ratio": 0.04, "count": 2}, ], ["TKN/BTC", "ETH/BTC"], ), # Performance data outside allow list ignored ( [{"method": "StaticPairList"}, {"method": "PerformanceFilter"}], ["ETH/BTC", "TKN/BTC"], [ {"pair": "OTHER/BTC", "profit_ratio": 0.05, "count": 3}, {"pair": "ETH/BTC", "profit_ratio": 0.04, "count": 2}, ], ["ETH/BTC", "TKN/BTC"], ), # Partial performance data missing and sorted between positive and negative profit ( [{"method": "StaticPairList"}, {"method": "PerformanceFilter"}], ["ETH/BTC", "TKN/BTC", "LTC/BTC"], [ {"pair": "ETH/BTC", "profit_ratio": -0.05, "count": 100}, {"pair": "TKN/BTC", "profit_ratio": 0.04, "count": 2}, ], ["TKN/BTC", "LTC/BTC", "ETH/BTC"], ), # Tie in performance data broken by count (ascending) ( [{"method": "StaticPairList"}, {"method": "PerformanceFilter"}], ["ETH/BTC", "TKN/BTC", "LTC/BTC"], [ {"pair": "LTC/BTC", "profit_ratio": -0.0501, "count": 101}, {"pair": "TKN/BTC", "profit_ratio": -0.0501, "count": 2}, {"pair": "ETH/BTC", "profit_ratio": -0.0501, "count": 100}, ], ["TKN/BTC", "ETH/BTC", "LTC/BTC"], ), # Tie in performance and count, broken by prior sorting sort ( [{"method": "StaticPairList"}, {"method": "PerformanceFilter"}], ["ETH/BTC", "TKN/BTC", "LTC/BTC"], [ {"pair": "LTC/BTC", "profit_ratio": -0.0501, "count": 1}, {"pair": "TKN/BTC", "profit_ratio": -0.0501, "count": 1}, {"pair": "ETH/BTC", "profit_ratio": -0.0501, "count": 1}, ], ["ETH/BTC", "TKN/BTC", "LTC/BTC"], ), ], ) def test_performance_filter( mocker, whitelist_conf, pairlists, pair_allowlist, overall_performance, allowlist_result, tickers, markets, ohlcv_history_list, ): allowlist_conf = whitelist_conf allowlist_conf["pairlists"] = pairlists allowlist_conf["exchange"]["pair_whitelist"] = pair_allowlist mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) freqtrade = get_patched_freqtradebot(mocker, allowlist_conf) mocker.patch.multiple(EXMS, get_tickers=tickers, markets=PropertyMock(return_value=markets)) mocker.patch.multiple( EXMS, get_historic_ohlcv=MagicMock(return_value=ohlcv_history_list), ) mocker.patch.multiple( "freqtrade.persistence.Trade", get_overall_performance=MagicMock(return_value=overall_performance), ) freqtrade.pairlists.refresh_pairlist() allowlist = freqtrade.pairlists.whitelist assert allowlist == allowlist_result @pytest.mark.parametrize( "wildcardlist,pairs,expected", [ (["BTC/USDT"], ["BTC/USDT"], ["BTC/USDT"]), (["BTC/USDT", "ETH/USDT"], ["BTC/USDT", "ETH/USDT"], ["BTC/USDT", "ETH/USDT"]), (["BTC/USDT", "ETH/USDT"], ["BTC/USDT"], ["BTC/USDT"]), # Test one too many ([".*/USDT"], ["BTC/USDT", "ETH/USDT"], ["BTC/USDT", "ETH/USDT"]), # Wildcard simple ( [".*C/USDT"], ["BTC/USDT", "ETC/USDT", "ETH/USDT"], ["BTC/USDT", "ETC/USDT"], ), # Wildcard exclude one ( [".*UP/USDT", "BTC/USDT", "ETH/USDT"], ["BTC/USDT", "ETC/USDT", "ETH/USDT", "BTCUP/USDT", "XRPUP/USDT", "XRPDOWN/USDT"], ["BTC/USDT", "ETH/USDT", "BTCUP/USDT", "XRPUP/USDT"], ), # Wildcard exclude one ( ["BTC/.*", "ETH/.*"], ["BTC/USDT", "ETC/USDT", "ETH/USDT", "BTC/USD", "ETH/EUR", "BTC/GBP"], ["BTC/USDT", "ETH/USDT", "BTC/USD", "ETH/EUR", "BTC/GBP"], ), # Wildcard exclude one ( ["*UP/USDT", "BTC/USDT", "ETH/USDT"], ["BTC/USDT", "ETC/USDT", "ETH/USDT", "BTCUP/USDT", "XRPUP/USDT", "XRPDOWN/USDT"], None, ), (["BTC/USD"], ["BTC/USD", "BTC/USDT"], ["BTC/USD"]), ], ) def test_expand_pairlist(wildcardlist, pairs, expected): if expected is None: with pytest.raises(ValueError, match=r"Wildcard error in \*UP/USDT,"): expand_pairlist(wildcardlist, pairs) else: assert sorted(expand_pairlist(wildcardlist, pairs)) == sorted(expected) conf = { "pairs": wildcardlist, "freqai": { "enabled": True, "feature_parameters": { "include_corr_pairlist": [ "BTC/USDT:USDT", "XRP/BUSD", ] }, }, } assert sorted(dynamic_expand_pairlist(conf, pairs)) == sorted( [*expected, "BTC/USDT:USDT", "XRP/BUSD"] ) @pytest.mark.parametrize( "wildcardlist,pairs,expected", [ (["BTC/USDT"], ["BTC/USDT"], ["BTC/USDT"]), (["BTC/USDT", "ETH/USDT"], ["BTC/USDT", "ETH/USDT"], ["BTC/USDT", "ETH/USDT"]), (["BTC/USDT", "ETH/USDT"], ["BTC/USDT"], ["BTC/USDT", "ETH/USDT"]), # Test one too many ([".*/USDT"], ["BTC/USDT", "ETH/USDT"], ["BTC/USDT", "ETH/USDT"]), # Wildcard simple ( [".*C/USDT"], ["BTC/USDT", "ETC/USDT", "ETH/USDT"], ["BTC/USDT", "ETC/USDT"], ), # Wildcard exclude one ( [".*UP/USDT", "BTC/USDT", "ETH/USDT"], ["BTC/USDT", "ETC/USDT", "ETH/USDT", "BTCUP/USDT", "XRPUP/USDT", "XRPDOWN/USDT"], ["BTC/USDT", "ETH/USDT", "BTCUP/USDT", "XRPUP/USDT"], ), # Wildcard exclude one ( ["BTC/.*", "ETH/.*"], ["BTC/USDT", "ETC/USDT", "ETH/USDT", "BTC/USD", "ETH/EUR", "BTC/GBP"], ["BTC/USDT", "ETH/USDT", "BTC/USD", "ETH/EUR", "BTC/GBP"], ), # Wildcard exclude one ( ["*UP/USDT", "BTC/USDT", "ETH/USDT"], ["BTC/USDT", "ETC/USDT", "ETH/USDT", "BTCUP/USDT", "XRPUP/USDT", "XRPDOWN/USDT"], None, ), (["HELLO/WORLD"], [], ["HELLO/WORLD"]), # Invalid pair kept (["BTC/USD"], ["BTC/USD", "BTC/USDT"], ["BTC/USD"]), (["BTC/USDT:USDT"], ["BTC/USDT:USDT", "BTC/USDT"], ["BTC/USDT:USDT"]), ( ["BB_BTC/USDT", "CC_BTC/USDT", "AA_ETH/USDT", "XRP/USDT", "ETH/USDT", "XX_BTC/USDT"], ["BTC/USDT", "ETH/USDT"], ["XRP/USDT", "ETH/USDT"], ), ], ) def test_expand_pairlist_keep_invalid(wildcardlist, pairs, expected): if expected is None: with pytest.raises(ValueError, match=r"Wildcard error in \*UP/USDT,"): expand_pairlist(wildcardlist, pairs, keep_invalid=True) else: assert sorted(expand_pairlist(wildcardlist, pairs, keep_invalid=True)) == sorted(expected) def test_ProducerPairlist_no_emc(mocker, whitelist_conf): mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) whitelist_conf["pairlists"] = [ { "method": "ProducerPairList", "number_assets": 10, "producer_name": "hello_world", } ] del whitelist_conf["external_message_consumer"] with pytest.raises( OperationalException, match=r"ProducerPairList requires external_message_consumer to be enabled.", ): get_patched_freqtradebot(mocker, whitelist_conf) def test_ProducerPairlist(mocker, whitelist_conf, markets): mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), ) whitelist_conf["pairlists"] = [ { "method": "ProducerPairList", "number_assets": 2, "producer_name": "hello_world", } ] whitelist_conf.update( { "external_message_consumer": { "enabled": True, "producers": [ { "name": "hello_world", "host": "null", "port": 9891, "ws_token": "dummy", } ], } } ) exchange = get_patched_exchange(mocker, whitelist_conf) dp = DataProvider(whitelist_conf, exchange, None) pairs = ["ETH/BTC", "LTC/BTC", "XRP/BTC"] # different producer dp._set_producer_pairs([*pairs, "MEEP/USDT"], "default") pm = PairListManager(exchange, whitelist_conf, dp) pm.refresh_pairlist() assert pm.whitelist == [] # proper producer dp._set_producer_pairs(pairs, "hello_world") pm.refresh_pairlist() # Pairlist reduced to 2 assert pm.whitelist == pairs[:2] assert len(pm.whitelist) == 2 whitelist_conf["exchange"]["pair_whitelist"] = ["TKN/BTC"] whitelist_conf["pairlists"] = [ {"method": "StaticPairList"}, { "method": "ProducerPairList", "producer_name": "hello_world", }, ] pm = PairListManager(exchange, whitelist_conf, dp) pm.refresh_pairlist() assert len(pm.whitelist) == 4 assert pm.whitelist == ["TKN/BTC", *pairs] @pytest.mark.usefixtures("init_persistence") def test_FullTradesFilter(mocker, default_conf_usdt, fee, caplog) -> None: default_conf_usdt["exchange"]["pair_whitelist"].extend(["ADA/USDT", "XRP/USDT", "ETC/USDT"]) default_conf_usdt["pairlists"] = [{"method": "StaticPairList"}, {"method": "FullTradesFilter"}] default_conf_usdt["max_open_trades"] = -1 mocker.patch(f"{EXMS}.exchange_has", MagicMock(return_value=True)) exchange = get_patched_exchange(mocker, default_conf_usdt) pm = PairListManager(exchange, default_conf_usdt) pm.refresh_pairlist() assert pm.whitelist == ["ETH/USDT", "XRP/USDT", "NEO/USDT", "TKN/USDT"] with time_machine.travel("2021-09-01 05:00:00 +00:00") as t: create_mock_trades_usdt(fee) pm.refresh_pairlist() # Unlimited max open trades, so no change to whitelist pm.refresh_pairlist() assert pm.whitelist == ["ETH/USDT", "XRP/USDT", "NEO/USDT", "TKN/USDT"] # Set max_open_trades to 4, the filter should empty the whitelist default_conf_usdt["max_open_trades"] = 4 pm.refresh_pairlist() assert pm.whitelist == [] assert log_has_re(r"Whitelist with 0 pairs: \[]", caplog) list_trades = LocalTrade.get_open_trades() assert len(list_trades) == 4 # Move to 1 hour later, close a trade, so original sorting is restored. t.move_to("2021-09-01 07:00:00 +00:00") list_trades[2].close(12) Trade.commit() # open trades count below max_open_trades, whitelist restored list_trades = LocalTrade.get_open_trades() assert len(list_trades) == 3 pm.refresh_pairlist() assert pm.whitelist == ["ETH/USDT", "XRP/USDT", "NEO/USDT", "TKN/USDT"] # Set max_open_trades to 3, the filter should empty the whitelist default_conf_usdt["max_open_trades"] = 3 pm.refresh_pairlist() assert pm.whitelist == [] assert log_has_re(r"Whitelist with 0 pairs: \[]", caplog) @pytest.mark.parametrize( "pairlists,trade_mode,result,coin_market_calls", [ ( [ # Get 2 pairs {"method": "StaticPairList", "allow_inactive": True}, {"method": "MarketCapPairList", "number_assets": 2}, ], "spot", ["BTC/USDT", "ETH/USDT"], 1, ), ( [ # Get 6 pairs {"method": "StaticPairList", "allow_inactive": True}, {"method": "MarketCapPairList", "number_assets": 6}, ], "spot", ["BTC/USDT", "ETH/USDT", "XRP/USDT", "ADA/USDT"], 1, ), ( [ # Get 3 pairs within top 6 ranks {"method": "StaticPairList", "allow_inactive": True}, {"method": "MarketCapPairList", "max_rank": 6, "number_assets": 3}, ], "spot", ["BTC/USDT", "ETH/USDT", "XRP/USDT"], 1, ), ( [ # Get 4 pairs within top 8 ranks {"method": "StaticPairList", "allow_inactive": True}, {"method": "MarketCapPairList", "max_rank": 8, "number_assets": 4}, ], "spot", ["BTC/USDT", "ETH/USDT", "XRP/USDT"], 1, ), ( [ # MarketCapPairList as generator {"method": "MarketCapPairList", "number_assets": 5} ], "spot", ["BTC/USDT", "ETH/USDT", "XRP/USDT"], 1, ), ( [ # MarketCapPairList as generator - low max_rank {"method": "MarketCapPairList", "max_rank": 2, "number_assets": 5} ], "spot", ["BTC/USDT", "ETH/USDT"], 1, ), ( [ # MarketCapPairList as generator - futures - low max_rank {"method": "MarketCapPairList", "max_rank": 2, "number_assets": 5} ], "futures", ["ETH/USDT:USDT"], 1, ), ( [ # MarketCapPairList as generator - futures - low number_assets {"method": "MarketCapPairList", "number_assets": 2} ], "futures", ["ETH/USDT:USDT", "ADA/USDT:USDT"], 1, ), ( [ # MarketCapPairList as generator - futures, 1 category {"method": "MarketCapPairList", "number_assets": 2, "categories": ["layer-1"]} ], "futures", ["ETH/USDT:USDT", "ADA/USDT:USDT"], ["layer-1"], ), ( [ # MarketCapPairList as generator - futures, 1 category { "method": "MarketCapPairList", "number_assets": 2, "categories": ["layer-1", "protocol"], } ], "futures", ["ETH/USDT:USDT", "ADA/USDT:USDT"], ["layer-1", "protocol"], ), ( [ # Blacklist high MC pairs {"method": "StaticPairList", "allow_inactive": True}, {"method": "MarketCapPairList", "mode": "blacklist"}, ], "spot", ["LTC/USDT", "NEO/USDT", "TKN/USDT", "ETC/USDT"], 1, ), ( [ # Blacklist high MC pairs {"method": "StaticPairList", "allow_inactive": True}, {"method": "MarketCapPairList", "mode": "blacklist", "max_rank": 2}, ], "spot", ["LTC/USDT", "XRP/USDT", "NEO/USDT", "TKN/USDT", "ETC/USDT", "ADA/USDT"], 1, ), ( [ # Blacklist top 6 MarketCap pairs - removes XRP which is at spot 6. {"method": "StaticPairList", "allow_inactive": True}, {"method": "MarketCapPairList", "mode": "blacklist", "max_rank": 6}, ], "spot", ["LTC/USDT", "NEO/USDT", "TKN/USDT", "ETC/USDT", "ADA/USDT"], 1, ), ], ) def test_MarketCapPairList_filter( mocker, default_conf_usdt, trade_mode, markets, pairlists, result, coin_market_calls ): test_value = [ {"symbol": "btc"}, {"symbol": "eth"}, {"symbol": "usdt"}, {"symbol": "bnb"}, {"symbol": "sol"}, {"symbol": "xrp"}, {"symbol": "usdc"}, {"symbol": "steth"}, {"symbol": "ada"}, {"symbol": "avax"}, ] default_conf_usdt["trading_mode"] = trade_mode if trade_mode == "spot": default_conf_usdt["exchange"]["pair_whitelist"].extend(["BTC/USDT", "ETC/USDT", "ADA/USDT"]) default_conf_usdt["pairlists"] = pairlists mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), ) mocker.patch( "freqtrade.plugins.pairlist.MarketCapPairList.FtCoinGeckoApi.get_coins_categories_list", return_value=[ {"category_id": "layer-1"}, {"category_id": "protocol"}, {"category_id": "defi"}, ], ) gcm_mock = mocker.patch( "freqtrade.plugins.pairlist.MarketCapPairList.FtCoinGeckoApi.get_coins_markets", return_value=test_value, ) exchange = get_patched_exchange(mocker, default_conf_usdt) pm = PairListManager(exchange, default_conf_usdt) pm.refresh_pairlist() if isinstance(coin_market_calls, int): assert gcm_mock.call_count == coin_market_calls else: assert gcm_mock.call_count == len(coin_market_calls) for call in coin_market_calls: assert any( "category" in c.kwargs and c.kwargs["category"] == call for c in gcm_mock.call_args_list ) assert pm.whitelist == result def test_MarketCapPairList_timing(mocker, default_conf_usdt, markets, time_machine): test_value = [ {"symbol": "btc"}, {"symbol": "eth"}, {"symbol": "usdt"}, {"symbol": "bnb"}, {"symbol": "sol"}, {"symbol": "xrp"}, {"symbol": "usdc"}, {"symbol": "steth"}, {"symbol": "ada"}, {"symbol": "avax"}, ] default_conf_usdt["trading_mode"] = "spot" default_conf_usdt["exchange"]["pair_whitelist"].extend(["BTC/USDT", "ETC/USDT", "ADA/USDT"]) default_conf_usdt["pairlists"] = [{"method": "MarketCapPairList", "number_assets": 2}] markets_mock = MagicMock(return_value=markets) mocker.patch.multiple( EXMS, get_markets=markets_mock, exchange_has=MagicMock(return_value=True), ) mocker.patch( "freqtrade.plugins.pairlist.MarketCapPairList.FtCoinGeckoApi.get_coins_markets", return_value=test_value, ) start_dt = dt_now() exchange = get_patched_exchange(mocker, default_conf_usdt) time_machine.move_to(start_dt) pm = PairListManager(exchange, default_conf_usdt) markets_mock.reset_mock() pm.refresh_pairlist() assert markets_mock.call_count == 4 markets_mock.reset_mock() time_machine.move_to(start_dt + timedelta(hours=20)) pm.refresh_pairlist() # Cached pairlist ... assert markets_mock.call_count == 1 markets_mock.reset_mock() time_machine.move_to(start_dt + timedelta(days=2)) pm.refresh_pairlist() # No longer cached pairlist ... assert markets_mock.call_count == 4 def test_MarketCapPairList_1000_K_fillup(mocker, default_conf_usdt, markets, time_machine): test_value = [ {"symbol": "btc"}, {"symbol": "eth"}, {"symbol": "usdt"}, {"symbol": "bnb"}, {"symbol": "sol"}, {"symbol": "xrp"}, {"symbol": "usdc"}, {"symbol": "steth"}, {"symbol": "ada"}, {"symbol": "avax"}, ] default_conf_usdt["trading_mode"] = "spot" default_conf_usdt["exchange"]["pair_whitelist"] = [] default_conf_usdt["pairlists"] = [{"method": "MarketCapPairList", "number_assets": 3}] markets["1000ETH/USDT"] = markets["ETH/USDT"] markets["KXRP/USDT"] = markets["XRP/USDT"] del markets["ETH/USDT"] del markets["XRP/USDT"] markets_mock = MagicMock(return_value=markets) mocker.patch.multiple( EXMS, get_markets=markets_mock, exchange_has=MagicMock(return_value=True), ) mocker.patch( "freqtrade.plugins.pairlist.MarketCapPairList.FtCoinGeckoApi.get_coins_markets", return_value=test_value, ) start_dt = dt_now() exchange = get_patched_exchange(mocker, default_conf_usdt) time_machine.move_to(start_dt) pm = PairListManager(exchange, default_conf_usdt) markets_mock.reset_mock() pm.refresh_pairlist() assert pm.whitelist == ["BTC/USDT", "1000ETH/USDT", "KXRP/USDT"] def test_MarketCapPairList_filter_special_no_pair_from_coingecko( mocker, default_conf_usdt, markets, ): default_conf_usdt["pairlists"] = [{"method": "MarketCapPairList", "number_assets": 2}] mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), ) # Simulate no pair returned from coingecko gcm_mock = mocker.patch( "freqtrade.plugins.pairlist.MarketCapPairList.FtCoinGeckoApi.get_coins_markets", return_value=[], ) exchange = get_patched_exchange(mocker, default_conf_usdt) pm = PairListManager(exchange, default_conf_usdt) pm.refresh_pairlist() assert gcm_mock.call_count == 1 assert pm.whitelist == [] def test_MarketCapPairList_exceptions(mocker, default_conf_usdt, caplog): exchange = get_patched_exchange(mocker, default_conf_usdt) default_conf_usdt["pairlists"] = [{"method": "MarketCapPairList"}] with pytest.raises(OperationalException, match=r"`number_assets` not specified.*"): # No number_assets PairListManager(exchange, default_conf_usdt) default_conf_usdt["pairlists"] = [ {"method": "MarketCapPairList", "number_assets": 20, "max_rank": 500} ] with caplog.at_level(logging.WARNING): PairListManager(exchange, default_conf_usdt) assert log_has_re("The max rank you have set \\(500\\) is quite high", caplog) # Test invalid coinmarkets list mocker.patch( "freqtrade.plugins.pairlist.MarketCapPairList.FtCoinGeckoApi.get_coins_categories_list", return_value=[ {"category_id": "layer-1"}, {"category_id": "protocol"}, {"category_id": "defi"}, ], ) default_conf_usdt["pairlists"] = [ { "method": "MarketCapPairList", "number_assets": 20, "categories": ["layer-1", "defi", "layer250"], } ] with pytest.raises( OperationalException, match=r"Category layer250 not in coingecko category list\." ): PairListManager(exchange, default_conf_usdt) @pytest.mark.parametrize( "pairlists,trade_mode,result", [ ( [ # Spot pairs that exist on both markets {"method": "StaticPairList", "allow_inactive": True}, {"method": "CrossMarketPairList", "pairs_exist_on": "both_markets"}, ], "spot", ["ETH/USDT"], ), ( [ # Spot pairs that exist only on spot market {"method": "StaticPairList", "allow_inactive": True}, {"method": "CrossMarketPairList", "pairs_exist_on": "current_market_only"}, ], "spot", ["LTC/USDT", "XRP/USDT", "NEO/USDT", "TKN/USDT", "BTC/USDT"], ), ( [ # Futures pairs that exist on both markets {"method": "StaticPairList", "allow_inactive": True}, {"method": "CrossMarketPairList", "pairs_exist_on": "both_markets"}, ], "futures", ["ETH/USDT:USDT"], ), ( [ # Futures pairs that exist only on futures market {"method": "StaticPairList", "allow_inactive": True}, {"method": "CrossMarketPairList", "pairs_exist_on": "current_market_only"}, ], "futures", ["ADA/USDT:USDT"], ), ( [ # CrossMarketPairList as generator, spot market, pairs that exist on both markets {"method": "CrossMarketPairList", "pairs_exist_on": "both_markets"}, ], "spot", ["ETH/USDT"], ), ( [ # CrossMarketPairList as generator, spot pairs that exist only on spot market {"method": "CrossMarketPairList", "pairs_exist_on": "current_market_only"}, ], "spot", ["BTC/USDT", "XRP/USDT", "NEO/USDT", "TKN/USDT"], ), ( [ # CrossMarketPairList as generator, futures pairs that exist on both markets {"method": "CrossMarketPairList", "pairs_exist_on": "both_markets"}, ], "futures", ["ETH/USDT:USDT"], ), ( [ # CrossMarketPairList as generator, futures pairs that exist only on futures market {"method": "CrossMarketPairList", "pairs_exist_on": "current_market_only"}, ], "futures", ["ADA/USDT:USDT"], ), ], ) def test_CrossMarketPairlist_filter( mocker, default_conf_usdt, trade_mode, markets, pairlists, result ): default_conf_usdt["trading_mode"] = trade_mode if trade_mode == "spot": default_conf_usdt["exchange"]["pair_whitelist"].extend(["BTC/USDT", "ETC/USDT", "ADA/USDT"]) else: default_conf_usdt["exchange"]["pair_whitelist"] = [ "BTC/USDT:USDT", "ETH/USDT:USDT", "ETC/USDT:USDT", "ADA/USDT:USDT", ] default_conf_usdt["pairlists"] = pairlists mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), ) exchange = get_patched_exchange(mocker, default_conf_usdt) pm = PairListManager(exchange, default_conf_usdt) pm.refresh_pairlist() assert pm.whitelist == result def test_CrossMarketPairlist_gen_pairlist_uses_cache(mocker, default_conf_usdt, markets): default_conf_usdt["trading_mode"] = "spot" default_conf_usdt["pairlists"] = [ {"method": "CrossMarketPairList", "pairs_exist_on": "both_markets"} ] mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), ) exchange = get_patched_exchange(mocker, default_conf_usdt) pm = PairListManager(exchange, default_conf_usdt) pl = pm._pairlist_handlers[0] pl._pair_cache["pairlist"] = ["ETH/USDT", "ADA/USDT"] pl._exchange.get_markets = MagicMock( side_effect=AssertionError("get_markets should not be called") ) result = pl.gen_pairlist({}) assert result == ["ETH/USDT", "ADA/USDT"] # Make sure the returned list is a copy, not the cached one assert result is not pl._pair_cache["pairlist"] result.append("BTC/USDT") # Make sure the cache is not modified assert pl._pair_cache["pairlist"] == ["ETH/USDT", "ADA/USDT"] def test_CrossMarketPairList_breaks_prefix_loop_on_match(mocker, default_conf_usdt, markets): default_conf_usdt["trading_mode"] = "spot" default_conf_usdt["pairlists"] = [ {"method": "CrossMarketPairList", "pairs_exist_on": "both_markets"} ] mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), ) exchange = get_patched_exchange(mocker, default_conf_usdt) pm = PairListManager(exchange, default_conf_usdt) pl = pm._pairlist_handlers[0] # Force base lookup path mocker.patch.object(pl, "get_base_list", return_value=["1000PEPE"]) mocker.patch.object(pl._exchange, "get_pair_base_currency", return_value="PEPE") def prefix_generator(): yield "1000" # first prefix => match via "1000PEPE" raise AssertionError("Prefix loop did not break after match") mocker.patch( "freqtrade.plugins.pairlist.CrossMarketPairList.PairPrefixes", new=prefix_generator(), ) result = pl.filter_pairlist(["PEPE/USDT"], {}) assert result == ["PEPE/USDT"] def test_CrossMarketPairList_breaks_prefix_loop_on_delayed_match( mocker, default_conf_usdt, markets ): default_conf_usdt["trading_mode"] = "spot" default_conf_usdt["pairlists"] = [ {"method": "CrossMarketPairList", "pairs_exist_on": "both_markets"} ] mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), ) exchange = get_patched_exchange(mocker, default_conf_usdt) pm = PairListManager(exchange, default_conf_usdt) pl = pm._pairlist_handlers[0] # Force second matching path: base startswith prefix and removeprefix() matches bases. mocker.patch.object(pl, "get_base_list", return_value=["PEPE"]) mocker.patch.object(pl._exchange, "get_pair_base_currency", return_value="1000PEPE") def prefix_generator(): yield "X" # no match, loop should continue yield "1000" # second path should match via removeprefix -> PEPE and break raise AssertionError("Prefix loop did not break after delayed match") mocker.patch( "freqtrade.plugins.pairlist.CrossMarketPairList.PairPrefixes", new=prefix_generator(), ) result = pl.filter_pairlist(["1000PEPE/USDT"], {}) assert result == ["1000PEPE/USDT"] @pytest.mark.parametrize( "pairlists,expected_error,expected_warning", [ ( [{"method": "StaticPairList"}], None, # Error None, # Warning ), ( [{"method": "VolumePairList", "number_assets": 10}], "VolumePairList", # Error None, # Warning ), ( [{"method": "MarketCapPairList", "number_assets": 10}], None, # Error r"MarketCapPairList.*lookahead.*", # Warning ), ( [{"method": "StaticPairList"}, {"method": "FullTradesFilter"}], None, # Error r"FullTradesFilter do not generate.*", # Warning ), ( # combi, fails and warns [ {"method": "VolumePairList", "number_assets": 10}, {"method": "MarketCapPairList", "number_assets": 10}, ], "VolumePairList", # Error r"MarketCapPairList.*lookahead.*", # Warning ), ], ) def test_backtesting_modes( mocker, default_conf_usdt, pairlists, expected_error, expected_warning, caplog, markets, tickers ): default_conf_usdt["runmode"] = "dry_run" default_conf_usdt["pairlists"] = pairlists mocker.patch.multiple( EXMS, markets=PropertyMock(return_value=markets), exchange_has=MagicMock(return_value=True), get_tickers=tickers, ) exchange = get_patched_exchange(mocker, default_conf_usdt) # Dry run mode - works always PairListManager(exchange, default_conf_usdt) default_conf_usdt["runmode"] = "backtest" if expected_error: with pytest.raises(OperationalException, match=f"Pairlist Handlers {expected_error}.*"): PairListManager(exchange, default_conf_usdt) if not expected_error: PairListManager(exchange, default_conf_usdt) if expected_warning: assert log_has_re(f"Pairlist Handlers {expected_warning}", caplog) def test_DelistFilter_error(whitelist_conf) -> None: whitelist_conf["pairlists"] = [{"method": "StaticPairList"}, {"method": "DelistFilter"}] exchange_mock = MagicMock() exchange_mock.get_option = MagicMock(return_value=False) with pytest.raises( OperationalException, match=r"DelistFilter doesn't support .* in .* mode\.", ): PairListManager(exchange_mock, whitelist_conf, MagicMock()) @pytest.mark.usefixtures("init_persistence") def test_DelistFilter(mocker, default_conf_usdt, time_machine, caplog) -> None: default_conf_usdt["exchange"]["pair_whitelist"] = [ "ETH/USDT", "XRP/USDT", "BTC/USDT", "NEO/USDT", ] default_conf_usdt["pairlists"] = [ {"method": "StaticPairList"}, {"method": "DelistFilter", "max_days_from_now": 3}, ] default_conf_usdt["max_open_trades"] = -1 exchange = get_patched_exchange(mocker, default_conf_usdt) def delist_mock(pair: str): mock_delist = { "XRP/USDT": dt_utc(2025, 9, 1) + timedelta(days=1), # Delisting in 1 day "NEO/USDT": dt_utc(2025, 9, 1) + timedelta(days=5, hours=2), # Delisting in 5 days } return mock_delist.get(pair, None) time_machine.move_to("2025-09-01 01:00:00 +00:00", tick=False) mocker.patch.object(exchange, "check_delisting_time", delist_mock) pm = PairListManager(exchange, default_conf_usdt) pm.refresh_pairlist() assert pm.whitelist == ["ETH/USDT", "BTC/USDT", "NEO/USDT"] assert log_has( "Removed XRP/USDT from whitelist, because it will be delisted on 2025-09-02 00:00:00.", caplog, ) # NEO is kept initially as delisting is in 5 days, but config is 3 days time_machine.move_to("2025-09-03 01:00:00 +00:00", tick=False) pm.refresh_pairlist() assert pm.whitelist == ["ETH/USDT", "BTC/USDT", "NEO/USDT"] # NEO not removed yet, expiry falls into the window 1 hour later time_machine.move_to("2025-09-03 02:00:00 +00:00", tick=False) pm.refresh_pairlist() assert pm.whitelist == ["ETH/USDT", "BTC/USDT"] assert log_has( "Removed NEO/USDT from whitelist, because it will be delisted on 2025-09-06 02:00:00.", caplog, )