Fix timezone in tests

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

diff --git a/tests/test_portfolio.py b/tests/test_portfolio.py
index 2a42d0cd5507dc453ba76ff4fa54585bc47404cf..f2f639470c0bbf880916d16f5d0583b59392357e 100644 (file)
--- a/tests/test_portfolio.py
+++ b/tests/test_portfolio.py
@@ -2,6 +2,7 @@ from .helper import *
 import portfolio
 import datetime
 
+@unittest.skipUnless("unit" in limits, "Unit skipped")
 class ComputationTest(WebMockTestCase):
     def test_compute_value(self):
         compute = mock.Mock()
@@ -25,6 +26,13 @@ class ComputationTest(WebMockTestCase):
         portfolio.Computation.compute_value("foo", "bid", compute_value="test")
         compute.assert_called_with("foo", "bid")
 
+    def test_eat_several(self):
+        self.m.ccxt.fetch_nth_order_book.return_value = D("0.00001275")
+
+        self.assertEqual(D("0.00001275"), portfolio.Computation.eat_several(self.m)({ "symbol": "BTC/HUC" }, "ask"))
+
+
+@unittest.skipUnless("unit" in limits, "Unit skipped")
 class TradeTest(WebMockTestCase):
 
     def test_values_assertion(self):
@@ -140,9 +148,9 @@ class TradeTest(WebMockTestCase):
 
             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)
+            order1.filled_amount.assert_called_with(in_base_currency=True, refetch=True)
+            order2.filled_amount.assert_called_with(in_base_currency=True, refetch=True)
+            order3.filled_amount.assert_called_with(in_base_currency=True, refetch=True)
 
         with self.subTest(inverted=True):
             value_from = portfolio.Amount("BTC", "0.5")
@@ -167,9 +175,9 @@ class TradeTest(WebMockTestCase):
 
             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)
+            order1.filled_amount.assert_called_with(in_base_currency=False, refetch=True)
+            order2.filled_amount.assert_called_with(in_base_currency=False, refetch=True)
+            order3.filled_amount.assert_called_with(in_base_currency=False, refetch=True)
 
 
     def test_filled_amount(self):
@@ -187,16 +195,16 @@ class TradeTest(WebMockTestCase):
         trade.orders.append(order2)
 
         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount())
-        order1.filled_amount.assert_called_with(in_base_currency=False)
-        order2.filled_amount.assert_called_with(in_base_currency=False)
+        order1.filled_amount.assert_called_with(in_base_currency=False, refetch=False)
+        order2.filled_amount.assert_called_with(in_base_currency=False, refetch=False)
 
         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount(in_base_currency=False))
-        order1.filled_amount.assert_called_with(in_base_currency=False)
-        order2.filled_amount.assert_called_with(in_base_currency=False)
+        order1.filled_amount.assert_called_with(in_base_currency=False, refetch=False)
+        order2.filled_amount.assert_called_with(in_base_currency=False, refetch=False)
 
         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount(in_base_currency=True))
-        order1.filled_amount.assert_called_with(in_base_currency=True)
-        order2.filled_amount.assert_called_with(in_base_currency=True)
+        order1.filled_amount.assert_called_with(in_base_currency=True, refetch=False)
+        order2.filled_amount.assert_called_with(in_base_currency=True, refetch=False)
 
     @mock.patch.object(portfolio.Computation, "compute_value")
     @mock.patch.object(portfolio.Trade, "filled_amount")
@@ -218,6 +226,26 @@ class TradeTest(WebMockTestCase):
             self.assertEqual(0, len(trade.orders))
             Order.assert_not_called()
 
+        self.m.get_ticker.return_value = None
+        with self.subTest(desc="Unknown ticker"):
+            filled_amount.return_value = portfolio.Amount("BTC", "3")
+            compute_value.return_value = D("0.125")
+
+            value_from = portfolio.Amount("BTC", "1")
+            value_from.rate = D("0.1")
+            value_from.linked_to = portfolio.Amount("FOO", "10")
+            value_to = portfolio.Amount("BTC", "10")
+            trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
+
+            trade.prepare_order()
+
+            filled_amount.assert_not_called()
+            compute_value.assert_not_called()
+            self.assertEqual(0, len(trade.orders))
+            Order.assert_not_called()
+            self.m.report.log_error.assert_called_once_with('prepare_order',
+                    message='Unknown ticker FOO/BTC')
+
         self.m.get_ticker.return_value = { "inverted": False }
         with self.subTest(desc="Already filled"):
             filled_amount.return_value = portfolio.Amount("FOO", "100")
@@ -484,6 +512,25 @@ class TradeTest(WebMockTestCase):
             trade.orders = []
             self.m.report.log_order.reset_mock()
 
+        with self.subTest(tick=22):
+            trade.update_order(order_mock, 22)
+            order_mock.cancel.assert_called()
+            new_order_mock.run.assert_called()
+            prepare_order.assert_called_with(compute_value=mock.ANY)
+            self.m.report.log_order.assert_called()
+            self.assertEqual(2, self.m.report.log_order.call_count)
+            calls = [
+                    mock.call(order_mock, 22, update="market_adjust_eat",
+                        compute_value=mock.ANY,
+                        new_order=new_order_mock),
+                    mock.call(order_mock, 22, new_order=new_order_mock),
+                    ]
+            self.m.report.log_order.assert_has_calls(calls)
+
+        order_mock.reset_mock()
+        new_order_mock.reset_mock()
+        trade.orders = []
+        self.m.report.log_order.reset_mock()
 
     def test_print_with_order(self):
         value_from = portfolio.Amount("BTC", "0.5")
