Merge with develop

freqtrade/tests/optimize/test_backtesting.py

@@ -16,7 +16,7 @@ from freqtrade import optimize, constants, DependencyException
 from freqtrade.analyze import Analyze
 from freqtrade.arguments import Arguments, TimeRange
 from freqtrade.optimize.backtesting import Backtesting, start, setup_configuration
-from freqtrade.tests.conftest import log_has
+from freqtrade.tests.conftest import log_has, patch_exchange
 
 
 def get_args(args) -> List[str]:
@@ -84,7 +84,7 @@ def load_data_test(what):
 
 
 def simple_backtest(config, contour, num_results, mocker) -> None:
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     backtesting = Backtesting(config)
 
     data = load_data_test(contour)
@@ -102,7 +102,8 @@ def simple_backtest(config, contour, num_results, mocker) -> None:
     assert len(results) == num_results
 
 
-def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=False, timerange=None):
+def mocked_load_data(datadir, pairs=[], ticker_interval='0m', refresh_pairs=False,
+                     timerange=None, exchange=None):
     tickerdata = optimize.load_tickerdata_file(datadir, 'UNITTEST/BTC', '1m', timerange=timerange)
     pairdata = {'UNITTEST/BTC': tickerdata}
     return pairdata
@@ -119,7 +120,7 @@ def _load_pair_as_ticks(pair, tickfreq):
 def _make_backtest_conf(mocker, conf=None, pair='UNITTEST/BTC', record=None):
     data = optimize.load_data(None, ticker_interval='8m', pairs=[pair])
     data = trim_dictlist(data, -201)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     backtesting = Backtesting(conf)
     return {
         'stake_amount': conf['stake_amount'],
@@ -295,8 +296,8 @@ def test_start(mocker, fee, default_conf, caplog) -> None:
     Test start() function
     """
     start_mock = MagicMock()
-    mocker.patch('freqtrade.exchange.get_fee', fee)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
     mocker.patch('freqtrade.optimize.backtesting.Backtesting.start', start_mock)
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(
         read_data=json.dumps(default_conf)
@@ -319,7 +320,8 @@ def test_backtesting_init(mocker, default_conf) -> None:
     """
     Test Backtesting._init() method
     """
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
+    get_fee = mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.5))
     backtesting = Backtesting(default_conf)
     assert backtesting.config == default_conf
     assert isinstance(backtesting.analyze, Analyze)
@@ -327,13 +329,15 @@ def test_backtesting_init(mocker, default_conf) -> None:
     assert callable(backtesting.tickerdata_to_dataframe)
     assert callable(backtesting.populate_buy_trend)
     assert callable(backtesting.populate_sell_trend)
+    get_fee.assert_called()
+    assert backtesting.fee == 0.5
 
 
 def test_tickerdata_to_dataframe(default_conf, mocker) -> None:
     """
     Test Backtesting.tickerdata_to_dataframe() method
     """
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     timerange = TimeRange(None, 'line', 0, -100)
     tick = optimize.load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
     tickerlist = {'UNITTEST/BTC': tick}
@@ -352,7 +356,7 @@ def test_get_timeframe(default_conf, mocker) -> None:
     """
     Test Backtesting.get_timeframe() method
     """
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
     data = backtesting.tickerdata_to_dataframe(
@@ -371,7 +375,7 @@ def test_generate_text_table(default_conf, mocker):
     """
     Test Backtesting.generate_text_table() method
     """
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
     results = pd.DataFrame(
@@ -408,8 +412,8 @@ def test_backtesting_start(default_conf, mocker, caplog) -> None:
 
     mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock())
     mocker.patch('freqtrade.optimize.load_data', mocked_load_data)
-    mocker.patch('freqtrade.exchange.get_ticker_history')
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history')
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.optimize.backtesting.Backtesting',
         backtest=MagicMock(),
@@ -449,8 +453,8 @@ def test_backtesting_start_no_data(default_conf, mocker, caplog) -> None:
 
     mocker.patch('freqtrade.freqtradebot.Analyze', MagicMock())
     mocker.patch('freqtrade.optimize.load_data', MagicMock(return_value={}))
-    mocker.patch('freqtrade.exchange.get_ticker_history')
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history')
+    patch_exchange(mocker)
     mocker.patch.multiple(
         'freqtrade.optimize.backtesting.Backtesting',
         backtest=MagicMock(),
@@ -477,8 +481,8 @@ def test_backtest(default_conf, fee, mocker) -> None:
     """
     Test Backtesting.backtest() method
     """
-    mocker.patch('freqtrade.exchange.get_fee', fee)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
     data = optimize.load_data(None, ticker_interval='5m', pairs=['UNITTEST/BTC'])
@@ -499,8 +503,8 @@ def test_backtest_1min_ticker_interval(default_conf, fee, mocker) -> None:
     """
     Test Backtesting.backtest() method with 1 min ticker
     """
-    mocker.patch('freqtrade.exchange.get_fee', fee)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
     # Run a backtesting for an exiting 5min ticker_interval
@@ -522,7 +526,7 @@ def test_processed(default_conf, mocker) -> None:
     """
     Test Backtesting.backtest() method with offline data
     """
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    patch_exchange(mocker)
     backtesting = Backtesting(default_conf)
 
     dict_of_tickerrows = load_data_test('raise')
@@ -536,7 +540,7 @@ def test_processed(default_conf, mocker) -> None:
 
 
 def test_backtest_pricecontours(default_conf, fee, mocker) -> None:
-    mocker.patch('freqtrade.optimize.backtesting.exchange.get_fee', fee)
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
     tests = [['raise', 18], ['lower', 0], ['sine', 16]]
     for [contour, numres] in tests:
         simple_backtest(default_conf, contour, numres, mocker)
@@ -544,8 +548,8 @@ def test_backtest_pricecontours(default_conf, fee, mocker) -> None:
 
 # Test backtest using offline data (testdata directory)
 def test_backtest_ticks(default_conf, fee, mocker):
-    mocker.patch('freqtrade.exchange.get_fee', fee)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
+    patch_exchange(mocker)
     ticks = [1, 5]
     fun = Backtesting(default_conf).populate_buy_trend
     for _ in ticks:
@@ -564,7 +568,6 @@ def test_backtest_clash_buy_sell(mocker, default_conf):
         sell_value = 1
         return _trend(dataframe, buy_value, sell_value)
 
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
     backtest_conf = _make_backtest_conf(mocker, conf=default_conf)
     backtesting = Backtesting(default_conf)
     backtesting.populate_buy_trend = fun  # Override
@@ -580,7 +583,6 @@ def test_backtest_only_sell(mocker, default_conf):
         sell_value = 1
         return _trend(dataframe, buy_value, sell_value)
 
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
     backtest_conf = _make_backtest_conf(mocker, conf=default_conf)
     backtesting = Backtesting(default_conf)
     backtesting.populate_buy_trend = fun  # Override
@@ -590,8 +592,7 @@ def test_backtest_only_sell(mocker, default_conf):
 
 
 def test_backtest_alternate_buy_sell(default_conf, fee, mocker):
-    mocker.patch('freqtrade.optimize.backtesting.exchange.get_fee', fee)
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
     backtest_conf = _make_backtest_conf(mocker, conf=default_conf, pair='UNITTEST/BTC')
     backtesting = Backtesting(default_conf)
     backtesting.populate_buy_trend = _trend_alternate  # Override
@@ -606,8 +607,8 @@ def test_backtest_alternate_buy_sell(default_conf, fee, mocker):
 def test_backtest_record(default_conf, fee, mocker):
     names = []
     records = []
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
-    mocker.patch('freqtrade.optimize.backtesting.exchange.get_fee', fee)
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
     mocker.patch(
         'freqtrade.optimize.backtesting.file_dump_json',
         new=lambda n, r: (names.append(n), records.append(r))
@@ -655,9 +656,9 @@ def test_backtest_record(default_conf, fee, mocker):
 def test_backtest_start_live(default_conf, mocker, caplog):
     conf = deepcopy(default_conf)
     conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
-    mocker.patch('freqtrade.exchange.get_ticker_history',
-                 new=lambda n, i: _load_pair_as_ticks(n, i))
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock())
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history',
+                 new=lambda s, n, i: _load_pair_as_ticks(n, i))
+    patch_exchange(mocker)
     mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', MagicMock())
     mocker.patch('freqtrade.optimize.backtesting.Backtesting._generate_text_table', MagicMock())
     mocker.patch('freqtrade.configuration.open', mocker.mock_open(

freqtrade/tests/optimize/test_hyperopt.py

@@ -10,7 +10,7 @@ import pytest
 from freqtrade.optimize.__init__ import load_tickerdata_file
 from freqtrade.optimize.hyperopt import Hyperopt, start
 from freqtrade.strategy.resolver import StrategyResolver
-from freqtrade.tests.conftest import log_has
+from freqtrade.tests.conftest import log_has, patch_exchange
 from freqtrade.tests.optimize.test_backtesting import get_args
 
 # Avoid to reinit the same object again and again
@@ -22,8 +22,7 @@ _HYPEROPT = None
 def init_hyperopt(default_conf, mocker):
     global _HYPEROPT_INITIALIZED, _HYPEROPT
     if not _HYPEROPT_INITIALIZED:
-        mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
-        mocker.patch('freqtrade.exchange.validate_pairs', MagicMock())
+        patch_exchange(mocker)
         _HYPEROPT = Hyperopt(default_conf)
         _HYPEROPT_INITIALIZED = True
 
@@ -61,8 +60,12 @@ def test_start(mocker, default_conf, caplog) -> None:
     Test start() function
     """
     start_mock = MagicMock()
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
     mocker.patch('freqtrade.optimize.hyperopt.Hyperopt.start', start_mock)
-    mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
+    patch_exchange(mocker)
 
     args = [
         '--config', 'config.json',
@@ -178,7 +181,7 @@ def test_fmin_best_results(mocker, init_hyperopt, default_conf, caplog) -> None:
 
     mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
     mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value=fmin_result)
-    mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
+    patch_exchange(mocker)
 
     StrategyResolver({'strategy': 'DefaultStrategy'})
     hyperopt = Hyperopt(conf)
@@ -222,7 +225,7 @@ def test_fmin_throw_value_error(mocker, init_hyperopt, default_conf, caplog) ->
     conf.update({'epochs': 1})
     conf.update({'timerange': None})
     conf.update({'spaces': 'all'})
-    mocker.patch('freqtrade.freqtradebot.exchange.validate_pairs', MagicMock())
+    patch_exchange(mocker)
 
     StrategyResolver({'strategy': 'DefaultStrategy'})
     hyperopt = Hyperopt(conf)
@@ -263,7 +266,7 @@ def test_resuming_previous_hyperopt_results_succeeds(mocker, init_hyperopt, defa
     mocker.patch('freqtrade.optimize.hyperopt.sorted', return_value=trials.results)
     mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
     mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock())
+    patch_exchange(mocker)
 
     StrategyResolver({'strategy': 'DefaultStrategy'})
     hyperopt = Hyperopt(conf)
@@ -334,7 +337,7 @@ def test_start_calls_fmin(mocker, init_hyperopt, default_conf) -> None:
     trials = create_trials(mocker)
     mocker.patch('freqtrade.optimize.hyperopt.sorted', return_value=trials.results)
     mocker.patch('freqtrade.optimize.hyperopt.load_data', MagicMock())
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock())
+    patch_exchange(mocker)
     mock_fmin = mocker.patch('freqtrade.optimize.hyperopt.fmin', return_value={})
 
     conf = deepcopy(default_conf)
