Fix mark finished order not alway called when necessary

[perso/Immae/Projets/Cryptomonnaies/Cryptoportfolio/Trader.git] / test.py

diff --git a/test.py b/test.py
index 0bfa2b7b6140d1c3f7e9320441347afce7cf95af..921af9f1b451595cfc9fb08cd9affaebb3741a47 100644 (file)
--- a/test.py
+++ b/test.py
@@ -1375,16 +1375,20 @@ class TradeTest(WebMockTestCase):
         value_to = portfolio.Amount("BTC", "1.0")
         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
 
-        self.assertEqual("buy", trade.order_action(False))
-        self.assertEqual("sell", trade.order_action(True))
+        trade.inverted = False
+        self.assertEqual("buy", trade.order_action())
+        trade.inverted = True
+        self.assertEqual("sell", trade.order_action())
 
         value_from = portfolio.Amount("BTC", "0")
         value_from.linked_to = portfolio.Amount("ETH", "0")
         value_to = portfolio.Amount("BTC", "-1.0")
         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
 
-        self.assertEqual("sell", trade.order_action(False))
-        self.assertEqual("buy", trade.order_action(True))
+        trade.inverted = False
+        self.assertEqual("sell", trade.order_action())
+        trade.inverted = True
+        self.assertEqual("buy", trade.order_action())
 
     def test_trade_type(self):
         value_from = portfolio.Amount("BTC", "0.5")
@@ -1402,26 +1406,59 @@ class TradeTest(WebMockTestCase):
         self.assertEqual("short", trade.trade_type)
 
     def test_is_fullfiled(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)
+        with self.subTest(inverted=False):
+            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)
 
-        order1 = mock.Mock()
-        order1.filled_amount.return_value = portfolio.Amount("BTC", "0.3")
+            order1 = mock.Mock()
+            order1.filled_amount.return_value = portfolio.Amount("BTC", "0.3")
 
-        order2 = mock.Mock()
-        order2.filled_amount.return_value = portfolio.Amount("BTC", "0.01")
-        trade.orders.append(order1)
-        trade.orders.append(order2)
+            order2 = mock.Mock()
+            order2.filled_amount.return_value = portfolio.Amount("BTC", "0.01")
+            trade.orders.append(order1)
+            trade.orders.append(order2)
+
+            self.assertFalse(trade.is_fullfiled)
+
+            order3 = mock.Mock()
+            order3.filled_amount.return_value = portfolio.Amount("BTC", "0.19")
+            trade.orders.append(order3)
+
+            self.assertTrue(trade.is_fullfiled)
+
+            order1.filled_amount.assert_called_with(in_base_currency=True)
+            order2.filled_amount.assert_called_with(in_base_currency=True)
+            order3.filled_amount.assert_called_with(in_base_currency=True)
+
+        with self.subTest(inverted=True):
+            value_from = portfolio.Amount("BTC", "0.5")
+            value_from.linked_to = portfolio.Amount("USDT", "1000.0")
+            value_to = portfolio.Amount("BTC", "1.0")
+            trade = portfolio.Trade(value_from, value_to, "USDT", self.m)
+            trade.inverted = True
+
+            order1 = mock.Mock()
+            order1.filled_amount.return_value = portfolio.Amount("BTC", "0.3")
+
+            order2 = mock.Mock()
+            order2.filled_amount.return_value = portfolio.Amount("BTC", "0.01")
+            trade.orders.append(order1)
+            trade.orders.append(order2)
+
+            self.assertFalse(trade.is_fullfiled)
 
-        self.assertFalse(trade.is_fullfiled)
+            order3 = mock.Mock()
+            order3.filled_amount.return_value = portfolio.Amount("BTC", "0.19")
+            trade.orders.append(order3)
 
-        order3 = mock.Mock()
-        order3.filled_amount.return_value = portfolio.Amount("BTC", "0.19")
-        trade.orders.append(order3)
+            self.assertTrue(trade.is_fullfiled)
+
+            order1.filled_amount.assert_called_with(in_base_currency=False)
+            order2.filled_amount.assert_called_with(in_base_currency=False)
+            order3.filled_amount.assert_called_with(in_base_currency=False)
 
