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                     "bid": D("0.2"),
  26                     "ask": D("0.4"),
  27                     "average": D("0.3"),
  28                     "foo": "bar",
  29                     }
  30             converted_amount = amount.in_currency("ETH", None)
  31
  32             self.assertEqual(D("3.0"), converted_amount.value)
  33             self.assertEqual("ETH", converted_amount.currency)
  34             self.assertEqual(amount, converted_amount.linked_to)
  35             self.assertEqual("bar", converted_amount.ticker["foo"])
  36
  37             converted_amount = amount.in_currency("ETH", None, action="bid", compute_value="default")
  38             self.assertEqual(D("2"), converted_amount.value)
  39
  40             converted_amount = amount.in_currency("ETH", None, compute_value="ask")
  41             self.assertEqual(D("4"), converted_amount.value)
  42
  43         converted_amount = amount.in_currency("ETH", None, rate=D("0.02"))
  44         self.assertEqual(D("0.2"), converted_amount.value)
  45
  46     def test__abs(self):
  47         amount = portfolio.Amount("SC", -120)
  48         self.assertEqual(120, abs(amount).value)
  49         self.assertEqual("SC", abs(amount).currency)
  50
  51         amount = portfolio.Amount("SC", 10)
  52         self.assertEqual(10, abs(amount).value)
  53         self.assertEqual("SC", abs(amount).currency)
  54
  55     def test__add(self):
  56         amount1 = portfolio.Amount("XVG", "12.9")
  57         amount2 = portfolio.Amount("XVG", "13.1")
  58
  59         self.assertEqual(26, (amount1 + amount2).value)
  60         self.assertEqual("XVG", (amount1 + amount2).currency)
  61
  62         amount3 = portfolio.Amount("ETH", "1.6")
  63         with self.assertRaises(Exception):
  64             amount1 + amount3
  65
  66         amount4 = portfolio.Amount("ETH", 0.0)
  67         self.assertEqual(amount1, amount1 + amount4)
  68
  69     def test__radd(self):
  70         amount = portfolio.Amount("XVG", "12.9")
  71
  72         self.assertEqual(amount, 0 + amount)
  73         with self.assertRaises(Exception):
  74             4 + amount
  75
  76     def test__sub(self):
  77         amount1 = portfolio.Amount("XVG", "13.3")
  78         amount2 = portfolio.Amount("XVG", "13.1")
  79
  80         self.assertEqual(D("0.2"), (amount1 - amount2).value)
  81         self.assertEqual("XVG", (amount1 - amount2).currency)
  82
  83         amount3 = portfolio.Amount("ETH", "1.6")
  84         with self.assertRaises(Exception):
  85             amount1 - amount3
  86
  87         amount4 = portfolio.Amount("ETH", 0.0)
  88         self.assertEqual(amount1, amount1 - amount4)
  89
  90     def test__mul(self):
  91         amount = portfolio.Amount("XEM", 11)
  92
  93         self.assertEqual(D("38.5"), (amount * D("3.5")).value)
  94         self.assertEqual(D("33"), (amount * 3).value)
  95
  96         with self.assertRaises(Exception):
  97             amount * amount
  98
  99     def test__rmul(self):
 100         amount = portfolio.Amount("XEM", 11)
 101
 102         self.assertEqual(D("38.5"), (D("3.5") * amount).value)
 103         self.assertEqual(D("33"), (3 * amount).value)
 104
 105     def test__floordiv(self):
 106         amount = portfolio.Amount("XEM", 11)
 107
 108         self.assertEqual(D("5.5"), (amount / 2).value)
 109         self.assertEqual(D("4.4"), (amount / D("2.5")).value)
 110
 111     def test__div(self):
 112         amount = portfolio.Amount("XEM", 11)
 113
 114         self.assertEqual(D("5.5"), (amount / 2).value)
 115         self.assertEqual(D("4.4"), (amount / D("2.5")).value)
 116
 117     def test__lt(self):
 118         amount1 = portfolio.Amount("BTD", 11.3)
 119         amount2 = portfolio.Amount("BTD", 13.1)
 120
 121         self.assertTrue(amount1 < amount2)
 122         self.assertFalse(amount2 < amount1)
 123         self.assertFalse(amount1 < amount1)
 124
 125         amount3 = portfolio.Amount("BTC", 1.6)
 126         with self.assertRaises(Exception):
 127             amount1 < amount3
 128
 129     def test__eq(self):
 130         amount1 = portfolio.Amount("BTD", 11.3)
 131         amount2 = portfolio.Amount("BTD", 13.1)
 132         amount3 = portfolio.Amount("BTD", 11.3)
 133
 134         self.assertFalse(amount1 == amount2)
 135         self.assertFalse(amount2 == amount1)
 136         self.assertTrue(amount1 == amount3)
 137         self.assertFalse(amount2 == 0)
 138
 139         amount4 = portfolio.Amount("BTC", 1.6)
 140         with self.assertRaises(Exception):
 141             amount1 == amount4
 142
 143         amount5 = portfolio.Amount("BTD", 0)
 144         self.assertTrue(amount5 == 0)
 145
 146     def test__str(self):
 147         amount1 = portfolio.Amount("BTX", 32)
 148         self.assertEqual("32.00000000 BTX", str(amount1))
 149
 150         amount2 = portfolio.Amount("USDT", 12000)
 151         amount1.linked_to = amount2
 152         self.assertEqual("32.00000000 BTX [12000.00000000 USDT]", str(amount1))
 153
 154     def test__repr(self):
 155         amount1 = portfolio.Amount("BTX", 32)
 156         self.assertEqual("Amount(32.00000000 BTX)", repr(amount1))
 157
 158         amount2 = portfolio.Amount("USDT", 12000)
 159         amount1.linked_to = amount2
 160         self.assertEqual("Amount(32.00000000 BTX -> Amount(12000.00000000 USDT))", repr(amount1))
 161
 162         amount3 = portfolio.Amount("BTC", 0.1)
 163         amount2.linked_to = amount3
 164         self.assertEqual("Amount(32.00000000 BTX -> Amount(12000.00000000 USDT -> Amount(0.10000000 BTC)))", repr(amount1))
 165
 166 class PortfolioTest(unittest.TestCase):
 167     import urllib3
 168     def fill_data(self):
 169         if self.json_response is not None:
 170             portfolio.Portfolio.data = self.json_response
 171
 172     def setUp(self):
 173         super(PortfolioTest, self).setUp()
 174
 175         with open("test_portfolio.json") as example:
 176             import json
 177             self.json_response = json.load(example)
 178
 179         self.patcher = mock.patch.multiple(portfolio.Portfolio, data=None, liquidities={})
 180         self.patcher.start()
 181
 182     @mock.patch.object(urllib3, "disable_warnings")
 183     @mock.patch.object(urllib3.poolmanager.PoolManager, "request")
 184     @mock.patch.object(portfolio.Portfolio, "URL", new="foo://bar")
 185     def test_get_cryptoportfolio(self, request, disable_warnings):
 186         request.side_effect = [
 187                 type('', (), { "data": '{ "foo": "bar" }' }),
 188                 type('', (), { "data": 'System Error' }),
 189                 Exception("Connection error"),
 190                 ]
 191
 192         portfolio.Portfolio.get_cryptoportfolio()
 193         self.assertIn("foo", portfolio.Portfolio.data)
 194         self.assertEqual("bar", portfolio.Portfolio.data["foo"])
 195         request.assert_called_with("GET", "foo://bar")
 196
 197         request.reset_mock()
 198         portfolio.Portfolio.get_cryptoportfolio()
 199         self.assertIsNone(portfolio.Portfolio.data)
 200         request.assert_called_with("GET", "foo://bar")
 201
 202         request.reset_mock()
 203         portfolio.Portfolio.data = "foo"
 204         portfolio.Portfolio.get_cryptoportfolio()
 205         request.assert_called_with("GET", "foo://bar")
 206         self.assertEqual("foo", portfolio.Portfolio.data)
 207         disable_warnings.assert_called_with()
 208
 209     @mock.patch.object(portfolio.Portfolio, "get_cryptoportfolio")
 210     def test_parse_cryptoportfolio(self, mock_get):
 211         mock_get.side_effect = self.fill_data
 212
 213         portfolio.Portfolio.parse_cryptoportfolio()
 214
 215         self.assertListEqual(
 216                 ["medium", "high"],
 217                 list(portfolio.Portfolio.liquidities.keys()))
 218
 219         liquidities = portfolio.Portfolio.liquidities
 220         self.assertEqual(10, len(liquidities["medium"].keys()))
 221         self.assertEqual(10, len(liquidities["high"].keys()))
 222
 223         expected = {'BTC': 2857, 'DGB': 1015, 'DOGE': 1805, 'SC': 623, 'ZEC': 3701}
 224         self.assertDictEqual(expected, liquidities["high"]['2018-01-08'])
 225
 226         expected = {'ETC': 1000, 'FCT': 1000, 'GAS': 1000, 'NAV': 1000, 'OMG': 1000, 'OMNI': 1000, 'PPC': 1000, 'RIC': 1000, 'VIA': 1000, 'XCP': 1000}
 227         self.assertDictEqual(expected, liquidities["medium"]['2018-01-08'])
 228
 229         # It doesn't refetch the data when available
 230         portfolio.Portfolio.parse_cryptoportfolio()
 231         mock_get.assert_called_once_with()
 232
 233         portfolio.Portfolio.data["portfolio_1"]["holding"]["direction"][3] = "short"
 234         self.assertRaises(AssertionError, portfolio.Portfolio.parse_cryptoportfolio)
 235
 236     @mock.patch.object(portfolio.Portfolio, "get_cryptoportfolio")
 237     def test_repartition_pertenthousand(self, mock_get):
 238         mock_get.side_effect = self.fill_data
 239
 240         expected_medium = {'USDT': 1000, 'ETC': 1000, 'FCT': 1000, 'OMG': 1000, 'STEEM': 1000, 'STRAT': 1000, 'XEM': 1000, 'XMR': 1000, 'XVC': 1000, 'ZRX': 1000}
 241         expected_high = {'USDT': 1226, 'BTC': 1429, 'ETC': 1127, 'ETH': 1569, 'FCT': 3341, 'GAS': 1308}
 242
 243         self.assertEqual(expected_medium, portfolio.Portfolio.repartition_pertenthousand())
 244         self.assertEqual(expected_medium, portfolio.Portfolio.repartition_pertenthousand(liquidity="medium"))
 245         self.assertEqual(expected_high, portfolio.Portfolio.repartition_pertenthousand(liquidity="high"))
 246
 247     def tearDown(self):
 248         self.patcher.stop()
 249
 250 class BalanceTest(unittest.TestCase):
 251     def setUp(self):
 252         super(BalanceTest, self).setUp()
 253
 254         self.fetch_balance = {
 255                 "free": "foo",
 256                 "info": "bar",
 257                 "used": "baz",
 258                 "total": "bazz",
 259                 "ETC": {
 260                     "free": 0.0,
 261                     "used": 0.0,
 262                     "total": 0.0
 263                     },
 264                 "USDT": {
 265                     "free": 6.0,
 266                     "used": 1.2,
 267                     "total": 7.2
 268                     },
 269                 "XVG": {
 270                     "free": 16,
 271                     "used": 0.0,
 272                     "total": 16
 273                     },
 274                 "XMR": {
 275                     "free": 0.0,
 276                     "used": 0.0,
 277                     "total": 0.0
 278                     },
 279                 }
 280         self.patcher = mock.patch.multiple(portfolio.Balance, known_balances={})
 281         self.patcher.start()
 282
 283     def test_values(self):
 284         balance = portfolio.Balance("BTC", 0.65, 0.35, 0.30)
 285         self.assertEqual(0.65, balance.total.value)
 286         self.assertEqual(0.35, balance.free.value)
 287         self.assertEqual(0.30, balance.used.value)
 288         self.assertEqual("BTC", balance.currency)
 289
 290         balance = portfolio.Balance.from_hash("BTC", { "total": 0.65, "free": 0.35, "used": 0.30})
 291         self.assertEqual(0.65, balance.total.value)
 292         self.assertEqual(0.35, balance.free.value)
 293         self.assertEqual(0.30, balance.used.value)
 294         self.assertEqual("BTC", balance.currency)
 295
 296     @mock.patch.object(portfolio.Trade, "get_ticker")
 297     def test_in_currency(self, get_ticker):
 298         portfolio.Balance.known_balances = {
 299                 "BTC": portfolio.Balance("BTC", "0.65", "0.35", "0.30"),
 300                 "ETH": portfolio.Balance("ETH", 3, 3, 0),
 301                 }
 302         market = mock.Mock()
 303         get_ticker.return_value = {
 304                 "bid": D("0.09"),
 305                 "ask": D("0.11"),
 306                 "average": D("0.1"),
 307                 }
 308
 309         amounts = portfolio.Balance.in_currency("BTC", market)
 310         self.assertEqual("BTC", amounts["ETH"].currency)
 311         self.assertEqual(D("0.65"), amounts["BTC"].value)
 312         self.assertEqual(D("0.30"), amounts["ETH"].value)
 313
 314         amounts = portfolio.Balance.in_currency("BTC", market, compute_value="bid")
 315         self.assertEqual(D("0.65"), amounts["BTC"].value)
 316         self.assertEqual(D("0.27"), amounts["ETH"].value)
 317
 318         amounts = portfolio.Balance.in_currency("BTC", market, compute_value="bid", type="used")
 319         self.assertEqual(D("0.30"), amounts["BTC"].value)
 320         self.assertEqual(0, amounts["ETH"].value)
 321
 322     def test_currencies(self):
 323         portfolio.Balance.known_balances = {
 324                 "BTC": portfolio.Balance("BTC", "0.65", "0.35", "0.30"),
 325                 "ETH": portfolio.Balance("ETH", 3, 3, 0),
 326                 }
 327         self.assertListEqual(["BTC", "ETH"], list(portfolio.Balance.currencies()))
 328
 329     @mock.patch.object(portfolio.market, "fetch_balance")
 330     def test_fetch_balances(self, fetch_balance):
 331         fetch_balance.return_value = self.fetch_balance
 332
 333         portfolio.Balance.fetch_balances(portfolio.market)
 334         self.assertNotIn("XMR", portfolio.Balance.currencies())
 335         self.assertListEqual(["USDT", "XVG"], list(portfolio.Balance.currencies()))
 336
 337         portfolio.Balance.known_balances["ETC"] = portfolio.Balance("ETC", "1", "0", "1")
 338         portfolio.Balance.fetch_balances(portfolio.market)
 339         self.assertEqual(0, portfolio.Balance.known_balances["ETC"].total)
 340         self.assertListEqual(["USDT", "XVG", "ETC"], list(portfolio.Balance.currencies()))
 341
 342     @mock.patch.object(portfolio.Portfolio, "repartition_pertenthousand")
 343     @mock.patch.object(portfolio.market, "fetch_balance")
 344     def test_dispatch_assets(self, fetch_balance, repartition):
 345         fetch_balance.return_value = self.fetch_balance
 346         portfolio.Balance.fetch_balances(portfolio.market)
 347
 348         self.assertNotIn("XEM", portfolio.Balance.currencies())
 349
 350         repartition.return_value = {
 351                 "XEM": 7500,
 352                 "BTC": 2600,
 353                 }
 354
 355         amounts = portfolio.Balance.dispatch_assets(portfolio.Amount("BTC", "10.1"))
 356         self.assertIn("XEM", portfolio.Balance.currencies())
 357         self.assertEqual(D("2.6"), amounts["BTC"].value)
 358         self.assertEqual(D("7.5"), amounts["XEM"].value)
 359
 360     @mock.patch.object(portfolio.Portfolio, "repartition_pertenthousand")
 361     @mock.patch.object(portfolio.Trade, "get_ticker")
 362     @mock.patch.object(portfolio.Trade, "compute_trades")
 363     def test_prepare_trades(self, compute_trades, get_ticker, repartition):
 364         repartition.return_value = {
 365                 "XEM": 7500,
 366                 "BTC": 2500,
 367                 }
 368         def _get_ticker(c1, c2, market):
 369             if c1 == "USDT" and c2 == "BTC":
 370                 return { "average": D("0.0001") }
 371             if c1 == "XVG" and c2 == "BTC":
 372                 return { "average": D("0.000001") }
 373             if c1 == "XEM" and c2 == "BTC":
 374                 return { "average": D("0.001") }
 375             self.fail("Should be called with {}, {}".format(c1, c2))
 376         get_ticker.side_effect = _get_ticker
 377
 378         market = mock.Mock()
 379         market.fetch_balance.return_value = {
 380                 "USDT": {
 381                     "free": D("10000.0"),
 382                     "used": D("0.0"),
 383                     "total": D("10000.0")
 384                     },
 385                 "XVG": {
 386                     "free": D("10000.0"),
 387                     "used": D("0.0"),
 388                     "total": D("10000.0")
 389                     },
 390                 }
 391         portfolio.Balance.prepare_trades(market)
 392         compute_trades.assert_called()
 393
 394         call = compute_trades.call_args
 395         self.assertEqual(market, call[1]["market"])
 396         self.assertEqual(1, call[0][0]["USDT"].value)
 397         self.assertEqual(D("0.01"), call[0][0]["XVG"].value)
 398         self.assertEqual(D("0.2525"), call[0][1]["BTC"].value)
 399         self.assertEqual(D("0.7575"), call[0][1]["XEM"].value)
 400
 401     @unittest.skip("TODO")
 402     def test_update_trades(self):
 403         pass
 404
 405     def test__repr(self):
 406         balance = portfolio.Balance("BTX", 3, 1, 2)
 407         self.assertEqual("Balance(BTX [1.00000000 BTX/2.00000000 BTX/3.00000000 BTX])", repr(balance))
 408
 409     def tearDown(self):
 410         self.patcher.stop()
 411
 412 class TradeTest(unittest.TestCase):
 413     import time
 414
 415     def setUp(self):
 416         super(TradeTest, self).setUp()
 417
 418         self.patcher = mock.patch.multiple(portfolio.Trade,
 419                 ticker_cache={},
 420                 ticker_cache_timestamp=self.time.time(),
 421                 fees_cache={},
 422                 trades={})
 423         self.patcher.start()
 424
 425     def test_get_ticker(self):
 426         market = mock.Mock()
 427         market.fetch_ticker.side_effect = [
 428                 { "bid": 1, "ask": 3 },
 429                 portfolio.ccxt.ExchangeError("foo"),
 430                 { "bid": 10, "ask": 40 },
 431                 portfolio.ccxt.ExchangeError("foo"),
 432                 portfolio.ccxt.ExchangeError("foo"),
 433                 ]
 434
 435         ticker = portfolio.Trade.get_ticker("ETH", "ETC", market)
 436         market.fetch_ticker.assert_called_with("ETH/ETC")
 437         self.assertEqual(1, ticker["bid"])
 438         self.assertEqual(3, ticker["ask"])
 439         self.assertEqual(2, ticker["average"])
 440         self.assertFalse(ticker["inverted"])
 441
 442         ticker = portfolio.Trade.get_ticker("ETH", "XVG", market)
 443         self.assertEqual(0.0625, ticker["average"])
 444         self.assertTrue(ticker["inverted"])
 445         self.assertIn("original", ticker)
 446         self.assertEqual(10, ticker["original"]["bid"])
 447
 448         ticker = portfolio.Trade.get_ticker("XVG", "XMR", market)
 449         self.assertIsNone(ticker)
 450
 451         market.fetch_ticker.assert_has_calls([
 452             mock.call("ETH/ETC"),
 453             mock.call("ETH/XVG"),
 454             mock.call("XVG/ETH"),
 455             mock.call("XVG/XMR"),
 456             mock.call("XMR/XVG"),
 457             ])
 458
 459         market2 = mock.Mock()
 460         market2.fetch_ticker.side_effect = [
 461                 { "bid": 1, "ask": 3 },
 462                 { "bid": 1.2, "ask": 3.5 },
 463                 ]
 464         ticker1 = portfolio.Trade.get_ticker("ETH", "ETC", market2)
 465         ticker2 = portfolio.Trade.get_ticker("ETH", "ETC", market2)
 466         ticker3 = portfolio.Trade.get_ticker("ETC", "ETH", market2)
 467         market2.fetch_ticker.assert_called_once_with("ETH/ETC")
 468         self.assertEqual(1, ticker1["bid"])
 469         self.assertDictEqual(ticker1, ticker2)
 470         self.assertDictEqual(ticker1, ticker3["original"])
 471
 472         ticker4 = portfolio.Trade.get_ticker("ETH", "ETC", market2, refresh=True)
 473         ticker5 = portfolio.Trade.get_ticker("ETH", "ETC", market2)
 474         self.assertEqual(1.2, ticker4["bid"])
 475         self.assertDictEqual(ticker4, ticker5)
 476
 477         market3 = mock.Mock()
 478         market3.fetch_ticker.side_effect = [
 479                 { "bid": 1, "ask": 3 },
 480                 { "bid": 1.2, "ask": 3.5 },
 481                 ]
 482         ticker6 = portfolio.Trade.get_ticker("ETH", "ETC", market3)
 483         portfolio.Trade.ticker_cache_timestamp -= 4
 484         ticker7 = portfolio.Trade.get_ticker("ETH", "ETC", market3)
 485         portfolio.Trade.ticker_cache_timestamp -= 2
 486         ticker8 = portfolio.Trade.get_ticker("ETH", "ETC", market3)
 487         self.assertDictEqual(ticker6, ticker7)
 488         self.assertEqual(1.2, ticker8["bid"])
 489
 490     @unittest.skip("TODO")
 491     def test_values_assertion(self):
 492         pass
 493
 494     @unittest.skip("TODO")
 495     def test_fetch_fees(self):
 496         pass
 497
 498     @unittest.skip("TODO")
 499     def test_compute_trades(self):
 500         pass
 501
 502     @unittest.skip("TODO")
 503     def test_action(self):
 504         pass
 505
 506     @unittest.skip("TODO")
 507     def test_action(self):
 508         pass
 509
 510     @unittest.skip("TODO")
 511     def test_order_action(self):
 512         pass
 513
 514     @unittest.skip("TODO")
 515     def test_prepare_order(self):
 516         pass
 517
 518     @unittest.skip("TODO")
 519     def test_all_orders(self):
 520         pass
 521
 522     @unittest.skip("TODO")
 523     def test_follow_orders(self):
 524         pass
 525
 526     @unittest.skip("TODO")
 527     def test_compute_value(self):
 528         pass
 529
 530     @unittest.skip("TODO")
 531     def test__repr(self):
 532         pass
 533
 534     def tearDown(self):
 535         self.patcher.stop()
 536
 537 class AcceptanceTest(unittest.TestCase):
 538     import time
 539
 540     def setUp(self):
 541         super(AcceptanceTest, self).setUp()
 542
 543         self.patchers = [
 544                 mock.patch.multiple(portfolio.Balance, known_balances={}),
 545                 mock.patch.multiple(portfolio.Portfolio, data=None, liquidities={}),
 546                 mock.patch.multiple(portfolio.Trade,
 547                     ticker_cache={},
 548                     ticker_cache_timestamp=self.time.time(),
 549                     fees_cache={},
 550                     trades={}),
 551                 mock.patch.multiple(portfolio.Computation,
 552                     computations=portfolio.Computation.computations)
 553                 ]
 554         for patcher in self.patchers:
 555             patcher.start()
 556
 557     def test_success_sell_only_necessary(self):
 558         fetch_balance = {
 559                 "ETH": {
 560                     "free": D("1.0"),
 561                     "used": D("0.0"),
 562                     "total": D("1.0"),
 563                     },
 564                 "ETC": {
 565                     "free": D("4.0"),
 566                     "used": D("0.0"),
 567                     "total": D("4.0"),
 568                     },
 569                 "XVG": {
 570                     "free": D("1000.0"),
 571                     "used": D("0.0"),
 572                     "total": D("1000.0"),
 573                     },
 574                 }
 575         repartition = {
 576                 "ETH": 2500,
 577                 "ETC": 2500,
 578                 "BTC": 4000,
 579                 "BTD": 500,
 580                 "USDT": 500,
 581                 }
 582
 583         def fetch_ticker(symbol):
 584             if symbol == "ETH/BTC":
 585                 return {
 586                         "symbol": "ETH/BTC",
 587                         "bid": D("0.14"),
 588                         "ask": D("0.16")
 589                         }
 590             if symbol == "ETC/BTC":
 591                 return {
 592                         "symbol": "ETC/BTC",
 593                         "bid": D("0.002"),
 594                         "ask": D("0.003")
 595                         }
 596             if symbol == "XVG/BTC":
 597                 return {
 598                         "symbol": "XVG/BTC",
 599                         "bid": D("0.00003"),
 600                         "ask": D("0.00005")
 601                         }
 602             if symbol == "BTD/BTC":
 603                 return {
 604                         "symbol": "BTD/BTC",
 605                         "bid": D("0.0008"),
 606                         "ask": D("0.0012")
 607                         }
 608             if symbol == "USDT/BTC":
 609                 raise portfolio.ccxt.ExchangeError
 610             if symbol == "BTC/USDT":
 611                 return {
 612                         "symbol": "BTC/USDT",
 613                         "bid": D("14000"),
 614                         "ask": D("16000")
 615                         }
 616             self.fail("Shouldn't have been called with {}".format(symbol))
 617
 618         market = mock.Mock()
 619         market.fetch_balance.return_value = fetch_balance
 620         market.fetch_ticker.side_effect = fetch_ticker
 621         with mock.patch.object(portfolio.Portfolio, "repartition_pertenthousand", return_value=repartition):
 622             # Action 1
 623             portfolio.Balance.prepare_trades(market)
 624
 625         balances = portfolio.Balance.known_balances
 626         self.assertEqual(portfolio.Amount("ETH", 1), balances["ETH"].total)
 627         self.assertEqual(portfolio.Amount("ETC", 4), balances["ETC"].total)
 628         self.assertEqual(portfolio.Amount("XVG", 1000), balances["XVG"].total)
 629
 630
 631         trades = portfolio.Trade.trades
 632         self.assertEqual(portfolio.Amount("BTC", D("0.15")), trades["ETH"].value_from)
 633         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades["ETH"].value_to)
 634         self.assertEqual("sell", trades["ETH"].action)
 635
 636         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades["ETC"].value_from)
 637         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades["ETC"].value_to)
 638         self.assertEqual("buy", trades["ETC"].action)
 639
 640         self.assertNotIn("BTC", trades)
 641
 642         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["BTD"].value_from)
 643         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades["BTD"].value_to)
 644         self.assertEqual("buy", trades["BTD"].action)
 645
 646         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["USDT"].value_from)
 647         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades["USDT"].value_to)
 648         self.assertEqual("buy", trades["USDT"].action)
 649
 650         self.assertEqual(portfolio.Amount("BTC", D("0.04")), trades["XVG"].value_from)
 651         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["XVG"].value_to)
 652         self.assertEqual("sell", trades["XVG"].action)
 653
 654         # Action 2
 655         portfolio.Trade.prepare_orders(only="sell", compute_value=lambda x, y: x["bid"] * D("1.001"))
 656
 657         all_orders = portfolio.Trade.all_orders()
 658         self.assertEqual(2, len(all_orders))
 659         self.assertEqual(2, 3*all_orders[0].amount.value)
 660         self.assertEqual(D("0.14014"), all_orders[0].rate)
 661         self.assertEqual(1000, all_orders[1].amount.value)
 662         self.assertEqual(D("0.00003003"), all_orders[1].rate)
 663
 664
 665         def create_order(symbol, type, action, amount, price=None):
 666             self.assertEqual("limit", type)
 667             if symbol == "ETH/BTC":
 668                 self.assertEqual("sell", action)
 669                 self.assertEqual(2, 3*amount)
 670                 self.assertEqual(D("0.14014"), price)
 671             elif symbol == "XVG/BTC":
 672                 self.assertEqual("sell", action)
 673                 self.assertEqual(1000, amount)
 674                 self.assertEqual(D("0.00003003"), price)
 675             else:
 676                 self.fail("I shouldn't have been called")
 677
 678             return {
 679                     "id": symbol,
 680                     }
 681         market.create_order.side_effect = create_order
 682
 683         # Action 3
 684         portfolio.Trade.run_orders()
 685
 686         self.assertEqual("open", all_orders[0].status)
 687         self.assertEqual("open", all_orders[1].status)
 688
 689         market.fetch_order.return_value = { "status": "closed" }
 690         with mock.patch.object(portfolio.time, "sleep") as sleep:
 691             # Action 4
 692             portfolio.Trade.follow_orders(verbose=False)
 693
 694             sleep.assert_called_with(30)
 695
 696         for order in all_orders:
 697             self.assertEqual("closed", order.status)
 698
 699         fetch_balance = {
 700                 "ETH": {
 701                     "free": D("1.0") / 3,
 702                     "used": D("0.0"),
 703                     "total": D("1.0") / 3,
 704                     },
 705                 "BTC": {
 706                     "free": D("0.134"),
 707                     "used": D("0.0"),
 708                     "total": D("0.134"),
 709                     },
 710                 "ETC": {
 711                     "free": D("4.0"),
 712                     "used": D("0.0"),
 713                     "total": D("4.0"),
 714                     },
 715                 "XVG": {
 716                     "free": D("0.0"),
 717                     "used": D("0.0"),
 718                     "total": D("0.0"),
 719                     },
 720                 }
 721         market.fetch_balance.return_value = fetch_balance
 722
 723         with mock.patch.object(portfolio.Portfolio, "repartition_pertenthousand", return_value=repartition):
 724             # Action 5
 725             portfolio.Balance.update_trades(market, only="buy", compute_value="average")
 726
 727         balances = portfolio.Balance.known_balances
 728         self.assertEqual(portfolio.Amount("ETH", 1 / D("3")), balances["ETH"].total)
 729         self.assertEqual(portfolio.Amount("ETC", 4), balances["ETC"].total)
 730         self.assertEqual(portfolio.Amount("BTC", D("0.134")), balances["BTC"].total)
 731         self.assertEqual(portfolio.Amount("XVG", 0), balances["XVG"].total)
 732
 733
 734         trades = portfolio.Trade.trades
 735         self.assertEqual(portfolio.Amount("BTC", D("0.15")), trades["ETH"].value_from)
 736         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades["ETH"].value_to)
 737         self.assertEqual("sell", trades["ETH"].action)
 738
 739         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades["ETC"].value_from)
 740         self.assertEqual(portfolio.Amount("BTC", D("0.0485")), trades["ETC"].value_to)
 741         self.assertEqual("buy", trades["ETC"].action)
 742
 743         self.assertNotIn("BTC", trades)
 744
 745         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["BTD"].value_from)
 746         self.assertEqual(portfolio.Amount("BTC", D("0.0097")), trades["BTD"].value_to)
 747         self.assertEqual("buy", trades["BTD"].action)
 748
 749         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["USDT"].value_from)
 750         self.assertEqual(portfolio.Amount("BTC", D("0.0097")), trades["USDT"].value_to)
 751         self.assertEqual("buy", trades["USDT"].action)
 752
 753         self.assertEqual(portfolio.Amount("BTC", D("0.04")), trades["XVG"].value_from)
 754         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades["XVG"].value_to)
 755         self.assertEqual("sell", trades["XVG"].action)
 756
 757         # Action 6
 758         portfolio.Trade.prepare_orders(only="buy", compute_value=lambda x, y: x["ask"])
 759
 760
 761         all_orders = portfolio.Trade.all_orders(state="pending")
 762         self.assertEqual(3, len(all_orders))
 763         self.assertEqual(portfolio.Amount("ETC", D("38.5")/3), all_orders[0].amount)
 764         self.assertEqual(D("0.003"), all_orders[0].rate)
 765         self.assertEqual("buy", all_orders[0].action)
 766
 767         self.assertEqual(portfolio.Amount("BTD", D("24.25")/3), all_orders[1].amount)
 768         self.assertEqual(D("0.0012"), all_orders[1].rate)
 769         self.assertEqual("buy", all_orders[1].action)
 770
 771         self.assertEqual(portfolio.Amount("BTC", D("0.0097")), all_orders[2].amount)
 772         self.assertEqual(D("16000"), all_orders[2].rate)
 773         self.assertEqual("sell", all_orders[2].action)
 774
 775         with mock.patch.object(portfolio.time, "sleep") as sleep:
 776             # Action 7
 777             portfolio.Trade.follow_orders(verbose=False)
 778
 779             sleep.assert_called_with(30)
 780
 781     def tearDown(self):
 782         for patcher in self.patchers:
 783             patcher.stop()
 784
 785 if __name__ == '__main__':
 786     unittest.main()