@@ -499,7 +502,7 @@ def test_generate_optimizer(mocker, init_hyperopt, default_conf) -> None:
         'freqtrade.optimize.hyperopt.Hyperopt.backtest',
         MagicMock(return_value=backtest_result)
     )
-    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock())
+    patch_exchange(mocker)
 
     optimizer_param = {
         'adx': {'enabled': False},

freqtrade/tests/optimize/test_optimize.py

@@ -12,7 +12,7 @@ from freqtrade.optimize.__init__ import make_testdata_path, download_pairs, \
     download_backtesting_testdata, load_tickerdata_file, trim_tickerlist, \
     load_cached_data_for_updating
 from freqtrade.arguments import TimeRange
-from freqtrade.tests.conftest import log_has
+from freqtrade.tests.conftest import log_has, get_patched_exchange
 
 # Change this if modifying UNITTEST/BTC testdatafile
 _BTC_UNITTEST_LENGTH = 13681
@@ -49,12 +49,11 @@ def _clean_test_file(file: str) -> None:
         os.rename(file_swp, file)
 
 
-def test_load_data_30min_ticker(ticker_history, mocker, caplog) -> None:
+def test_load_data_30min_ticker(ticker_history, mocker, caplog, default_conf) -> None:
     """
     Test load_data() with 30 min ticker
     """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
-
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
     file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-30m.json')
     _backup_file(file, copy_file=True)
     optimize.load_data(None, pairs=['UNITTEST/BTC'], ticker_interval='30m')
@@ -63,11 +62,11 @@ def test_load_data_30min_ticker(ticker_history, mocker, caplog) -> None:
     _clean_test_file(file)
 
 
-def test_load_data_5min_ticker(ticker_history, mocker, caplog) -> None:
+def test_load_data_5min_ticker(ticker_history, mocker, caplog, default_conf) -> None:
     """
     Test load_data() with 5 min ticker
     """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
 
     file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-5m.json')
     _backup_file(file, copy_file=True)
@@ -81,7 +80,7 @@ def test_load_data_1min_ticker(ticker_history, mocker, caplog) -> None:
     """
     Test load_data() with 1 min ticker
     """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
 
     file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'UNITTEST_BTC-1m.json')
     _backup_file(file, copy_file=True)
