Merge branch 'develop' into pr/yazeed/3008

2020-08-14 06:58:09 +02:00
parent c9711678fd 067d1fd72a
commit 05bd099f51
160 changed files with 7932 additions and 2670 deletions
--- a/tests/optimize/test_backtest_detail.py
+++ b/tests/optimize/test_backtest_detail.py
@@ -360,7 +360,7 @@ def test_backtest_results(default_conf, fee, mocker, caplog, data) -> None:
    """
    default_conf["stoploss"] = data.stop_loss
    default_conf["minimal_roi"] = data.roi
-    default_conf["ticker_interval"] = tests_timeframe
+    default_conf["timeframe"] = tests_timeframe
    default_conf["trailing_stop"] = data.trailing_stop
    default_conf["trailing_only_offset_is_reached"] = data.trailing_only_offset_is_reached
    # Only add this to configuration If it's necessary
--- a/tests/optimize/test_backtesting.py
+++ b/tests/optimize/test_backtesting.py
@@ -2,7 +2,7 @@

 import random
 from pathlib import Path
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, PropertyMock

 import numpy as np
 import pandas as pd
@@ -10,8 +10,9 @@ import pytest
 from arrow import Arrow

 from freqtrade import constants
+from freqtrade.commands.optimize_commands import (setup_optimize_configuration,
+                                                  start_backtesting)
 from freqtrade.configuration import TimeRange
-from freqtrade.commands.optimize_commands import setup_optimize_configuration, start_backtesting
 from freqtrade.data import history
 from freqtrade.data.btanalysis import evaluate_result_multi
 from freqtrade.data.converter import clean_ohlcv_dataframe
@@ -80,7 +81,7 @@ def load_data_test(what, testdatadir):

 def simple_backtest(config, contour, num_results, mocker, testdatadir) -> None:
    patch_exchange(mocker)
-    config['ticker_interval'] = '1m'
+    config['timeframe'] = '1m'
    backtesting = Backtesting(config)

    data = load_data_test(contour, testdatadir)
@@ -164,7 +165,7 @@ def test_setup_optimize_configuration_without_arguments(mocker, default_conf, ca
    assert 'pair_whitelist' in config['exchange']
    assert 'datadir' in config
    assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
-    assert 'ticker_interval' in config
+    assert 'timeframe' in config
    assert not log_has_re('Parameter -i/--ticker-interval detected .*', caplog)

    assert 'position_stacking' not in config
@@ -188,7 +189,7 @@ def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) ->
        '--config', 'config.json',
        '--strategy', 'DefaultStrategy',
        '--datadir', '/foo/bar',
-        '--ticker-interval', '1m',
+        '--timeframe', '1m',
        '--enable-position-stacking',
        '--disable-max-market-positions',
        '--timerange', ':100',
@@ -207,8 +208,8 @@ def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) ->
    assert config['runmode'] == RunMode.BACKTEST

    assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
-    assert 'ticker_interval' in config
-    assert log_has('Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
+    assert 'timeframe' in config
+    assert log_has('Parameter -i/--timeframe detected ... Using timeframe: 1m ...',
                   caplog)

    assert 'position_stacking' in config
@@ -285,9 +286,9 @@ def test_backtesting_init(mocker, default_conf, order_types) -> None:
    assert not backtesting.strategy.order_types["stoploss_on_exchange"]


-def test_backtesting_init_no_ticker_interval(mocker, default_conf, caplog) -> None:
+def test_backtesting_init_no_timeframe(mocker, default_conf, caplog) -> None:
    patch_exchange(mocker)
-    del default_conf['ticker_interval']
+    del default_conf['timeframe']
    default_conf['strategy_list'] = ['DefaultStrategy',
                                     'SampleStrategy']

@@ -307,6 +308,11 @@ def test_data_with_fee(default_conf, mocker, testdatadir) -> None:
    assert backtesting.fee == 0.1234
    assert fee_mock.call_count == 0

+    default_conf['fee'] = 0.0
+    backtesting = Backtesting(default_conf)
+    assert backtesting.fee == 0.0
+    assert fee_mock.call_count == 0
+

 def test_data_to_dataframe_bt(default_conf, mocker, testdatadir) -> None:
    patch_exchange(mocker)
@@ -332,10 +338,12 @@ def test_backtesting_start(default_conf, mocker, testdatadir, caplog) -> None:
    mocker.patch('freqtrade.data.history.get_timerange', get_timerange)
    patch_exchange(mocker)
    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest')
+    mocker.patch('freqtrade.optimize.backtesting.generate_backtest_stats')
    mocker.patch('freqtrade.optimize.backtesting.show_backtest_results')
+    mocker.patch('freqtrade.pairlist.pairlistmanager.PairListManager.whitelist',
+                 PropertyMock(return_value=['UNITTEST/BTC']))

-    default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
-    default_conf['ticker_interval'] = '1m'
+    default_conf['timeframe'] = '1m'
    default_conf['datadir'] = testdatadir
    default_conf['export'] = None
    default_conf['timerange'] = '-1510694220'
@@ -362,10 +370,10 @@ def test_backtesting_start_no_data(default_conf, mocker, caplog, testdatadir) ->
    mocker.patch('freqtrade.data.history.get_timerange', get_timerange)
    patch_exchange(mocker)
    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest')
-    mocker.patch('freqtrade.optimize.backtesting.show_backtest_results')
+    mocker.patch('freqtrade.pairlist.pairlistmanager.PairListManager.whitelist',
+                 PropertyMock(return_value=['UNITTEST/BTC']))

-    default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
-    default_conf['ticker_interval'] = "1m"
+    default_conf['timeframe'] = "1m"
    default_conf['datadir'] = testdatadir
    default_conf['export'] = None
    default_conf['timerange'] = '20180101-20180102'
@@ -375,6 +383,61 @@ def test_backtesting_start_no_data(default_conf, mocker, caplog, testdatadir) ->
        backtesting.start()


+def test_backtesting_no_pair_left(default_conf, mocker, caplog, testdatadir) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=True))
+    mocker.patch('freqtrade.data.history.history_utils.load_pair_history',
+                 MagicMock(return_value=pd.DataFrame()))
+    mocker.patch('freqtrade.data.history.get_timerange', get_timerange)
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest')
+    mocker.patch('freqtrade.pairlist.pairlistmanager.PairListManager.whitelist',
+                 PropertyMock(return_value=[]))
+
+    default_conf['timeframe'] = "1m"
+    default_conf['datadir'] = testdatadir
+    default_conf['export'] = None
+    default_conf['timerange'] = '20180101-20180102'
+
+    with pytest.raises(OperationalException, match='No pair in whitelist.'):
+        Backtesting(default_conf)
+
+    default_conf['pairlists'] = [{"method": "VolumePairList", "number_assets": 5}]
+    with pytest.raises(OperationalException, match='VolumePairList not allowed for backtesting.'):
+        Backtesting(default_conf)
+
+
+def test_backtesting_pairlist_list(default_conf, mocker, caplog, testdatadir, tickers) -> None:
+    mocker.patch('freqtrade.exchange.Exchange.exchange_has', MagicMock(return_value=True))
+    mocker.patch('freqtrade.exchange.Exchange.get_tickers', tickers)
+    mocker.patch('freqtrade.exchange.Exchange.price_to_precision', lambda s, x, y: y)
+    mocker.patch('freqtrade.data.history.get_timerange', get_timerange)
+    patch_exchange(mocker)
+    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest')
+    mocker.patch('freqtrade.pairlist.pairlistmanager.PairListManager.whitelist',
+                 PropertyMock(return_value=['XRP/BTC']))
+    mocker.patch('freqtrade.pairlist.pairlistmanager.PairListManager.refresh_pairlist')
+
+    default_conf['ticker_interval'] = "1m"
+    default_conf['datadir'] = testdatadir
+    default_conf['export'] = None
+    # Use stoploss from strategy
+    del default_conf['stoploss']
+    default_conf['timerange'] = '20180101-20180102'
+
+    default_conf['pairlists'] = [{"method": "VolumePairList", "number_assets": 5}]
+    with pytest.raises(OperationalException, match='VolumePairList not allowed for backtesting.'):
+        Backtesting(default_conf)
+
+    default_conf['pairlists'] = [{"method": "StaticPairList"}, {"method": "PrecisionFilter"}, ]
+    Backtesting(default_conf)
+
+    # Multiple strategies
+    default_conf['strategy_list'] = ['DefaultStrategy', 'TestStrategyLegacy']
+    with pytest.raises(OperationalException,
+                       match='PrecisionFilter not allowed for backtesting multiple strategies.'):
+        Backtesting(default_conf)
+
+
 def test_backtest(default_conf, fee, mocker, testdatadir) -> None:
    default_conf['ask_strategy']['use_sell_signal'] = False
    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
@@ -428,7 +491,7 @@ def test_backtest(default_conf, fee, mocker, testdatadir) -> None:
                t["close_rate"], 6) < round(ln.iloc[0]["high"], 6))


-def test_backtest_1min_ticker_interval(default_conf, fee, mocker, testdatadir) -> None:
+def test_backtest_1min_timeframe(default_conf, fee, mocker, testdatadir) -> None:
    default_conf['ask_strategy']['use_sell_signal'] = False
    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
    patch_exchange(mocker)
@@ -509,7 +572,7 @@ def test_backtest_alternate_buy_sell(default_conf, fee, mocker, testdatadir):
    mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
    backtest_conf = _make_backtest_conf(mocker, conf=default_conf,
                                        pair='UNITTEST/BTC', datadir=testdatadir)
-    default_conf['ticker_interval'] = '1m'
+    default_conf['timeframe'] = '1m'
    backtesting = Backtesting(default_conf)
    backtesting.strategy.advise_buy = _trend_alternate  # Override
    backtesting.strategy.advise_sell = _trend_alternate  # Override
@@ -530,7 +593,7 @@ def test_backtest_multi_pair(default_conf, fee, mocker, tres, pair, testdatadir)
        """
        Buy every xth candle - sell every other xth -2 (hold on to pairs a bit)
        """
-        if metadata['pair'] in('ETH/BTC', 'LTC/BTC'):
+        if metadata['pair'] in ('ETH/BTC', 'LTC/BTC'):
            multi = 20
        else:
            multi = 18
@@ -548,7 +611,7 @@ def test_backtest_multi_pair(default_conf, fee, mocker, tres, pair, testdatadir)

    # Remove data for one pair from the beginning of the data
    data[pair] = data[pair][tres:].reset_index()
-    default_conf['ticker_interval'] = '5m'
+    default_conf['timeframe'] = '5m'

    backtesting = Backtesting(default_conf)
    backtesting.strategy.advise_buy = _trend_alternate_hold  # Override
@@ -585,12 +648,13 @@ def test_backtest_multi_pair(default_conf, fee, mocker, tres, pair, testdatadir)


 def test_backtest_start_timerange(default_conf, mocker, caplog, testdatadir):
-    default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']

    patch_exchange(mocker)
-    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', MagicMock())
-    mocker.patch('freqtrade.optimize.backtesting.show_backtest_results', MagicMock())
-
+    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest')
+    mocker.patch('freqtrade.optimize.backtesting.generate_backtest_stats')
+    mocker.patch('freqtrade.optimize.backtesting.show_backtest_results')
+    mocker.patch('freqtrade.pairlist.pairlistmanager.PairListManager.whitelist',
+                 PropertyMock(return_value=['UNITTEST/BTC']))
    patched_configuration_load_config_file(mocker, default_conf)

    args = [
@@ -598,7 +662,7 @@ def test_backtest_start_timerange(default_conf, mocker, caplog, testdatadir):
        '--config', 'config.json',
        '--strategy', 'DefaultStrategy',
        '--datadir', str(testdatadir),
-        '--ticker-interval', '1m',
+        '--timeframe', '1m',
        '--timerange', '1510694220-1510700340',
        '--enable-position-stacking',
        '--disable-max-market-positions'
@@ -607,7 +671,7 @@ def test_backtest_start_timerange(default_conf, mocker, caplog, testdatadir):
    start_backtesting(args)
    # check the logs, that will contain the backtest result
    exists = [
-        'Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
+        'Parameter -i/--timeframe detected ... Using timeframe: 1m ...',
        'Ignoring max_open_trades (--disable-max-market-positions was used) ...',
        'Parameter --timerange detected: 1510694220-1510700340 ...',
        f'Using data directory: {testdatadir} ...',
@@ -624,17 +688,26 @@ def test_backtest_start_timerange(default_conf, mocker, caplog, testdatadir):
        assert log_has(line, caplog)


+@pytest.mark.filterwarnings("ignore:deprecated")
 def test_backtest_start_multi_strat(default_conf, mocker, caplog, testdatadir):
-    default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']

    patch_exchange(mocker)
    backtestmock = MagicMock()
+    mocker.patch('freqtrade.pairlist.pairlistmanager.PairListManager.whitelist',
+                 PropertyMock(return_value=['UNITTEST/BTC']))
    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', backtestmock)
-    gen_table_mock = MagicMock()
-    mocker.patch('freqtrade.optimize.optimize_reports.generate_text_table', gen_table_mock)
-    gen_strattable_mock = MagicMock()
-    mocker.patch('freqtrade.optimize.optimize_reports.generate_text_table_strategy',
-                 gen_strattable_mock)
+    text_table_mock = MagicMock()
+    sell_reason_mock = MagicMock()
+    strattable_mock = MagicMock()
+    strat_summary = MagicMock()
+
+    mocker.patch.multiple('freqtrade.optimize.optimize_reports',
+                          text_table_bt_results=text_table_mock,
+                          text_table_strategy=strattable_mock,
+                          generate_pair_metrics=MagicMock(),
+                          generate_sell_reason_stats=sell_reason_mock,
+                          generate_strategy_metrics=strat_summary,
+                          )
    patched_configuration_load_config_file(mocker, default_conf)

    args = [
@@ -642,7 +715,7 @@ def test_backtest_start_multi_strat(default_conf, mocker, caplog, testdatadir):
        '--config', 'config.json',
        '--datadir', str(testdatadir),
        '--strategy-path', str(Path(__file__).parents[1] / 'strategy/strats'),
-        '--ticker-interval', '1m',
+        '--timeframe', '1m',
        '--timerange', '1510694220-1510700340',
        '--enable-position-stacking',
        '--disable-max-market-positions',
@@ -654,12 +727,14 @@ def test_backtest_start_multi_strat(default_conf, mocker, caplog, testdatadir):
    start_backtesting(args)
    # 2 backtests, 4 tables
    assert backtestmock.call_count == 2
-    assert gen_table_mock.call_count == 4
-    assert gen_strattable_mock.call_count == 1
+    assert text_table_mock.call_count == 4
+    assert strattable_mock.call_count == 1
+    assert sell_reason_mock.call_count == 2
+    assert strat_summary.call_count == 1

    # check the logs, that will contain the backtest result
    exists = [
-        'Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
+        'Parameter -i/--timeframe detected ... Using timeframe: 1m ...',
        'Ignoring max_open_trades (--disable-max-market-positions was used) ...',
        'Parameter --timerange detected: 1510694220-1510700340 ...',
        f'Using data directory: {testdatadir} ...',
@@ -676,3 +751,92 @@ def test_backtest_start_multi_strat(default_conf, mocker, caplog, testdatadir):

    for line in exists:
        assert log_has(line, caplog)
+
+
+@pytest.mark.filterwarnings("ignore:deprecated")
+def test_backtest_start_multi_strat_nomock(default_conf, mocker, caplog, testdatadir, capsys):
+
+    patch_exchange(mocker)
+    backtestmock = MagicMock(side_effect=[
+        pd.DataFrame({'pair': ['XRP/BTC', 'LTC/BTC'],
+                      'profit_percent': [0.0, 0.0],
+                      'profit_abs': [0.0, 0.0],
+                      'open_time': pd.to_datetime(['2018-01-29 18:40:00',
+                                                   '2018-01-30 03:30:00', ], utc=True
+                                                  ),
+                      'close_time': pd.to_datetime(['2018-01-29 20:45:00',
+                                                    '2018-01-30 05:35:00', ], utc=True),
+                      'open_index': [78, 184],
+                      'close_index': [125, 192],
+                      'trade_duration': [235, 40],
+                      'open_at_end': [False, False],
+                      'open_rate': [0.104445, 0.10302485],
+                      'close_rate': [0.104969, 0.103541],
+                      'sell_reason': [SellType.ROI, SellType.ROI]
+                      }),
+        pd.DataFrame({'pair': ['XRP/BTC', 'LTC/BTC', 'ETH/BTC'],
+                      'profit_percent': [0.03, 0.01, 0.1],
+                      'profit_abs': [0.01, 0.02, 0.2],
+                      'open_time': pd.to_datetime(['2018-01-29 18:40:00',
+                                                   '2018-01-30 03:30:00',
+                                                   '2018-01-30 05:30:00'], utc=True
+                                                  ),
+                      'close_time': pd.to_datetime(['2018-01-29 20:45:00',
+                                                    '2018-01-30 05:35:00',
+                                                    '2018-01-30 08:30:00'], utc=True),
+                      'open_index': [78, 184, 185],
+                      'close_index': [125, 224, 205],
+                      'trade_duration': [47, 40, 20],
+                      'open_at_end': [False, False, False],
+                      'open_rate': [0.104445, 0.10302485, 0.122541],
+                      'close_rate': [0.104969, 0.103541, 0.123541],
+                      'sell_reason': [SellType.ROI, SellType.ROI, SellType.STOP_LOSS]
+                      }),
+    ])
+    mocker.patch('freqtrade.pairlist.pairlistmanager.PairListManager.whitelist',
+                 PropertyMock(return_value=['UNITTEST/BTC']))
+    mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', backtestmock)
+
+    patched_configuration_load_config_file(mocker, default_conf)
+
+    args = [
+        'backtesting',
+        '--config', 'config.json',
+        '--datadir', str(testdatadir),
+        '--strategy-path', str(Path(__file__).parents[1] / 'strategy/strats'),
+        '--timeframe', '1m',
+        '--timerange', '1510694220-1510700340',
+        '--enable-position-stacking',
+        '--disable-max-market-positions',
+        '--strategy-list',
+        'DefaultStrategy',
+        'TestStrategyLegacy',
+    ]
+    args = get_args(args)
+    start_backtesting(args)
+
+    # check the logs, that will contain the backtest result
+    exists = [
+        'Parameter -i/--timeframe detected ... Using timeframe: 1m ...',
+        'Ignoring max_open_trades (--disable-max-market-positions was used) ...',
+        'Parameter --timerange detected: 1510694220-1510700340 ...',
+        f'Using data directory: {testdatadir} ...',
+        'Using stake_currency: BTC ...',
+        'Using stake_amount: 0.001 ...',
+        'Loading data from 2017-11-14T20:57:00+00:00 '
+        'up to 2017-11-14T22:58:00+00:00 (0 days)..',
+        'Backtesting with data from 2017-11-14T21:17:00+00:00 '
+        'up to 2017-11-14T22:58:00+00:00 (0 days)..',
+        'Parameter --enable-position-stacking detected ...',
+        'Running backtesting for Strategy DefaultStrategy',
+        'Running backtesting for Strategy TestStrategyLegacy',
+    ]
+
+    for line in exists:
+        assert log_has(line, caplog)
+
+    captured = capsys.readouterr()
+    assert 'BACKTESTING REPORT' in captured.out
+    assert 'SELL REASON STATS' in captured.out
+    assert 'LEFT OPEN TRADES REPORT' in captured.out
+    assert 'STRATEGY SUMMARY' in captured.out
--- a/tests/optimize/test_edge_cli.py
+++ b/tests/optimize/test_edge_cli.py
@@ -29,7 +29,7 @@ def test_setup_optimize_configuration_without_arguments(mocker, default_conf, ca
    assert 'pair_whitelist' in config['exchange']
    assert 'datadir' in config
    assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
-    assert 'ticker_interval' in config
+    assert 'timeframe' in config
    assert not log_has_re('Parameter -i/--ticker-interval detected .*', caplog)

    assert 'timerange' not in config
@@ -48,7 +48,7 @@ def test_setup_edge_configuration_with_arguments(mocker, edge_conf, caplog) -> N
        '--config', 'config.json',
        '--strategy', 'DefaultStrategy',
        '--datadir', '/foo/bar',
-        '--ticker-interval', '1m',
+        '--timeframe', '1m',
        '--timerange', ':100',
        '--stoplosses=-0.01,-0.10,-0.001'
    ]
@@ -62,8 +62,8 @@ def test_setup_edge_configuration_with_arguments(mocker, edge_conf, caplog) -> N
    assert 'datadir' in config
    assert config['runmode'] == RunMode.EDGE
    assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
-    assert 'ticker_interval' in config
-    assert log_has('Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
+    assert 'timeframe' in config
+    assert log_has('Parameter -i/--timeframe detected ... Using timeframe: 1m ...',
                   caplog)

    assert 'timerange' in config
--- a/tests/optimize/test_hyperopt.py
+++ b/tests/optimize/test_hyperopt.py
@@ -1,5 +1,6 @@
 # pragma pylint: disable=missing-docstring,W0212,C0103
 import locale
+import logging
 from datetime import datetime
 from pathlib import Path
 from typing import Dict, List
@@ -56,14 +57,14 @@ def hyperopt_results():


 # Functions for recurrent object patching
-def create_trials(mocker, hyperopt, testdatadir) -> List[Dict]:
+def create_results(mocker, hyperopt, testdatadir) -> List[Dict]:
    """
