Move tests out of freqtrade module

tests/strategy/legacy_strategy.py

@@ -0,0 +1,235 @@
+
+# --- Do not remove these libs ---
+from freqtrade.strategy.interface import IStrategy
+from pandas import DataFrame
+# --------------------------------
+
+# Add your lib to import here
+import talib.abstract as ta
+import freqtrade.vendor.qtpylib.indicators as qtpylib
+import numpy  # noqa
+
+
+# This class is a sample. Feel free to customize it.
+class TestStrategyLegacy(IStrategy):
+    """
+    This is a test strategy using the legacy function headers, which will be
+    removed in a future update.
+    Please do not use this as a template, but refer to user_data/strategy/sample_strategy.py
+    for a uptodate version of this template.
+
+    """
+
+    # Minimal ROI designed for the strategy.
+    # This attribute will be overridden if the config file contains "minimal_roi"
+    minimal_roi = {
+        "40": 0.0,
+        "30": 0.01,
+        "20": 0.02,
+        "0": 0.04
+    }
+
+    # Optimal stoploss designed for the strategy
+    # This attribute will be overridden if the config file contains "stoploss"
+    stoploss = -0.10
+
+    # Optimal ticker interval for the strategy
+    ticker_interval = '5m'
+
+    def populate_indicators(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Adds several different TA indicators to the given DataFrame
+
+        Performance Note: For the best performance be frugal on the number of indicators
+        you are using. Let uncomment only the indicator you are using in your strategies
+        or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
+        """
+
+        # Momentum Indicator
+        # ------------------------------------
+
+        # ADX
+        dataframe['adx'] = ta.ADX(dataframe)
+
+        """
+        # Awesome oscillator
+        dataframe['ao'] = qtpylib.awesome_oscillator(dataframe)
+
+        # Commodity Channel Index: values Oversold:<-100, Overbought:>100
+        dataframe['cci'] = ta.CCI(dataframe)
+
+        # MACD
+        macd = ta.MACD(dataframe)
+        dataframe['macd'] = macd['macd']
+        dataframe['macdsignal'] = macd['macdsignal']
+        dataframe['macdhist'] = macd['macdhist']
+
+        # MFI
+        dataframe['mfi'] = ta.MFI(dataframe)
+
+        # Minus Directional Indicator / Movement
+        dataframe['minus_dm'] = ta.MINUS_DM(dataframe)
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+
+        # Plus Directional Indicator / Movement
+        dataframe['plus_dm'] = ta.PLUS_DM(dataframe)
+        dataframe['plus_di'] = ta.PLUS_DI(dataframe)
+        dataframe['minus_di'] = ta.MINUS_DI(dataframe)
+
+        # ROC
+        dataframe['roc'] = ta.ROC(dataframe)
+
+        # RSI
+        dataframe['rsi'] = ta.RSI(dataframe)
+
+        # Inverse Fisher transform on RSI, values [-1.0, 1.0] (https://goo.gl/2JGGoy)
+        rsi = 0.1 * (dataframe['rsi'] - 50)
+        dataframe['fisher_rsi'] = (numpy.exp(2 * rsi) - 1) / (numpy.exp(2 * rsi) + 1)
+
+        # Inverse Fisher transform on RSI normalized, value [0.0, 100.0] (https://goo.gl/2JGGoy)
+        dataframe['fisher_rsi_norma'] = 50 * (dataframe['fisher_rsi'] + 1)
+
+        # Stoch
+        stoch = ta.STOCH(dataframe)
+        dataframe['slowd'] = stoch['slowd']
+        dataframe['slowk'] = stoch['slowk']
+
+        # Stoch fast
+        stoch_fast = ta.STOCHF(dataframe)
+        dataframe['fastd'] = stoch_fast['fastd']
+        dataframe['fastk'] = stoch_fast['fastk']
+
+        # Stoch RSI
+        stoch_rsi = ta.STOCHRSI(dataframe)
+        dataframe['fastd_rsi'] = stoch_rsi['fastd']
+        dataframe['fastk_rsi'] = stoch_rsi['fastk']
+        """
+
+        # Overlap Studies
+        # ------------------------------------
+
+        # Bollinger bands
+        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
+        dataframe['bb_lowerband'] = bollinger['lower']
+        dataframe['bb_middleband'] = bollinger['mid']
+        dataframe['bb_upperband'] = bollinger['upper']
+
+        """
+        # EMA - Exponential Moving Average
+        dataframe['ema3'] = ta.EMA(dataframe, timeperiod=3)
+        dataframe['ema5'] = ta.EMA(dataframe, timeperiod=5)
+        dataframe['ema10'] = ta.EMA(dataframe, timeperiod=10)
+        dataframe['ema50'] = ta.EMA(dataframe, timeperiod=50)
+        dataframe['ema100'] = ta.EMA(dataframe, timeperiod=100)
+
+        # SAR Parabol
+        dataframe['sar'] = ta.SAR(dataframe)
+
+        # SMA - Simple Moving Average
+        dataframe['sma'] = ta.SMA(dataframe, timeperiod=40)
+        """
+
+        # TEMA - Triple Exponential Moving Average
+        dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)
+
+        # Cycle Indicator
+        # ------------------------------------
+        # Hilbert Transform Indicator - SineWave
+        hilbert = ta.HT_SINE(dataframe)
+        dataframe['htsine'] = hilbert['sine']
+        dataframe['htleadsine'] = hilbert['leadsine']
+
+        # Pattern Recognition - Bullish candlestick patterns
+        # ------------------------------------
+        """
+        # Hammer: values [0, 100]
+        dataframe['CDLHAMMER'] = ta.CDLHAMMER(dataframe)
+        # Inverted Hammer: values [0, 100]
+        dataframe['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(dataframe)
+        # Dragonfly Doji: values [0, 100]
+        dataframe['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(dataframe)
+        # Piercing Line: values [0, 100]
+        dataframe['CDLPIERCING'] = ta.CDLPIERCING(dataframe) # values [0, 100]
+        # Morningstar: values [0, 100]
+        dataframe['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(dataframe) # values [0, 100]
+        # Three White Soldiers: values [0, 100]
+        dataframe['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(dataframe) # values [0, 100]
+        """
+
+        # Pattern Recognition - Bearish candlestick patterns
+        # ------------------------------------
+        """
+        # Hanging Man: values [0, 100]
+        dataframe['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(dataframe)
+        # Shooting Star: values [0, 100]
+        dataframe['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(dataframe)
+        # Gravestone Doji: values [0, 100]
+        dataframe['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(dataframe)
+        # Dark Cloud Cover: values [0, 100]
+        dataframe['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(dataframe)
+        # Evening Doji Star: values [0, 100]
+        dataframe['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(dataframe)
+        # Evening Star: values [0, 100]
+        dataframe['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(dataframe)
+        """
+
+        # Pattern Recognition - Bullish/Bearish candlestick patterns
+        # ------------------------------------
+        """
+        # Three Line Strike: values [0, -100, 100]
+        dataframe['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(dataframe)
+        # Spinning Top: values [0, -100, 100]
+        dataframe['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(dataframe) # values [0, -100, 100]
+        # Engulfing: values [0, -100, 100]
+        dataframe['CDLENGULFING'] = ta.CDLENGULFING(dataframe) # values [0, -100, 100]
+        # Harami: values [0, -100, 100]
+        dataframe['CDLHARAMI'] = ta.CDLHARAMI(dataframe) # values [0, -100, 100]
+        # Three Outside Up/Down: values [0, -100, 100]
+        dataframe['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(dataframe) # values [0, -100, 100]
+        # Three Inside Up/Down: values [0, -100, 100]
+        dataframe['CDL3INSIDE'] = ta.CDL3INSIDE(dataframe) # values [0, -100, 100]
+        """
+
+        # Chart type
+        # ------------------------------------
+        """
+        # Heikinashi stategy
+        heikinashi = qtpylib.heikinashi(dataframe)
+        dataframe['ha_open'] = heikinashi['open']
+        dataframe['ha_close'] = heikinashi['close']
+        dataframe['ha_high'] = heikinashi['high']
+        dataframe['ha_low'] = heikinashi['low']
+        """
+
+        return dataframe
+
+    def populate_buy_trend(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Based on TA indicators, populates the buy signal for the given dataframe
+        :param dataframe: DataFrame
+        :return: DataFrame with buy column
+        """
+        dataframe.loc[
+            (
+                (dataframe['adx'] > 30) &
+                (dataframe['tema'] <= dataframe['bb_middleband']) &
+                (dataframe['tema'] > dataframe['tema'].shift(1))
+            ),
+            'buy'] = 1
+
+        return dataframe
+
+    def populate_sell_trend(self, dataframe: DataFrame) -> DataFrame:
+        """
+        Based on TA indicators, populates the sell signal for the given dataframe
+        :param dataframe: DataFrame
+        :return: DataFrame with buy column
+        """
+        dataframe.loc[
+            (
+                (dataframe['adx'] > 70) &
+                (dataframe['tema'] > dataframe['bb_middleband']) &
+                (dataframe['tema'] < dataframe['tema'].shift(1))
+            ),
+            'sell'] = 1
+        return dataframe

tests/strategy/test_default_strategy.py

@@ -0,0 +1,36 @@
+import json
+
+import pytest
+from pandas import DataFrame
+
+from freqtrade.data.converter import parse_ticker_dataframe
+from freqtrade.strategy.default_strategy import DefaultStrategy
+
+
+@pytest.fixture
+def result():
+    with open('freqtrade/tests/testdata/ETH_BTC-1m.json') as data_file:
+        return parse_ticker_dataframe(json.load(data_file), '1m', pair="UNITTEST/BTC",
+                                      fill_missing=True)
+
+
+def test_default_strategy_structure():
+    assert hasattr(DefaultStrategy, 'minimal_roi')
+    assert hasattr(DefaultStrategy, 'stoploss')
+    assert hasattr(DefaultStrategy, 'ticker_interval')
+    assert hasattr(DefaultStrategy, 'populate_indicators')
+    assert hasattr(DefaultStrategy, 'populate_buy_trend')
+    assert hasattr(DefaultStrategy, 'populate_sell_trend')
+
+
+def test_default_strategy(result):
+    strategy = DefaultStrategy({})
+
+    metadata = {'pair': 'ETH/BTC'}
+    assert type(strategy.minimal_roi) is dict
+    assert type(strategy.stoploss) is float
+    assert type(strategy.ticker_interval) is str
+    indicators = strategy.populate_indicators(result, metadata)
+    assert type(indicators) is DataFrame
+    assert type(strategy.populate_buy_trend(indicators, metadata)) is DataFrame
+    assert type(strategy.populate_sell_trend(indicators, metadata)) is DataFrame

tests/strategy/test_interface.py

@@ -0,0 +1,304 @@
+# pragma pylint: disable=missing-docstring, C0103
+
+import logging
+from unittest.mock import MagicMock
+
+import arrow
+from pandas import DataFrame
+
+from freqtrade.configuration import TimeRange
+from freqtrade.data.converter import parse_ticker_dataframe
+from freqtrade.data.history import load_tickerdata_file
+from freqtrade.persistence import Trade
+from freqtrade.tests.conftest import get_patched_exchange, log_has
+from freqtrade.strategy.default_strategy import DefaultStrategy
+
+# Avoid to reinit the same object again and again
+_STRATEGY = DefaultStrategy(config={})
+
+
+def test_returns_latest_buy_signal(mocker, default_conf, ticker_history):
+    mocker.patch.object(
+        _STRATEGY, '_analyze_ticker_internal',
+        return_value=DataFrame([{'buy': 1, 'sell': 0, 'date': arrow.utcnow()}])
+    )
+    assert _STRATEGY.get_signal('ETH/BTC', '5m', ticker_history) == (True, False)
+
+    mocker.patch.object(
+        _STRATEGY, '_analyze_ticker_internal',
+        return_value=DataFrame([{'buy': 0, 'sell': 1, 'date': arrow.utcnow()}])
+    )
+    assert _STRATEGY.get_signal('ETH/BTC', '5m', ticker_history) == (False, True)
+
+
+def test_returns_latest_sell_signal(mocker, default_conf, ticker_history):
+    mocker.patch.object(
+        _STRATEGY, '_analyze_ticker_internal',
+        return_value=DataFrame([{'sell': 1, 'buy': 0, 'date': arrow.utcnow()}])
+    )
+
+    assert _STRATEGY.get_signal('ETH/BTC', '5m', ticker_history) == (False, True)
+
+    mocker.patch.object(
+        _STRATEGY, '_analyze_ticker_internal',
+        return_value=DataFrame([{'sell': 0, 'buy': 1, 'date': arrow.utcnow()}])
+    )
+    assert _STRATEGY.get_signal('ETH/BTC', '5m', ticker_history) == (True, False)
+
+
+def test_get_signal_empty(default_conf, mocker, caplog):
+    assert (False, False) == _STRATEGY.get_signal('foo', default_conf['ticker_interval'],
+                                                  DataFrame())
+    assert log_has('Empty ticker history for pair foo', caplog)
+    caplog.clear()
+
+    assert (False, False) == _STRATEGY.get_signal('bar', default_conf['ticker_interval'],
+                                                  [])
+    assert log_has('Empty ticker history for pair bar', caplog)
+
+
+def test_get_signal_exception_valueerror(default_conf, mocker, caplog, ticker_history):
+    caplog.set_level(logging.INFO)
+    mocker.patch.object(
+        _STRATEGY, '_analyze_ticker_internal',
+        side_effect=ValueError('xyz')
+    )
+    assert (False, False) == _STRATEGY.get_signal('foo', default_conf['ticker_interval'],
+                                                  ticker_history)
+    assert log_has('Unable to analyze ticker for pair foo: xyz', caplog)
+
+
+def test_get_signal_empty_dataframe(default_conf, mocker, caplog, ticker_history):
+    caplog.set_level(logging.INFO)
+    mocker.patch.object(
+        _STRATEGY, '_analyze_ticker_internal',
+        return_value=DataFrame([])
+    )
+    assert (False, False) == _STRATEGY.get_signal('xyz', default_conf['ticker_interval'],
+                                                  ticker_history)
+    assert log_has('Empty dataframe for pair xyz', caplog)
+
+
+def test_get_signal_old_dataframe(default_conf, mocker, caplog, ticker_history):
+    caplog.set_level(logging.INFO)
+    # default_conf defines a 5m interval. we check interval * 2 + 5m
+    # this is necessary as the last candle is removed (partial candles) by default
+    oldtime = arrow.utcnow().shift(minutes=-16)
+    ticks = DataFrame([{'buy': 1, 'date': oldtime}])
+    mocker.patch.object(
+        _STRATEGY, '_analyze_ticker_internal',
+        return_value=DataFrame(ticks)
+    )
+    assert (False, False) == _STRATEGY.get_signal('xyz', default_conf['ticker_interval'],
+                                                  ticker_history)
+    assert log_has('Outdated history for pair xyz. Last tick is 16 minutes old', caplog)
+
+
+def test_get_signal_handles_exceptions(mocker, default_conf):
+    exchange = get_patched_exchange(mocker, default_conf)
+    mocker.patch.object(
+        _STRATEGY, 'analyze_ticker',
+        side_effect=Exception('invalid ticker history ')
+    )
+    assert _STRATEGY.get_signal(exchange, 'ETH/BTC', '5m') == (False, False)
+
+
+def test_tickerdata_to_dataframe(default_conf, testdatadir) -> None:
+    strategy = DefaultStrategy(default_conf)
+
+    timerange = TimeRange(None, 'line', 0, -100)
+    tick = load_tickerdata_file(testdatadir, 'UNITTEST/BTC', '1m', timerange=timerange)
+    tickerlist = {'UNITTEST/BTC': parse_ticker_dataframe(tick, '1m', pair="UNITTEST/BTC",
+                                                         fill_missing=True)}
+    data = strategy.tickerdata_to_dataframe(tickerlist)
+    assert len(data['UNITTEST/BTC']) == 102       # partial candle was removed
+
+
+def test_min_roi_reached(default_conf, fee) -> None:
+
+    # Use list to confirm sequence does not matter
+    min_roi_list = [{20: 0.05, 55: 0.01, 0: 0.1},
+                    {0: 0.1, 20: 0.05, 55: 0.01}]
+    for roi in min_roi_list:
+        strategy = DefaultStrategy(default_conf)
+        strategy.minimal_roi = roi
+        trade = Trade(
+            pair='ETH/BTC',
+            stake_amount=0.001,
+            open_date=arrow.utcnow().shift(hours=-1).datetime,
+            fee_open=fee.return_value,
+            fee_close=fee.return_value,
+            exchange='bittrex',
+            open_rate=1,
+        )
+
+        assert not strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-56).datetime)
+        assert strategy.min_roi_reached(trade, 0.12, arrow.utcnow().shift(minutes=-56).datetime)
+
+        assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-39).datetime)
+        assert strategy.min_roi_reached(trade, 0.06, arrow.utcnow().shift(minutes=-39).datetime)
+
+        assert not strategy.min_roi_reached(trade, -0.01, arrow.utcnow().shift(minutes=-1).datetime)
+        assert strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-1).datetime)
+
+
+def test_min_roi_reached2(default_conf, fee) -> None:
+
+    # test with ROI raising after last interval
+    min_roi_list = [{20: 0.07,
+                     30: 0.05,
+                     55: 0.30,
+                     0: 0.1
+                     },
+                    {0: 0.1,
+                     20: 0.07,
+                     30: 0.05,
+                     55: 0.30
+                     },
+                    ]
+    for roi in min_roi_list:
+        strategy = DefaultStrategy(default_conf)
+        strategy.minimal_roi = roi
+        trade = Trade(
+            pair='ETH/BTC',
+            stake_amount=0.001,
+            open_date=arrow.utcnow().shift(hours=-1).datetime,
+            fee_open=fee.return_value,
+            fee_close=fee.return_value,
+            exchange='bittrex',
+            open_rate=1,
+        )
+
+        assert not strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-56).datetime)
+        assert strategy.min_roi_reached(trade, 0.12, arrow.utcnow().shift(minutes=-56).datetime)
+
+        assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-39).datetime)
+        assert strategy.min_roi_reached(trade, 0.071, arrow.utcnow().shift(minutes=-39).datetime)
+
+        assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-26).datetime)
+        assert strategy.min_roi_reached(trade, 0.06, arrow.utcnow().shift(minutes=-26).datetime)
+
+        # Should not trigger with 20% profit since after 55 minutes only 30% is active.
+        assert not strategy.min_roi_reached(trade, 0.20, arrow.utcnow().shift(minutes=-2).datetime)
+        assert strategy.min_roi_reached(trade, 0.31, arrow.utcnow().shift(minutes=-2).datetime)
+
+
+def test_min_roi_reached3(default_conf, fee) -> None:
+
+    # test for issue #1948
+    min_roi = {20: 0.07,
+               30: 0.05,
+               55: 0.30,
+               }
+    strategy = DefaultStrategy(default_conf)
+    strategy.minimal_roi = min_roi
+    trade = Trade(
+            pair='ETH/BTC',
+            stake_amount=0.001,
+            open_date=arrow.utcnow().shift(hours=-1).datetime,
+            fee_open=fee.return_value,
+            fee_close=fee.return_value,
+            exchange='bittrex',
+            open_rate=1,
+    )
+
+    assert not strategy.min_roi_reached(trade, 0.02, arrow.utcnow().shift(minutes=-56).datetime)
+    assert not strategy.min_roi_reached(trade, 0.12, arrow.utcnow().shift(minutes=-56).datetime)
+
+    assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-39).datetime)
+    assert strategy.min_roi_reached(trade, 0.071, arrow.utcnow().shift(minutes=-39).datetime)
+
+    assert not strategy.min_roi_reached(trade, 0.04, arrow.utcnow().shift(minutes=-26).datetime)
+    assert strategy.min_roi_reached(trade, 0.06, arrow.utcnow().shift(minutes=-26).datetime)
+
+    # Should not trigger with 20% profit since after 55 minutes only 30% is active.
+    assert not strategy.min_roi_reached(trade, 0.20, arrow.utcnow().shift(minutes=-2).datetime)
+    assert strategy.min_roi_reached(trade, 0.31, arrow.utcnow().shift(minutes=-2).datetime)
+
+
+def test_analyze_ticker_default(ticker_history, mocker, caplog) -> None:
+    caplog.set_level(logging.DEBUG)
+    ind_mock = MagicMock(side_effect=lambda x, meta: x)
+    buy_mock = MagicMock(side_effect=lambda x, meta: x)
+    sell_mock = MagicMock(side_effect=lambda x, meta: x)
+    mocker.patch.multiple(
+        'freqtrade.strategy.interface.IStrategy',
+        advise_indicators=ind_mock,
+        advise_buy=buy_mock,
+        advise_sell=sell_mock,
+
+    )
+    strategy = DefaultStrategy({})
+    strategy.analyze_ticker(ticker_history, {'pair': 'ETH/BTC'})
+    assert ind_mock.call_count == 1
+    assert buy_mock.call_count == 1
+    assert buy_mock.call_count == 1
+
+    assert log_has('TA Analysis Launched', caplog)
+    assert not log_has('Skipping TA Analysis for already analyzed candle', caplog)
+    caplog.clear()
+
+    strategy.analyze_ticker(ticker_history, {'pair': 'ETH/BTC'})
+    # No analysis happens as process_only_new_candles is true
+    assert ind_mock.call_count == 2
+    assert buy_mock.call_count == 2
+    assert buy_mock.call_count == 2
+    assert log_has('TA Analysis Launched', caplog)
+    assert not log_has('Skipping TA Analysis for already analyzed candle', caplog)
+
+
+def test__analyze_ticker_internal_skip_analyze(ticker_history, mocker, caplog) -> None:
+    caplog.set_level(logging.DEBUG)
+    ind_mock = MagicMock(side_effect=lambda x, meta: x)
+    buy_mock = MagicMock(side_effect=lambda x, meta: x)
+    sell_mock = MagicMock(side_effect=lambda x, meta: x)
+    mocker.patch.multiple(
+        'freqtrade.strategy.interface.IStrategy',
+        advise_indicators=ind_mock,
+        advise_buy=buy_mock,
+        advise_sell=sell_mock,
+
+    )
+    strategy = DefaultStrategy({})
+    strategy.process_only_new_candles = True
+
+    ret = strategy._analyze_ticker_internal(ticker_history, {'pair': 'ETH/BTC'})
+    assert 'high' in ret.columns
+    assert 'low' in ret.columns
+    assert 'close' in ret.columns
+    assert isinstance(ret, DataFrame)
+    assert ind_mock.call_count == 1
+    assert buy_mock.call_count == 1
+    assert buy_mock.call_count == 1
+    assert log_has('TA Analysis Launched', caplog)
+    assert not log_has('Skipping TA Analysis for already analyzed candle', caplog)
+    caplog.clear()
+
+    ret = strategy._analyze_ticker_internal(ticker_history, {'pair': 'ETH/BTC'})
+    # No analysis happens as process_only_new_candles is true
+    assert ind_mock.call_count == 1
+    assert buy_mock.call_count == 1
+    assert buy_mock.call_count == 1
+    # only skipped analyze adds buy and sell columns, otherwise it's all mocked
+    assert 'buy' in ret.columns
+    assert 'sell' in ret.columns
+    assert ret['buy'].sum() == 0
+    assert ret['sell'].sum() == 0
+    assert not log_has('TA Analysis Launched', caplog)
+    assert log_has('Skipping TA Analysis for already analyzed candle', caplog)
+
+
+def test_is_pair_locked(default_conf):
+    strategy = DefaultStrategy(default_conf)
+    # dict should be empty
+    assert not strategy._pair_locked_until
+
+    pair = 'ETH/BTC'
+    assert not strategy.is_pair_locked(pair)
+    strategy.lock_pair(pair, arrow.utcnow().shift(minutes=4).datetime)
+    # ETH/BTC locked for 4 minutes
+    assert strategy.is_pair_locked(pair)
+
+    # XRP/BTC should not be locked now
+    pair = 'XRP/BTC'
+    assert not strategy.is_pair_locked(pair)