@@ -91,12 +90,12 @@ def test_load_data_1min_ticker(ticker_history, mocker, caplog) -> None:
     _clean_test_file(file)
 
 
-def test_load_data_with_new_pair_1min(ticker_history, mocker, caplog) -> None:
+def test_load_data_with_new_pair_1min(ticker_history, mocker, caplog, default_conf) -> None:
     """
     Test load_data() with 1 min ticker
     """
-    mocker.patch('freqtrade.optimize.get_ticker_history', return_value=ticker_history)
-
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
+    exchange = get_patched_exchange(mocker, default_conf)
     file = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
 
     _backup_file(file)
@@ -114,6 +113,7 @@ def test_load_data_with_new_pair_1min(ticker_history, mocker, caplog) -> None:
     optimize.load_data(None,
                        ticker_interval='1m',
                        refresh_pairs=True,
+                       exchange=exchange,
                        pairs=['MEME/BTC'])
     assert os.path.isfile(file) is True
     assert log_has('Download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
@@ -124,9 +124,9 @@ def test_testdata_path() -> None:
     assert os.path.join('freqtrade', 'tests', 'testdata') in make_testdata_path(None)
 
 
-def test_download_pairs(ticker_history, mocker) -> None:
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=ticker_history)
-
+def test_download_pairs(ticker_history, mocker, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
+    exchange = get_patched_exchange(mocker, default_conf)
     file1_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
     file1_5 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-5m.json')
     file2_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'CFI_BTC-1m.json')
