1 files changed, 99 insertions, 36 deletions

diff --git a/test.py b/test.py
index 8a6ba50..8240eb4 100644
--- a/test.py
+++ b/test.py
@@ -174,7 +174,7 @@ class PortfolioTest(unittest.TestCase):
 
         with open("test_portfolio.json") as example:
             import json
-            self.json_response = json.load(example)
+            self.json_response = json.load(example, parse_int=portfolio.D, parse_float=portfolio.D)
 
         self.patcher = mock.patch.multiple(portfolio.Portfolio, data=None, liquidities={})
         self.patcher.start()
@@ -220,29 +220,63 @@ class PortfolioTest(unittest.TestCase):
         self.assertEqual(10, len(liquidities["medium"].keys()))
         self.assertEqual(10, len(liquidities["high"].keys()))
 
-        expected = {'BTC': 2857, 'DGB': 1015, 'DOGE': 1805, 'SC': 623, 'ZEC': 3701}
+        expected = {
+                'BTC':  (D("0.2857"), "long"),
+                'DGB':  (D("0.1015"), "long"),
+                'DOGE': (D("0.1805"), "long"),
+                'SC':   (D("0.0623"), "long"),
+                'ZEC':  (D("0.3701"), "long"),
+                }
         self.assertDictEqual(expected, liquidities["high"]['2018-01-08'])
 
-        expected = {'ETC': 1000, 'FCT': 1000, 'GAS': 1000, 'NAV': 1000, 'OMG': 1000, 'OMNI': 1000, 'PPC': 1000, 'RIC': 1000, 'VIA': 1000, 'XCP': 1000}
+        expected = {
+                'BTC':  (D("1.1102e-16"), "long"),
+                'ETC':  (D("0.1"), "long"),
+                'FCT':  (D("0.1"), "long"),
+                'GAS':  (D("0.1"), "long"),
+                'NAV':  (D("0.1"), "long"),
+                'OMG':  (D("0.1"), "long"),
+                'OMNI': (D("0.1"), "long"),
+                'PPC':  (D("0.1"), "long"),
+                'RIC':  (D("0.1"), "long"),
+                'VIA':  (D("0.1"), "long"),
+                'XCP':  (D("0.1"), "long"),
+                }
         self.assertDictEqual(expected, liquidities["medium"]['2018-01-08'])
 
         # It doesn't refetch the data when available
         portfolio.Portfolio.parse_cryptoportfolio()
         mock_get.assert_called_once_with()
 
-        portfolio.Portfolio.data["portfolio_1"]["holding"]["direction"][3] = "short"
-        self.assertRaises(AssertionError, portfolio.Portfolio.parse_cryptoportfolio)
-
     @mock.patch.object(portfolio.Portfolio, "get_cryptoportfolio")
-    def test_repartition_pertenthousand(self, mock_get):
+    def test_repartition(self, mock_get):
         mock_get.side_effect = self.fill_data
 
-        expected_medium = {'USDT': 1000, 'ETC': 1000, 'FCT': 1000, 'OMG': 1000, 'STEEM': 1000, 'STRAT': 1000, 'XEM': 1000, 'XMR': 1000, 'XVC': 1000, 'ZRX': 1000}
-        expected_high = {'USDT': 1226, 'BTC': 1429, 'ETC': 1127, 'ETH': 1569, 'FCT': 3341, 'GAS': 1308}
+        expected_medium = {
+                'BTC':   (D("1.1102e-16"), "long"),
+                'USDT':  (D("0.1"), "long"),
+                'ETC':   (D("0.1"), "long"),
+                'FCT':   (D("0.1"), "long"),
+                'OMG':   (D("0.1"), "long"),
+                'STEEM': (D("0.1"), "long"),
+                'STRAT': (D("0.1"), "long"),
+                'XEM':   (D("0.1"), "long"),
+                'XMR':   (D("0.1"), "long"),
+                'XVC':   (D("0.1"), "long"),
+                'ZRX':   (D("0.1"), "long"),
+                }
+        expected_high = {
+                'USDT': (D("0.1226"), "long"),
+                'BTC':  (D("0.1429"), "long"),
+                'ETC':  (D("0.1127"), "long"),
+                'ETH':  (D("0.1569"), "long"),
+                'FCT':  (D("0.3341"), "long"),
+                'GAS':  (D("0.1308"), "long"),
+                }
 