-    When creating trials, mock the hyperopt Trials so that *by default*
+    When creating results, mock the hyperopt so that *by default*
      - we don't create any pickle'd files in the filesystem
      - we might have a pickle'd file so make sure that we return
        false when looking for it
    """
-    hyperopt.trials_file = testdatadir / 'optimize/ut_trials.pickle'
+    hyperopt.results_file = testdatadir / 'optimize/ut_results.pickle'

    mocker.patch.object(Path, "is_file", MagicMock(return_value=False))
    stat_mock = MagicMock()
@@ -93,7 +94,7 @@ def test_setup_hyperopt_configuration_without_arguments(mocker, default_conf, ca
    assert 'pair_whitelist' in config['exchange']
    assert 'datadir' in config
    assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
-    assert 'ticker_interval' in config
+    assert 'timeframe' in config
    assert not log_has_re('Parameter -i/--ticker-interval detected .*', caplog)

    assert 'position_stacking' not in config
@@ -116,7 +117,7 @@ def test_setup_hyperopt_configuration_with_arguments(mocker, default_conf, caplo
        '--config', 'config.json',
        '--hyperopt', 'DefaultHyperOpt',
        '--datadir', '/foo/bar',
-        '--ticker-interval', '1m',
+        '--timeframe', '1m',
        '--timerange', ':100',
        '--enable-position-stacking',
        '--disable-max-market-positions',
@@ -135,8 +136,8 @@ def test_setup_hyperopt_configuration_with_arguments(mocker, default_conf, caplo
    assert config['runmode'] == RunMode.HYPEROPT

    assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
-    assert 'ticker_interval' in config
-    assert log_has('Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
+    assert 'timeframe' in config
+    assert log_has('Parameter -i/--timeframe detected ... Using timeframe: 1m ...',
                   caplog)

    assert 'position_stacking' in config
@@ -196,7 +197,8 @@ def test_hyperoptresolver(mocker, default_conf, caplog) -> None:
                   "Using populate_sell_trend from the strategy.", caplog)
    assert log_has("Hyperopt class does not provide populate_buy_trend() method. "
                   "Using populate_buy_trend from the strategy.", caplog)
-    assert hasattr(x, "ticker_interval")
+    assert hasattr(x, "ticker_interval")  # DEPRECATED
+    assert hasattr(x, "timeframe")


 def test_hyperoptresolver_wrongname(mocker, default_conf, caplog) -> None:
@@ -477,28 +479,30 @@ def test_no_log_if_loss_does_not_improve(hyperopt, caplog) -> None:
    assert caplog.record_tuples == []


-def test_save_trials_saves_trials(mocker, hyperopt, testdatadir, caplog) -> None:
-    trials = create_trials(mocker, hyperopt, testdatadir)
+def test_save_results_saves_epochs(mocker, hyperopt, testdatadir, caplog) -> None:
+    epochs = create_results(mocker, hyperopt, testdatadir)
    mock_dump = mocker.patch('freqtrade.optimize.hyperopt.dump', return_value=None)
-    trials_file = testdatadir / 'optimize' / 'ut_trials.pickle'
+    results_file = testdatadir / 'optimize' / 'ut_results.pickle'

-    hyperopt.trials = trials
-    hyperopt.save_trials(final=True)
-    assert log_has(f"1 epoch saved to '{trials_file}'.", caplog)
+    caplog.set_level(logging.DEBUG)
+
+    hyperopt.epochs = epochs
+    hyperopt._save_results()
+    assert log_has(f"1 epoch saved to '{results_file}'.", caplog)
    mock_dump.assert_called_once()

-    hyperopt.trials = trials + trials
-    hyperopt.save_trials(final=True)
-    assert log_has(f"2 epochs saved to '{trials_file}'.", caplog)
+    hyperopt.epochs = epochs + epochs
+    hyperopt._save_results()
+    assert log_has(f"2 epochs saved to '{results_file}'.", caplog)


-def test_read_trials_returns_trials_file(mocker, hyperopt, testdatadir, caplog) -> None:
-    trials = create_trials(mocker, hyperopt, testdatadir)
-    mock_load = mocker.patch('freqtrade.optimize.hyperopt.load', return_value=trials)
-    trials_file = testdatadir / 'optimize' / 'ut_trials.pickle'
-    hyperopt_trial = hyperopt._read_trials(trials_file)
-    assert log_has(f"Reading Trials from '{trials_file}'", caplog)
-    assert hyperopt_trial == trials
+def test_read_results_returns_epochs(mocker, hyperopt, testdatadir, caplog) -> None:
+    epochs = create_results(mocker, hyperopt, testdatadir)
+    mock_load = mocker.patch('freqtrade.optimize.hyperopt.load', return_value=epochs)
+    results_file = testdatadir / 'optimize' / 'ut_results.pickle'
+    hyperopt_epochs = hyperopt._read_results(results_file)
+    assert log_has(f"Reading epochs from '{results_file}'", caplog)
+    assert hyperopt_epochs == epochs
    mock_load.assert_called_once()


@@ -541,7 +545,7 @@ def test_start_calls_optimizer(mocker, default_conf, caplog, capsys) -> None:
    )
    patch_exchange(mocker)
    # Co-test loading timeframe from strategy
-    del default_conf['ticker_interval']
+    del default_conf['timeframe']
    default_conf.update({'config': 'config.json.example',
                         'hyperopt': 'DefaultHyperOpt',
                         'epochs': 1,
@@ -823,7 +827,7 @@ def test_continue_hyperopt(mocker, default_conf, caplog):
    Hyperopt(default_conf)

    assert unlinkmock.call_count == 0
-    assert log_has(f"Continuing on previous hyperopt results.", caplog)
+    assert log_has("Continuing on previous hyperopt results.", caplog)


 def test_print_json_spaces_all(mocker, default_conf, caplog, capsys) -> None:
--- a/tests/optimize/test_optimize_reports.py
+++ b/tests/optimize/test_optimize_reports.py
@@ -1,17 +1,19 @@
 from pathlib import Path

 import pandas as pd
+import pytest
 from arrow import Arrow

 from freqtrade.edge import PairInfo
 from freqtrade.optimize.optimize_reports import (
-    generate_edge_table, generate_text_table, generate_text_table_sell_reason,
-    generate_text_table_strategy, store_backtest_result)
+    generate_pair_metrics, generate_edge_table, generate_sell_reason_stats,
+    text_table_bt_results, text_table_sell_reason, generate_strategy_metrics,
+    text_table_strategy, store_backtest_result)
 from freqtrade.strategy.interface import SellType
 from tests.conftest import patch_exchange


-def test_generate_text_table(default_conf, mocker):
+def test_text_table_bt_results(default_conf, mocker):

    results = pd.DataFrame(
        {
@@ -35,12 +37,38 @@ def test_generate_text_table(default_conf, mocker):
        '|   TOTAL |      2 |          15.00 |          30.00 |       0.60000000 |'
        '          15.00 |        0:20:00 |      2 |       0 |        0 |'
    )
-    assert generate_text_table(data={'ETH/BTC': {}},
-                               stake_currency='BTC', max_open_trades=2,
-                               results=results) == result_str
+
+    pair_results = generate_pair_metrics(data={'ETH/BTC': {}}, stake_currency='BTC',
+                                         max_open_trades=2, results=results)
+    assert text_table_bt_results(pair_results, stake_currency='BTC') == result_str


-def test_generate_text_table_sell_reason(default_conf, mocker):
+def test_generate_pair_metrics(default_conf, mocker):
+
+    results = pd.DataFrame(
+        {
+            'pair': ['ETH/BTC', 'ETH/BTC'],
+            'profit_percent': [0.1, 0.2],
+            'profit_abs': [0.2, 0.4],
+            'trade_duration': [10, 30],
+            'wins': [2, 0],
+            'draws': [0, 0],
+            'losses': [0, 0]
+        }
+    )
+
+    pair_results = generate_pair_metrics(data={'ETH/BTC': {}}, stake_currency='BTC',
+                                         max_open_trades=2, results=results)
+    assert isinstance(pair_results, list)
+    assert len(pair_results) == 2
+    assert pair_results[-1]['key'] == 'TOTAL'
+    assert (
+        pytest.approx(pair_results[-1]['profit_mean_pct']) == pair_results[-1]['profit_mean'] * 100)
+    assert (
+        pytest.approx(pair_results[-1]['profit_sum_pct']) == pair_results[-1]['profit_sum'] * 100)
+
+
+def test_text_table_sell_reason(default_conf):

    results = pd.DataFrame(
        {
@@ -65,11 +93,49 @@ def test_generate_text_table_sell_reason(default_conf, mocker):
        '|     stop_loss |       1 |      0 |       0 |        1 |'
        '            -10 |            -10 |             -0.2 |             -5 |'
    )
-    assert generate_text_table_sell_reason(stake_currency='BTC', max_open_trades=2,
-                                           results=results) == result_str
+
+    sell_reason_stats = generate_sell_reason_stats(max_open_trades=2,
+                                                   results=results)
+    assert text_table_sell_reason(sell_reason_stats=sell_reason_stats,
+                                  stake_currency='BTC') == result_str


-def test_generate_text_table_strategy(default_conf, mocker):
+def test_generate_sell_reason_stats(default_conf):
+
+    results = pd.DataFrame(
+        {
+            'pair': ['ETH/BTC', 'ETH/BTC', 'ETH/BTC'],
+            'profit_percent': [0.1, 0.2, -0.1],
+            'profit_abs': [0.2, 0.4, -0.2],
+            'trade_duration': [10, 30, 10],
+            'wins': [2, 0, 0],
+            'draws': [0, 0, 0],
+            'losses': [0, 0, 1],
+            'sell_reason': [SellType.ROI, SellType.ROI, SellType.STOP_LOSS]
+        }
+    )
+
+    sell_reason_stats = generate_sell_reason_stats(max_open_trades=2,
+                                                   results=results)
+    roi_result = sell_reason_stats[0]
+    assert roi_result['sell_reason'] == 'roi'
+    assert roi_result['trades'] == 2
+    assert pytest.approx(roi_result['profit_mean']) == 0.15
+    assert roi_result['profit_mean_pct'] == round(roi_result['profit_mean'] * 100, 2)
+    assert pytest.approx(roi_result['profit_mean']) == 0.15
+    assert roi_result['profit_mean_pct'] == round(roi_result['profit_mean'] * 100, 2)
+
+    stop_result = sell_reason_stats[1]
+
+    assert stop_result['sell_reason'] == 'stop_loss'
+    assert stop_result['trades'] == 1
+    assert pytest.approx(stop_result['profit_mean']) == -0.1
+    assert stop_result['profit_mean_pct'] == round(stop_result['profit_mean'] * 100, 2)
+    assert pytest.approx(stop_result['profit_mean']) == -0.1
+    assert stop_result['profit_mean_pct'] == round(stop_result['profit_mean'] * 100, 2)
+
+
+def test_text_table_strategy(default_conf, mocker):
    results = {}
    results['TestStrategy1'] = pd.DataFrame(
        {
@@ -106,7 +172,12 @@ def test_generate_text_table_strategy(default_conf, mocker):
        '| TestStrategy2 |      3 |          30.00 |          90.00 |       1.30000000 |'
        '          45.00 |        0:20:00 |      3 |       0 |        0 |'
    )
-    assert generate_text_table_strategy('BTC', 2, all_results=results) == result_str
+
+    strategy_results = generate_strategy_metrics(stake_currency='BTC',
+                                                 max_open_trades=2,
+                                                 all_results=results)
+
+    assert text_table_strategy(strategy_results, 'BTC') == result_str


 def test_generate_edge_table(edge_conf, mocker):