Merge branch 'retry_vanished' into dev

1 files changed, 64 insertions, 48 deletions

diff --git a/test.py b/test.py
index 7b17f9e..a9a80c5 100644
--- a/test.py
+++ b/test.py
@@ -1403,6 +1403,38 @@ class MarketTest(WebMockTestCase):
                 else:
                     time_mock.assert_called_with(sleep)
 
+        with self.subTest("disappearing order"), \
+                mock.patch("market.ReportStore"):
+            all_orders.reset_mock()
+            m = market.Market(self.ccxt, self.market_args())
+
+            order_mock1 = mock.Mock()
+            order_mock2 = mock.Mock()
+            all_orders.side_effect = [
+                    [order_mock1, order_mock2],
+                    [order_mock1, order_mock2],
+
+                    [order_mock1, order_mock2],
+                    [order_mock1, order_mock2],
+
+                    []
+                    ]
+
+            order_mock1.get_status.side_effect = ["open", "closed"]
+            order_mock2.get_status.side_effect = ["open", "error_disappeared"]
+
+            order_mock1.trade = mock.Mock()
+            trade_mock = mock.Mock()
+            order_mock2.trade = trade_mock
+
+            trade_mock.tick_actions_recreate.return_value = "tick1"
+
+            m.follow_orders()
+
+            trade_mock.tick_actions_recreate.assert_called_once_with(2)
+            trade_mock.prepare_order.assert_called_once_with(compute_value="tick1")
+            m.report.log_error.assert_called_once_with("follow_orders", message=mock.ANY)
+
     @mock.patch.object(market.BalanceStore, "fetch_balances")
     def test_move_balance(self, fetch_balances):
         for debug in [True, False]:
@@ -2406,27 +2438,6 @@ class TradeTest(WebMockTestCase):
         order1.filled_amount.assert_called_with(in_base_currency=True)
         order2.filled_amount.assert_called_with(in_base_currency=True)
 
-    def test_reopen_same_order(self):
-        value_from = portfolio.Amount("BTC", "0.5")
-        value_from.linked_to = portfolio.Amount("ETH", "10.0")
-        value_to = portfolio.Amount("BTC", "1.0")
-        trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
-        order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
-                D("0.1"), "BTC", "long", self.m, "trade")
-        with mock.patch("portfolio.Order.run") as run:
-            new_order = trade.reopen_same_order(order)
-            self.assertEqual("buy", new_order.action)
-            self.assertEqual(portfolio.Amount("ETH", 10), new_order.amount)
-            self.assertEqual(D("0.1"), new_order.rate)
-            self.assertEqual("BTC", new_order.base_currency)
-            self.assertEqual("long", new_order.trade_type)
-            self.assertEqual(self.m, new_order.market)
-            self.assertEqual(False, new_order.close_if_possible)
-            self.assertEqual(trade, new_order.trade)
-            run.assert_called_once()
-            self.assertEqual(1, len(trade.orders))
-            self.assertEqual(new_order, trade.orders[0])
-
     @mock.patch.object(portfolio.Computation, "compute_value")
     @mock.patch.object(portfolio.Trade, "filled_amount")
     @mock.patch.object(portfolio, "Order")
@@ -2582,6 +2593,21 @@ class TradeTest(WebMockTestCase):
                     D("125"), "FOO", "long", self.m,
                     trade, close_if_possible=False)
 
+    def test_tick_actions_recreate(self):
+        value_from = portfolio.Amount("BTC", "0.5")
+        value_from.linked_to = portfolio.Amount("ETH", "10.0")
+        value_to = portfolio.Amount("BTC", "1.0")
+        trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
+
+        self.assertEqual("average", trade.tick_actions_recreate(0))
+        self.assertEqual("foo", trade.tick_actions_recreate(0, default="foo"))
+        self.assertEqual("average", trade.tick_actions_recreate(1))
+        self.assertEqual(trade.tick_actions[2][1], trade.tick_actions_recreate(2))
+        self.assertEqual(trade.tick_actions[2][1], trade.tick_actions_recreate(3))
+        self.assertEqual(trade.tick_actions[5][1], trade.tick_actions_recreate(5))
+        self.assertEqual(trade.tick_actions[5][1], trade.tick_actions_recreate(6))
+        self.assertEqual("default", trade.tick_actions_recreate(7))
+        self.assertEqual("default", trade.tick_actions_recreate(8))
 
     @mock.patch.object(portfolio.Trade, "prepare_order")
     def test_update_order(self, prepare_order):
@@ -2984,12 +3010,12 @@ class OrderTest(WebMockTestCase):
         self.m.ccxt.privatePostReturnOrderTrades.return_value = [
                 {
                     "tradeID": 42, "type": "buy", "fee": "0.0015",
-                    "date": "2017-12-30 12:00:12", "rate": "0.1",
+                    "date": "2017-12-30 13:00:12", "rate": "0.1",
                     "amount": "3", "total": "0.3"
                     },
                 {
                     "tradeID": 43, "type": "buy", "fee": "0.0015",
-                    "date": "2017-12-30 13:00:12", "rate": "0.2",
+                    "date": "2017-12-30 12:00:12", "rate": "0.2",
                     "amount": "2", "total": "0.4"
                     }
             ]