-        self.assertEqual(expected_medium, portfolio.Portfolio.repartition_pertenthousand())
-        self.assertEqual(expected_medium, portfolio.Portfolio.repartition_pertenthousand(liquidity="medium"))
-        self.assertEqual(expected_high, portfolio.Portfolio.repartition_pertenthousand(liquidity="high"))
+        self.assertEqual(expected_medium, portfolio.Portfolio.repartition())
+        self.assertEqual(expected_medium, portfolio.Portfolio.repartition(liquidity="medium"))
+        self.assertEqual(expected_high, portfolio.Portfolio.repartition(liquidity="high"))
 
     def tearDown(self):
         self.patcher.stop()
@@ -339,7 +373,7 @@ class BalanceTest(unittest.TestCase):
         self.assertEqual(0, portfolio.Balance.known_balances["ETC"].total)
         self.assertListEqual(["USDT", "XVG", "ETC"], list(portfolio.Balance.currencies()))
 
-    @mock.patch.object(portfolio.Portfolio, "repartition_pertenthousand")
+    @mock.patch.object(portfolio.Portfolio, "repartition")
     @mock.patch.object(portfolio.market, "fetch_balance")
     def test_dispatch_assets(self, fetch_balance, repartition):
         fetch_balance.return_value = self.fetch_balance
@@ -348,8 +382,8 @@ class BalanceTest(unittest.TestCase):
         self.assertNotIn("XEM", portfolio.Balance.currencies())
 
         repartition.return_value = {
-                "XEM": 7500,
-                "BTC": 2600,
+                "XEM": (D("0.75"), "long"),
+                "BTC": (D("0.26"), "long"),
                 }
 
         amounts = portfolio.Balance.dispatch_assets(portfolio.Amount("BTC", "10.1"))
@@ -357,13 +391,13 @@ class BalanceTest(unittest.TestCase):
         self.assertEqual(D("2.6"), amounts["BTC"].value)
         self.assertEqual(D("7.5"), amounts["XEM"].value)
 
-    @mock.patch.object(portfolio.Portfolio, "repartition_pertenthousand")
+    @mock.patch.object(portfolio.Portfolio, "repartition")
     @mock.patch.object(portfolio.Trade, "get_ticker")
     @mock.patch.object(portfolio.Trade, "compute_trades")
     def test_prepare_trades(self, compute_trades, get_ticker, repartition):
         repartition.return_value = {
-                "XEM": 7500,
-                "BTC": 2500,
+                "XEM": (D("0.75"), "long"),
+                "BTC": (D("0.25"), "long"),
                 }
         def _get_ticker(c1, c2, market):
             if c1 == "USDT" and c2 == "BTC":
@@ -587,11 +621,12 @@ class AcceptanceTest(unittest.TestCase):
                     },
                 }
         repartition = {
-                "ETH": 2500,
-                "ETC": 2500,
-                "BTC": 4000,
-                "BTD": 500,
-                "USDT": 500,
+                "ETH":  (D("0.25"), "long"),
+                "ETC":  (D("0.25"), "long"),
+                "BTC":  (D("0.4"),  "long"),
+                "BTD":  (D("0.01"), "short"),
+                "B2X":  (D("0.04"), "long"),
+                "USDT": (D("0.05"), "long"),
                 }
 
         def fetch_ticker(symbol):
@@ -619,6 +654,12 @@ class AcceptanceTest(unittest.TestCase):
                         "bid": D("0.0008"),
                         "ask": D("0.0012")
                         }
+            if symbol == "B2X/BTC":
+                return {
+                        "symbol": "B2X/BTC",
+                        "bid": D("0.0008"),
+                        "ask": D("0.0012")
+                        }
             if symbol == "USDT/BTC":
                 raise portfolio.ExchangeError
             if symbol == "BTC/USDT":
@@ -632,7 +673,7 @@ class AcceptanceTest(unittest.TestCase):
         market = mock.Mock()
         market.fetch_balance.return_value = fetch_balance
         market.fetch_ticker.side_effect = fetch_ticker
-        with mock.patch.object(portfolio.Portfolio, "repartition_pertenthousand", return_value=repartition):
+        with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
             # Action 1
             portfolio.Balance.prepare_trades(market)
 
@@ -654,9 +695,13 @@ class AcceptanceTest(unittest.TestCase):
         self.assertNotIn("BTC", trades)
 
         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["BTD"].value_from)
-        self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades["BTD"].value_to)
+        self.assertEqual(portfolio.Amount("BTC", D("0.002")), trades["BTD"].value_to)
         self.assertEqual("buy", trades["BTD"].action)
 
