move project into freqtrade/

freqtrade/tests/test_analyze.py

@@ -0,0 +1,52 @@
+# pragma pylint: disable=missing-docstring
+import unittest
+from unittest.mock import patch
+
+import arrow
+from pandas import DataFrame
+
+from freqtrade.analyze import parse_ticker_dataframe, populate_buy_trend, populate_indicators, \
+    get_buy_signal
+
+RESULT_BITTREX = {
+    'success': True,
+    'message': '',
+    'result': [
+        {'O': 0.00065311, 'H': 0.00065311, 'L': 0.00065311, 'C': 0.00065311, 'V': 22.17210568, 'T': '2017-08-30T10:40:00', 'BV': 0.01448082},
+        {'O': 0.00066194, 'H': 0.00066195, 'L': 0.00066194, 'C': 0.00066195, 'V': 33.4727437, 'T': '2017-08-30T10:34:00', 'BV': 0.02215696},
+        {'O': 0.00065311, 'H': 0.00065311, 'L': 0.00065311, 'C': 0.00065311, 'V': 53.85127609, 'T': '2017-08-30T10:37:00', 'BV': 0.0351708},
+        {'O': 0.00066194, 'H': 0.00066194, 'L': 0.00065311, 'C': 0.00065311, 'V': 46.29210665, 'T': '2017-08-30T10:42:00', 'BV': 0.03063118},
+    ]
+}
+
+class TestAnalyze(unittest.TestCase):
+    def setUp(self):
+        self.result = parse_ticker_dataframe(RESULT_BITTREX['result'], arrow.get('2017-08-30T10:00:00'))
+
+    def test_1_dataframe_has_correct_columns(self):
+        self.assertEqual(self.result.columns.tolist(),
+                         ['close', 'high', 'low', 'open', 'date', 'volume'])
+
+    def test_2_orders_by_date(self):
+        self.assertEqual(self.result['date'].tolist(),
+                         ['2017-08-30T10:34:00',
+                          '2017-08-30T10:37:00',
+                          '2017-08-30T10:40:00',
+                          '2017-08-30T10:42:00'])
+
+    def test_3_populates_buy_trend(self):
+        dataframe = populate_buy_trend(populate_indicators(self.result))
+        self.assertTrue('buy' in dataframe.columns)
+        self.assertTrue('buy_price' in dataframe.columns)
+
+    def test_4_returns_latest_buy_signal(self):
+        buydf = DataFrame([{'buy': 1, 'date': arrow.utcnow()}])
+        with patch('freqtrade.analyze.analyze_ticker', return_value=buydf):
+            self.assertEqual(get_buy_signal('BTC-ETH'), True)
+        buydf = DataFrame([{'buy': 0, 'date': arrow.utcnow()}])
+        with patch('freqtrade.analyze.analyze_ticker', return_value=buydf):
+            self.assertEqual(get_buy_signal('BTC-ETH'), False)
+
+
+if __name__ == '__main__':
+    unittest.main()

freqtrade/tests/test_backtesting.py

@@ -0,0 +1,75 @@
+# pragma pylint: disable=missing-docstring
+import json
+import logging
+import os
+import unittest
+from unittest.mock import patch
+
+import arrow
+from pandas import DataFrame
+
+from freqtrade.analyze import analyze_ticker
+from freqtrade.main import should_sell
+from freqtrade.persistence import Trade
+
+
+def print_results(results):
+    print('Made {} buys. Average profit {:.2f}%. Total profit was {:.3f}. Average duration {:.1f} mins.'.format(
+        len(results.index),
+        results.profit.mean() * 100.0,
+        results.profit.sum(),
+        results.duration.mean()*5
+    ))
+
+class TestMain(unittest.TestCase):
+    pairs = ['btc-neo', 'btc-eth', 'btc-omg', 'btc-edg', 'btc-pay', 'btc-pivx', 'btc-qtum', 'btc-mtl', 'btc-etc', 'btc-ltc']
+    conf = {
+        "minimal_roi": {
+            "60":  0.0,
+            "40":  0.01,
+            "20":  0.02,
+            "0":  0.03
+        },
+        "stoploss": -0.40
+    }
+
+    @classmethod
+    def setUpClass(cls):
+        logging.disable(logging.DEBUG) # disable debug logs that slow backtesting a lot
+
+    @unittest.skipIf(not os.environ.get('BACKTEST', False), "slow, should be run manually")
+    def test_backtest(self):
+        trades = []
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            for pair in self.pairs:
+                with open('testdata/'+pair+'.json') as data_file:
+                    data = json.load(data_file)
+
+                    with patch('freqtrade.analyze.get_ticker', return_value=data):
+                        with patch('arrow.utcnow', return_value=arrow.get('2017-08-20T14:50:00')):
+                            ticker = analyze_ticker(pair)
+                            # for each buy point
+                            for index, row in ticker[ticker.buy == 1].iterrows():
+                                trade = Trade(
+                                    open_rate=row['close'],
+                                    open_date=arrow.get(row['date']).datetime,
+                                    amount=1,
+                                )
+                                # calculate win/lose forwards from buy point
+                                for index2, row2 in ticker[index:].iterrows():
+                                    if should_sell(trade, row2['close'], arrow.get(row2['date']).datetime):
+                                        current_profit = (row2['close'] - trade.open_rate) / trade.open_rate
+
+                                        trades.append((pair, current_profit, index2 - index))
+                                        break
+            
+        labels = ['currency', 'profit', 'duration']
+        results = DataFrame.from_records(trades, columns=labels)
+
+        print('====================== BACKTESTING REPORT ================================')
+
+        for pair in self.pairs:
+            print('For currency {}:'.format(pair))
+            print_results(results[results.currency == pair])
+        print('TOTAL OVER ALL TRADES:')
+        print_results(results)