@@ -140,7 +140,8 @@ def test_download_pairs(ticker_history, mocker) -> None:
     assert os.path.isfile(file1_1) is False
     assert os.path.isfile(file2_1) is False
 
-    assert download_pairs(None, pairs=['MEME/BTC', 'CFI/BTC'], ticker_interval='1m') is True
+    assert download_pairs(None, exchange,
+                          pairs=['MEME/BTC', 'CFI/BTC'], ticker_interval='1m') is True
 
     assert os.path.isfile(file1_1) is True
     assert os.path.isfile(file2_1) is True
@@ -152,7 +153,8 @@ def test_download_pairs(ticker_history, mocker) -> None:
     assert os.path.isfile(file1_5) is False
     assert os.path.isfile(file2_5) is False
 
-    assert download_pairs(None, pairs=['MEME/BTC', 'CFI/BTC'], ticker_interval='5m') is True
+    assert download_pairs(None, exchange,
+                          pairs=['MEME/BTC', 'CFI/BTC'], ticker_interval='5m') is True
 
     assert os.path.isfile(file1_5) is True
     assert os.path.isfile(file2_5) is True
@@ -265,30 +267,32 @@ def test_load_cached_data_for_updating(mocker) -> None:
     assert start_ts is None
 
 
-def test_download_pairs_exception(ticker_history, mocker, caplog) -> None:
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=ticker_history)
+def test_download_pairs_exception(ticker_history, mocker, caplog, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
     mocker.patch('freqtrade.optimize.__init__.download_backtesting_testdata',
                  side_effect=BaseException('File Error'))
+    exchange = get_patched_exchange(mocker, default_conf)
 
     file1_1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-1m.json')
     file1_5 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'MEME_BTC-5m.json')
     _backup_file(file1_1)
     _backup_file(file1_5)
 
