Don’t raise when some market is disabled

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

diff --git a/tests/test_market.py b/tests/test_market.py
index 07188aca1d7c7344d315d0501f1740fe0ed4511b..93164803b2ed03ff2d7614762eab4249088af3d8 100644 (file)
--- a/tests/test_market.py
+++ b/tests/test_market.py
@@ -402,6 +402,40 @@ class MarketTest(WebMockTestCase):
             m.report.log_order.assert_called_with(order_mock2, 2, new_order=new_order_mock)
             new_order_mock.run.assert_called_once_with()
 
+        with self.subTest("disappearing order no action to do"), \
+                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"
+            trade_mock.prepare_order.return_value = None
+
+            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)
+            m.report.log_order.assert_called_with(order_mock2, 2, finished=True)
+
     @mock.patch.object(market.BalanceStore, "fetch_balances")
     def test_move_balance(self, fetch_balances):
         for debug in [True, False]:
@@ -849,7 +883,7 @@ class MarketTest(WebMockTestCase):
     @mock.patch("market.ReportStore.log_error")
     @mock.patch("market.Market.store_report")
     def test_process(self, store_report, log_error, process):
-        m = market.Market(self.ccxt, self.market_args())
+        m = market.Market(self.ccxt, self.market_args(), options={"foo": "bar"})
         with self.subTest(actions=[], before=False, after=False):
             m.process([])
 
@@ -863,7 +897,7 @@ class MarketTest(WebMockTestCase):
         with self.subTest(before=True, after=False):
             m.process(["foo"], before=True)
 
-            process.assert_called_once_with("foo", steps="before")
+            process.assert_called_once_with("foo", options={"foo": "bar"}, steps="before")
             store_report.assert_called_once()
             log_error.assert_not_called()
 
@@ -873,7 +907,7 @@ class MarketTest(WebMockTestCase):
         with self.subTest(before=False, after=True):
             m.process(["sell_all"], after=True)
 
-            process.assert_called_once_with("sell_all", steps="after")
+            process.assert_called_once_with("sell_all", options={"foo": "bar"}, steps="after")
             store_report.assert_called_once()
             log_error.assert_not_called()
 
@@ -883,7 +917,7 @@ class MarketTest(WebMockTestCase):
         with self.subTest(before=False, after=False):
             m.process(["foo"])
 
-            process.assert_called_once_with("foo", steps="all")
+            process.assert_called_once_with("foo", options={"foo": "bar"}, steps="all")
             store_report.assert_called_once()
             log_error.assert_not_called()
 
@@ -893,7 +927,7 @@ class MarketTest(WebMockTestCase):
         with self.subTest(before=True, after=True):
             m.process(["sell_all"], before=True, after=True)
 
-            process.assert_called_once_with("sell_all", steps="all")
+            process.assert_called_once_with("sell_all", options={"foo": "bar"}, steps="all")
             store_report.assert_called_once()
             log_error.assert_not_called()
 
@@ -976,7 +1010,7 @@ class ProcessorTest(WebMockTestCase):
         with self.subTest("nominal case"):
             processor = market.Processor(self.m)
 
-            processor.process("sell_all", foo="bar")
+            processor.process("sell_all", options="bar")
             self.assertEqual(3, process_step.call_count)
 
             steps = list(map(lambda x: x[1][1]["name"], process_step.mock_calls))
@@ -984,7 +1018,7 @@ class ProcessorTest(WebMockTestCase):
             kwargs = list(map(lambda x: x[1][2], process_step.mock_calls))
             self.assertEqual(["all_sell", "wait", "all_buy"], steps)
             self.assertEqual(["sell_all", "sell_all", "sell_all"], scenario_names)
-            self.assertEqual([{"foo":"bar"}, {"foo":"bar"}, {"foo":"bar"}], kwargs)
+            self.assertEqual(["bar", "bar", "bar"], kwargs)
 
             process_step.reset_mock()
 