tests/strategy/test_strategy.py

@@ -0,0 +1,385 @@
+# pragma pylint: disable=missing-docstring, protected-access, C0103
+import logging
+import tempfile
+import warnings
+from base64 import urlsafe_b64encode
+from os import path
+from pathlib import Path
+
+import pytest
+from pandas import DataFrame
+
+from freqtrade import OperationalException
+from freqtrade.resolvers import StrategyResolver
+from freqtrade.strategy.interface import IStrategy
+from freqtrade.tests.conftest import log_has, log_has_re
+
+
+def test_search_strategy():
+    default_config = {}
+    default_location = Path(__file__).parent.parent.parent.joinpath('strategy').resolve()
+
+    s, _ = StrategyResolver._search_object(
+        directory=default_location,
+        object_type=IStrategy,
+        kwargs={'config': default_config},
+        object_name='DefaultStrategy'
+    )
+    assert isinstance(s, IStrategy)
+
+    s, _ = StrategyResolver._search_object(
+        directory=default_location,
+        object_type=IStrategy,
+        kwargs={'config': default_config},
+        object_name='NotFoundStrategy'
+    )
+    assert s is None
+
+
+def test_load_strategy(default_conf, result):
+    default_conf.update({'strategy': 'SampleStrategy'})
+    resolver = StrategyResolver(default_conf)
+    assert 'adx' in resolver.strategy.advise_indicators(result, {'pair': 'ETH/BTC'})
+
+
+def test_load_strategy_base64(result, caplog, default_conf):
+    with open("user_data/strategies/sample_strategy.py", "rb") as file:
+        encoded_string = urlsafe_b64encode(file.read()).decode("utf-8")
+    default_conf.update({'strategy': 'SampleStrategy:{}'.format(encoded_string)})
+
+    resolver = StrategyResolver(default_conf)
+    assert 'adx' in resolver.strategy.advise_indicators(result, {'pair': 'ETH/BTC'})
+    # Make sure strategy was loaded from base64 (using temp directory)!!
+    assert log_has_re(r"Using resolved strategy SampleStrategy from '"
+                      + tempfile.gettempdir() + r"/.*/SampleStrategy\.py'\.\.\.", caplog)
+
+
+def test_load_strategy_invalid_directory(result, caplog, default_conf):
+    resolver = StrategyResolver(default_conf)
+    extra_dir = Path.cwd() / 'some/path'
+    resolver._load_strategy('SampleStrategy', config=default_conf, extra_dir=extra_dir)
+
+    assert log_has_re(r'Path .*' + r'some.*path.*' + r'.* does not exist', caplog)
+
+    assert 'adx' in resolver.strategy.advise_indicators(result, {'pair': 'ETH/BTC'})
+
+
+def test_load_not_found_strategy(default_conf):
+    strategy = StrategyResolver(default_conf)
+    with pytest.raises(OperationalException,
+                       match=r"Impossible to load Strategy 'NotFoundStrategy'. "
+                             r"This class does not exist or contains Python code errors."):
+        strategy._load_strategy(strategy_name='NotFoundStrategy', config=default_conf)
+
+
+def test_strategy(result, default_conf):
+    default_conf.update({'strategy': 'DefaultStrategy'})
+
+    resolver = StrategyResolver(default_conf)
+    metadata = {'pair': 'ETH/BTC'}
+    assert resolver.strategy.minimal_roi[0] == 0.04
+    assert default_conf["minimal_roi"]['0'] == 0.04
+
+    assert resolver.strategy.stoploss == -0.10
+    assert default_conf['stoploss'] == -0.10
+
+    assert resolver.strategy.ticker_interval == '5m'
+    assert default_conf['ticker_interval'] == '5m'
+
+    df_indicators = resolver.strategy.advise_indicators(result, metadata=metadata)
+    assert 'adx' in df_indicators
+
+    dataframe = resolver.strategy.advise_buy(df_indicators, metadata=metadata)
+    assert 'buy' in dataframe.columns
+
+    dataframe = resolver.strategy.advise_sell(df_indicators, metadata=metadata)
+    assert 'sell' in dataframe.columns
+
+
+def test_strategy_override_minimal_roi(caplog, default_conf):
+    caplog.set_level(logging.INFO)
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'minimal_roi': {
+            "0": 0.5
+        }
+    })
+    resolver = StrategyResolver(default_conf)
+
+    assert resolver.strategy.minimal_roi[0] == 0.5
+    assert log_has("Override strategy 'minimal_roi' with value in config file: {'0': 0.5}.", caplog)
+
+
+def test_strategy_override_stoploss(caplog, default_conf):
+    caplog.set_level(logging.INFO)
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'stoploss': -0.5
+    })
+    resolver = StrategyResolver(default_conf)
+
+    assert resolver.strategy.stoploss == -0.5
+    assert log_has("Override strategy 'stoploss' with value in config file: -0.5.", caplog)
+
+
+def test_strategy_override_trailing_stop(caplog, default_conf):
+    caplog.set_level(logging.INFO)
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'trailing_stop': True
+    })
+    resolver = StrategyResolver(default_conf)
+
+    assert resolver.strategy.trailing_stop
+    assert isinstance(resolver.strategy.trailing_stop, bool)
+    assert log_has("Override strategy 'trailing_stop' with value in config file: True.", caplog)
+
+
+def test_strategy_override_trailing_stop_positive(caplog, default_conf):
+    caplog.set_level(logging.INFO)
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'trailing_stop_positive': -0.1,
+        'trailing_stop_positive_offset': -0.2
+
+    })
+    resolver = StrategyResolver(default_conf)
+
+    assert resolver.strategy.trailing_stop_positive == -0.1
+    assert log_has("Override strategy 'trailing_stop_positive' with value in config file: -0.1.",
+                   caplog)
+
+    assert resolver.strategy.trailing_stop_positive_offset == -0.2
+    assert log_has("Override strategy 'trailing_stop_positive' with value in config file: -0.1.",
+                   caplog)
+
+
+def test_strategy_override_ticker_interval(caplog, default_conf):
+    caplog.set_level(logging.INFO)
+
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'ticker_interval': 60,
+        'stake_currency': 'ETH'
+    })
+    resolver = StrategyResolver(default_conf)
+
+    assert resolver.strategy.ticker_interval == 60
+    assert resolver.strategy.stake_currency == 'ETH'
+    assert log_has("Override strategy 'ticker_interval' with value in config file: 60.",
+                   caplog)
+
+
+def test_strategy_override_process_only_new_candles(caplog, default_conf):
+    caplog.set_level(logging.INFO)
+
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'process_only_new_candles': True
+    })
+    resolver = StrategyResolver(default_conf)
+
+    assert resolver.strategy.process_only_new_candles
+    assert log_has("Override strategy 'process_only_new_candles' with value in config file: True.",
+                   caplog)
+
+
+def test_strategy_override_order_types(caplog, default_conf):
+    caplog.set_level(logging.INFO)
+
+    order_types = {
+        'buy': 'market',
+        'sell': 'limit',
+        'stoploss': 'limit',
+        'stoploss_on_exchange': True,
+    }
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'order_types': order_types
+    })
+    resolver = StrategyResolver(default_conf)
+
+    assert resolver.strategy.order_types
+    for method in ['buy', 'sell', 'stoploss', 'stoploss_on_exchange']:
+        assert resolver.strategy.order_types[method] == order_types[method]
+
+    assert log_has("Override strategy 'order_types' with value in config file:"
+                   " {'buy': 'market', 'sell': 'limit', 'stoploss': 'limit',"
+                   " 'stoploss_on_exchange': True}.", caplog)
+
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'order_types': {'buy': 'market'}
+    })
+    # Raise error for invalid configuration
+    with pytest.raises(ImportError,
+                       match=r"Impossible to load Strategy 'DefaultStrategy'. "
+                             r"Order-types mapping is incomplete."):
+        StrategyResolver(default_conf)
+
+
+def test_strategy_override_order_tif(caplog, default_conf):
+    caplog.set_level(logging.INFO)
+
+    order_time_in_force = {
+        'buy': 'fok',
+        'sell': 'gtc',
+    }
+
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'order_time_in_force': order_time_in_force
+    })
+    resolver = StrategyResolver(default_conf)
+
+    assert resolver.strategy.order_time_in_force
+    for method in ['buy', 'sell']:
+        assert resolver.strategy.order_time_in_force[method] == order_time_in_force[method]
+
+    assert log_has("Override strategy 'order_time_in_force' with value in config file:"
+                   " {'buy': 'fok', 'sell': 'gtc'}.", caplog)
+
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'order_time_in_force': {'buy': 'fok'}
+    })
+    # Raise error for invalid configuration
+    with pytest.raises(ImportError,
+                       match=r"Impossible to load Strategy 'DefaultStrategy'. "
+                             r"Order-time-in-force mapping is incomplete."):
+        StrategyResolver(default_conf)
+
+
+def test_strategy_override_use_sell_signal(caplog, default_conf):
+    caplog.set_level(logging.INFO)
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+    })
+    resolver = StrategyResolver(default_conf)
+    assert not resolver.strategy.use_sell_signal
+    assert isinstance(resolver.strategy.use_sell_signal, bool)
+    # must be inserted to configuration
+    assert 'use_sell_signal' in default_conf['experimental']
+    assert not default_conf['experimental']['use_sell_signal']
+
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'experimental': {
+            'use_sell_signal': True,
+        },
+    })
+    resolver = StrategyResolver(default_conf)
+
+    assert resolver.strategy.use_sell_signal
+    assert isinstance(resolver.strategy.use_sell_signal, bool)
+    assert log_has("Override strategy 'use_sell_signal' with value in config file: True.", caplog)
+
+
+def test_strategy_override_use_sell_profit_only(caplog, default_conf):
+    caplog.set_level(logging.INFO)
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+    })
+    resolver = StrategyResolver(default_conf)
+    assert not resolver.strategy.sell_profit_only
+    assert isinstance(resolver.strategy.sell_profit_only, bool)
+    # must be inserted to configuration
+    assert 'sell_profit_only' in default_conf['experimental']
+    assert not default_conf['experimental']['sell_profit_only']
+
+    default_conf.update({
+        'strategy': 'DefaultStrategy',
+        'experimental': {
+            'sell_profit_only': True,
+        },
+    })
+    resolver = StrategyResolver(default_conf)
+
+    assert resolver.strategy.sell_profit_only
+    assert isinstance(resolver.strategy.sell_profit_only, bool)
+    assert log_has("Override strategy 'sell_profit_only' with value in config file: True.", caplog)
+
+
+@pytest.mark.filterwarnings("ignore:deprecated")
+def test_deprecate_populate_indicators(result, default_conf):
+    default_location = path.join(path.dirname(path.realpath(__file__)))
+    default_conf.update({'strategy': 'TestStrategyLegacy',
+                         'strategy_path': default_location})
+    resolver = StrategyResolver(default_conf)
+    with warnings.catch_warnings(record=True) as w:
+        # Cause all warnings to always be triggered.
+        warnings.simplefilter("always")
+        indicators = resolver.strategy.advise_indicators(result, {'pair': 'ETH/BTC'})
+        assert len(w) == 1
+        assert issubclass(w[-1].category, DeprecationWarning)
+        assert "deprecated - check out the Sample strategy to see the current function headers!" \
+            in str(w[-1].message)
+
+    with warnings.catch_warnings(record=True) as w:
+        # Cause all warnings to always be triggered.
+        warnings.simplefilter("always")
+        resolver.strategy.advise_buy(indicators, {'pair': 'ETH/BTC'})
+        assert len(w) == 1
+        assert issubclass(w[-1].category, DeprecationWarning)
+        assert "deprecated - check out the Sample strategy to see the current function headers!" \
+            in str(w[-1].message)
+
+    with warnings.catch_warnings(record=True) as w:
+        # Cause all warnings to always be triggered.
+        warnings.simplefilter("always")
+        resolver.strategy.advise_sell(indicators, {'pair': 'ETH_BTC'})
+        assert len(w) == 1
+        assert issubclass(w[-1].category, DeprecationWarning)
+        assert "deprecated - check out the Sample strategy to see the current function headers!" \
+            in str(w[-1].message)
+
+
+@pytest.mark.filterwarnings("ignore:deprecated")
+def test_call_deprecated_function(result, monkeypatch, default_conf):
+    default_location = path.join(path.dirname(path.realpath(__file__)))
+    default_conf.update({'strategy': 'TestStrategyLegacy',
+                         'strategy_path': default_location})
+    resolver = StrategyResolver(default_conf)
+    metadata = {'pair': 'ETH/BTC'}
+
+    # Make sure we are using a legacy function
+    assert resolver.strategy._populate_fun_len == 2
+    assert resolver.strategy._buy_fun_len == 2
+    assert resolver.strategy._sell_fun_len == 2
+    assert resolver.strategy.INTERFACE_VERSION == 1
+
+    indicator_df = resolver.strategy.advise_indicators(result, metadata=metadata)
+    assert isinstance(indicator_df, DataFrame)
+    assert 'adx' in indicator_df.columns
+
+    buydf = resolver.strategy.advise_buy(result, metadata=metadata)
+    assert isinstance(buydf, DataFrame)
+    assert 'buy' in buydf.columns
+
+    selldf = resolver.strategy.advise_sell(result, metadata=metadata)
+    assert isinstance(selldf, DataFrame)
+    assert 'sell' in selldf
+
+
+def test_strategy_interface_versioning(result, monkeypatch, default_conf):
+    default_conf.update({'strategy': 'DefaultStrategy'})
+    resolver = StrategyResolver(default_conf)
+    metadata = {'pair': 'ETH/BTC'}
+
+    # Make sure we are using a legacy function
+    assert resolver.strategy._populate_fun_len == 3
+    assert resolver.strategy._buy_fun_len == 3
+    assert resolver.strategy._sell_fun_len == 3
+    assert resolver.strategy.INTERFACE_VERSION == 2
+
+    indicator_df = resolver.strategy.advise_indicators(result, metadata=metadata)
+    assert isinstance(indicator_df, DataFrame)
+    assert 'adx' in indicator_df.columns
+
+    buydf = resolver.strategy.advise_buy(result, metadata=metadata)
+    assert isinstance(buydf, DataFrame)
+    assert 'buy' in buydf.columns
+
+    selldf = resolver.strategy.advise_sell(result, metadata=metadata)
+    assert isinstance(selldf, DataFrame)
+    assert 'sell' in selldf