-    download_pairs(None, pairs=['MEME/BTC'], ticker_interval='1m')
+    download_pairs(None, exchange, pairs=['MEME/BTC'], ticker_interval='1m')
     # clean files freshly downloaded
     _clean_test_file(file1_1)
     _clean_test_file(file1_5)
     assert log_has('Failed to download the pair: "MEME/BTC", Interval: 1m', caplog.record_tuples)
 
 
-def test_download_backtesting_testdata(ticker_history, mocker) -> None:
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=ticker_history)
+def test_download_backtesting_testdata(ticker_history, mocker, default_conf) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=ticker_history)
+    exchange = get_patched_exchange(mocker, default_conf)
 
     # Download a 1 min ticker file
     file1 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'XEL_BTC-1m.json')
     _backup_file(file1)
-    download_backtesting_testdata(None, pair="XEL/BTC", tick_interval='1m')
+    download_backtesting_testdata(None, exchange, pair="XEL/BTC", tick_interval='1m')
     assert os.path.isfile(file1) is True
     _clean_test_file(file1)
 
@@ -296,21 +300,21 @@ def test_download_backtesting_testdata(ticker_history, mocker) -> None:
     file2 = os.path.join(os.path.dirname(__file__), '..', 'testdata', 'STORJ_BTC-5m.json')
     _backup_file(file2)
 
-    download_backtesting_testdata(None, pair="STORJ/BTC", tick_interval='5m')
+    download_backtesting_testdata(None, exchange, pair="STORJ/BTC", tick_interval='5m')
     assert os.path.isfile(file2) is True
     _clean_test_file(file2)
 
 
-def test_download_backtesting_testdata2(mocker) -> None:
+def test_download_backtesting_testdata2(mocker, default_conf) -> None:
     tick = [
         [1509836520000, 0.00162008, 0.00162008, 0.00162008, 0.00162008, 108.14853839],
         [1509836580000, 0.00161, 0.00161, 0.00161, 0.00161, 82.390199]
     ]
     json_dump_mock = mocker.patch('freqtrade.misc.file_dump_json', return_value=None)
-    mocker.patch('freqtrade.optimize.__init__.get_ticker_history', return_value=tick)
-
-    download_backtesting_testdata(None, pair="UNITTEST/BTC", tick_interval='1m')
-    download_backtesting_testdata(None, pair="UNITTEST/BTC", tick_interval='3m')
+    mocker.patch('freqtrade.exchange.Exchange.get_ticker_history', return_value=tick)
+    exchange = get_patched_exchange(mocker, default_conf)
+    download_backtesting_testdata(None, exchange, pair="UNITTEST/BTC", tick_interval='1m')
+    download_backtesting_testdata(None, exchange, pair="UNITTEST/BTC", tick_interval='3m')
     assert json_dump_mock.call_count == 2
 
 
@@ -326,8 +330,10 @@ def test_load_tickerdata_file() -> None:
 
 
 def test_init(default_conf, mocker) -> None:
+    exchange = get_patched_exchange(mocker, default_conf)
     assert {} == optimize.load_data(
         '',
+        exchange=exchange,
         pairs=[],
         refresh_pairs=True,
         ticker_interval=default_conf['ticker_interval']