freqtrade/tests/test_main.py

@@ -0,0 +1,115 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+from jsonschema import validate
+
+from freqtrade import exchange
+from freqtrade.main import create_trade, handle_trade, close_trade_if_fulfilled, init, \
+    get_target_bid
+from freqtrade.misc import CONF_SCHEMA
+from freqtrade.persistence import Trade
+
+
+class TestMain(unittest.TestCase):
+    conf = {
+        "max_open_trades": 3,
+        "stake_currency": "BTC",
+        "stake_amount": 0.05,
+        "dry_run": True,
+        "minimal_roi": {
+            "2880": 0.005,
+            "720": 0.01,
+            "0": 0.02
+        },
+        "bid_strategy": {
+            "ask_last_balance": 0.0
+        },
+        "bittrex": {
+            "enabled": True,
+            "key": "key",
+            "secret": "secret",
+            "pair_whitelist": [
+                "BTC_ETH"
+            ]
+        },
+        "telegram": {
+            "enabled": True,
+            "token": "token",
+            "chat_id": "chat_id"
+        }
+    }
+
+    def test_1_create_trade(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True) as buy_signal:
+                with patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock()):
+                    with patch.multiple('freqtrade.main.exchange',
+                                        get_ticker=MagicMock(return_value={
+                                            'bid': 0.07256061,
+                                            'ask': 0.072661,
+                                            'last': 0.07256061
+                                        }),
+                                        buy=MagicMock(return_value='mocked_order_id')):
+                        init(self.conf, 'sqlite://')
+                        trade = create_trade(15.0, exchange.Exchange.BITTREX)
+                        Trade.session.add(trade)
+                        Trade.session.flush()
+                        self.assertIsNotNone(trade)
+                        self.assertEqual(trade.open_rate, 0.072661)
+                        self.assertEqual(trade.pair, 'BTC_ETH')
+                        self.assertEqual(trade.exchange, exchange.Exchange.BITTREX)
+                        self.assertEqual(trade.amount, 206.43811673387373)
+                        self.assertEqual(trade.stake_amount, 15.0)
+                        self.assertEqual(trade.is_open, True)
+                        self.assertIsNotNone(trade.open_date)
+                        buy_signal.assert_called_once_with('BTC_ETH')
+
+    def test_2_handle_trade(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch.multiple('freqtrade.main.telegram', init=MagicMock(), send_msg=MagicMock()):
+                with patch.multiple('freqtrade.main.exchange',
+                                    get_ticker=MagicMock(return_value={
+                                        'bid': 0.17256061,
+                                        'ask': 0.172661,
+                                        'last': 0.17256061
+                                    }),
+                                    buy=MagicMock(return_value='mocked_order_id')):
+                    trade = Trade.query.filter(Trade.is_open.is_(True)).first()
+                    self.assertTrue(trade)
+                    handle_trade(trade)
+                    self.assertEqual(trade.close_rate, 0.17256061)
+                    self.assertEqual(trade.close_profit, 137.4872490056564)
+                    self.assertIsNotNone(trade.close_date)
+                    self.assertEqual(trade.open_order_id, 'dry_run')
+
+    def test_3_close_trade(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            trade = Trade.query.filter(Trade.is_open.is_(True)).first()
+            self.assertTrue(trade)
+
+            # Simulate that there is no open order
+            trade.open_order_id = None
+
+            closed = close_trade_if_fulfilled(trade)
+            self.assertTrue(closed)
+            self.assertEqual(trade.is_open, False)
+
+    def test_balance_fully_ask_side(self):
+        with patch.dict('freqtrade.main._CONF', {'bid_strategy': {'ask_last_balance': 0.0}}):
+            self.assertEqual(get_target_bid({'ask': 20, 'last': 10}), 20)
+
+    def test_balance_fully_last_side(self):
+        with patch.dict('freqtrade.main._CONF', {'bid_strategy': {'ask_last_balance': 1.0}}):
+            self.assertEqual(get_target_bid({'ask': 20, 'last': 10}), 10)
+
+    def test_balance_when_last_bigger_than_ask(self):
+        with patch.dict('freqtrade.main._CONF', {'bid_strategy': {'ask_last_balance': 1.0}}):
+            self.assertEqual(get_target_bid({'ask': 5, 'last': 10}), 5)
+
+    @classmethod
+    def setUpClass(cls):
+        validate(cls.conf, CONF_SCHEMA)
+
+
+if __name__ == '__main__':
+    unittest.main()

freqtrade/tests/test_persistence.py

@@ -0,0 +1,28 @@
+import unittest
+from unittest.mock import patch
+
+from freqtrade.exchange import Exchange
+from freqtrade.persistence import Trade
+
+
+class TestTrade(unittest.TestCase):
+    def test_1_exec_sell_order(self):
+        with patch('freqtrade.main.exchange.sell', side_effect='mocked_order_id') as api_mock:
+            trade = Trade(
+                pair='BTC_ETH',
+                stake_amount=1.00,
+                open_rate=0.50,
+                amount=10.00,
+                exchange=Exchange.BITTREX,
+                open_order_id='mocked'
+            )
+            profit = trade.exec_sell_order(1.00, 10.00)
+            api_mock.assert_called_once_with('BTC_ETH', 1.0, 10.0)
+            self.assertEqual(profit, 100.0)
+            self.assertEqual(trade.close_rate, 1.0)
+            self.assertEqual(trade.close_profit, profit)
+            self.assertIsNotNone(trade.close_date)
+
+
+if __name__ == '__main__':
+    unittest.main()

freqtrade/tests/test_telegram.py

@@ -0,0 +1,195 @@
+import unittest
+from datetime import datetime
+from unittest.mock import patch, MagicMock
+
+from jsonschema import validate
+from telegram import Bot, Update, Message, Chat
+
+from freqtrade import exchange
+from freqtrade.main import init, create_trade
+from freqtrade.misc import update_state, State, get_state, CONF_SCHEMA
+from freqtrade.persistence import Trade
+from freqtrade.rpc.telegram import _status, _profit, _forcesell, _performance, _start, _stop
+
+
+class MagicBot(MagicMock, Bot):
+    pass
+
+
+class TestTelegram(unittest.TestCase):
+
+    conf = {
+        "max_open_trades": 3,
+        "stake_currency": "BTC",
+        "stake_amount": 0.05,
+        "dry_run": True,
+        "minimal_roi": {
+            "2880": 0.005,
+            "720": 0.01,
+            "0": 0.02
+        },
+        "bid_strategy": {
+            "ask_last_balance": 0.0
+        },
+        "bittrex": {
+            "enabled": True,
+            "key": "key",
+            "secret": "secret",
+            "pair_whitelist": [
+                "BTC_ETH"
+            ]
+        },
+        "telegram": {
+            "enabled": True,
+            "token": "token",
+            "chat_id": "0"
+        },
+        "initial_state": "running"
+    }
+
+    def test_1_status_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True):
+                msg_mock = MagicMock()
+                with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                    with patch.multiple('freqtrade.main.exchange',
+                                        get_ticker=MagicMock(return_value={
+                                            'bid': 0.07256061,
+                                            'ask': 0.072661,
+                                            'last': 0.07256061
+                                        }),
+                                        buy=MagicMock(return_value='mocked_order_id')):
+                        init(self.conf, 'sqlite://')
+
+                        # Create some test data
+                        trade = create_trade(15.0, exchange.Exchange.BITTREX)
+                        self.assertTrue(trade)
+                        Trade.session.add(trade)
+                        Trade.session.flush()
+
+                        _status(bot=MagicBot(), update=self.update)
+                        self.assertEqual(msg_mock.call_count, 2)
+                        self.assertIn('[BTC_ETH]', msg_mock.call_args_list[-1][0][0])
+
+    def test_2_profit_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True):
+                msg_mock = MagicMock()
+                with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                    with patch.multiple('freqtrade.main.exchange',
+                                        get_ticker=MagicMock(return_value={
+                                            'bid': 0.07256061,
+                                            'ask': 0.072661,
+                                            'last': 0.07256061
+                                        }),
+                                        buy=MagicMock(return_value='mocked_order_id')):
+                        init(self.conf, 'sqlite://')
+
+                        # Create some test data
+                        trade = create_trade(15.0, exchange.Exchange.BITTREX)
+                        self.assertTrue(trade)
+                        trade.close_rate = 0.07256061
+                        trade.close_profit = 100.00
+                        trade.close_date = datetime.utcnow()
+                        trade.open_order_id = None
+                        trade.is_open = False
+                        Trade.session.add(trade)
+                        Trade.session.flush()
+
+                        _profit(bot=MagicBot(), update=self.update)
+                        self.assertEqual(msg_mock.call_count, 2)
+                        self.assertIn('(100.00%)', msg_mock.call_args_list[-1][0][0])
+
+    def test_3_forcesell_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True):
+                msg_mock = MagicMock()
+                with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                    with patch.multiple('freqtrade.main.exchange',
+                                        get_ticker=MagicMock(return_value={
+                                            'bid': 0.07256061,
+                                            'ask': 0.072661,
+                                            'last': 0.07256061
+                                        }),
+                                        buy=MagicMock(return_value='mocked_order_id')):
+                        init(self.conf, 'sqlite://')
+
+                        # Create some test data
+                        trade = create_trade(15.0, exchange.Exchange.BITTREX)
+                        self.assertTrue(trade)
+                        Trade.session.add(trade)
+                        Trade.session.flush()
+
+                        self.update.message.text = '/forcesell 1'
+                        _forcesell(bot=MagicBot(), update=self.update)
+
+                        self.assertEqual(msg_mock.call_count, 2)
+                        self.assertIn('Selling [BTC/ETH]', msg_mock.call_args_list[-1][0][0])
+                        self.assertIn('0.072561', msg_mock.call_args_list[-1][0][0])
+
+    def test_4_performance_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            with patch('freqtrade.main.get_buy_signal', side_effect=lambda _: True):
+                msg_mock = MagicMock()
+                with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                    with patch.multiple('freqtrade.main.exchange',
+                                        get_ticker=MagicMock(return_value={
+                                            'bid': 0.07256061,
+                                            'ask': 0.072661,
+                                            'last': 0.07256061
+                                        }),
+                                        buy=MagicMock(return_value='mocked_order_id')):
+                        init(self.conf, 'sqlite://')
+
+                        # Create some test data
+                        trade = create_trade(15.0, exchange.Exchange.BITTREX)
+                        self.assertTrue(trade)
+                        trade.close_rate = 0.07256061
+                        trade.close_profit = 100.00
+                        trade.close_date = datetime.utcnow()
+                        trade.open_order_id = None
+                        trade.is_open = False
+                        Trade.session.add(trade)
+                        Trade.session.flush()
+
+                        _performance(bot=MagicBot(), update=self.update)
+                        self.assertEqual(msg_mock.call_count, 2)
+                        self.assertIn('Performance', msg_mock.call_args_list[-1][0][0])
+                        self.assertIn('BTC_ETH	100.00%', msg_mock.call_args_list[-1][0][0])
+
+    def test_5_start_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            msg_mock = MagicMock()
+            with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                init(self.conf, 'sqlite://')
+
+                update_state(State.STOPPED)
+                self.assertEqual(get_state(), State.STOPPED)
+                _start(bot=MagicBot(), update=self.update)
+                self.assertEqual(get_state(), State.RUNNING)
+                self.assertEqual(msg_mock.call_count, 0)
+
+    def test_6_stop_handle(self):
+        with patch.dict('freqtrade.main._CONF', self.conf):
+            msg_mock = MagicMock()
+            with patch.multiple('freqtrade.main.telegram', _CONF=self.conf, init=MagicMock(), send_msg=msg_mock):
+                init(self.conf, 'sqlite://')
+
+                update_state(State.RUNNING)
+                self.assertEqual(get_state(), State.RUNNING)
+                _stop(bot=MagicBot(), update=self.update)
+                self.assertEqual(get_state(), State.STOPPED)
+                self.assertEqual(msg_mock.call_count, 1)
+                self.assertIn('Stopping trader', msg_mock.call_args_list[0][0][0])
+
+    def setUp(self):
+        self.update = Update(0)
+        self.update.message = Message(0, 0, datetime.utcnow(), Chat(0, 0))
+
+    @classmethod
+    def setUpClass(cls):
+        validate(cls.conf, CONF_SCHEMA)
+
+
+if __name__ == '__main__':
+    unittest.main()