TST: Make tests pass the new Order/Trade/Position API

Author: kernc

backtesting/test/_test.py

@@ -59,8 +59,10 @@ def init(self):
 
     def next(self):
         if crossover(self.sma1, self.sma2):
+            self.position.close()
             self.buy()
         elif crossover(self.sma2, self.sma1):
+            self.position.close()
             self.sell()
 
 
@@ -153,48 +155,51 @@ def next(self, FIVE_DAYS=pd.Timedelta('3 days')):
                 assert not np.isnan(self.sma[-1])
                 assert self.data.index[-1]
 
-                self.orders.is_long
-                self.orders.is_short
-                self.orders.entry
-                self.orders.sl
-                self.orders.tp
-
                 self.position
                 self.position.size
                 self.position.pl
                 self.position.pl_pct
-                self.position.open_price
-                self.position.open_time
                 self.position.is_long
 
                 if crossover(self.sma, self.data.Close):
-                    self.orders.cancel()
-                    self.sell()
-                    assert not self.orders.is_long
-                    assert self.orders.is_short
-                    assert self.orders.entry
-                    assert not self.orders.sl
-                    assert not self.orders.tp
+                    self.orders.cancel()  # cancels only non-contingent
                     price = self.data.Close[-1]
                     sl, tp = 1.05 * price, .9 * price
-                    self.sell(price, sl=sl, tp=tp)
-                    self.orders.set_entry(price)
-                    self.orders.set_sl(sl)
-                    self.orders.set_tp(tp)
-                    assert self.orders.entry == price
-                    assert self.orders.sl == sl
-                    assert self.orders.tp == tp
+
+                    n_orders = len(self.orders)
+                    self.sell(size=.21, limit=price, stop=price, sl=sl, tp=tp)
+                    assert len(self.orders) == n_orders + 1
+
+                    order = self.orders[-1]
+                    assert order.limit == price
+                    assert order.stop == price
+                    assert order.size == -.21
+                    assert order.sl == sl
+                    assert order.tp == tp
+                    assert not order.is_contingent
 
                 elif self.position:
-                    assert not self.orders.entry
                     assert not self.position.is_long
-                    assert not not self.position.is_short
-                    assert self.position.open_price
+                    assert self.position.is_short
                     assert self.position.pl
                     assert self.position.pl_pct
                     assert self.position.size < 0
-                    if self.data.index[-1] - self.position.open_time > FIVE_DAYS:
-                        self.position.close()
+
+                    trade = self.trades[0]
+                    if self.data.index[-1] - self.data.index[trade.entry_bar] > FIVE_DAYS:
+                        assert not trade.is_long
+                        assert trade.is_short
+                        assert trade.size < 0
+                        assert trade.entry_bar > 0
+                        assert trade.exit_bar is None
+                        assert trade.entry_price > 0
+                        assert trade.exit_price is None
+                        assert trade.pl / 1
+                        assert trade.pl_pct / 1
+                        assert trade.value > 0
+                        assert trade.sl
+                        assert trade.tp
+                        self.position.close(.5)
 
         bt = Backtest(GOOG, Assertive)
         stats = bt.run()
@@ -239,36 +244,42 @@ def test_compute_stats(self):
             pd.Series({
                 # NOTE: These values are also used on the website!
                 '# Trades': 65,
-                'Avg. Drawdown Duration': pd.Timedelta('41 days 00:00:00'),
-                'Avg. Drawdown [%]': -6.087158560194047,
+                'Avg. Drawdown Duration': pd.Timedelta('40 days 00:00:00'),
+                'Avg. Drawdown [%]': -5.752030209842444,
                 'Avg. Trade Duration': pd.Timedelta('46 days 00:00:00'),
-                'Avg. Trade [%]': 3.0404430275631444,
-                'Best Trade [%]': 54.05363186670138,
+                'Avg. Trade [%]': 3.097629974370268,
+                'Best Trade [%]': 53.59595229490424,
                 'Buy & Hold Return [%]': 703.4582419772772,
-                'Calmar Ratio': 0.0631443286380662,
+                'Calmar Ratio': 0.06715981043291917,
                 'Duration': pd.Timedelta('3116 days 00:00:00'),
                 'End': pd.Timestamp('2013-03-01 00:00:00'),
-                'Equity Final [$]': 52624.29346696951,
-                'Equity Peak [$]': 76908.27001642012,
-                'Expectancy [%]': 8.774692825628644,
-                'Exposure Time [%]': 93.93453145057767,
+                'Equity Final [$]': 49072.06999999996,
+                'Equity Peak [$]': 70073.97999999997,
+                'Expectancy [%]': 8.791710931051735,
+                'Exposure Time [%]': 93.99441340782123,
                 'Max. Drawdown Duration': pd.Timedelta('584 days 00:00:00'),
-                'Max. Drawdown [%]': -48.15069053929621,
+                'Max. Drawdown [%]': -46.123268579863776,
                 'Max. Trade Duration': pd.Timedelta('183 days 00:00:00'),
-                'Return [%]': 426.2429346696951,
-                'SQN': 0.91553210127173,
-                'Sharpe Ratio': 0.23169782960690408,
-                'Sortino Ratio': 0.7096713270577958,
+                'Return [%]': 390.7206999999997,
+                'SQN': 0.9565100140529863,
+                'Sharpe Ratio': 0.2357610034211845,
+                'Sortino Ratio': 0.7355072888872161,
                 'Start': pd.Timestamp('2004-08-19 00:00:00'),
                 'Win Rate [%]': 46.15384615384615,
-                'Worst Trade [%]': -18.85561318387153,
+                'Worst Trade [%]': -18.39887353835481,
             }).sort_index()
         )