@@ -999,7 +1033,7 @@ class ProcessorTest(WebMockTestCase):
 
         method, arguments = processor.method_arguments("wait_for_recent")
         self.assertEqual(market.Portfolio.wait_for_recent, method)
-        self.assertEqual(["delta", "poll"], arguments)
+        self.assertEqual(["delta"], arguments)
 
         method, arguments = processor.method_arguments("prepare_trades")
         self.assertEqual(m.prepare_trades, method)
@@ -1023,6 +1057,9 @@ class ProcessorTest(WebMockTestCase):
         method, arguments = processor.method_arguments("print_tickers")
         self.assertEqual(m.print_tickers, method)
 
+        method, arguments = processor.method_arguments("fetch_balances")
+        self.assertEqual(m.balances.fetch_balances, method)
+
     def test_process_step(self):
         processor = market.Processor(self.m)
 
@@ -1035,19 +1072,17 @@ class ProcessorTest(WebMockTestCase):
                 mock.call("process_foo__2_sell_begin"),
                 mock.call("process_foo__2_sell_end"),
                 ])
-            self.m.balances.fetch_balances.assert_has_calls([
-                mock.call(tag="process_foo__2_sell_begin"),
-                mock.call(tag="process_foo__2_sell_end"),
-                ])
 
-            self.assertEqual(5, run_action.call_count)
+            self.assertEqual(7, run_action.call_count)
 
             run_action.assert_has_calls([
+                mock.call('fetch_balances', {}, {'foo': 'bar', 'tag': 'process_foo__2_sell_begin'}),
                 mock.call('prepare_trades', {}, {'foo': 'bar'}),
                 mock.call('prepare_orders', {'only': 'dispose', 'compute_value': 'average'}, {'foo': 'bar'}),
                 mock.call('run_orders', {}, {'foo': 'bar'}),
                 mock.call('follow_orders', {}, {'foo': 'bar'}),
                 mock.call('close_trades', {}, {'foo': 'bar'}),
+                mock.call('fetch_balances', {}, {'foo': 'bar', 'tag': 'process_foo__2_sell_end'}),
                 ])
 
         self.m.reset_mock()
@@ -1060,30 +1095,31 @@ class ProcessorTest(WebMockTestCase):
                 mock.call("process_foo__0_print_balances_begin"),
                 mock.call("process_foo__0_print_balances_end"),
                 ])
-            self.m.balances.fetch_balances.assert_has_calls([
-                mock.call(add_portfolio=True, checkpoint='end',
-                    log_tickers=True,
-                    add_usdt=True,
-                    tag='process_foo__0_print_balances_begin')
-                ])
 
-            self.assertEqual(0, run_action.call_count)
+            self.assertEqual(1, run_action.call_count)
+            run_action.assert_has_calls([
+                mock.call('fetch_balances',
+                    {'checkpoint': 'end', 'log_tickers': True, 'add_usdt': True, 'add_portfolio': True},
+                    {'foo': 'bar', 'tag': 'process_foo__0_print_balances_begin'}),
+                ])
 
         self.m.reset_mock()
         with mock.patch.object(processor, "run_action") as run_action:
             step = processor.scenarios["sell_needed"][1]
 
             processor.process_step("foo", step, {"foo":"bar"})
-            self.m.balances.fetch_balances.assert_not_called()
+            self.assertEqual(1, run_action.call_count)
 
         self.m.reset_mock()
         with mock.patch.object(processor, "run_action") as run_action:
             step = processor.scenarios["print_balances"][0]
 
             processor.process_step("foo", step, {"foo":"bar"})
-            self.m.balances.fetch_balances.assert_called_once_with(
-                    add_portfolio=True, add_usdt=True, log_tickers=True,
-                    tag='process_foo__1_print_balances_begin')
+            run_action.assert_has_calls([
+                mock.call('fetch_balances',
+                    {'log_tickers': True, 'add_usdt': True, 'add_portfolio': True},
+                    {'foo': 'bar', 'tag': 'process_foo__1_print_balances_begin'}),
+                ])
 
     def test_parse_args(self):
         processor = market.Processor(self.m)