@@ -3002,8 +3028,8 @@ class OrderTest(WebMockTestCase):
 
         self.m.ccxt.privatePostReturnOrderTrades.assert_called_with({"orderNumber": 12})
         self.assertEqual(2, len(order.mouvements))
-        self.assertEqual(42, order.mouvements[0].id)
-        self.assertEqual(43, order.mouvements[1].id)
+        self.assertEqual(43, order.mouvements[0].id)
+        self.assertEqual(42, order.mouvements[1].id)
 
         self.m.ccxt.privatePostReturnOrderTrades.side_effect = portfolio.ExchangeError
         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
@@ -3059,9 +3085,9 @@ class OrderTest(WebMockTestCase):
         self.m.report.log_debug_action.assert_called_once()
 
     @mock.patch.object(portfolio.Order, "fetch_mouvements")
-    @mock.patch.object(portfolio.Order, "fix_disappeared_order")
+    @mock.patch.object(portfolio.Order, "mark_disappeared_order")
     @mock.patch.object(portfolio.Order, "mark_finished_order")
-    def test_fetch(self, mark_finished_order, fix_disappeared_order, fetch_mouvements):
+    def test_fetch(self, mark_finished_order, mark_disappeared_order, fetch_mouvements):
         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
                 D("0.1"), "BTC", "long", self.m, "trade")
         order.id = 45
@@ -3072,7 +3098,7 @@ class OrderTest(WebMockTestCase):
             self.m.report.log_debug_action.reset_mock()
             self.m.ccxt.fetch_order.assert_not_called()
             mark_finished_order.assert_not_called()
-            fix_disappeared_order.assert_not_called()
+            mark_disappeared_order.assert_not_called()
             fetch_mouvements.assert_not_called()
 
         with self.subTest(debug=False):
@@ -3090,7 +3116,7 @@ class OrderTest(WebMockTestCase):
             self.assertEqual(1, len(order.results))
             self.m.report.log_debug_action.assert_not_called()
             mark_finished_order.assert_called_once()
-            fix_disappeared_order.assert_called_once()
+            mark_disappeared_order.assert_called_once()
 
             mark_finished_order.reset_mock()
             with self.subTest(missing_order=True):
@@ -3101,7 +3127,7 @@ class OrderTest(WebMockTestCase):
                 self.assertEqual("closed_unknown", order.status)
                 mark_finished_order.assert_called_once()
 
-    def test_fix_disappeared_order(self):
+    def test_mark_disappeared_order(self):
         with self.subTest("Open order"):
             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
                     D("0.1"), "BTC", "long", self.m, "trade")
@@ -3116,9 +3142,8 @@ class OrderTest(WebMockTestCase):
                 "fee":"0.00150000",
                 "date":"2018-04-02 00:09:13"
                 }))
-            with mock.patch.object(order, "trade") as trade:
-                order.fix_disappeared_order()
-                trade.reopen_same_order.assert_not_called()
+            order.mark_disappeared_order()
+            self.assertEqual("pending", order.status)
 
         with self.subTest("Non-zero amount"):
             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
@@ -3135,10 +3160,8 @@ class OrderTest(WebMockTestCase):
                 "fee":"0.00150000",
                 "date":"2018-04-02 00:09:13"
                 }))
-            with mock.patch.object(order, "trade") as trade:
-                order.fix_disappeared_order()
-                self.assertEqual("closed", order.status)
-                trade.reopen_same_order.assert_not_called()
+            order.mark_disappeared_order()
+            self.assertEqual("closed", order.status)
 
         with self.subTest("Other mouvements"):
             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
@@ -3165,10 +3188,8 @@ class OrderTest(WebMockTestCase):
                 "fee":"0.00150000",
                 "date":"2018-04-02 00:09:13"
                 }))
-            with mock.patch.object(order, "trade") as trade:
-                order.fix_disappeared_order()
-                self.assertEqual("closed", order.status)
-                trade.reopen_same_order.assert_not_called()
+            order.mark_disappeared_order()
+            self.assertEqual("error_disappeared", order.status)
 
         with self.subTest("Order disappeared"):
             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
@@ -3185,13 +3206,8 @@ class OrderTest(WebMockTestCase):
                 "fee":"0.00150000",
                 "date":"2018-04-02 00:09:13"
                 }))
-            with mock.patch.object(order, "trade") as trade:
-                trade.reopen_same_order.return_value = "New order"
-                order.fix_disappeared_order()
-                self.assertEqual("error_disappeared", order.status)
-                trade.reopen_same_order.assert_called_once_with(order)
-                self.m.report.log_error.assert_called_once_with('fetch',
-                        message='Order Order(buy long 10.00000000 ETH at 0.1 BTC [error_disappeared]) disappeared, recreating it as New order')
+            order.mark_disappeared_order()
+            self.assertEqual("error_disappeared", order.status)
 
     @mock.patch.object(portfolio.Order, "fetch")
     def test_get_status(self, fetch):