@@ -589,6 +636,7 @@ class TradeTest(WebMockTestCase):
         self.assertEqual("ETH", as_json["currency"])
         self.assertEqual("BTC", as_json["base_currency"])
 
+@unittest.skipUnless("unit" in limits, "Unit skipped")
 class BalanceTest(WebMockTestCase):
     def test_values(self):
         balance = portfolio.Balance("BTC", {
@@ -664,6 +712,7 @@ class BalanceTest(WebMockTestCase):
         self.assertEqual(D(0), as_json["margin_available"])
         self.assertEqual(D(0), as_json["margin_borrowed"])
 
+@unittest.skipUnless("unit" in limits, "Unit skipped")
 class OrderTest(WebMockTestCase):
     def test_values(self):
         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
@@ -799,14 +848,20 @@ class OrderTest(WebMockTestCase):
             order.cancel()
             self.m.ccxt.cancel_order.assert_not_called()
 
-    def test_dust_amount_remaining(self):
+    def test_mark_dust_amount_remaining(self):
         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
                 D("0.1"), "BTC", "long", self.m, "trade")
-        order.remaining_amount = mock.Mock(return_value=portfolio.Amount("ETH", 1))
-        self.assertFalse(order.dust_amount_remaining())
+        self.m.ccxt.is_dust_trade.return_value = False
+        order.mark_dust_amount_remaining_order()
+        self.assertEqual("pending", order.status)
+
+        self.m.ccxt.is_dust_trade.return_value = True
+        order.mark_dust_amount_remaining_order()
+        self.assertEqual("pending", order.status)
 
-        order.remaining_amount = mock.Mock(return_value=portfolio.Amount("ETH", D("0.0001")))
-        self.assertTrue(order.dust_amount_remaining())
+        order.status = "open"
+        order.mark_dust_amount_remaining_order()
+        self.assertEqual("closed_dust_remaining", order.status)
 
     @mock.patch.object(portfolio.Order, "fetch")
     @mock.patch.object(portfolio.Order, "filled_amount", return_value=portfolio.Amount("ETH", 1))
@@ -837,6 +892,8 @@ class OrderTest(WebMockTestCase):
         fetch.assert_not_called()
         order.status = "open"
         self.assertEqual(portfolio.Amount("ETH", 5), order.filled_amount(in_base_currency=False))
+        fetch.assert_not_called()
+        self.assertEqual(portfolio.Amount("ETH", 5), order.filled_amount(in_base_currency=False, refetch=True))
         fetch.assert_called_once()
         self.assertEqual(portfolio.Amount("BTC", "0.7"), order.filled_amount(in_base_currency=True))
 
@@ -941,6 +998,7 @@ class OrderTest(WebMockTestCase):
                     "status": "foo",
                     "datetime": "timestamp"
                     }
+            self.m.ccxt.is_dust_trade.return_value = False
             order.fetch()
 
             self.m.ccxt.fetch_order.assert_called_once_with(45)
@@ -1303,7 +1361,7 @@ class OrderTest(WebMockTestCase):
         with self.subTest(similar_open_order=True):
             order = portfolio.Order("buy", portfolio.Amount("ETH", "0.001"),
                     D("0.1"), "BTC", "long", self.m, "trade")
-            order.start_date = datetime.datetime(2018, 3, 25, 15, 15, 55)
+            order.start_date = datetime.datetime(2018, 3, 25, 15, 15, 55, 0, tz(2))
 
             self.m.ccxt.order_precision.return_value = 8
             self.m.ccxt.fetch_orders.return_value = [
@@ -1413,7 +1471,7 @@ class OrderTest(WebMockTestCase):
         with self.subTest(similar_open_order=False, past_trades=True):
             order = portfolio.Order("buy", portfolio.Amount("ETH", "0.001"),
                     D("0.1"), "BTC", "long", self.m, "trade")
-            order.start_date = datetime.datetime(2018, 3, 25, 15, 15, 55)
+            order.start_date = datetime.datetime(2018, 3, 25, 15, 15, 55, 0, tz(2))
 
             self.m.ccxt.order_precision.return_value = 8
             self.m.ccxt.fetch_orders.return_value = []
@@ -1725,6 +1783,7 @@ class OrderTest(WebMockTestCase):
             result = order.retrieve_order()
             self.assertFalse(result)
 
+@unittest.skipUnless("unit" in limits, "Unit skipped")
 class MouvementTest(WebMockTestCase):
     def test_values(self):
         mouvement = portfolio.Mouvement("ETH", "BTC", {
@@ -1782,6 +1841,7 @@ class MouvementTest(WebMockTestCase):
         self.assertEqual("BTC", as_json["base_currency"])
         self.assertEqual("ETH", as_json["currency"])
 
+@unittest.skipUnless("unit" in limits, "Unit skipped")
 class AmountTest(WebMockTestCase):
     def test_values(self):
         amount = portfolio.Amount("BTC", "0.65")
@@ -1796,7 +1856,7 @@ class AmountTest(WebMockTestCase):
         with self.subTest(desc="no ticker for currency"):
             self.m.get_ticker.return_value = None
 
-            self.assertRaises(Exception, amount.in_currency, "ETH", self.m)
+            self.assertEqual(portfolio.Amount("ETH", 0), amount.in_currency("ETH", self.m))
 
         with self.subTest(desc="nominal case"):
             self.m.get_ticker.return_value = {