-        self.assertTrue(trade.is_fullfiled)
 
     def test_filled_amount(self):
         value_from = portfolio.Amount("BTC", "0.5")
@@ -1746,25 +1783,46 @@ class TradeTest(WebMockTestCase):
         trade.orders.append(order_mock1)
         trade.orders.append(order_mock2)
 
-        trade.print_with_order()
+        with mock.patch.object(trade, "filled_amount") as filled:
+            filled.return_value = portfolio.Amount("BTC", "0.1")
+
+            trade.print_with_order()
+
+            self.m.report.print_log.assert_called()
+            calls = self.m.report.print_log.mock_calls
+            self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire)", str(calls[0][1][0]))
+            self.assertEqual("\tMock 1", str(calls[1][1][0]))
+            self.assertEqual("\tMock 2", str(calls[2][1][0]))
+            self.assertEqual("\t\tMouvement 1", str(calls[3][1][0]))
+            self.assertEqual("\t\tMouvement 2", str(calls[4][1][0]))
+
+            self.m.report.print_log.reset_mock()
 
-        self.m.report.print_log.assert_called()
-        calls = self.m.report.print_log.mock_calls
-        self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire)", str(calls[0][1][0]))
-        self.assertEqual("\tMock 1", str(calls[1][1][0]))
-        self.assertEqual("\tMock 2", str(calls[2][1][0]))
-        self.assertEqual("\t\tMouvement 1", str(calls[3][1][0]))
-        self.assertEqual("\t\tMouvement 2", str(calls[4][1][0]))
+            filled.return_value = portfolio.Amount("BTC", "0.5")
+            trade.print_with_order()
+            calls = self.m.report.print_log.mock_calls
+            self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire ✔)", str(calls[0][1][0]))
+
+            self.m.report.print_log.reset_mock()
+
+            filled.return_value = portfolio.Amount("BTC", "0.1")
+            trade.closed = True
+            trade.print_with_order()
+            calls = self.m.report.print_log.mock_calls
+            self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire ❌)", str(calls[0][1][0]))
 
     def test_close(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)
+        order1 = mock.Mock()
+        trade.orders.append(order1)
 
         trade.close()
 
         self.assertEqual(True, trade.closed)
+        order1.cancel.assert_called_once_with()
 
     def test_pending(self):
         value_from = portfolio.Amount("BTC", "0.5")
@@ -1888,27 +1946,57 @@ class OrderTest(WebMockTestCase):
 
     @mock.patch.object(portfolio.Order, "fetch")
     def test_cancel(self, fetch):
-        self.m.debug = True
-        order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
-                D("0.1"), "BTC", "long", self.m, "trade")
-        order.status = "open"
+        with self.subTest(debug=True):
+            self.m.debug = True
+            order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+                    D("0.1"), "BTC", "long", self.m, "trade")
+            order.status = "open"
 
-        order.cancel()
-        self.m.ccxt.cancel_order.assert_not_called()
-        self.m.report.log_debug_action.assert_called_once()
-        self.m.report.log_debug_action.reset_mock()
-        self.assertEqual("canceled", order.status)
+            order.cancel()
+            self.m.ccxt.cancel_order.assert_not_called()
+            self.m.report.log_debug_action.assert_called_once()
+            self.m.report.log_debug_action.reset_mock()
+            self.assertEqual("canceled", order.status)
 
-        self.m.debug = False
-        order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
-                D("0.1"), "BTC", "long", self.m, "trade")
-        order.status = "open"
-        order.id = 42
+        with self.subTest(desc="Nominal case"):
+            self.m.debug = False
+            order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+                    D("0.1"), "BTC", "long", self.m, "trade")
+            order.status = "open"
+            order.id = 42
 
