From f48f5d0f31de205e274303ed5aef14d595b7ab1b Mon Sep 17 00:00:00 2001 From: kryofly Date: Thu, 28 Dec 2017 15:58:02 +0100 Subject: [PATCH] tests for dataframe, whitelist and backtesting --- freqtrade/tests/optimize/test_backtesting.py | 104 +++++++++++++++++++ freqtrade/tests/test_acl_pair.py | 83 +++++++++++++++ freqtrade/tests/test_dataframe.py | 27 +++++ 3 files changed, 214 insertions(+) create mode 100644 freqtrade/tests/test_acl_pair.py create mode 100644 freqtrade/tests/test_dataframe.py diff --git a/freqtrade/tests/optimize/test_backtesting.py b/freqtrade/tests/optimize/test_backtesting.py index 99f95d9bf..e4405fb4c 100644 --- a/freqtrade/tests/optimize/test_backtesting.py +++ b/freqtrade/tests/optimize/test_backtesting.py @@ -1,5 +1,6 @@ # pragma pylint: disable=missing-docstring,W0212 +import math import os import pandas as pd from freqtrade import exchange, optimize @@ -120,3 +121,106 @@ def test_download_backtesting_testdata(default_conf, ticker_history, mocker): if os.path.isfile(file2): os.remove(file2) + + +def trim_dataframe(df, num): + new = dict() + for pair, pair_data in df.items(): + new[pair] = pair_data[-num:] # last 50 rows + return new + +def load_data_test(what): + data = optimize.load_data(ticker_interval=1, pairs=['BTC_UNITEST']) + data = trim_dataframe(data, -40) + pair = data['BTC_UNITEST'] + + # Depending on the what parameter we now adjust the + # loaded data: + # 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}] + if what == 'raise': + o = h = l = c = 0.001 + l -= 0.0001 + h += 0.0001 + for frame in pair: + o += 0.0001 + h += 0.0001 + l += 0.0001 + c += 0.0001 + o = round(o,9) # round to satoshis + h = round(h,9) + l = round(l,9) + c = round(c,9) + frame['O'] = o + frame['H'] = h + frame['L'] = l + frame['C'] = c + if what == 'lower': + o = h = l = c = 0.001 + l -= 0.0001 + h += 0.0001 + for frame in pair: + o -= 0.0001 + h -= 0.0001 + l -= 0.0001 + c -= 0.0001 + o = round(o,9) # round to satoshis + h = round(h,9) + l = round(l,9) + c = round(c,9) + frame['O'] = o + frame['H'] = h + frame['L'] = l + frame['C'] = c + if what == 'sine': + i = 0 + o = h = l = c = (2 + math.sin(i/10)) / 1000 + h += 0.0001 + l -= 0.0001 + for frame in pair: + o = (2 + math.sin(i/10)) / 1000 + h = (2 + math.sin(i/10)) / 1000 + 0.0001 + l = (2 + math.sin(i/10)) / 1000 - 0.0001 + c = (2 + math.sin(i/10)) / 1000 - 0.000001 + + o = round(o,9) # round to satoshis + h = round(h,9) + l = round(l,9) + c = round(c,9) + frame['O'] = o + frame['H'] = h + frame['L'] = l + frame['C'] = c + i += 1 + return data + +def simple_backtest(config, contour, num_results): + data = load_data_test(contour) + processed = optimize.preprocess(data) + assert isinstance(processed, dict) + results = backtest(config['stake_amount'], processed, 1, True) + # results :: + assert len(results) == num_results + +# Test backtest on offline data +# loaded by freqdata/optimize/__init__.py::load_data() + +def test_backtest(default_conf, mocker): + mocker.patch.dict('freqtrade.main._CONF', default_conf) + data = optimize.load_data(ticker_interval=5, pairs=['BTC_ETH']) + results = backtest(default_conf['stake_amount'], optimize.preprocess(data), 10, True) + num_resutls = len(results) + assert num_resutls > 0 + +def test_processed(default_conf, mocker): + mocker.patch.dict('freqtrade.main._CONF', default_conf) + data = load_data_test('raise') + processed = optimize.preprocess(data) + +def test_raise(default_conf, mocker): + mocker.patch.dict('freqtrade.main._CONF', default_conf) + tests = [['raise', 359], ['lower', 0], ['sine', 1734]] + for [contour, numres] in tests: + simple_backtest(default_conf, contour, numres) + + + diff --git a/freqtrade/tests/test_acl_pair.py b/freqtrade/tests/test_acl_pair.py new file mode 100644 index 000000000..b1e57755c --- /dev/null +++ b/freqtrade/tests/test_acl_pair.py @@ -0,0 +1,83 @@ + +# whitelist, blacklist, filtering, all of that will +# eventually become some rules to run on a generic ACL engine + +# perhaps try to anticipate that by using some python package + +import pytest +from unittest.mock import MagicMock +import copy + +from freqtrade.main import refresh_whitelist +#from freqtrade.exchange import Exchanges +from freqtrade import exchange + +# "deep equal" +def assert_list_equal (l1, l2): + for pair in l1: + assert pair in l2 + for pair in l2: + assert pair in l1 + +def whitelist_conf(): + return { + "stake_currency":"BTC", + "exchange": { + "pair_whitelist": [ + "BTC_ETH", + "BTC_TKN", + "BTC_TRST", + "BTC_SWT", + "BTC_BCC" + ], + }, + } + +def get_health(): + return [{'Currency': 'ETH', + 'IsActive': True + }, + {'Currency': 'TKN', + 'IsActive': True + }] + +def get_health_empty(): + return [] + +# below three test could be merged into a single +# test that ran randomlly generated health lists + +def test_refresh_whitelist(mocker): + conf = whitelist_conf() + mocker.patch.dict('freqtrade.main._CONF', conf) + mocker.patch.multiple('freqtrade.main.exchange', + get_wallet_health=get_health) + # no argument: use the whitelist provided by config + refresh_whitelist() + whitelist = ['BTC_ETH', 'BTC_TKN'] + pairslist = conf['exchange']['pair_whitelist'] + # Ensure all except those in whitelist are removed + assert_list_equal(whitelist, pairslist) + +def test_refresh_whitelist_dynamic(mocker): + conf = whitelist_conf() + mocker.patch.dict('freqtrade.main._CONF', conf) + mocker.patch.multiple('freqtrade.main.exchange', + get_wallet_health=get_health) + # argument: use the whitelist dynamically by exchange-volume + whitelist = ['BTC_ETH', 'BTC_TKN'] + refresh_whitelist(whitelist) + pairslist = conf['exchange']['pair_whitelist'] + assert_list_equal(whitelist, pairslist) + +def test_refresh_whitelist_dynamic_empty(mocker): + conf = whitelist_conf() + mocker.patch.dict('freqtrade.main._CONF', conf) + mocker.patch.multiple('freqtrade.main.exchange', + get_wallet_health=get_health_empty) + # argument: use the whitelist dynamically by exchange-volume + whitelist = [] + conf['exchange']['pair_whitelist'] = [] + refresh_whitelist(whitelist) + pairslist = conf['exchange']['pair_whitelist'] + assert_list_equal(whitelist, pairslist) diff --git a/freqtrade/tests/test_dataframe.py b/freqtrade/tests/test_dataframe.py new file mode 100644 index 000000000..58d1474fd --- /dev/null +++ b/freqtrade/tests/test_dataframe.py @@ -0,0 +1,27 @@ + +import pytest +import pandas + +from freqtrade import analyze +import freqtrade.optimize +from pandas import DataFrame + +_pairs = ['BTC_ETH'] + +def load_dataframe_pair(pairs): + ld = freqtrade.optimize.load_data(ticker_interval=5, pairs=pairs) + assert isinstance(ld, dict) + assert isinstance(pairs[0], str) + dataframe = ld[pairs[0]] + dataframe = analyze.analyze_ticker(dataframe) + return dataframe + +def test_dataframe_load(): + dataframe = load_dataframe_pair(_pairs) + assert isinstance(dataframe, pandas.core.frame.DataFrame) + +def test_dataframe_columns_exists(): + dataframe = load_dataframe_pair(_pairs) + assert 'high' in dataframe.columns + assert 'low' in dataframe.columns + assert 'close' in dataframe.columns