freqtrade_origin/freqtrade/tests/optimize/test_backtesting.py

202 lines
7.9 KiB
Python
Raw Normal View History

# pragma pylint: disable=missing-docstring,W0212
2018-01-05 09:23:12 +00:00
import logging
import math
2017-12-26 06:05:49 +00:00
import pandas as pd
2018-01-24 10:05:27 +00:00
import pytest
2018-01-05 09:23:12 +00:00
from unittest.mock import MagicMock
from freqtrade import exchange, optimize
from freqtrade.exchange import Bittrex
2018-01-02 19:32:11 +00:00
from freqtrade.optimize import preprocess
2017-12-26 06:05:49 +00:00
from freqtrade.optimize.backtesting import backtest, generate_text_table, get_timeframe
2018-01-05 09:23:12 +00:00
import freqtrade.optimize.backtesting as backtesting
2018-01-24 09:32:52 +00:00
from freqtrade.strategy.strategy import Strategy
2018-01-24 10:05:27 +00:00
@pytest.fixture
def default_strategy():
2018-01-24 09:32:52 +00:00
strategy = Strategy()
strategy.init({'strategy': 'default_strategy'})
return strategy
2017-12-16 02:39:47 +00:00
2018-01-17 17:19:39 +00:00
def trim_dictlist(dl, num):
new = {}
for pair, pair_data in dl.items():
new[pair] = pair_data[num:]
return new
2017-12-26 06:05:49 +00:00
def test_generate_text_table():
results = pd.DataFrame(
{
'currency': ['BTC_ETH', 'BTC_ETH'],
'profit_percent': [0.1, 0.2],
'profit_BTC': [0.2, 0.4],
2018-01-03 10:30:24 +00:00
'duration': [10, 30],
2018-01-03 10:35:54 +00:00
'profit': [2, 0],
'loss': [0, 0]
2017-12-26 06:05:49 +00:00
}
)
2018-01-02 14:40:33 +00:00
print(generate_text_table({'BTC_ETH': {}}, results, 'BTC', 5))
2017-12-26 06:05:49 +00:00
assert generate_text_table({'BTC_ETH': {}}, results, 'BTC', 5) == (
2018-01-03 16:36:40 +00:00
'pair buy count avg profit % total profit BTC avg duration profit loss\n' # noqa
'------- ----------- -------------- ------------------ -------------- -------- ------\n' # noqa
'BTC_ETH 2 15.00 0.60000000 100.0 2 0\n' # noqa
'TOTAL 2 15.00 0.60000000 100.0 2 0') # noqa
2017-12-26 06:05:49 +00:00
2018-01-24 10:05:27 +00:00
def test_get_timeframe(default_strategy):
2018-01-03 16:36:40 +00:00
data = preprocess(optimize.load_data(
None, ticker_interval=1, pairs=['BTC_UNITEST']))
2017-12-26 06:05:49 +00:00
min_date, max_date = get_timeframe(data)
assert min_date.isoformat() == '2017-11-04T23:02:00+00:00'
assert max_date.isoformat() == '2017-11-14T22:59:00+00:00'
2018-01-24 10:05:27 +00:00
def test_backtest(default_strategy, default_conf, mocker):
mocker.patch.dict('freqtrade.main._CONF', default_conf)
exchange._API = Bittrex({'key': '', 'secret': ''})
data = optimize.load_data(None, ticker_interval=5, pairs=['BTC_ETH'])
2018-01-17 17:19:39 +00:00
data = trim_dictlist(data, -200)
2018-01-11 16:45:41 +00:00
results = backtest({'stake_amount': default_conf['stake_amount'],
'processed': optimize.preprocess(data),
'max_open_trades': 10,
'realistic': True})
assert not results.empty
2018-01-24 10:05:27 +00:00
def test_backtest_1min_ticker_interval(default_strategy, default_conf, mocker):
mocker.patch.dict('freqtrade.main._CONF', default_conf)
exchange._API = Bittrex({'key': '', 'secret': ''})
# Run a backtesting for an exiting 5min ticker_interval
data = optimize.load_data(None, ticker_interval=1, pairs=['BTC_UNITEST'])
2018-01-17 17:19:39 +00:00
data = trim_dictlist(data, -200)
2018-01-11 16:45:41 +00:00
results = backtest({'stake_amount': default_conf['stake_amount'],
'processed': optimize.preprocess(data),
'max_open_trades': 1,
'realistic': True})
assert not results.empty
def load_data_test(what):
2018-01-15 21:25:02 +00:00
timerange = ((None, 'line'), None, -100)
data = optimize.load_data(None, ticker_interval=1, pairs=['BTC_UNITEST'], timerange=timerange)
pair = data['BTC_UNITEST']
datalen = len(pair)
# Depending on the what parameter we now adjust the
# loaded data looks:
# pair :: [{'O': 0.123, 'H': 0.123, 'L': 0.123,
# 'C': 0.123, 'V': 123.123,
# 'T': '2017-11-04T23:02:00', 'BV': 0.123}]
base = 0.001
if what == 'raise':
return {'BTC_UNITEST':
2018-01-03 16:36:40 +00:00
[{'T': pair[x]['T'], # Keep old dates
'V': pair[x]['V'], # Keep old volume
'BV': pair[x]['BV'], # keep too
2018-01-03 16:36:40 +00:00
'O': x * base, # But replace O,H,L,C
'H': x * base + 0.0001,
'L': x * base - 0.0001,
'C': x * base} for x in range(0, datalen)]}
if what == 'lower':
return {'BTC_UNITEST':
[{'T': pair[x]['T'], # Keep old dates
'V': pair[x]['V'], # Keep old volume
'BV': pair[x]['BV'], # keep too
'O': 1 - x * base, # But replace O,H,L,C
'H': 1 - x * base + 0.0001,
'L': 1 - x * base - 0.0001,
'C': 1 - x * base} for x in range(0, datalen)]}
if what == 'sine':
hz = 0.1 # frequency
return {'BTC_UNITEST':
[{'T': pair[x]['T'], # Keep old dates
'V': pair[x]['V'], # Keep old volume
'BV': pair[x]['BV'], # keep too
2018-01-03 16:36:40 +00:00
# But replace O,H,L,C
'O': math.sin(x * hz) / 1000 + base,
'H': math.sin(x * hz) / 1000 + base + 0.0001,
'L': math.sin(x * hz) / 1000 + base - 0.0001,
'C': math.sin(x * hz) / 1000 + base} for x in range(0, datalen)]}
return data
def simple_backtest(config, contour, num_results):
data = load_data_test(contour)
processed = optimize.preprocess(data)
assert isinstance(processed, dict)
2018-01-11 16:45:41 +00:00
results = backtest({'stake_amount': config['stake_amount'],
'processed': processed,
'max_open_trades': 1,
'realistic': True})
# results :: <class 'pandas.core.frame.DataFrame'>
assert len(results) == num_results
# Test backtest on offline data
# loaded by freqdata/optimize/__init__.py::load_data()
2018-01-24 10:05:27 +00:00
def test_backtest2(default_conf, mocker, default_strategy):
mocker.patch.dict('freqtrade.main._CONF', default_conf)
data = optimize.load_data(None, ticker_interval=5, pairs=['BTC_ETH'])
2018-01-17 17:19:39 +00:00
data = trim_dictlist(data, -200)
2018-01-11 16:45:41 +00:00
results = backtest({'stake_amount': default_conf['stake_amount'],
'processed': optimize.preprocess(data),
'max_open_trades': 10,
'realistic': True})
assert not results.empty
2018-01-24 10:05:27 +00:00
def test_processed(default_conf, mocker, default_strategy):
mocker.patch.dict('freqtrade.main._CONF', default_conf)
dict_of_tickerrows = load_data_test('raise')
dataframes = optimize.preprocess(dict_of_tickerrows)
dataframe = dataframes['BTC_UNITEST']
cols = dataframe.columns
# assert the dataframe got some of the indicator columns
for col in ['close', 'high', 'low', 'open', 'date',
'ema50', 'ao', 'macd', 'plus_dm']:
assert col in cols
2018-01-24 10:05:27 +00:00
def test_backtest_pricecontours(default_conf, mocker, default_strategy):
mocker.patch.dict('freqtrade.main._CONF', default_conf)
tests = [['raise', 17], ['lower', 0], ['sine', 17]]
for [contour, numres] in tests:
simple_backtest(default_conf, contour, numres)
2018-01-05 09:23:12 +00:00
2018-01-15 21:25:02 +00:00
def mocked_load_data(datadir, pairs=[], ticker_interval=0, refresh_pairs=False, timerange=None):
tickerdata = optimize.load_tickerdata_file(datadir, 'BTC_UNITEST', 1, timerange=timerange)
2018-01-05 09:23:12 +00:00
pairdata = {'BTC_UNITEST': tickerdata}
2018-01-15 21:25:02 +00:00
return pairdata
2018-01-05 09:23:12 +00:00
def test_backtest_start(default_conf, mocker, caplog):
default_conf['exchange']['pair_whitelist'] = ['BTC_UNITEST']
mocker.patch.dict('freqtrade.main._CONF', default_conf)
mocker.patch('freqtrade.misc.load_config', new=lambda s: default_conf)
mocker.patch.multiple('freqtrade.optimize',
load_data=mocked_load_data)
args = MagicMock()
args.ticker_interval = 1
args.level = 10
args.live = False
args.datadir = None
2018-01-11 14:45:39 +00:00
args.export = None
2018-01-15 21:25:02 +00:00
args.timerange = '-100' # needed due to MagicMock malleability
2018-01-05 09:23:12 +00:00
backtesting.start(args)
# check the logs, that will contain the backtest result
exists = ['Using max_open_trades: 1 ...',
'Using stake_amount: 0.001 ...',
2018-01-26 09:25:35 +00:00
'Measuring data from 2017-11-14T21:17:00+00:00 '
'up to 2017-11-14T22:59:00+00:00 (0 days)..']
2018-01-05 09:23:12 +00:00
for line in exists:
assert ('freqtrade.optimize.backtesting',
logging.INFO,
line) in caplog.record_tuples