+        self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["B2X"].value_from)
+        self.assertEqual(portfolio.Amount("BTC", D("0.008")), trades["B2X"].value_to)
+        self.assertEqual("buy", trades["B2X"].action)
+
         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["USDT"].value_from)
         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades["USDT"].value_to)
         self.assertEqual("buy", trades["USDT"].action)
@@ -680,7 +725,7 @@ class AcceptanceTest(unittest.TestCase):
             self.assertEqual("limit", type)
             if symbol == "ETH/BTC":
                 self.assertEqual("sell", action)
-                self.assertEqual(2, 3*amount)
+                self.assertEqual(D('0.66666666'), amount)
                 self.assertEqual(D("0.14014"), price)
             elif symbol == "XVG/BTC":
                 self.assertEqual("sell", action)
@@ -693,6 +738,7 @@ class AcceptanceTest(unittest.TestCase):
                     "id": symbol,
                     }
         market.create_order.side_effect = create_order
+        market.order_precision.return_value = 8
 
         # Action 3
         portfolio.Trade.run_orders()
@@ -734,7 +780,7 @@ class AcceptanceTest(unittest.TestCase):
                 }
         market.fetch_balance.return_value = fetch_balance
 
-        with mock.patch.object(portfolio.Portfolio, "repartition_pertenthousand", return_value=repartition):
+        with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
             # Action 5
             portfolio.Balance.update_trades(market, only="buy", compute_value="average")
 
@@ -757,9 +803,13 @@ class AcceptanceTest(unittest.TestCase):
         self.assertNotIn("BTC", trades)
 
         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["BTD"].value_from)
-        self.assertEqual(portfolio.Amount("BTC", D("0.0097")), trades["BTD"].value_to)
+        self.assertEqual(portfolio.Amount("BTC", D("0.00194")), trades["BTD"].value_to)
         self.assertEqual("buy", trades["BTD"].action)
 
+        self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["B2X"].value_from)
+        self.assertEqual(portfolio.Amount("BTC", D("0.00776")), trades["B2X"].value_to)
+        self.assertEqual("buy", trades["B2X"].action)
+
         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["USDT"].value_from)
         self.assertEqual(portfolio.Amount("BTC", D("0.0097")), trades["USDT"].value_to)
         self.assertEqual("buy", trades["USDT"].action)
@@ -772,21 +822,34 @@ class AcceptanceTest(unittest.TestCase):
         portfolio.Trade.prepare_orders(only="buy", compute_value=lambda x, y: x["ask"])
 
         all_orders = portfolio.Trade.all_orders(state="pending")
-        self.assertEqual(3, len(all_orders))
-        self.assertEqual(portfolio.Amount("ETC", D("38.5")/3), all_orders[0].amount)
+        self.assertEqual(4, len(all_orders))
+        self.assertEqual(portfolio.Amount("ETC", D("12.83333333")), round(all_orders[0].amount))
         self.assertEqual(D("0.003"), all_orders[0].rate)
         self.assertEqual("buy", all_orders[0].action)
+        self.assertEqual("long", all_orders[0].trade_type)
 
-        self.assertEqual(portfolio.Amount("BTD", D("24.25")/3), all_orders[1].amount)
+        self.assertEqual(portfolio.Amount("BTD", D("1.61666666")), round(all_orders[1].amount))
         self.assertEqual(D("0.0012"), all_orders[1].rate)
-        self.assertEqual("buy", all_orders[1].action)
+        self.assertEqual("sell", all_orders[1].action)
+        self.assertEqual("short", all_orders[1].trade_type)
+
+        diff = portfolio.Amount("B2X", D("19.4")/3) - all_orders[2].amount
+        self.assertAlmostEqual(0, diff.value)
+        self.assertEqual(D("0.0012"), all_orders[2].rate)
+        self.assertEqual("buy", all_orders[2].action)
+        self.assertEqual("long", all_orders[2].trade_type)
+
+        self.assertEqual(portfolio.Amount("BTC", D("0.0097")), all_orders[3].amount)
+        self.assertEqual(D("16000"), all_orders[3].rate)
+        self.assertEqual("sell", all_orders[3].action)
+        self.assertEqual("long", all_orders[3].trade_type)
 
-        self.assertEqual(portfolio.Amount("BTC", D("0.0097")), all_orders[2].amount)
-        self.assertEqual(D("16000"), all_orders[2].rate)
-        self.assertEqual("sell", all_orders[2].action)
+        # Action 7
+        # TODO
+        # portfolio.Trade.run_orders()
 
         with mock.patch.object(portfolio.time, "sleep") as sleep:
-            # Action 7
+            # Action 8
             portfolio.Trade.follow_orders(verbose=False)
 
             sleep.assert_called_with(30)