stable/tests/optimize/test_backtesting.py

751 lines
29 KiB
Python
Raw Normal View History

# pragma pylint: disable=missing-docstring, W0212, line-too-long, C0103, unused-argument
2018-03-17 21:44:47 +00:00
import random
from pathlib import Path
2018-01-05 09:23:12 +00:00
from unittest.mock import MagicMock
2018-03-17 21:44:47 +00:00
import numpy as np
2018-03-17 21:44:47 +00:00
import pandas as pd
2018-07-04 07:31:35 +00:00
import pytest
2018-03-17 21:44:47 +00:00
from arrow import Arrow
from freqtrade import constants
from freqtrade.configuration import TimeRange
2020-01-26 12:33:13 +00:00
from freqtrade.commands.optimize_commands import setup_optimize_configuration, start_backtesting
2018-12-13 05:35:28 +00:00
from freqtrade.data import history
from freqtrade.data.btanalysis import evaluate_result_multi
from freqtrade.data.converter import clean_ohlcv_dataframe
from freqtrade.data.dataprovider import DataProvider
2019-12-17 22:06:03 +00:00
from freqtrade.data.history import get_timerange
from freqtrade.exceptions import DependencyException, OperationalException
from freqtrade.optimize.backtesting import Backtesting
from freqtrade.resolvers import StrategyResolver
2018-12-25 13:35:48 +00:00
from freqtrade.state import RunMode
2018-12-13 05:35:28 +00:00
from freqtrade.strategy.interface import SellType
2019-09-08 07:54:15 +00:00
from tests.conftest import (get_args, log_has, log_has_re, patch_exchange,
patched_configuration_load_config_file)
2019-10-05 13:34:31 +00:00
ORDER_TYPES = [
{
'buy': 'limit',
'sell': 'limit',
'stoploss': 'limit',
'stoploss_on_exchange': False
},
{
'buy': 'limit',
'sell': 'limit',
'stoploss': 'limit',
'stoploss_on_exchange': True
}]
2018-01-28 07:38:41 +00:00
def trim_dictlist(dict_list, num):
2018-01-17 17:19:39 +00:00
new = {}
2018-01-28 07:38:41 +00:00
for pair, pair_data in dict_list.items():
2019-05-08 18:33:22 +00:00
new[pair] = pair_data[num:].reset_index()
2018-01-17 17:19:39 +00:00
return new
2019-09-07 18:56:03 +00:00
def load_data_test(what, testdatadir):
timerange = TimeRange.parse_timerange('1510694220-1510700340')
data = history.load_pair_history(pair='UNITTEST/BTC', datadir=testdatadir,
timeframe='1m', timerange=timerange,
drop_incomplete=False,
fill_up_missing=False)
base = 0.001
if what == 'raise':
data.loc[:, 'open'] = data.index * base
data.loc[:, 'high'] = data.index * base + 0.0001
data.loc[:, 'low'] = data.index * base - 0.0001
data.loc[:, 'close'] = data.index * base
if what == 'lower':
data.loc[:, 'open'] = 1 - data.index * base
data.loc[:, 'high'] = 1 - data.index * base + 0.0001
data.loc[:, 'low'] = 1 - data.index * base - 0.0001
data.loc[:, 'close'] = 1 - data.index * base
if what == 'sine':
hz = 0.1 # frequency
data.loc[:, 'open'] = np.sin(data.index * hz) / 1000 + base
data.loc[:, 'high'] = np.sin(data.index * hz) / 1000 + base + 0.0001
data.loc[:, 'low'] = np.sin(data.index * hz) / 1000 + base - 0.0001
data.loc[:, 'close'] = np.sin(data.index * hz) / 1000 + base
return {'UNITTEST/BTC': clean_ohlcv_dataframe(data, timeframe='1m', pair='UNITTEST/BTC',
fill_missing=True)}
2019-09-07 18:56:03 +00:00
def simple_backtest(config, contour, num_results, mocker, testdatadir) -> None:
2018-06-17 20:32:56 +00:00
patch_exchange(mocker)
config['ticker_interval'] = '1m'
2018-04-21 22:19:11 +00:00
backtesting = Backtesting(config)
2019-09-07 18:56:03 +00:00
data = load_data_test(contour, testdatadir)
processed = backtesting.strategy.ohlcvdata_to_dataframe(data)
2019-12-17 22:06:03 +00:00
min_date, max_date = get_timerange(processed)
assert isinstance(processed, dict)
results = backtesting.backtest(
2019-12-13 23:12:44 +00:00
processed=processed,
stake_amount=config['stake_amount'],
start_date=min_date,
end_date=max_date,
max_open_trades=1,
position_stacking=False,
)
# results :: <class 'pandas.core.frame.DataFrame'>
assert len(results) == num_results
# FIX: fixturize this?
2019-12-13 23:12:44 +00:00
def _make_backtest_conf(mocker, datadir, conf=None, pair='UNITTEST/BTC'):
data = history.load_data(datadir=datadir, timeframe='1m', pairs=[pair])
data = trim_dictlist(data, -201)
2018-06-17 20:32:56 +00:00
patch_exchange(mocker)
2018-04-21 22:19:11 +00:00
backtesting = Backtesting(conf)
processed = backtesting.strategy.ohlcvdata_to_dataframe(data)
2019-12-17 22:06:03 +00:00
min_date, max_date = get_timerange(processed)
return {
'processed': processed,
2019-12-13 23:12:44 +00:00
'stake_amount': conf['stake_amount'],
'start_date': min_date,
'end_date': max_date,
2019-12-13 23:12:44 +00:00
'max_open_trades': 10,
'position_stacking': False,
}
def _trend(signals, buy_value, sell_value):
n = len(signals['low'])
buy = np.zeros(n)
sell = np.zeros(n)
for i in range(0, len(signals['buy'])):
if random.random() > 0.5: # Both buy and sell signals at same timeframe
buy[i] = buy_value
sell[i] = sell_value
signals['buy'] = buy
signals['sell'] = sell
return signals
def _trend_alternate(dataframe=None, metadata=None):
signals = dataframe
low = signals['low']
n = len(low)
buy = np.zeros(n)
sell = np.zeros(n)
for i in range(0, len(buy)):
if i % 2 == 0:
buy[i] = 1
else:
sell[i] = 1
signals['buy'] = buy
signals['sell'] = sell
return dataframe
# Unit tests
2020-01-26 12:33:13 +00:00
def test_setup_optimize_configuration_without_arguments(mocker, default_conf, caplog) -> None:
patched_configuration_load_config_file(mocker, default_conf)
args = [
2019-09-14 11:18:52 +00:00
'backtesting',
'--config', 'config.json',
'--strategy', 'DefaultStrategy',
]
2020-01-26 12:33:13 +00:00
config = setup_optimize_configuration(get_args(args), RunMode.BACKTEST)
assert 'max_open_trades' in config
assert 'stake_currency' in config
assert 'stake_amount' in config
assert 'exchange' in config
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 not log_has_re('Parameter -i/--ticker-interval detected .*', caplog)
assert 'position_stacking' not in config
assert not log_has('Parameter --enable-position-stacking detected ...', caplog)
assert 'timerange' not in config
assert 'export' not in config
2018-12-25 13:35:48 +00:00
assert 'runmode' in config
assert config['runmode'] == RunMode.BACKTEST
2019-01-01 13:07:40 +00:00
def test_setup_bt_configuration_with_arguments(mocker, default_conf, caplog) -> None:
patched_configuration_load_config_file(mocker, default_conf)
2019-07-11 22:41:09 +00:00
mocker.patch(
2019-07-12 00:26:27 +00:00
'freqtrade.configuration.configuration.create_datadir',
lambda c, x: x
2019-07-11 22:41:09 +00:00
)
args = [
2019-09-14 11:18:52 +00:00
'backtesting',
'--config', 'config.json',
'--strategy', 'DefaultStrategy',
'--datadir', '/foo/bar',
'--ticker-interval', '1m',
'--enable-position-stacking',
2018-07-17 19:05:03 +00:00
'--disable-max-market-positions',
'--timerange', ':100',
2018-06-03 12:52:03 +00:00
'--export', '/bar/foo',
2019-10-05 13:34:31 +00:00
'--export-filename', 'foo_bar.json',
'--fee', '0',
]
2020-01-26 12:33:13 +00:00
config = setup_optimize_configuration(get_args(args), RunMode.BACKTEST)
assert 'max_open_trades' in config
assert 'stake_currency' in config
assert 'stake_amount' in config
assert 'exchange' in config
assert 'pair_whitelist' in config['exchange']
assert 'datadir' in config
2018-12-25 13:35:48 +00:00
assert config['runmode'] == RunMode.BACKTEST
assert log_has('Using data directory: {} ...'.format(config['datadir']), caplog)
assert 'ticker_interval' in config
2019-04-24 19:24:00 +00:00
assert log_has('Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
caplog)
assert 'position_stacking' in config
assert log_has('Parameter --enable-position-stacking detected ...', caplog)
2018-07-17 19:05:03 +00:00
assert 'use_max_market_positions' in config
assert log_has('Parameter --disable-max-market-positions detected ...', caplog)
assert log_has('max_open_trades set to unlimited ...', caplog)
assert 'timerange' in config
assert log_has('Parameter --timerange detected: {} ...'.format(config['timerange']), caplog)
assert 'export' in config
assert log_has('Parameter --export detected: {} ...'.format(config['export']), caplog)
2018-06-03 12:52:03 +00:00
assert 'exportfilename' in config
assert log_has('Storing backtest results to {} ...'.format(config['exportfilename']), caplog)
2019-10-05 13:34:31 +00:00
assert 'fee' in config
assert log_has('Parameter --fee detected, setting fee to: {} ...'.format(config['fee']), caplog)
2020-01-26 12:33:13 +00:00
def test_setup_optimize_configuration_unlimited_stake_amount(mocker, default_conf, caplog) -> None:
default_conf['stake_amount'] = constants.UNLIMITED_STAKE_AMOUNT
2018-06-03 22:48:26 +00:00
patched_configuration_load_config_file(mocker, default_conf)
2018-06-03 22:48:26 +00:00
args = [
2019-09-14 11:18:52 +00:00
'backtesting',
2018-06-03 22:48:26 +00:00
'--config', 'config.json',
'--strategy', 'DefaultStrategy',
]
with pytest.raises(DependencyException, match=r'.*stake amount.*'):
2020-01-26 12:33:13 +00:00
setup_optimize_configuration(get_args(args), RunMode.BACKTEST)
2018-06-03 22:48:26 +00:00
2018-04-21 22:19:11 +00:00
def test_start(mocker, fee, default_conf, caplog) -> None:
start_mock = MagicMock()
2018-06-17 20:29:57 +00:00
mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
2018-06-17 20:32:56 +00:00
patch_exchange(mocker)
mocker.patch('freqtrade.optimize.backtesting.Backtesting.start', start_mock)
patched_configuration_load_config_file(mocker, default_conf)
2019-07-11 21:39:42 +00:00
args = [
2019-09-14 11:18:52 +00:00
'backtesting',
'--config', 'config.json',
'--strategy', 'DefaultStrategy',
]
2020-02-10 09:35:48 +00:00
pargs = get_args(args)
start_backtesting(pargs)
assert log_has('Starting freqtrade in Backtesting mode', caplog)
assert start_mock.call_count == 1
@pytest.mark.parametrize("order_types", ORDER_TYPES)
def test_backtesting_init(mocker, default_conf, order_types) -> None:
"""
Check that stoploss_on_exchange is set to False while backtesting
since backtesting assumes a perfect stoploss anyway.
"""
default_conf["order_types"] = order_types
2018-06-17 20:32:56 +00:00
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 backtesting.timeframe == '5m'
assert callable(backtesting.strategy.ohlcvdata_to_dataframe)
2019-09-18 19:57:37 +00:00
assert callable(backtesting.strategy.advise_buy)
assert callable(backtesting.strategy.advise_sell)
assert isinstance(backtesting.strategy.dp, DataProvider)
get_fee.assert_called()
2018-06-23 04:58:25 +00:00
assert backtesting.fee == 0.5
assert not backtesting.strategy.order_types["stoploss_on_exchange"]
def test_backtesting_init_no_ticker_interval(mocker, default_conf, caplog) -> None:
patch_exchange(mocker)
del default_conf['ticker_interval']
default_conf['strategy_list'] = ['DefaultStrategy',
2019-08-27 04:41:07 +00:00
'SampleStrategy']
mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.5))
with pytest.raises(OperationalException):
Backtesting(default_conf)
log_has("Ticker-interval needs to be set in either configuration "
"or as cli argument `--ticker-interval 5m`", caplog)
def test_data_with_fee(default_conf, mocker, testdatadir) -> None:
2019-10-05 13:34:31 +00:00
patch_exchange(mocker)
default_conf['fee'] = 0.1234
fee_mock = mocker.patch('freqtrade.exchange.Exchange.get_fee', MagicMock(return_value=0.5))
backtesting = Backtesting(default_conf)
assert backtesting.fee == 0.1234
assert fee_mock.call_count == 0
def test_data_to_dataframe_bt(default_conf, mocker, testdatadir) -> None:
2018-06-17 20:32:56 +00:00
patch_exchange(mocker)
timerange = TimeRange.parse_timerange('1510694220-1510700340')
data = history.load_data(testdatadir, '1m', ['UNITTEST/BTC'], timerange=timerange,
fill_up_missing=True)
2018-04-21 22:19:11 +00:00
backtesting = Backtesting(default_conf)
processed = backtesting.strategy.ohlcvdata_to_dataframe(data)
assert len(processed['UNITTEST/BTC']) == 102
# Load strategy to compare the result between Backtesting function and strategy are the same
default_conf.update({'strategy': 'DefaultStrategy'})
strategy = StrategyResolver.load_strategy(default_conf)
processed2 = strategy.ohlcvdata_to_dataframe(data)
assert processed['UNITTEST/BTC'].equals(processed2['UNITTEST/BTC'])
2019-09-07 18:56:03 +00:00
def test_backtesting_start(default_conf, mocker, testdatadir, caplog) -> None:
2019-12-17 22:06:03 +00:00
def get_timerange(input1):
return Arrow(2017, 11, 14, 21, 17), Arrow(2017, 11, 14, 22, 59)
2019-12-17 22:06:03 +00:00
mocker.patch('freqtrade.data.history.get_timerange', get_timerange)
2018-06-17 20:32:56 +00:00
patch_exchange(mocker)
2020-01-02 08:31:35 +00:00
mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', MagicMock())
mocker.patch('freqtrade.optimize.backtesting.generate_text_table', MagicMock(return_value=1))
default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
2018-10-16 18:09:12 +00:00
default_conf['ticker_interval'] = '1m'
2019-09-07 18:56:03 +00:00
default_conf['datadir'] = testdatadir
default_conf['export'] = None
default_conf['timerange'] = '-1510694220'
backtesting = Backtesting(default_conf)
backtesting.start()
# check the logs, that will contain the backtest result
exists = [
'Using stake_currency: BTC ...',
'Using stake_amount: 0.001 ...',
'Backtesting with data from 2017-11-14T21:17:00+00:00 '
'up to 2017-11-14T22:59:00+00:00 (0 days)..'
]
for line in exists:
assert log_has(line, caplog)
def test_backtesting_start_no_data(default_conf, mocker, caplog, testdatadir) -> None:
2019-12-17 22:06:03 +00:00
def get_timerange(input1):
return Arrow(2017, 11, 14, 21, 17), Arrow(2017, 11, 14, 22, 59)
mocker.patch('freqtrade.data.history.history_utils.load_pair_history',
MagicMock(return_value=pd.DataFrame()))
2019-12-17 22:06:03 +00:00
mocker.patch('freqtrade.data.history.get_timerange', get_timerange)
2018-06-17 20:32:56 +00:00
patch_exchange(mocker)
2020-01-02 08:31:35 +00:00
mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', MagicMock())
mocker.patch('freqtrade.optimize.backtesting.generate_text_table', MagicMock(return_value=1))
default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
default_conf['ticker_interval'] = "1m"
default_conf['datadir'] = testdatadir
default_conf['export'] = None
default_conf['timerange'] = '20180101-20180102'
backtesting = Backtesting(default_conf)
2019-10-23 18:27:51 +00:00
with pytest.raises(OperationalException, match='No data found. Terminating.'):
backtesting.start()
2019-09-07 18:56:03 +00:00
def test_backtest(default_conf, fee, mocker, testdatadir) -> None:
default_conf['ask_strategy']['use_sell_signal'] = False
2018-06-17 20:29:57 +00:00
mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
2018-06-17 20:32:56 +00:00
patch_exchange(mocker)
2018-04-21 22:19:11 +00:00
backtesting = Backtesting(default_conf)
pair = 'UNITTEST/BTC'
timerange = TimeRange('date', None, 1517227800, 0)
data = history.load_data(datadir=testdatadir, timeframe='5m', pairs=['UNITTEST/BTC'],
timerange=timerange)
processed = backtesting.strategy.ohlcvdata_to_dataframe(data)
min_date, max_date = get_timerange(processed)
results = backtesting.backtest(
processed=processed,
2019-12-13 23:12:44 +00:00
stake_amount=default_conf['stake_amount'],
start_date=min_date,
end_date=max_date,
max_open_trades=10,
position_stacking=False,
)
assert not results.empty
assert len(results) == 2
expected = pd.DataFrame(
{'pair': [pair, pair],
'profit_percent': [0.0, 0.0],
'profit_abs': [0.0, 0.0],
'open_time': pd.to_datetime([Arrow(2018, 1, 29, 18, 40, 0).datetime,
Arrow(2018, 1, 30, 3, 30, 0).datetime], utc=True
),
'close_time': pd.to_datetime([Arrow(2018, 1, 29, 22, 35, 0).datetime,
Arrow(2018, 1, 30, 4, 10, 0).datetime], utc=True),
'open_index': [78, 184],
'close_index': [125, 192],
'trade_duration': [235, 40],
'open_at_end': [False, False],
2018-07-08 18:18:34 +00:00
'open_rate': [0.104445, 0.10302485],
'close_rate': [0.104969, 0.103541],
2018-07-11 18:03:40 +00:00
'sell_reason': [SellType.ROI, SellType.ROI]
})
pd.testing.assert_frame_equal(results, expected)
data_pair = processed[pair]
for _, t in results.iterrows():
ln = data_pair.loc[data_pair["date"] == t["open_time"]]
2018-07-08 18:18:34 +00:00
# Check open trade rate alignes to open rate
assert ln is not None
2018-07-08 18:18:34 +00:00
assert round(ln.iloc[0]["open"], 6) == round(t["open_rate"], 6)
# check close trade rate alignes to close rate or is between high and low
ln = data_pair.loc[data_pair["date"] == t["close_time"]]
assert (round(ln.iloc[0]["open"], 6) == round(t["close_rate"], 6) or
round(ln.iloc[0]["low"], 6) < round(
t["close_rate"], 6) < round(ln.iloc[0]["high"], 6))
2019-09-07 18:56:03 +00:00
def test_backtest_1min_ticker_interval(default_conf, fee, mocker, testdatadir) -> None:
default_conf['ask_strategy']['use_sell_signal'] = False
2018-06-17 20:29:57 +00:00
mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
2018-06-17 20:32:56 +00:00
patch_exchange(mocker)
2018-04-21 22:19:11 +00:00
backtesting = Backtesting(default_conf)
# Run a backtesting for an exiting 1min timeframe
timerange = TimeRange.parse_timerange('1510688220-1510700340')
data = history.load_data(datadir=testdatadir, timeframe='1m', pairs=['UNITTEST/BTC'],
timerange=timerange)
processed = backtesting.strategy.ohlcvdata_to_dataframe(data)
2019-12-17 22:06:03 +00:00
min_date, max_date = get_timerange(processed)
results = backtesting.backtest(
2019-12-13 23:12:44 +00:00
processed=processed,
stake_amount=default_conf['stake_amount'],
start_date=min_date,
end_date=max_date,
max_open_trades=1,
position_stacking=False,
)
assert not results.empty
assert len(results) == 1
2019-09-07 18:56:03 +00:00
def test_processed(default_conf, mocker, testdatadir) -> None:
2018-06-17 20:32:56 +00:00
patch_exchange(mocker)
2018-04-21 22:19:11 +00:00
backtesting = Backtesting(default_conf)
2019-09-07 18:56:03 +00:00
dict_of_tickerrows = load_data_test('raise', testdatadir)
dataframes = backtesting.strategy.ohlcvdata_to_dataframe(dict_of_tickerrows)
dataframe = dataframes['UNITTEST/BTC']
cols = dataframe.columns
# assert the dataframe got some of the indicator columns
for col in ['close', 'high', 'low', 'open', 'date',
'ema10', 'rsi', 'fastd', 'plus_di']:
assert col in cols
2019-09-07 18:56:03 +00:00
def test_backtest_pricecontours(default_conf, fee, mocker, testdatadir) -> None:
# TODO: Evaluate usefullness of this, the patterns and buy-signls are unrealistic
2018-06-17 20:29:57 +00:00
mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
tests = [['raise', 19], ['lower', 0], ['sine', 35]]
for [contour, numres] in tests:
2019-09-07 18:56:03 +00:00
simple_backtest(default_conf, contour, numres, mocker, testdatadir)
2019-09-07 18:56:03 +00:00
def test_backtest_clash_buy_sell(mocker, default_conf, testdatadir):
# Override the default buy trend function in our default_strategy
2018-06-26 05:08:09 +00:00
def fun(dataframe=None, pair=None):
buy_value = 1
sell_value = 1
return _trend(dataframe, buy_value, sell_value)
2019-09-07 18:56:03 +00:00
backtest_conf = _make_backtest_conf(mocker, conf=default_conf, datadir=testdatadir)
2018-04-21 22:19:11 +00:00
backtesting = Backtesting(default_conf)
2019-09-18 19:57:37 +00:00
backtesting.strategy.advise_buy = fun # Override
backtesting.strategy.advise_sell = fun # Override
2019-12-13 23:12:44 +00:00
results = backtesting.backtest(**backtest_conf)
assert results.empty
2019-09-07 18:56:03 +00:00
def test_backtest_only_sell(mocker, default_conf, testdatadir):
# Override the default buy trend function in our default_strategy
2018-06-26 05:08:09 +00:00
def fun(dataframe=None, pair=None):
buy_value = 0
sell_value = 1
return _trend(dataframe, buy_value, sell_value)
2019-09-07 18:56:03 +00:00
backtest_conf = _make_backtest_conf(mocker, conf=default_conf, datadir=testdatadir)
2018-04-21 22:19:11 +00:00
backtesting = Backtesting(default_conf)
2019-09-18 19:57:37 +00:00
backtesting.strategy.advise_buy = fun # Override
backtesting.strategy.advise_sell = fun # Override
2019-12-13 23:12:44 +00:00
results = backtesting.backtest(**backtest_conf)
assert results.empty
2019-09-07 18:56:03 +00:00
def test_backtest_alternate_buy_sell(default_conf, fee, mocker, testdatadir):
2018-06-17 20:29:57 +00:00
mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
2018-11-15 19:02:48 +00:00
mocker.patch('freqtrade.optimize.backtesting.file_dump_json', MagicMock())
2019-09-07 18:56:03 +00:00
backtest_conf = _make_backtest_conf(mocker, conf=default_conf,
pair='UNITTEST/BTC', datadir=testdatadir)
default_conf['ticker_interval'] = '1m'
2018-04-21 22:19:11 +00:00
backtesting = Backtesting(default_conf)
2019-09-18 19:57:37 +00:00
backtesting.strategy.advise_buy = _trend_alternate # Override
backtesting.strategy.advise_sell = _trend_alternate # Override
2019-12-13 23:12:44 +00:00
results = backtesting.backtest(**backtest_conf)
backtesting._store_backtest_result("test_.json", results)
# 200 candles in backtest data
# won't buy on first (shifted by 1)
# 100 buys signals
assert len(results) == 100
# One trade was force-closed at the end
assert len(results.loc[results.open_at_end]) == 0
@pytest.mark.parametrize("pair", ['ADA/BTC', 'LTC/BTC'])
@pytest.mark.parametrize("tres", [0, 20, 30])
2019-09-07 18:56:03 +00:00
def test_backtest_multi_pair(default_conf, fee, mocker, tres, pair, testdatadir):
2018-11-05 19:03:04 +00:00
def _trend_alternate_hold(dataframe=None, metadata=None):
"""
2019-03-26 17:53:16 +00:00
Buy every xth candle - sell every other xth -2 (hold on to pairs a bit)
2018-11-05 19:03:04 +00:00
"""
if metadata['pair'] in('ETH/BTC', 'LTC/BTC'):
multi = 20
else:
multi = 18
2018-11-05 19:03:04 +00:00
dataframe['buy'] = np.where(dataframe.index % multi == 0, 1, 0)
dataframe['sell'] = np.where((dataframe.index + multi - 2) % multi == 0, 1, 0)
return dataframe
mocker.patch('freqtrade.exchange.Exchange.get_fee', fee)
2018-11-06 19:37:59 +00:00
patch_exchange(mocker)
2018-11-05 19:03:04 +00:00
pairs = ['ADA/BTC', 'DASH/BTC', 'ETH/BTC', 'LTC/BTC', 'NXT/BTC']
data = history.load_data(datadir=testdatadir, timeframe='5m', pairs=pairs)
# Only use 500 lines to increase performance
2018-11-05 19:03:04 +00:00
data = trim_dictlist(data, -500)
# Remove data for one pair from the beginning of the data
2019-05-08 18:33:22 +00:00
data[pair] = data[pair][tres:].reset_index()
2018-11-05 19:03:04 +00:00
default_conf['ticker_interval'] = '5m'
backtesting = Backtesting(default_conf)
2019-09-18 19:57:37 +00:00
backtesting.strategy.advise_buy = _trend_alternate_hold # Override
backtesting.strategy.advise_sell = _trend_alternate_hold # Override
2018-11-05 19:03:04 +00:00
processed = backtesting.strategy.ohlcvdata_to_dataframe(data)
min_date, max_date = get_timerange(processed)
2018-11-05 19:03:04 +00:00
backtest_conf = {
'processed': processed,
2019-12-13 23:12:44 +00:00
'stake_amount': default_conf['stake_amount'],
2018-11-05 19:03:04 +00:00
'start_date': min_date,
'end_date': max_date,
2019-12-13 23:12:44 +00:00
'max_open_trades': 3,
'position_stacking': False,
2018-11-05 19:03:04 +00:00
}
2019-12-13 23:12:44 +00:00
results = backtesting.backtest(**backtest_conf)
2018-11-05 19:03:04 +00:00
# Make sure we have parallel trades
assert len(evaluate_result_multi(results, '5m', 2)) > 0
2018-11-05 19:03:04 +00:00
# make sure we don't have trades with more than configured max_open_trades
assert len(evaluate_result_multi(results, '5m', 3)) == 0
2018-11-05 19:03:04 +00:00
backtest_conf = {
'processed': processed,
2019-12-13 23:12:44 +00:00
'stake_amount': default_conf['stake_amount'],
2018-11-05 19:03:04 +00:00
'start_date': min_date,
'end_date': max_date,
2019-12-13 23:12:44 +00:00
'max_open_trades': 1,
'position_stacking': False,
2018-11-05 19:03:04 +00:00
}
2019-12-13 23:12:44 +00:00
results = backtesting.backtest(**backtest_conf)
assert len(evaluate_result_multi(results, '5m', 1)) == 0
2018-11-05 19:03:04 +00:00
2018-04-21 22:19:11 +00:00
def test_backtest_record(default_conf, fee, mocker):
names = []
records = []
2018-06-17 20:32:56 +00:00
patch_exchange(mocker)
2018-06-17 20:29:57 +00:00
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))
)
2018-04-21 22:19:11 +00:00
backtesting = Backtesting(default_conf)
results = pd.DataFrame({"pair": ["UNITTEST/BTC", "UNITTEST/BTC",
"UNITTEST/BTC", "UNITTEST/BTC"],
"profit_percent": [0.003312, 0.010801, 0.013803, 0.002780],
"profit_abs": [0.000003, 0.000011, 0.000014, 0.000003],
"open_time": [Arrow(2017, 11, 14, 19, 32, 00).datetime,
Arrow(2017, 11, 14, 21, 36, 00).datetime,
Arrow(2017, 11, 14, 22, 12, 00).datetime,
Arrow(2017, 11, 14, 22, 44, 00).datetime],
"close_time": [Arrow(2017, 11, 14, 21, 35, 00).datetime,
Arrow(2017, 11, 14, 22, 10, 00).datetime,
Arrow(2017, 11, 14, 22, 43, 00).datetime,
Arrow(2017, 11, 14, 22, 58, 00).datetime],
"open_rate": [0.002543, 0.003003, 0.003089, 0.003214],
"close_rate": [0.002546, 0.003014, 0.003103, 0.003217],
"open_index": [1, 119, 153, 185],
"close_index": [118, 151, 184, 199],
"trade_duration": [123, 34, 31, 14],
2018-07-11 18:32:56 +00:00
"open_at_end": [False, False, False, True],
"sell_reason": [SellType.ROI, SellType.STOP_LOSS,
SellType.ROI, SellType.FORCE_SELL]
})
backtesting._store_backtest_result("backtest-result.json", results)
2018-06-10 11:25:52 +00:00
assert len(results) == 4
# Assert file_dump_json was only called once
assert names == ['backtest-result.json']
records = records[0]
# Ensure records are of correct type
2018-06-10 11:25:52 +00:00
assert len(records) == 4
2018-07-28 20:00:12 +00:00
# reset test to test with strategy name
names = []
records = []
backtesting._store_backtest_result(Path("backtest-result.json"), results, "DefStrat")
2018-07-28 20:00:12 +00:00
assert len(results) == 4
# Assert file_dump_json was only called once
assert names == [Path('backtest-result-DefStrat.json')]
2018-07-28 20:00:12 +00:00
records = records[0]
# Ensure records are of correct type
assert len(records) == 4
# ('UNITTEST/BTC', 0.00331158, '1510684320', '1510691700', 0, 117)
# Below follows just a typecheck of the schema/type of trade-records
oix = None
for (pair, profit, date_buy, date_sell, buy_index, dur,
2018-07-11 18:32:56 +00:00
openr, closer, open_at_end, sell_reason) in records:
assert pair == 'UNITTEST/BTC'
assert isinstance(profit, float)
# FIX: buy/sell should be converted to ints
assert isinstance(date_buy, float)
assert isinstance(date_sell, float)
assert isinstance(openr, float)
assert isinstance(closer, float)
assert isinstance(open_at_end, bool)
2018-07-11 18:32:56 +00:00
assert isinstance(sell_reason, str)
isinstance(buy_index, pd._libs.tslib.Timestamp)
if oix:
assert buy_index > oix
oix = buy_index
assert dur > 0
2019-09-08 07:54:15 +00:00
def test_backtest_start_timerange(default_conf, mocker, caplog, testdatadir):
default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
2019-12-27 09:29:06 +00:00
patch_exchange(mocker)
mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', MagicMock())
2020-01-02 08:31:35 +00:00
mocker.patch('freqtrade.optimize.backtesting.generate_text_table', MagicMock())
patched_configuration_load_config_file(mocker, default_conf)
args = [
2019-09-14 11:18:52 +00:00
'backtesting',
'--config', 'config.json',
'--strategy', 'DefaultStrategy',
2019-09-08 07:54:15 +00:00
'--datadir', str(testdatadir),
'--ticker-interval', '1m',
'--timerange', '1510694220-1510700340',
2018-07-17 19:05:03 +00:00
'--enable-position-stacking',
'--disable-max-market-positions'
]
args = get_args(args)
start_backtesting(args)
# check the logs, that will contain the backtest result
exists = [
2019-04-24 19:24:00 +00:00
'Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
2018-07-17 19:05:03 +00:00
'Ignoring max_open_trades (--disable-max-market-positions was used) ...',
'Parameter --timerange detected: 1510694220-1510700340 ...',
2019-09-08 07:54:15 +00:00
f'Using data directory: {testdatadir} ...',
'Using stake_currency: BTC ...',
'Using stake_amount: 0.001 ...',
2019-10-23 18:27:51 +00:00
'Loading data from 2017-11-14T20:57:00+00:00 '
'up to 2017-11-14T22:58:00+00:00 (0 days)..',
2019-10-23 18:27:51 +00:00
'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 ...'
]
for line in exists:
assert log_has(line, caplog)
2018-07-28 05:55:59 +00:00
2019-09-08 07:54:15 +00:00
def test_backtest_start_multi_strat(default_conf, mocker, caplog, testdatadir):
2018-07-31 19:08:03 +00:00
default_conf['exchange']['pair_whitelist'] = ['UNITTEST/BTC']
2019-12-27 09:29:06 +00:00
patch_exchange(mocker)
2018-07-28 05:55:59 +00:00
backtestmock = MagicMock()
mocker.patch('freqtrade.optimize.backtesting.Backtesting.backtest', backtestmock)
gen_table_mock = MagicMock()
2020-01-02 08:31:35 +00:00
mocker.patch('freqtrade.optimize.backtesting.generate_text_table', gen_table_mock)
2018-07-29 11:07:30 +00:00
gen_strattable_mock = MagicMock()
2020-01-02 08:31:35 +00:00
mocker.patch('freqtrade.optimize.backtesting.generate_text_table_strategy', gen_strattable_mock)
patched_configuration_load_config_file(mocker, default_conf)
2018-07-28 05:55:59 +00:00
args = [
2019-09-14 11:18:52 +00:00
'backtesting',
2018-07-28 05:55:59 +00:00
'--config', 'config.json',
2019-09-08 07:54:15 +00:00
'--datadir', str(testdatadir),
2020-02-19 06:15:55 +00:00
'--strategy-path', str(Path(__file__).parents[1] / 'strategy/strats'),
2018-07-28 05:55:59 +00:00
'--ticker-interval', '1m',
'--timerange', '1510694220-1510700340',
2018-07-28 05:55:59 +00:00
'--enable-position-stacking',
'--disable-max-market-positions',
'--strategy-list',
'DefaultStrategy',
2020-02-19 18:42:04 +00:00
'TestStrategyLegacy',
2018-07-28 05:55:59 +00:00
]
args = get_args(args)
start_backtesting(args)
2018-07-28 05:55:59 +00:00
# 2 backtests, 4 tables
assert backtestmock.call_count == 2
assert gen_table_mock.call_count == 4
2018-07-29 11:07:30 +00:00
assert gen_strattable_mock.call_count == 1
2018-07-28 05:55:59 +00:00
# check the logs, that will contain the backtest result
exists = [
2019-04-24 19:24:00 +00:00
'Parameter -i/--ticker-interval detected ... Using ticker_interval: 1m ...',
2018-07-28 05:55:59 +00:00
'Ignoring max_open_trades (--disable-max-market-positions was used) ...',
'Parameter --timerange detected: 1510694220-1510700340 ...',
2019-09-08 07:54:15 +00:00
f'Using data directory: {testdatadir} ...',
2018-07-28 05:55:59 +00:00
'Using stake_currency: BTC ...',
'Using stake_amount: 0.001 ...',
2019-10-23 18:27:51 +00:00
'Loading data from 2017-11-14T20:57:00+00:00 '
'up to 2017-11-14T22:58:00+00:00 (0 days)..',
2019-10-23 18:27:51 +00:00
'Backtesting with data from 2017-11-14T21:17:00+00:00 '
'up to 2017-11-14T22:58:00+00:00 (0 days)..',
2018-07-28 05:55:59 +00:00
'Parameter --enable-position-stacking detected ...',
'Running backtesting for Strategy DefaultStrategy',
2020-02-19 18:42:04 +00:00
'Running backtesting for Strategy TestStrategyLegacy',
2018-07-28 05:55:59 +00:00
]
for line in exists:
assert log_has(line, caplog)