-        self.assertTrue(
-            stats._trade_data.columns.equals(
-                pd.Index(['Equity', 'Exit Entry', 'Exit Position',
-                          'Entry Price', 'Exit Price', 'P/L', 'Returns',
-                          'Drawdown', 'Drawdown Duration'])))
+
+        self.assertSequenceEqual(
+            sorted(stats['_equity_curve'].columns),
+            sorted(['Equity', 'DrawdownPct', 'DrawdownDuration']))
+
+        self.assertEqual(len(stats['_trades']), 65)
+
+        self.assertSequenceEqual(
+            sorted(stats['_trades'].columns),
+            sorted(['Size', 'EntryBar', 'ExitBar', 'EntryPrice', 'ExitPrice',
+                    'PnL', 'ReturnPct', 'EntryTime', 'ExitTime', 'Duration']))
 
     def test_compute_stats_bordercase(self):
 
@@ -306,7 +317,7 @@ def next(self):
                 stats = Backtest(GOOG.iloc[:100], strategy).run()
 
                 self.assertFalse(np.isnan(stats['Equity Final [$]']))
-                self.assertFalse(stats._trade_data['Equity'].isnull().any())
+                self.assertFalse(stats['_equity_curve']['Equity'].isnull().any())
                 self.assertEqual(stats['_strategy'].__class__, strategy)
 
 
@@ -321,8 +332,6 @@ def coroutine(self):
             assert self.position.size > 0
             assert self.position.pl
             assert self.position.pl_pct
-            assert self.position.open_price > 0
-            assert self.position.open_time
 
             yield self.position.close()
 
@@ -332,8 +341,6 @@ def coroutine(self):
             assert not self.position.size
             assert not self.position.pl
             assert not self.position.pl_pct
-            assert not self.position.open_price
-            assert not self.position.open_time
 
         class S(Strategy):
             def init(self):
@@ -361,8 +368,8 @@ def test_optimize(self):
         self.assertIsInstance(res, pd.Series)
 
         res2 = bt.optimize(**OPT_PARAMS, maximize=lambda s: s['SQN'])
-        self.assertSequenceEqual(res.filter(regex='^[^_]').to_dict(),
-                                 res2.filter(regex='^[^_]').to_dict())
+        self.assertDictEqual(res.filter(regex='^[^_]').fillna(-1).to_dict(),
+                             res2.filter(regex='^[^_]').fillna(-1).to_dict())
 
         res3, heatmap = bt.optimize(**OPT_PARAMS, return_heatmap=True,
                                     constraint=lambda d: d.slow > 2 * d.fast)
@@ -558,7 +565,7 @@ def init(self):
                                 self.data.Close < sma)
 
         stats = Backtest(GOOG, S).run()
-        self.assertGreater(stats['# Trades'], 1000)
+        self.assertEqual(stats['# Trades'], 1224)
 
     def test_TrailingStrategy(self):
         class S(TrailingStrategy):
@@ -574,7 +581,7 @@ def next(self):
                     self.buy()
 
         stats = Backtest(GOOG, S).run()
-        self.assertGreater(stats['# Trades'], 6)
+        self.assertEqual(stats['# Trades'], 50)
 
 
 class TestUtil(TestCase):