test.py

   1 import portfolio
   2 import unittest
   3 from decimal import Decimal as D
   4 from unittest import mock
   5
   6 class AmountTest(unittest.TestCase):
   7     def test_values(self):
   8         amount = portfolio.Amount("BTC", "0.65")
   9         self.assertEqual(D("0.65"), amount.value)
  10         self.assertEqual("BTC", amount.currency)
  11
  12     def test_in_currency(self):
  13         amount = portfolio.Amount("ETC", 10)
  14
  15         self.assertEqual(amount, amount.in_currency("ETC", None))
  16
  17         ticker_mock = unittest.mock.Mock()
  18         with mock.patch.object(portfolio.Trade, 'get_ticker', new=ticker_mock):
  19             ticker_mock.return_value = None
  20
  21             self.assertRaises(Exception, amount.in_currency, "ETH", None)
  22
  23         with mock.patch.object(portfolio.Trade, 'get_ticker', new=ticker_mock):
  24             ticker_mock.return_value = {
  25                     "average": D("0.3"),
  26                     "foo": "bar",
  27                     }
  28             converted_amount = amount.in_currency("ETH", None)
  29
  30             self.assertEqual(D("3.0"), converted_amount.value)
  31             self.assertEqual("ETH", converted_amount.currency)
  32             self.assertEqual(amount, converted_amount.linked_to)
  33             self.assertEqual("bar", converted_amount.ticker["foo"])
  34
  35     def test__abs(self):
  36         amount = portfolio.Amount("SC", -120)
  37         self.assertEqual(120, abs(amount).value)
  38         self.assertEqual("SC", abs(amount).currency)
  39
  40         amount = portfolio.Amount("SC", 10)
  41         self.assertEqual(10, abs(amount).value)
  42         self.assertEqual("SC", abs(amount).currency)
  43
  44     def test__add(self):
  45         amount1 = portfolio.Amount("XVG", "12.9")
  46         amount2 = portfolio.Amount("XVG", "13.1")
  47
  48         self.assertEqual(26, (amount1 + amount2).value)
  49         self.assertEqual("XVG", (amount1 + amount2).currency)
  50
  51         amount3 = portfolio.Amount("ETH", "1.6")
  52         with self.assertRaises(Exception):
  53             amount1 + amount3
  54
  55         amount4 = portfolio.Amount("ETH", 0.0)
  56         self.assertEqual(amount1, amount1 + amount4)
  57
  58     def test__radd(self):
  59         amount = portfolio.Amount("XVG", "12.9")
  60
  61         self.assertEqual(amount, 0 + amount)
  62         with self.assertRaises(Exception):
  63             4 + amount
  64
  65     def test__sub(self):
  66         amount1 = portfolio.Amount("XVG", "13.3")
  67         amount2 = portfolio.Amount("XVG", "13.1")
  68
  69         self.assertEqual(D("0.2"), (amount1 - amount2).value)
  70         self.assertEqual("XVG", (amount1 - amount2).currency)
  71
  72         amount3 = portfolio.Amount("ETH", "1.6")
  73         with self.assertRaises(Exception):
  74             amount1 - amount3
  75
  76         amount4 = portfolio.Amount("ETH", 0.0)
  77         self.assertEqual(amount1, amount1 - amount4)
  78
  79     def test__mul(self):
  80         amount = portfolio.Amount("XEM", 11)
  81
  82         self.assertEqual(D("38.5"), (amount * D("3.5")).value)
  83         self.assertEqual(D("33"), (amount * 3).value)
  84
  85         with self.assertRaises(Exception):
  86             amount * amount
  87
  88     def test__rmul(self):
  89         amount = portfolio.Amount("XEM", 11)
  90
  91         self.assertEqual(D("38.5"), (D("3.5") * amount).value)
  92         self.assertEqual(D("33"), (3 * amount).value)
  93
  94     def test__floordiv(self):
  95         amount = portfolio.Amount("XEM", 11)
  96
  97         self.assertEqual(D("5.5"), (amount / 2).value)
  98         self.assertEqual(D("4.4"), (amount / D("2.5")).value)
  99
 100     def test__div(self):
 101         amount = portfolio.Amount("XEM", 11)
 102
 103         self.assertEqual(D("5.5"), (amount / 2).value)
 104         self.assertEqual(D("4.4"), (amount / D("2.5")).value)
 105
 106     def test__lt(self):
 107         amount1 = portfolio.Amount("BTD", 11.3)
 108         amount2 = portfolio.Amount("BTD", 13.1)
 109
 110         self.assertTrue(amount1 < amount2)
 111         self.assertFalse(amount2 < amount1)
 112         self.assertFalse(amount1 < amount1)
 113
 114         amount3 = portfolio.Amount("BTC", 1.6)
 115         with self.assertRaises(Exception):
 116             amount1 < amount3
 117
 118     def test__eq(self):
 119         amount1 = portfolio.Amount("BTD", 11.3)
 120         amount2 = portfolio.Amount("BTD", 13.1)
 121         amount3 = portfolio.Amount("BTD", 11.3)
 122
 123         self.assertFalse(amount1 == amount2)
 124         self.assertFalse(amount2 == amount1)
 125         self.assertTrue(amount1 == amount3)
 126         self.assertFalse(amount2 == 0)
 127
 128         amount4 = portfolio.Amount("BTC", 1.6)
 129         with self.assertRaises(Exception):
 130             amount1 == amount4
 131
 132         amount5 = portfolio.Amount("BTD", 0)
 133         self.assertTrue(amount5 == 0)
 134
 135     def test__str(self):
 136         amount1 = portfolio.Amount("BTX", 32)
 137         self.assertEqual("32.00000000 BTX", str(amount1))
 138
 139         amount2 = portfolio.Amount("USDT", 12000)
 140         amount1.linked_to = amount2
 141         self.assertEqual("32.00000000 BTX [12000.00000000 USDT]", str(amount1))
 142
 143     def test__repr(self):
 144         amount1 = portfolio.Amount("BTX", 32)
 145         self.assertEqual("Amount(32.00000000 BTX)", repr(amount1))
 146
 147         amount2 = portfolio.Amount("USDT", 12000)
 148         amount1.linked_to = amount2
 149         self.assertEqual("Amount(32.00000000 BTX -> Amount(12000.00000000 USDT))", repr(amount1))
 150
 151         amount3 = portfolio.Amount("BTC", 0.1)
 152         amount2.linked_to = amount3
 153         self.assertEqual("Amount(32.00000000 BTX -> Amount(12000.00000000 USDT -> Amount(0.10000000 BTC)))", repr(amount1))
 154
 155 class PortfolioTest(unittest.TestCase):
 156     import urllib3
 157     def fill_data(self):
 158         if self.json_response is not None:
 159             portfolio.Portfolio.data = self.json_response
 160
 161     def setUp(self):
 162         super(PortfolioTest, self).setUp()
 163
 164         with open("test_portfolio.json") as example:
 165             import json
 166             self.json_response = json.load(example)
 167
 168         self.patcher = mock.patch.multiple(portfolio.Portfolio, data=None, liquidities={})
 169         self.patcher.start()
 170
 171     @mock.patch.object(urllib3, "disable_warnings")
 172     @mock.patch.object(urllib3.poolmanager.PoolManager, "request")
 173     @mock.patch.object(portfolio.Portfolio, "URL", new="foo://bar")
 174     def test_get_cryptoportfolio(self, request, disable_warnings):
 175         request.side_effect = [
 176                 type('', (), { "data": '{ "foo": "bar" }' }),
 177                 type('', (), { "data": 'System Error' }),
 178                 Exception("Connection error"),
 179                 ]
 180
 181         portfolio.Portfolio.get_cryptoportfolio()
 182         self.assertIn("foo", portfolio.Portfolio.data)
 183         self.assertEqual("bar", portfolio.Portfolio.data["foo"])
 184         request.assert_called_with("GET", "foo://bar")
 185
 186         request.reset_mock()
 187         portfolio.Portfolio.get_cryptoportfolio()
 188         self.assertIsNone(portfolio.Portfolio.data)
 189         request.assert_called_with("GET", "foo://bar")
 190
 191         request.reset_mock()
 192         portfolio.Portfolio.data = "foo"
 193         portfolio.Portfolio.get_cryptoportfolio()
 194         request.assert_called_with("GET", "foo://bar")
 195         self.assertEqual("foo", portfolio.Portfolio.data)
 196         disable_warnings.assert_called_with()
 197
 198     @mock.patch.object(portfolio.Portfolio, "get_cryptoportfolio")
 199     def test_parse_cryptoportfolio(self, mock_get):
 200         mock_get.side_effect = self.fill_data
 201
 202         portfolio.Portfolio.parse_cryptoportfolio()
 203
 204         self.assertListEqual(
 205                 ["medium", "high"],
 206                 list(portfolio.Portfolio.liquidities.keys()))
 207
 208         liquidities = portfolio.Portfolio.liquidities
 209         self.assertEqual(10, len(liquidities["medium"].keys()))
 210         self.assertEqual(10, len(liquidities["high"].keys()))
 211
 212         expected = {'BTC': 2857, 'DGB': 1015, 'DOGE': 1805, 'SC': 623, 'ZEC': 3701}
 213         self.assertDictEqual(expected, liquidities["high"]['2018-01-08'])
 214
 215         expected = {'ETC': 1000, 'FCT': 1000, 'GAS': 1000, 'NAV': 1000, 'OMG': 1000, 'OMNI': 1000, 'PPC': 1000, 'RIC': 1000, 'VIA': 1000, 'XCP': 1000}
 216         self.assertDictEqual(expected, liquidities["medium"]['2018-01-08'])
 217
 218         # It doesn't refetch the data when available
 219         portfolio.Portfolio.parse_cryptoportfolio()
 220         mock_get.assert_called_once_with()
 221
 222         portfolio.Portfolio.data["portfolio_1"]["holding"]["direction"][3] = "short"
 223         self.assertRaises(AssertionError, portfolio.Portfolio.parse_cryptoportfolio)
 224
 225     @mock.patch.object(portfolio.Portfolio, "get_cryptoportfolio")
 226     def test_repartition_pertenthousand(self, mock_get):
 227         mock_get.side_effect = self.fill_data
 228
 229         expected_medium = {'USDT': 1000, 'ETC': 1000, 'FCT': 1000, 'OMG': 1000, 'STEEM': 1000, 'STRAT': 1000, 'XEM': 1000, 'XMR': 1000, 'XVC': 1000, 'ZRX': 1000}
 230         expected_high = {'USDT': 1226, 'BTC': 1429, 'ETC': 1127, 'ETH': 1569, 'FCT': 3341, 'GAS': 1308}
 231
 232         self.assertEqual(expected_medium, portfolio.Portfolio.repartition_pertenthousand())
 233         self.assertEqual(expected_medium, portfolio.Portfolio.repartition_pertenthousand(liquidity="medium"))
 234         self.assertEqual(expected_high, portfolio.Portfolio.repartition_pertenthousand(liquidity="high"))
 235
 236     def tearDown(self):
 237         self.patcher.stop()
 238
 239 class BalanceTest(unittest.TestCase):
 240     def setUp(self):
 241         super(BalanceTest, self).setUp()
 242
 243         self.fetch_balance = {
 244                 "free": "foo",
 245                 "info": "bar",
 246                 "used": "baz",
 247                 "total": "bazz",
 248                 "USDT": {
 249                     "free": 6.0,
 250                     "used": 1.2,
 251                     "total": 7.2
 252                     },
 253                 "XVG": {
 254                     "free": 16,
 255                     "used": 0.0,
 256                     "total": 16
 257                     },
 258                 "XMR": {
 259                     "free": 0.0,
 260                     "used": 0.0,
 261                     "total": 0.0
 262                     },
 263                 }
 264         self.patcher = mock.patch.multiple(portfolio.Balance, known_balances={})
 265         self.patcher.start()
 266
 267     def test_values(self):
 268         balance = portfolio.Balance("BTC", 0.65, 0.35, 0.30)
 269         self.assertEqual(0.65, balance.total.value)
 270         self.assertEqual(0.35, balance.free.value)
 271         self.assertEqual(0.30, balance.used.value)
 272         self.assertEqual("BTC", balance.currency)
 273
 274         balance = portfolio.Balance.from_hash("BTC", { "total": 0.65, "free": 0.35, "used": 0.30})
 275         self.assertEqual(0.65, balance.total.value)
 276         self.assertEqual(0.35, balance.free.value)
 277         self.assertEqual(0.30, balance.used.value)
 278         self.assertEqual("BTC", balance.currency)
 279
 280     @mock.patch.object(portfolio.Trade, "get_ticker")
 281     def test_in_currency(self, get_ticker):
 282         portfolio.Balance.known_balances = {
 283                 "BTC": portfolio.Balance("BTC", "0.65", "0.35", "0.30"),
 284                 "ETH": portfolio.Balance("ETH", 3, 3, 0),
 285                 }
 286         market = mock.Mock()
 287         get_ticker.return_value = {
 288                 "bid": D("0.09"),
 289                 "ask": D("0.11"),
 290                 "average": D("0.1"),
 291                 }
 292
 293         amounts = portfolio.Balance.in_currency("BTC", market)
 294         self.assertEqual("BTC", amounts["ETH"].currency)
 295         self.assertEqual(D("0.65"), amounts["BTC"].value)
 296         self.assertEqual(D("0.30"), amounts["ETH"].value)
 297
 298         amounts = portfolio.Balance.in_currency("BTC", market, action="bid")
 299         self.assertEqual(D("0.65"), amounts["BTC"].value)
 300         self.assertEqual(D("0.27"), amounts["ETH"].value)
 301
 302         amounts = portfolio.Balance.in_currency("BTC", market, action="bid", type="used")
 303         self.assertEqual(D("0.30"), amounts["BTC"].value)
 304         self.assertEqual(0, amounts["ETH"].value)
 305
 306     def test_currencies(self):
 307         portfolio.Balance.known_balances = {
 308                 "BTC": portfolio.Balance("BTC", "0.65", "0.35", "0.30"),
 309                 "ETH": portfolio.Balance("ETH", 3, 3, 0),
 310                 }
 311         self.assertListEqual(["BTC", "ETH"], list(portfolio.Balance.currencies()))
 312
 313     @mock.patch.object(portfolio.market, "fetch_balance")
 314     def test_fetch_balances(self, fetch_balance):
 315         fetch_balance.return_value = self.fetch_balance
 316
 317         portfolio.Balance.fetch_balances(portfolio.market)
 318         self.assertNotIn("XMR", portfolio.Balance.currencies())
 319         self.assertEqual(["USDT", "XVG"], list(portfolio.Balance.currencies()))
 320
 321     @mock.patch.object(portfolio.Portfolio, "repartition_pertenthousand")
 322     @mock.patch.object(portfolio.market, "fetch_balance")
 323     def test_dispatch_assets(self, fetch_balance, repartition):
 324         fetch_balance.return_value = self.fetch_balance
 325         portfolio.Balance.fetch_balances(portfolio.market)
 326
 327         self.assertNotIn("XEM", portfolio.Balance.currencies())
 328
 329         repartition.return_value = {
 330                 "XEM": 7500,
 331                 "BTC": 2600,
 332                 }
 333
 334         amounts = portfolio.Balance.dispatch_assets(portfolio.Amount("BTC", "10.1"))
 335         self.assertIn("XEM", portfolio.Balance.currencies())
 336         self.assertEqual(D("2.6"), amounts["BTC"].value)
 337         self.assertEqual(D("7.5"), amounts["XEM"].value)
 338
 339     @mock.patch.object(portfolio.Portfolio, "repartition_pertenthousand")
 340     @mock.patch.object(portfolio.Trade, "get_ticker")
 341     @mock.patch.object(portfolio.Trade, "compute_trades")
 342     def test_prepare_trades(self, compute_trades, get_ticker, repartition):
 343         repartition.return_value = {
 344                 "XEM": 7500,
 345                 "BTC": 2500,
 346                 }
 347         get_ticker.side_effect = [
 348                 { "average": D("0.0001") },
 349                 { "average": D("0.000001") }
 350                 ]
 351         market = mock.Mock()
 352         market.fetch_balance.return_value = {
 353                 "USDT": {
 354                     "free": D("10000.0"),
 355                     "used": D("0.0"),
 356                     "total": D("10000.0")
 357                     },
 358                 "XVG": {
 359                     "free": D("10000.0"),
 360                     "used": D("0.0"),
 361                     "total": D("10000.0")
 362                     },
 363                 }
 364         portfolio.Balance.prepare_trades(market)
 365         compute_trades.assert_called()
 366
 367         call = compute_trades.call_args
 368         self.assertEqual(market, call[1]["market"])
 369         self.assertEqual(1, call[0][0]["USDT"].value)
 370         self.assertEqual(D("0.01"), call[0][0]["XVG"].value)
 371         self.assertEqual(D("0.2525"), call[0][1]["BTC"].value)
 372         self.assertEqual(D("0.7575"), call[0][1]["XEM"].value)
 373
 374     def test__repr(self):
 375         balance = portfolio.Balance("BTX", 3, 1, 2)
 376         self.assertEqual("Balance(BTX [1.00000000 BTX/2.00000000 BTX/3.00000000 BTX])", repr(balance))
 377
 378     def tearDown(self):
 379         self.patcher.stop()
 380
 381 class TradeTest(unittest.TestCase):
 382     import time
 383
 384     def setUp(self):
 385         super(TradeTest, self).setUp()
 386
 387         self.patcher = mock.patch.multiple(portfolio.Trade,
 388                 ticker_cache={},
 389                 ticker_cache_timestamp=self.time.time(),
 390                 fees_cache={},
 391                 trades={})
 392         self.patcher.start()
 393
 394     def test_get_ticker(self):
 395         market = mock.Mock()
 396         market.fetch_ticker.side_effect = [
 397                 { "bid": 1, "ask": 3 },
 398                 portfolio.ccxt.ExchangeError("foo"),
 399                 { "bid": 10, "ask": 40 },
 400                 portfolio.ccxt.ExchangeError("foo"),
 401                 portfolio.ccxt.ExchangeError("foo"),
 402                 ]
 403
 404         ticker = portfolio.Trade.get_ticker("ETH", "ETC", market)
 405         market.fetch_ticker.assert_called_with("ETH/ETC")
 406         self.assertEqual(1, ticker["bid"])
 407         self.assertEqual(3, ticker["ask"])
 408         self.assertEqual(2, ticker["average"])
 409         self.assertFalse(ticker["inverted"])
 410
 411         ticker = portfolio.Trade.get_ticker("ETH", "XVG", market)
 412         self.assertEqual(0.0625, ticker["average"])
 413         self.assertTrue(ticker["inverted"])
 414         self.assertIn("original", ticker)
 415         self.assertEqual(10, ticker["original"]["bid"])
 416
 417         ticker = portfolio.Trade.get_ticker("XVG", "XMR", market)
 418         self.assertIsNone(ticker)
 419
 420         market.fetch_ticker.assert_has_calls([
 421             mock.call("ETH/ETC"),
 422             mock.call("ETH/XVG"),
 423             mock.call("XVG/ETH"),
 424             mock.call("XVG/XMR"),
 425             mock.call("XMR/XVG"),
 426             ])
 427
 428         market2 = mock.Mock()
 429         market2.fetch_ticker.side_effect = [
 430                 { "bid": 1, "ask": 3 },
 431                 { "bid": 1.2, "ask": 3.5 },
 432                 ]
 433         ticker1 = portfolio.Trade.get_ticker("ETH", "ETC", market2)
 434         ticker2 = portfolio.Trade.get_ticker("ETH", "ETC", market2)
 435         ticker3 = portfolio.Trade.get_ticker("ETC", "ETH", market2)
 436         market2.fetch_ticker.assert_called_once_with("ETH/ETC")
 437         self.assertEqual(1, ticker1["bid"])
 438         self.assertDictEqual(ticker1, ticker2)
 439         self.assertDictEqual(ticker1, ticker3["original"])
 440
 441         ticker4 = portfolio.Trade.get_ticker("ETH", "ETC", market2, refresh=True)
 442         ticker5 = portfolio.Trade.get_ticker("ETH", "ETC", market2)
 443         self.assertEqual(1.2, ticker4["bid"])
 444         self.assertDictEqual(ticker4, ticker5)
 445
 446         market3 = mock.Mock()
 447         market3.fetch_ticker.side_effect = [
 448                 { "bid": 1, "ask": 3 },
 449                 { "bid": 1.2, "ask": 3.5 },
 450                 ]
 451         ticker6 = portfolio.Trade.get_ticker("ETH", "ETC", market3)
 452         portfolio.Trade.ticker_cache_timestamp -= 4
 453         ticker7 = portfolio.Trade.get_ticker("ETH", "ETC", market3)
 454         portfolio.Trade.ticker_cache_timestamp -= 2
 455         ticker8 = portfolio.Trade.get_ticker("ETH", "ETC", market3)
 456         self.assertDictEqual(ticker6, ticker7)
 457         self.assertEqual(1.2, ticker8["bid"])
 458
 459     @unittest.skip("TODO")
 460     def test_values_assertion(self):
 461         pass
 462
 463     @unittest.skip("TODO")
 464     def test_fetch_fees(self):
 465         pass
 466
 467     @unittest.skip("TODO")
 468     def test_compute_trades(self):
 469         pass
 470
 471     @unittest.skip("TODO")
 472     def test_action(self):
 473         pass
 474
 475     @unittest.skip("TODO")
 476     def test_action(self):
 477         pass
 478
 479     @unittest.skip("TODO")
 480     def test_order_action(self):
 481         pass
 482
 483     @unittest.skip("TODO")
 484     def test_prepare_order(self):
 485         pass
 486
 487     @unittest.skip("TODO")
 488     def test_all_orders(self):
 489         pass
 490
 491     @unittest.skip("TODO")
 492     def test_follow_orders(self):
 493         pass
 494
 495     @unittest.skip("TODO")
 496     def test__repr(self):
 497         pass
 498
 499     def tearDown(self):
 500         self.patcher.stop()
 501
 502 if __name__ == '__main__':
 503     unittest.main()