1 files changed, 104 insertions, 14 deletions

diff --git a/tests/test_store.py b/tests/test_store.py
index 12999d3..ee7e063 100644
--- a/tests/test_store.py
+++ b/tests/test_store.py
@@ -391,6 +391,18 @@ class BalanceStoreTest(WebMockTestCase):
                     tag=None, ticker_currency='FOO', tickers='tickers',
                     type='type')
 
+        balance_store = market.BalanceStore(self.m)
+
+        with self.subTest(add_portfolio=True),\
+                mock.patch.object(market.Portfolio, "repartition") as repartition:
+            repartition.return_value = {
+                    "DOGE": D("0.5"),
+                    "USDT": D("0.5"),
+                    }
+            balance_store.fetch_balances(add_portfolio=True)
+            self.assertListEqual(["USDT", "XVG", "XMR", "DOGE"], list(balance_store.currencies()))
+
+
     @mock.patch.object(market.Portfolio, "repartition")
     def test_dispatch_assets(self, repartition):
         self.m.ccxt.fetch_all_balances.return_value = self.fetch_balance
@@ -1101,7 +1113,8 @@ class PortfolioTest(WebMockTestCase):
         self.wm.get(market.Portfolio.URL, text=self.json_response)
 
     @mock.patch.object(market.Portfolio, "parse_cryptoportfolio")