-        order.cancel()
-        self.m.ccxt.cancel_order.assert_called_with(42)
-        fetch.assert_called_once_with()
-        self.m.report.log_debug_action.assert_not_called()
+            order.cancel()
+            self.m.ccxt.cancel_order.assert_called_with(42)
+            fetch.assert_called_once_with()
+            self.m.report.log_debug_action.assert_not_called()
+
+        with self.subTest(exception=True):
+            self.m.ccxt.cancel_order.side_effect = portfolio.OrderNotFound
+            order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+                    D("0.1"), "BTC", "long", self.m, "trade")
+            order.status = "open"
+            order.id = 42
+            order.cancel()
+            self.m.ccxt.cancel_order.assert_called_with(42)
+            self.m.report.log_error.assert_called_once()
+
+        self.m.reset_mock()
+        with self.subTest(id=None):
+            self.m.ccxt.cancel_order.side_effect = portfolio.OrderNotFound
+            order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+                    D("0.1"), "BTC", "long", self.m, "trade")
+            order.status = "open"
+            order.cancel()
+            self.m.ccxt.cancel_order.assert_not_called()
+
+        self.m.reset_mock()
+        with self.subTest(open=False):
+            self.m.ccxt.cancel_order.side_effect = portfolio.OrderNotFound
+            order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+                    D("0.1"), "BTC", "long", self.m, "trade")
+            order.status = "closed"
+            order.cancel()
+            self.m.ccxt.cancel_order.assert_not_called()
 
     def test_dust_amount_remaining(self):
         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
@@ -2030,7 +2118,8 @@ class OrderTest(WebMockTestCase):
         self.m.report.log_debug_action.assert_called_once()
 
     @mock.patch.object(portfolio.Order, "fetch_mouvements")
-    def test_fetch(self, fetch_mouvements):
+    @mock.patch.object(portfolio.Order, "mark_finished_order")
+    def test_fetch(self, mark_finished_order, fetch_mouvements):
         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
                 D("0.1"), "BTC", "long", self.m, "trade")
         order.id = 45
@@ -2040,6 +2129,7 @@ class OrderTest(WebMockTestCase):
             self.m.report.log_debug_action.assert_called_once()
             self.m.report.log_debug_action.reset_mock()
             self.m.ccxt.fetch_order.assert_not_called()
+            mark_finished_order.assert_not_called()
             fetch_mouvements.assert_not_called()
 
         with self.subTest(debug=False):
@@ -2050,23 +2140,25 @@ class OrderTest(WebMockTestCase):
                     }
             order.fetch()
 
-            self.m.ccxt.fetch_order.assert_called_once_with(45, symbol="ETH")
+            self.m.ccxt.fetch_order.assert_called_once_with(45)
             fetch_mouvements.assert_called_once()
             self.assertEqual("foo", order.status)
             self.assertEqual("timestamp", order.timestamp)
             self.assertEqual(1, len(order.results))
             self.m.report.log_debug_action.assert_not_called()
+            mark_finished_order.assert_called_once()
 
+            mark_finished_order.reset_mock()
             with self.subTest(missing_order=True):
                 self.m.ccxt.fetch_order.side_effect = [
                         portfolio.OrderNotCached,
                         ]
                 order.fetch()
                 self.assertEqual("closed_unknown", order.status)
+                mark_finished_order.assert_called_once()
 
     @mock.patch.object(portfolio.Order, "fetch")
-    @mock.patch.object(portfolio.Order, "mark_finished_order")
-    def test_get_status(self, mark_finished_order, fetch):
+    def test_get_status(self, fetch):
         with self.subTest(debug=True):
             self.m.debug = True
             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
@@ -2085,10 +2177,8 @@ class OrderTest(WebMockTestCase):
                 return update_status
             fetch.side_effect = _fetch(order)
             self.assertEqual("open", order.get_status())
-            mark_finished_order.assert_not_called()
             fetch.assert_called_once()
 
-        mark_finished_order.reset_mock()
         fetch.reset_mock()
         with self.subTest(debug=False, finished=True):
             self.m.debug = False
@@ -2100,7 +2190,6 @@ class OrderTest(WebMockTestCase):
                 return update_status
             fetch.side_effect = _fetch(order)
             self.assertEqual("closed", order.get_status())
-            mark_finished_order.assert_called_once()
             fetch.assert_called_once()
 
     def test_run(self):