-    def test_get_cryptoportfolio(self, parse_cryptoportfolio):
+    @mock.patch.object(market.Portfolio, "store_cryptoportfolio")
+    def test_get_cryptoportfolio(self, store_cryptoportfolio, parse_cryptoportfolio):
         with self.subTest(parallel=False):
             self.wm.get(market.Portfolio.URL, [
                 {"text":'{ "foo": "bar" }', "status_code": 200},
@@ -1116,23 +1129,28 @@ class PortfolioTest(WebMockTestCase):
             market.Portfolio.report.log_error.assert_not_called()
             market.Portfolio.report.log_http_request.assert_called_once()
             parse_cryptoportfolio.assert_called_once_with()
+            store_cryptoportfolio.assert_called_once_with()
             market.Portfolio.report.log_http_request.reset_mock()
             parse_cryptoportfolio.reset_mock()
+            store_cryptoportfolio.reset_mock()
             market.Portfolio.data = store.LockedVar(None)
 
             market.Portfolio.get_cryptoportfolio()
             self.assertIsNone(market.Portfolio.data.get())
             self.assertEqual(2, self.wm.call_count)
             parse_cryptoportfolio.assert_not_called()
+            store_cryptoportfolio.assert_not_called()
             market.Portfolio.report.log_error.assert_not_called()
             market.Portfolio.report.log_http_request.assert_called_once()
             market.Portfolio.report.log_http_request.reset_mock()
             parse_cryptoportfolio.reset_mock()
+            store_cryptoportfolio.reset_mock()
 
             market.Portfolio.data = store.LockedVar("Foo")
             market.Portfolio.get_cryptoportfolio()
             self.assertEqual(2, self.wm.call_count)
             parse_cryptoportfolio.assert_not_called()
+            store_cryptoportfolio.assert_not_called()
 
             market.Portfolio.get_cryptoportfolio(refetch=True)
             self.assertEqual("Foo", market.Portfolio.data.get())
@@ -1153,6 +1171,7 @@ class PortfolioTest(WebMockTestCase):
                     market.Portfolio.get_cryptoportfolio()
                     self.assertIn("foo", market.Portfolio.data.get())
                 parse_cryptoportfolio.reset_mock()
+                store_cryptoportfolio.reset_mock()
                 with self.subTest(worker=False):
                     market.Portfolio.data = store.LockedVar(None)
                     market.Portfolio.worker = mock.Mock()
@@ -1160,6 +1179,7 @@ class PortfolioTest(WebMockTestCase):
                     market.Portfolio.get_cryptoportfolio()
                     notify.assert_called_once_with()
                     parse_cryptoportfolio.assert_not_called()
+                    store_cryptoportfolio.assert_not_called()
 
     def test_parse_cryptoportfolio(self):
         with self.subTest(description="Normal case"):
@@ -1223,25 +1243,95 @@ class PortfolioTest(WebMockTestCase):
             self.assertEqual({}, market.Portfolio.liquidities.get("high"))
             self.assertEqual(datetime.datetime(1,1,1), market.Portfolio.last_date.get())
 
-
-    @mock.patch.object(market.Portfolio, "get_cryptoportfolio")
-    def test_repartition(self, get_cryptoportfolio):
-        market.Portfolio.liquidities = store.LockedVar({
+    @mock.patch.object(store.dbs, "redis_connected")
+    @mock.patch.object(store.dbs, "redis")
+    def test_store_cryptoportfolio(self, redis, redis_connected):
+        store.Portfolio.liquidities = store.LockedVar({
                 "medium": {
-                    "2018-03-01": "medium_2018-03-01",
-                    "2018-03-08": "medium_2018-03-08",
+                    datetime.datetime(2018,3,1): "medium_2018-03-01",
+                    datetime.datetime(2018,3,8): "medium_2018-03-08",
                     },
                 "high": {
-                    "2018-03-01": "high_2018-03-01",
-                    "2018-03-08": "high_2018-03-08",
+                    datetime.datetime(2018,3,1): "high_2018-03-01",
+                    datetime.datetime(2018,3,8): "high_2018-03-08",
                     }
                 })
-        market.Portfolio.last_date = store.LockedVar("2018-03-08")
+        store.Portfolio.last_date = store.LockedVar(datetime.datetime(2018,3,8))
+
+        with self.subTest(redis_connected=False):
+            redis_connected.return_value = False
+            store.Portfolio.store_cryptoportfolio()
+            redis.set.assert_not_called()
+
+        with self.subTest(redis_connected=True):
+            redis_connected.return_value = True
+            store.Portfolio.store_cryptoportfolio()
+            redis.set.assert_has_calls([
+                mock.call("/cryptoportfolio/repartition/latest", '{"medium": "medium_2018-03-08", "high": "high_2018-03-08"}'),
+                mock.call("/cryptoportfolio/repartition/date", "2018-03-08"),
+                ])
+
+    @mock.patch.object(store.dbs, "redis_connected")
+    @mock.patch.object(store.dbs, "redis")
+    def test_retrieve_cryptoportfolio(self, redis, redis_connected):
+        with self.subTest(redis_connected=False):
+            redis_connected.return_value = False
+            store.Portfolio.retrieve_cryptoportfolio()
+            redis.get.assert_not_called()
+            self.assertIsNone(store.Portfolio.data.get())
+
+        with self.subTest(redis_connected=True, value=None):
+            redis_connected.return_value = True
+            redis.get.return_value = None
+            store.Portfolio.retrieve_cryptoportfolio()
+            self.assertEqual(2, redis.get.call_count)
+
+        redis.reset_mock()
+        with self.subTest(redis_connected=True, value="present"):
+            redis_connected.return_value = True
+            redis.get.side_effect = [
+                    b'{ "medium": "medium_repartition", "high": "high_repartition" }',
+                    b"2018-03-08"
+                    ]
+            store.Portfolio.retrieve_cryptoportfolio()
+            self.assertEqual(2, redis.get.call_count)
+            self.assertEqual(datetime.datetime(2018,3,8), store.Portfolio.last_date.get())
+            self.assertEqual("", store.Portfolio.data.get())
+            expected_liquidities = {
+                    'high': { datetime.datetime(2018, 3, 8): 'high_repartition' },
+                    'medium': { datetime.datetime(2018, 3, 8): 'medium_repartition' },
+                    }
+            self.assertEqual(expected_liquidities, store.Portfolio.liquidities.get())
+
+    @mock.patch.object(market.Portfolio, "get_cryptoportfolio")
+    @mock.patch.object(market.Portfolio, "retrieve_cryptoportfolio")
+    def test_repartition(self, retrieve_cryptoportfolio, get_cryptoportfolio):
+        with self.subTest(from_cache=False):
+            market.Portfolio.liquidities = store.LockedVar({
+                    "medium": {
+                        "2018-03-01": "medium_2018-03-01",
+                        "2018-03-08": "medium_2018-03-08",
+                        },
+                    "high": {
+                        "2018-03-01": "high_2018-03-01",
+                        "2018-03-08": "high_2018-03-08",
+                        }
+                    })
+            market.Portfolio.last_date = store.LockedVar("2018-03-08")
+
+            self.assertEqual("medium_2018-03-08", market.Portfolio.repartition())
+            get_cryptoportfolio.assert_called_once_with()
+            retrieve_cryptoportfolio.assert_not_called()
+            self.assertEqual("medium_2018-03-08", market.Portfolio.repartition(liquidity="medium"))
+            self.assertEqual("high_2018-03-08", market.Portfolio.repartition(liquidity="high"))
+
+        retrieve_cryptoportfolio.reset_mock()
+        get_cryptoportfolio.reset_mock()
 
-        self.assertEqual("medium_2018-03-08", market.Portfolio.repartition())
-        get_cryptoportfolio.assert_called_once_with()
-        self.assertEqual("medium_2018-03-08", market.Portfolio.repartition(liquidity="medium"))
-        self.assertEqual("high_2018-03-08", market.Portfolio.repartition(liquidity="high"))
+        with self.subTest(from_cache=True):
+            self.assertEqual("medium_2018-03-08", market.Portfolio.repartition(from_cache=True))
+            get_cryptoportfolio.assert_called_once_with()
+            retrieve_cryptoportfolio.assert_called_once_with()
 
     @mock.patch.object(market.time, "sleep")
     @mock.patch.object(market.Portfolio, "get_cryptoportfolio")