test.py

   1 import sys
   2 import portfolio
   3 import unittest
   4 from decimal import Decimal as D
   5 from unittest import mock
   6 import requests
   7 import requests_mock
   8 from io import StringIO
   9 import helper
  10
  11 limits = ["acceptance", "unit"]
  12 for test_type in limits:
  13     if "--no{}".format(test_type) in sys.argv:
  14         sys.argv.remove("--no{}".format(test_type))
  15         limits.remove(test_type)
  16     if "--only{}".format(test_type) in sys.argv:
  17         sys.argv.remove("--only{}".format(test_type))
  18         limits = [test_type]
  19         break
  20
  21 class WebMockTestCase(unittest.TestCase):
  22     import time
  23
  24     def setUp(self):
  25         super(WebMockTestCase, self).setUp()
  26         self.wm = requests_mock.Mocker()
  27         self.wm.start()
  28
  29         self.patchers = [
  30                 mock.patch.multiple(portfolio.BalanceStore,
  31                     all={},),
  32                 mock.patch.multiple(portfolio.TradeStore,
  33                     all=[],
  34                     debug=False),
  35                 mock.patch.multiple(portfolio.Portfolio, data=None, liquidities={}),
  36                 mock.patch.multiple(portfolio.Computation,
  37                     computations=portfolio.Computation.computations),
  38                 mock.patch.multiple(helper,
  39                     fees_cache={},
  40                     ticker_cache={},
  41                     ticker_cache_timestamp=self.time.time()),
  42                 ]
  43         for patcher in self.patchers:
  44             patcher.start()
  45
  46     def tearDown(self):
  47         for patcher in self.patchers:
  48             patcher.stop()
  49         self.wm.stop()
  50         super(WebMockTestCase, self).tearDown()
  51
  52 @unittest.skipUnless("unit" in limits, "Unit skipped")
  53 class PortfolioTest(WebMockTestCase):
  54     def fill_data(self):
  55         if self.json_response is not None:
  56             portfolio.Portfolio.data = self.json_response
  57
  58     def setUp(self):
  59         super(PortfolioTest, self).setUp()
  60
  61         with open("test_portfolio.json") as example:
  62             self.json_response = example.read()
  63
  64         self.wm.get(portfolio.Portfolio.URL, text=self.json_response)
  65
  66     def test_get_cryptoportfolio(self):
  67         self.wm.get(portfolio.Portfolio.URL, [
  68             {"text":'{ "foo": "bar" }', "status_code": 200},
  69             {"text": "System Error", "status_code": 500},
  70             {"exc": requests.exceptions.ConnectTimeout},
  71             ])
  72         portfolio.Portfolio.get_cryptoportfolio()
  73         self.assertIn("foo", portfolio.Portfolio.data)
  74         self.assertEqual("bar", portfolio.Portfolio.data["foo"])
  75         self.assertTrue(self.wm.called)
  76         self.assertEqual(1, self.wm.call_count)
  77
  78         portfolio.Portfolio.get_cryptoportfolio()
  79         self.assertIsNone(portfolio.Portfolio.data)
  80         self.assertEqual(2, self.wm.call_count)
  81
  82         portfolio.Portfolio.data = "Foo"
  83         portfolio.Portfolio.get_cryptoportfolio()
  84         self.assertEqual("Foo", portfolio.Portfolio.data)
  85         self.assertEqual(3, self.wm.call_count)
  86
  87     def test_parse_cryptoportfolio(self):
  88         portfolio.Portfolio.parse_cryptoportfolio()
  89
  90         self.assertListEqual(
  91                 ["medium", "high"],
  92                 list(portfolio.Portfolio.liquidities.keys()))
  93
  94         liquidities = portfolio.Portfolio.liquidities
  95         self.assertEqual(10, len(liquidities["medium"].keys()))
  96         self.assertEqual(10, len(liquidities["high"].keys()))
  97
  98         expected = {
  99                 'BTC':  (D("0.2857"), "long"),
 100                 'DGB':  (D("0.1015"), "long"),
 101                 'DOGE': (D("0.1805"), "long"),
 102                 'SC':   (D("0.0623"), "long"),
 103                 'ZEC':  (D("0.3701"), "long"),
 104                 }
 105         self.assertDictEqual(expected, liquidities["high"]['2018-01-08'])
 106
 107         expected = {
 108                 'BTC':  (D("1.1102e-16"), "long"),
 109                 'ETC':  (D("0.1"), "long"),
 110                 'FCT':  (D("0.1"), "long"),
 111                 'GAS':  (D("0.1"), "long"),
 112                 'NAV':  (D("0.1"), "long"),
 113                 'OMG':  (D("0.1"), "long"),
 114                 'OMNI': (D("0.1"), "long"),
 115                 'PPC':  (D("0.1"), "long"),
 116                 'RIC':  (D("0.1"), "long"),
 117                 'VIA':  (D("0.1"), "long"),
 118                 'XCP':  (D("0.1"), "long"),
 119                 }
 120         self.assertDictEqual(expected, liquidities["medium"]['2018-01-08'])
 121
 122         # It doesn't refetch the data when available
 123         portfolio.Portfolio.parse_cryptoportfolio()
 124
 125         self.assertEqual(1, self.wm.call_count)
 126
 127     def test_repartition(self):
 128         expected_medium = {
 129                 'BTC':   (D("1.1102e-16"), "long"),
 130                 'USDT':  (D("0.1"), "long"),
 131                 'ETC':   (D("0.1"), "long"),
 132                 'FCT':   (D("0.1"), "long"),
 133                 'OMG':   (D("0.1"), "long"),
 134                 'STEEM': (D("0.1"), "long"),
 135                 'STRAT': (D("0.1"), "long"),
 136                 'XEM':   (D("0.1"), "long"),
 137                 'XMR':   (D("0.1"), "long"),
 138                 'XVC':   (D("0.1"), "long"),
 139                 'ZRX':   (D("0.1"), "long"),
 140                 }
 141         expected_high = {
 142                 'USDT': (D("0.1226"), "long"),
 143                 'BTC':  (D("0.1429"), "long"),
 144                 'ETC':  (D("0.1127"), "long"),
 145                 'ETH':  (D("0.1569"), "long"),
 146                 'FCT':  (D("0.3341"), "long"),
 147                 'GAS':  (D("0.1308"), "long"),
 148                 }
 149
 150         self.assertEqual(expected_medium, portfolio.Portfolio.repartition())
 151         self.assertEqual(expected_medium, portfolio.Portfolio.repartition(liquidity="medium"))
 152         self.assertEqual(expected_high, portfolio.Portfolio.repartition(liquidity="high"))
 153
 154 @unittest.skipUnless("unit" in limits, "Unit skipped")
 155 class AmountTest(WebMockTestCase):
 156     def test_values(self):
 157         amount = portfolio.Amount("BTC", "0.65")
 158         self.assertEqual(D("0.65"), amount.value)
 159         self.assertEqual("BTC", amount.currency)
 160
 161     def test_in_currency(self):
 162         amount = portfolio.Amount("ETC", 10)
 163
 164         self.assertEqual(amount, amount.in_currency("ETC", None))
 165
 166         ticker_mock = unittest.mock.Mock()
 167         with mock.patch.object(helper, 'get_ticker', new=ticker_mock):
 168             ticker_mock.return_value = None
 169
 170             self.assertRaises(Exception, amount.in_currency, "ETH", None)
 171
 172         with mock.patch.object(helper, 'get_ticker', new=ticker_mock):
 173             ticker_mock.return_value = {
 174                     "bid": D("0.2"),
 175                     "ask": D("0.4"),
 176                     "average": D("0.3"),
 177                     "foo": "bar",
 178                     }
 179             converted_amount = amount.in_currency("ETH", None)
 180
 181             self.assertEqual(D("3.0"), converted_amount.value)
 182             self.assertEqual("ETH", converted_amount.currency)
 183             self.assertEqual(amount, converted_amount.linked_to)
 184             self.assertEqual("bar", converted_amount.ticker["foo"])
 185
 186             converted_amount = amount.in_currency("ETH", None, action="bid", compute_value="default")
 187             self.assertEqual(D("2"), converted_amount.value)
 188
 189             converted_amount = amount.in_currency("ETH", None, compute_value="ask")
 190             self.assertEqual(D("4"), converted_amount.value)
 191
 192         converted_amount = amount.in_currency("ETH", None, rate=D("0.02"))
 193         self.assertEqual(D("0.2"), converted_amount.value)
 194
 195     def test__round(self):
 196         amount = portfolio.Amount("BAR", portfolio.D("1.23456789876"))
 197         self.assertEqual(D("1.23456789"), round(amount).value)
 198         self.assertEqual(D("1.23"), round(amount, 2).value)
 199
 200     def test__abs(self):
 201         amount = portfolio.Amount("SC", -120)
 202         self.assertEqual(120, abs(amount).value)
 203         self.assertEqual("SC", abs(amount).currency)
 204
 205         amount = portfolio.Amount("SC", 10)
 206         self.assertEqual(10, abs(amount).value)
 207         self.assertEqual("SC", abs(amount).currency)
 208
 209     def test__add(self):
 210         amount1 = portfolio.Amount("XVG", "12.9")
 211         amount2 = portfolio.Amount("XVG", "13.1")
 212
 213         self.assertEqual(26, (amount1 + amount2).value)
 214         self.assertEqual("XVG", (amount1 + amount2).currency)
 215
 216         amount3 = portfolio.Amount("ETH", "1.6")
 217         with self.assertRaises(Exception):
 218             amount1 + amount3
 219
 220         amount4 = portfolio.Amount("ETH", 0.0)
 221         self.assertEqual(amount1, amount1 + amount4)
 222
 223         self.assertEqual(amount1, amount1 + 0)
 224
 225     def test__radd(self):
 226         amount = portfolio.Amount("XVG", "12.9")
 227
 228         self.assertEqual(amount, 0 + amount)
 229         with self.assertRaises(Exception):
 230             4 + amount
 231
 232     def test__sub(self):
 233         amount1 = portfolio.Amount("XVG", "13.3")
 234         amount2 = portfolio.Amount("XVG", "13.1")
 235
 236         self.assertEqual(D("0.2"), (amount1 - amount2).value)
 237         self.assertEqual("XVG", (amount1 - amount2).currency)
 238
 239         amount3 = portfolio.Amount("ETH", "1.6")
 240         with self.assertRaises(Exception):
 241             amount1 - amount3
 242
 243         amount4 = portfolio.Amount("ETH", 0.0)
 244         self.assertEqual(amount1, amount1 - amount4)
 245
 246     def test__rsub(self):
 247         amount = portfolio.Amount("ETH", "1.6")
 248         with self.assertRaises(Exception):
 249             3 - amount
 250
 251         self.assertEqual(portfolio.Amount("ETH", "-1.6"), -amount)
 252
 253     def test__mul(self):
 254         amount = portfolio.Amount("XEM", 11)
 255
 256         self.assertEqual(D("38.5"), (amount * D("3.5")).value)
 257         self.assertEqual(D("33"), (amount * 3).value)
 258
 259         with self.assertRaises(Exception):
 260             amount * amount
 261
 262     def test__rmul(self):
 263         amount = portfolio.Amount("XEM", 11)
 264
 265         self.assertEqual(D("38.5"), (D("3.5") * amount).value)
 266         self.assertEqual(D("33"), (3 * amount).value)
 267
 268     def test__floordiv(self):
 269         amount = portfolio.Amount("XEM", 11)
 270
 271         self.assertEqual(D("5.5"), (amount / 2).value)
 272         self.assertEqual(D("4.4"), (amount / D("2.5")).value)
 273
 274         with self.assertRaises(Exception):
 275             amount / amount
 276
 277     def test__truediv(self):
 278         amount = portfolio.Amount("XEM", 11)
 279
 280         self.assertEqual(D("5.5"), (amount / 2).value)
 281         self.assertEqual(D("4.4"), (amount / D("2.5")).value)
 282
 283     def test__lt(self):
 284         amount1 = portfolio.Amount("BTD", 11.3)
 285         amount2 = portfolio.Amount("BTD", 13.1)
 286
 287         self.assertTrue(amount1 < amount2)
 288         self.assertFalse(amount2 < amount1)
 289         self.assertFalse(amount1 < amount1)
 290
 291         amount3 = portfolio.Amount("BTC", 1.6)
 292         with self.assertRaises(Exception):
 293             amount1 < amount3
 294
 295     def test__le(self):
 296         amount1 = portfolio.Amount("BTD", 11.3)
 297         amount2 = portfolio.Amount("BTD", 13.1)
 298
 299         self.assertTrue(amount1 <= amount2)
 300         self.assertFalse(amount2 <= amount1)
 301         self.assertTrue(amount1 <= amount1)
 302
 303         amount3 = portfolio.Amount("BTC", 1.6)
 304         with self.assertRaises(Exception):
 305             amount1 <= amount3
 306
 307     def test__gt(self):
 308         amount1 = portfolio.Amount("BTD", 11.3)
 309         amount2 = portfolio.Amount("BTD", 13.1)
 310
 311         self.assertTrue(amount2 > amount1)
 312         self.assertFalse(amount1 > amount2)
 313         self.assertFalse(amount1 > amount1)
 314
 315         amount3 = portfolio.Amount("BTC", 1.6)
 316         with self.assertRaises(Exception):
 317             amount3 > amount1
 318
 319     def test__ge(self):
 320         amount1 = portfolio.Amount("BTD", 11.3)
 321         amount2 = portfolio.Amount("BTD", 13.1)
 322
 323         self.assertTrue(amount2 >= amount1)
 324         self.assertFalse(amount1 >= amount2)
 325         self.assertTrue(amount1 >= amount1)
 326
 327         amount3 = portfolio.Amount("BTC", 1.6)
 328         with self.assertRaises(Exception):
 329             amount3 >= amount1
 330
 331     def test__eq(self):
 332         amount1 = portfolio.Amount("BTD", 11.3)
 333         amount2 = portfolio.Amount("BTD", 13.1)
 334         amount3 = portfolio.Amount("BTD", 11.3)
 335
 336         self.assertFalse(amount1 == amount2)
 337         self.assertFalse(amount2 == amount1)
 338         self.assertTrue(amount1 == amount3)
 339         self.assertFalse(amount2 == 0)
 340
 341         amount4 = portfolio.Amount("BTC", 1.6)
 342         with self.assertRaises(Exception):
 343             amount1 == amount4
 344
 345         amount5 = portfolio.Amount("BTD", 0)
 346         self.assertTrue(amount5 == 0)
 347
 348     def test__ne(self):
 349         amount1 = portfolio.Amount("BTD", 11.3)
 350         amount2 = portfolio.Amount("BTD", 13.1)
 351         amount3 = portfolio.Amount("BTD", 11.3)
 352
 353         self.assertTrue(amount1 != amount2)
 354         self.assertTrue(amount2 != amount1)
 355         self.assertFalse(amount1 != amount3)
 356         self.assertTrue(amount2 != 0)
 357
 358         amount4 = portfolio.Amount("BTC", 1.6)
 359         with self.assertRaises(Exception):
 360             amount1 != amount4
 361
 362         amount5 = portfolio.Amount("BTD", 0)
 363         self.assertFalse(amount5 != 0)
 364
 365     def test__neg(self):
 366         amount1 = portfolio.Amount("BTD", "11.3")
 367
 368         self.assertEqual(portfolio.D("-11.3"), (-amount1).value)
 369
 370     def test__str(self):
 371         amount1 = portfolio.Amount("BTX", 32)
 372         self.assertEqual("32.00000000 BTX", str(amount1))
 373
 374         amount2 = portfolio.Amount("USDT", 12000)
 375         amount1.linked_to = amount2
 376         self.assertEqual("32.00000000 BTX [12000.00000000 USDT]", str(amount1))
 377
 378     def test__repr(self):
 379         amount1 = portfolio.Amount("BTX", 32)
 380         self.assertEqual("Amount(32.00000000 BTX)", repr(amount1))
 381
 382         amount2 = portfolio.Amount("USDT", 12000)
 383         amount1.linked_to = amount2
 384         self.assertEqual("Amount(32.00000000 BTX -> Amount(12000.00000000 USDT))", repr(amount1))
 385
 386         amount3 = portfolio.Amount("BTC", 0.1)
 387         amount2.linked_to = amount3
 388         self.assertEqual("Amount(32.00000000 BTX -> Amount(12000.00000000 USDT -> Amount(0.10000000 BTC)))", repr(amount1))
 389
 390 @unittest.skipUnless("unit" in limits, "Unit skipped")
 391 class BalanceTest(WebMockTestCase):
 392     def test_values(self):
 393         balance = portfolio.Balance("BTC", {
 394             "exchange_total": "0.65",
 395             "exchange_free": "0.35",
 396             "exchange_used": "0.30",
 397             "margin_total": "-10",
 398             "margin_borrowed": "-10",
 399             "margin_free": "0",
 400             "margin_position_type": "short",
 401             "margin_borrowed_base_currency": "USDT",
 402             "margin_liquidation_price": "1.20",
 403             "margin_pending_gain": "10",
 404             "margin_lending_fees": "0.4",
 405             "margin_borrowed_base_price": "0.15",
 406             })
 407         self.assertEqual(portfolio.D("0.65"), balance.exchange_total.value)
 408         self.assertEqual(portfolio.D("0.35"), balance.exchange_free.value)
 409         self.assertEqual(portfolio.D("0.30"), balance.exchange_used.value)
 410         self.assertEqual("BTC", balance.exchange_total.currency)
 411         self.assertEqual("BTC", balance.exchange_free.currency)
 412         self.assertEqual("BTC", balance.exchange_total.currency)
 413
 414         self.assertEqual(portfolio.D("-10"), balance.margin_total.value)
 415         self.assertEqual(portfolio.D("-10"), balance.margin_borrowed.value)
 416         self.assertEqual(portfolio.D("0"), balance.margin_free.value)
 417         self.assertEqual("BTC", balance.margin_total.currency)
 418         self.assertEqual("BTC", balance.margin_borrowed.currency)
 419         self.assertEqual("BTC", balance.margin_free.currency)
 420
 421         self.assertEqual("BTC", balance.currency)
 422
 423         self.assertEqual(portfolio.D("0.4"), balance.margin_lending_fees.value)
 424         self.assertEqual("USDT", balance.margin_lending_fees.currency)
 425
 426     def test__repr(self):
 427         self.assertEqual("Balance(BTX Exch: [✔2.00000000 BTX])",
 428                 repr(portfolio.Balance("BTX", { "exchange_free": 2, "exchange_total": 2 })))
 429         balance = portfolio.Balance("BTX", { "exchange_total": 3,
 430             "exchange_used": 1, "exchange_free": 2 })
 431         self.assertEqual("Balance(BTX Exch: [✔2.00000000 BTX + ❌1.00000000 BTX = 3.00000000 BTX])", repr(balance))
 432
 433         balance = portfolio.Balance("BTX", { "exchange_total": 1, "exchange_used": 1})
 434         self.assertEqual("Balance(BTX Exch: [❌1.00000000 BTX])", repr(balance))
 435
 436         balance = portfolio.Balance("BTX", { "margin_total": 3,
 437             "margin_borrowed": 1, "margin_free": 2 })
 438         self.assertEqual("Balance(BTX Margin: [✔2.00000000 BTX + borrowed 1.00000000 BTX = 3.00000000 BTX])", repr(balance))
 439
 440         balance = portfolio.Balance("BTX", { "margin_total": 2, "margin_free": 2 })
 441         self.assertEqual("Balance(BTX Margin: [✔2.00000000 BTX])", repr(balance))
 442
 443         balance = portfolio.Balance("BTX", { "margin_total": -3,
 444             "margin_borrowed_base_price": D("0.1"),
 445             "margin_borrowed_base_currency": "BTC",
 446             "margin_lending_fees": D("0.002") })
 447         self.assertEqual("Balance(BTX Margin: [-3.00000000 BTX @@ 0.10000000 BTC/0.00200000 BTC])", repr(balance))
 448
 449         balance = portfolio.Balance("BTX", { "margin_total": 1,
 450             "margin_borrowed": 1, "exchange_free": 2, "exchange_total": 2})
 451         self.assertEqual("Balance(BTX Exch: [✔2.00000000 BTX] Margin: [borrowed 1.00000000 BTX] Total: [0.00000000 BTX])", repr(balance))
 452
 453 @unittest.skipUnless("unit" in limits, "Unit skipped")
 454 class HelperTest(WebMockTestCase):
 455     def test_get_ticker(self):
 456         market = mock.Mock()
 457         market.fetch_ticker.side_effect = [
 458                 { "bid": 1, "ask": 3 },
 459                 helper.ExchangeError("foo"),
 460                 { "bid": 10, "ask": 40 },
 461                 helper.ExchangeError("foo"),
 462                 helper.ExchangeError("foo"),
 463                 ]
 464
 465         ticker = helper.get_ticker("ETH", "ETC", market)
 466         market.fetch_ticker.assert_called_with("ETH/ETC")
 467         self.assertEqual(1, ticker["bid"])
 468         self.assertEqual(3, ticker["ask"])
 469         self.assertEqual(2, ticker["average"])
 470         self.assertFalse(ticker["inverted"])
 471
 472         ticker = helper.get_ticker("ETH", "XVG", market)
 473         self.assertEqual(0.0625, ticker["average"])
 474         self.assertTrue(ticker["inverted"])
 475         self.assertIn("original", ticker)
 476         self.assertEqual(10, ticker["original"]["bid"])
 477
 478         ticker = helper.get_ticker("XVG", "XMR", market)
 479         self.assertIsNone(ticker)
 480
 481         market.fetch_ticker.assert_has_calls([
 482             mock.call("ETH/ETC"),
 483             mock.call("ETH/XVG"),
 484             mock.call("XVG/ETH"),
 485             mock.call("XVG/XMR"),
 486             mock.call("XMR/XVG"),
 487             ])
 488
 489         market2 = mock.Mock()
 490         market2.fetch_ticker.side_effect = [
 491                 { "bid": 1, "ask": 3 },
 492                 { "bid": 1.2, "ask": 3.5 },
 493                 ]
 494         ticker1 = helper.get_ticker("ETH", "ETC", market2)
 495         ticker2 = helper.get_ticker("ETH", "ETC", market2)
 496         ticker3 = helper.get_ticker("ETC", "ETH", market2)
 497         market2.fetch_ticker.assert_called_once_with("ETH/ETC")
 498         self.assertEqual(1, ticker1["bid"])
 499         self.assertDictEqual(ticker1, ticker2)
 500         self.assertDictEqual(ticker1, ticker3["original"])
 501
 502         ticker4 = helper.get_ticker("ETH", "ETC", market2, refresh=True)
 503         ticker5 = helper.get_ticker("ETH", "ETC", market2)
 504         self.assertEqual(1.2, ticker4["bid"])
 505         self.assertDictEqual(ticker4, ticker5)
 506
 507         market3 = mock.Mock()
 508         market3.fetch_ticker.side_effect = [
 509                 { "bid": 1, "ask": 3 },
 510                 { "bid": 1.2, "ask": 3.5 },
 511                 ]
 512         ticker6 = helper.get_ticker("ETH", "ETC", market3)
 513         helper.ticker_cache_timestamp -= 4
 514         ticker7 = helper.get_ticker("ETH", "ETC", market3)
 515         helper.ticker_cache_timestamp -= 2
 516         ticker8 = helper.get_ticker("ETH", "ETC", market3)
 517         self.assertDictEqual(ticker6, ticker7)
 518         self.assertEqual(1.2, ticker8["bid"])
 519
 520     def test_fetch_fees(self):
 521         market = mock.Mock()
 522         market.fetch_fees.return_value = "Foo"
 523         self.assertEqual("Foo", helper.fetch_fees(market))
 524         market.fetch_fees.assert_called_once()
 525         self.assertEqual("Foo", helper.fetch_fees(market))
 526         market.fetch_fees.assert_called_once()
 527
 528     @mock.patch.object(portfolio.Portfolio, "repartition")
 529     @mock.patch.object(helper, "get_ticker")
 530     @mock.patch.object(portfolio.TradeStore, "compute_trades")
 531     def test_prepare_trades(self, compute_trades, get_ticker, repartition):
 532         repartition.return_value = {
 533                 "XEM": (D("0.75"), "long"),
 534                 "BTC": (D("0.25"), "long"),
 535                 }
 536         def _get_ticker(c1, c2, market):
 537             if c1 == "USDT" and c2 == "BTC":
 538                 return { "average": D("0.0001") }
 539             if c1 == "XVG" and c2 == "BTC":
 540                 return { "average": D("0.000001") }
 541             if c1 == "XEM" and c2 == "BTC":
 542                 return { "average": D("0.001") }
 543             self.fail("Should be called with {}, {}".format(c1, c2))
 544         get_ticker.side_effect = _get_ticker
 545
 546         market = mock.Mock()
 547         market.fetch_all_balances.return_value = {
 548                 "USDT": {
 549                     "exchange_free": D("10000.0"),
 550                     "exchange_used": D("0.0"),
 551                     "exchange_total": D("10000.0"),
 552                     "total": D("10000.0")
 553                     },
 554                 "XVG": {
 555                     "exchange_free": D("10000.0"),
 556                     "exchange_used": D("0.0"),
 557                     "exchange_total": D("10000.0"),
 558                     "total": D("10000.0")
 559                     },
 560                 }
 561         helper.prepare_trades(market)
 562         compute_trades.assert_called()
 563
 564         call = compute_trades.call_args
 565         self.assertEqual(market, call[1]["market"])
 566         self.assertEqual(1, call[0][0]["USDT"].value)
 567         self.assertEqual(D("0.01"), call[0][0]["XVG"].value)
 568         self.assertEqual(D("0.2525"), call[0][1]["BTC"].value)
 569         self.assertEqual(D("0.7575"), call[0][1]["XEM"].value)
 570
 571     @mock.patch.object(portfolio.Portfolio, "repartition")
 572     @mock.patch.object(helper, "get_ticker")
 573     @mock.patch.object(portfolio.TradeStore, "compute_trades")
 574     def test_update_trades(self, compute_trades, get_ticker, repartition):
 575         repartition.return_value = {
 576                 "XEM": (D("0.75"), "long"),
 577                 "BTC": (D("0.25"), "long"),
 578                 }
 579         def _get_ticker(c1, c2, market):
 580             if c1 == "USDT" and c2 == "BTC":
 581                 return { "average": D("0.0001") }
 582             if c1 == "XVG" and c2 == "BTC":
 583                 return { "average": D("0.000001") }
 584             if c1 == "XEM" and c2 == "BTC":
 585                 return { "average": D("0.001") }
 586             self.fail("Should be called with {}, {}".format(c1, c2))
 587         get_ticker.side_effect = _get_ticker
 588
 589         market = mock.Mock()
 590         market.fetch_all_balances.return_value = {
 591                 "USDT": {
 592                     "exchange_free": D("10000.0"),
 593                     "exchange_used": D("0.0"),
 594                     "exchange_total": D("10000.0"),
 595                     "total": D("10000.0")
 596                     },
 597                 "XVG": {
 598                     "exchange_free": D("10000.0"),
 599                     "exchange_used": D("0.0"),
 600                     "exchange_total": D("10000.0"),
 601                     "total": D("10000.0")
 602                     },
 603                 }
 604         helper.update_trades(market)
 605         compute_trades.assert_called()
 606
 607         call = compute_trades.call_args
 608         self.assertEqual(market, call[1]["market"])
 609         self.assertEqual(1, call[0][0]["USDT"].value)
 610         self.assertEqual(D("0.01"), call[0][0]["XVG"].value)
 611         self.assertEqual(D("0.2525"), call[0][1]["BTC"].value)
 612         self.assertEqual(D("0.7575"), call[0][1]["XEM"].value)
 613
 614     @mock.patch.object(portfolio.Portfolio, "repartition")
 615     @mock.patch.object(helper, "get_ticker")
 616     @mock.patch.object(portfolio.TradeStore, "compute_trades")
 617     def test_prepare_trades_to_sell_all(self, compute_trades, get_ticker, repartition):
 618         def _get_ticker(c1, c2, market):
 619             if c1 == "USDT" and c2 == "BTC":
 620                 return { "average": D("0.0001") }
 621             if c1 == "XVG" and c2 == "BTC":
 622                 return { "average": D("0.000001") }
 623             self.fail("Should be called with {}, {}".format(c1, c2))
 624         get_ticker.side_effect = _get_ticker
 625
 626         market = mock.Mock()
 627         market.fetch_all_balances.return_value = {
 628                 "USDT": {
 629                     "exchange_free": D("10000.0"),
 630                     "exchange_used": D("0.0"),
 631                     "exchange_total": D("10000.0"),
 632                     "total": D("10000.0")
 633                     },
 634                 "XVG": {
 635                     "exchange_free": D("10000.0"),
 636                     "exchange_used": D("0.0"),
 637                     "exchange_total": D("10000.0"),
 638                     "total": D("10000.0")
 639                     },
 640                 }
 641         helper.prepare_trades_to_sell_all(market)
 642         repartition.assert_not_called()
 643         compute_trades.assert_called()
 644
 645         call = compute_trades.call_args
 646         self.assertEqual(market, call[1]["market"])
 647         self.assertEqual(1, call[0][0]["USDT"].value)
 648         self.assertEqual(D("0.01"), call[0][0]["XVG"].value)
 649         self.assertEqual(D("1.01"), call[0][1]["BTC"].value)
 650
 651     @mock.patch.object(portfolio.time, "sleep")
 652     @mock.patch.object(portfolio.TradeStore, "all_orders")
 653     def test_follow_orders(self, all_orders, time_mock):
 654         for verbose, debug, sleep in [
 655                 (True, False, None), (False, False, None),
 656                 (True, True, None), (True, False, 12),
 657                 (True, True, 12)]:
 658             with self.subTest(sleep=sleep, debug=debug, verbose=verbose), \
 659                     mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
 660                 portfolio.TradeStore.debug = debug
 661                 order_mock1 = mock.Mock()
 662                 order_mock2 = mock.Mock()
 663                 order_mock3 = mock.Mock()
 664                 all_orders.side_effect = [
 665                         [order_mock1, order_mock2],
 666                         [order_mock1, order_mock2],
 667
 668                         [order_mock1, order_mock3],
 669                         [order_mock1, order_mock3],
 670
 671                         [order_mock1, order_mock3],
 672                         [order_mock1, order_mock3],
 673
 674                         []
 675                         ]
 676
 677                 order_mock1.get_status.side_effect = ["open", "open", "closed"]
 678                 order_mock2.get_status.side_effect = ["open"]
 679                 order_mock3.get_status.side_effect = ["open", "closed"]
 680
 681                 order_mock1.trade = mock.Mock()
 682                 order_mock2.trade = mock.Mock()
 683                 order_mock3.trade = mock.Mock()
 684
 685                 helper.follow_orders(verbose=verbose, sleep=sleep)
 686
 687                 order_mock1.trade.update_order.assert_any_call(order_mock1, 1)
 688                 order_mock1.trade.update_order.assert_any_call(order_mock1, 2)
 689                 self.assertEqual(2, order_mock1.trade.update_order.call_count)
 690                 self.assertEqual(3, order_mock1.get_status.call_count)
 691
 692                 order_mock2.trade.update_order.assert_any_call(order_mock2, 1)
 693                 self.assertEqual(1, order_mock2.trade.update_order.call_count)
 694                 self.assertEqual(1, order_mock2.get_status.call_count)
 695
 696                 order_mock3.trade.update_order.assert_any_call(order_mock3, 2)
 697                 self.assertEqual(1, order_mock3.trade.update_order.call_count)
 698                 self.assertEqual(2, order_mock3.get_status.call_count)
 699
 700                 if sleep is None:
 701                     if debug:
 702                         time_mock.assert_called_with(7)
 703                     else:
 704                         time_mock.assert_called_with(30)
 705                 else:
 706                     time_mock.assert_called_with(sleep)
 707
 708                 if verbose:
 709                     self.assertNotEqual("", stdout_mock.getvalue())
 710                 else:
 711                     self.assertEqual("", stdout_mock.getvalue())
 712
 713     @mock.patch.object(portfolio.BalanceStore, "fetch_balances")
 714     def test_move_balance(self, fetch_balances):
 715         for debug in [True, False]:
 716             with self.subTest(debug=debug),\
 717                     mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
 718                 value_from = portfolio.Amount("BTC", "1.0")
 719                 value_from.linked_to = portfolio.Amount("ETH", "10.0")
 720                 value_to = portfolio.Amount("BTC", "10.0")
 721                 trade1 = portfolio.Trade(value_from, value_to, "ETH")
 722
 723                 value_from = portfolio.Amount("BTC", "0.0")
 724                 value_from.linked_to = portfolio.Amount("ETH", "0.0")
 725                 value_to = portfolio.Amount("BTC", "-3.0")
 726                 trade2 = portfolio.Trade(value_from, value_to, "ETH")
 727
 728                 value_from = portfolio.Amount("USDT", "0.0")
 729                 value_from.linked_to = portfolio.Amount("XVG", "0.0")
 730                 value_to = portfolio.Amount("USDT", "-50.0")
 731                 trade3 = portfolio.Trade(value_from, value_to, "XVG")
 732
 733                 portfolio.TradeStore.all = [trade1, trade2, trade3]
 734                 balance1 = portfolio.Balance("BTC", { "margin_free": "0" })
 735                 balance2 = portfolio.Balance("USDT", { "margin_free": "100" })
 736                 balance3 = portfolio.Balance("ETC", { "margin_free": "10" })
 737                 portfolio.BalanceStore.all = {"BTC": balance1, "USDT": balance2, "ETC": balance3}
 738
 739                 market = mock.Mock()
 740
 741                 helper.move_balances(market, debug=debug)
 742
 743                 fetch_balances.assert_called_with(market)
 744                 if debug:
 745                     self.assertRegex(stdout_mock.getvalue(), "market.transfer_balance")
 746                 else:
 747                     market.transfer_balance.assert_any_call("BTC", 3, "exchange", "margin")
 748                     market.transfer_balance.assert_any_call("USDT", 50, "margin", "exchange")
 749                     market.transfer_balance.assert_any_call("ETC", 10, "margin", "exchange")
 750
 751     @mock.patch.object(helper, "prepare_trades")
 752     @mock.patch.object(portfolio.TradeStore, "prepare_orders")
 753     @mock.patch.object(portfolio.TradeStore, "print_all_with_order")
 754     @mock.patch('sys.stdout', new_callable=StringIO)
 755     def test_print_orders(self, stdout_mock, print_all_with_order, prepare_orders, prepare_trades):
 756         market = mock.Mock()
 757         portfolio.BalanceStore.all = {
 758                 "BTC": portfolio.Balance("BTC", {
 759                     "total": "0.65",
 760                     "exchange_total":"0.65",
 761                     "exchange_free": "0.35",
 762                     "exchange_used": "0.30"}),
 763                 "ETH": portfolio.Balance("ETH", {
 764                     "total": 3,
 765                     "exchange_total": 3,
 766                     "exchange_free": 3,
 767                     "exchange_used": 0}),
 768                 }
 769         helper.print_orders(market)
 770         prepare_trades.assert_called_with(market, base_currency="BTC",
 771                 compute_value="average", debug=True)
 772         prepare_orders.assert_called_with(compute_value="average")
 773         print_all_with_order.assert_called()
 774         self.assertRegex(stdout_mock.getvalue(), "Balance")
 775
 776     @mock.patch.object(helper, "prepare_trades")
 777     @mock.patch.object(helper, "follow_orders")
 778     @mock.patch.object(portfolio.TradeStore, "prepare_orders")
 779     @mock.patch.object(portfolio.TradeStore, "print_all_with_order")
 780     @mock.patch.object(portfolio.TradeStore, "run_orders")
 781     @mock.patch('sys.stdout', new_callable=StringIO)
 782     def test_process_sell_needed__1_sell(self, stdout_mock, run_orders,
 783             print_all_with_order, prepare_orders, follow_orders,
 784             prepare_trades):
 785         market = mock.Mock()
 786         portfolio.BalanceStore.all = {
 787                 "BTC": portfolio.Balance("BTC", {
 788                     "total": "0.65",
 789                     "exchange_total":"0.65",
 790                     "exchange_free": "0.35",
 791                     "exchange_used": "0.30"}),
 792                 "ETH": portfolio.Balance("ETH", {
 793                     "total": 3,
 794                     "exchange_total": 3,
 795                     "exchange_free": 3,
 796                     "exchange_used": 0}),
 797                 }
 798         helper.process_sell_needed__1_sell(market)
 799         prepare_trades.assert_called_with(market, base_currency="BTC",
 800                 debug=False)
 801         prepare_orders.assert_called_with(compute_value="average",
 802                 only="dispose")
 803         print_all_with_order.assert_called()
 804         run_orders.assert_called()
 805         follow_orders.assert_called()
 806         self.assertRegex(stdout_mock.getvalue(), "Balance")
 807
 808     @mock.patch.object(helper, "update_trades")
 809     @mock.patch.object(helper, "follow_orders")
 810     @mock.patch.object(helper, "move_balances")
 811     @mock.patch.object(portfolio.TradeStore, "prepare_orders")
 812     @mock.patch.object(portfolio.TradeStore, "print_all_with_order")
 813     @mock.patch.object(portfolio.TradeStore, "run_orders")
 814     @mock.patch('sys.stdout', new_callable=StringIO)
 815     def test_process_sell_needed__2_buy(self, stdout_mock, run_orders,
 816             print_all_with_order, prepare_orders, move_balances,
 817             follow_orders, update_trades):
 818         market = mock.Mock()
 819         portfolio.BalanceStore.all = {
 820                 "BTC": portfolio.Balance("BTC", {
 821                     "total": "0.65",
 822                     "exchange_total":"0.65",
 823                     "exchange_free": "0.35",
 824                     "exchange_used": "0.30"}),
 825                 "ETH": portfolio.Balance("ETH", {
 826                     "total": 3,
 827                     "exchange_total": 3,
 828                     "exchange_free": 3,
 829                     "exchange_used": 0}),
 830                 }
 831         helper.process_sell_needed__2_buy(market)
 832         update_trades.assert_called_with(market, base_currency="BTC",
 833                 debug=False, only="acquire")
 834         prepare_orders.assert_called_with(compute_value="average",
 835                 only="acquire")
 836         print_all_with_order.assert_called()
 837         move_balances.assert_called_with(market, debug=False)
 838         run_orders.assert_called()
 839         follow_orders.assert_called()
 840         self.assertRegex(stdout_mock.getvalue(), "Balance")
 841
 842     @mock.patch.object(helper, "prepare_trades_to_sell_all")
 843     @mock.patch.object(helper, "follow_orders")
 844     @mock.patch.object(portfolio.TradeStore, "prepare_orders")
 845     @mock.patch.object(portfolio.TradeStore, "print_all_with_order")
 846     @mock.patch.object(portfolio.TradeStore, "run_orders")
 847     @mock.patch('sys.stdout', new_callable=StringIO)
 848     def test_process_sell_all__1_sell(self, stdout_mock, run_orders,
 849             print_all_with_order, prepare_orders, follow_orders,
 850             prepare_trades_to_sell_all):
 851         market = mock.Mock()
 852         portfolio.BalanceStore.all = {
 853                 "BTC": portfolio.Balance("BTC", {
 854                     "total": "0.65",
 855                     "exchange_total":"0.65",
 856                     "exchange_free": "0.35",
 857                     "exchange_used": "0.30"}),
 858                 "ETH": portfolio.Balance("ETH", {
 859                     "total": 3,
 860                     "exchange_total": 3,
 861                     "exchange_free": 3,
 862                     "exchange_used": 0}),
 863                 }
 864         helper.process_sell_all__1_all_sell(market)
 865         prepare_trades_to_sell_all.assert_called_with(market, base_currency="BTC",
 866                 debug=False)
 867         prepare_orders.assert_called_with(compute_value="average")
 868         print_all_with_order.assert_called()
 869         run_orders.assert_called()
 870         follow_orders.assert_called()
 871         self.assertRegex(stdout_mock.getvalue(), "Balance")
 872
 873     @mock.patch.object(helper, "prepare_trades")
 874     @mock.patch.object(helper, "follow_orders")
 875     @mock.patch.object(helper, "move_balances")
 876     @mock.patch.object(portfolio.TradeStore, "prepare_orders")
 877     @mock.patch.object(portfolio.TradeStore, "print_all_with_order")
 878     @mock.patch.object(portfolio.TradeStore, "run_orders")
 879     @mock.patch('sys.stdout', new_callable=StringIO)
 880     def test_process_sell_all__2_all_buy(self, stdout_mock, run_orders,
 881             print_all_with_order, prepare_orders, move_balances,
 882             follow_orders, prepare_trades):
 883         market = mock.Mock()
 884         portfolio.BalanceStore.all = {
 885                 "BTC": portfolio.Balance("BTC", {
 886                     "total": "0.65",
 887                     "exchange_total":"0.65",
 888                     "exchange_free": "0.35",
 889                     "exchange_used": "0.30"}),
 890                 "ETH": portfolio.Balance("ETH", {
 891                     "total": 3,
 892                     "exchange_total": 3,
 893                     "exchange_free": 3,
 894                     "exchange_used": 0}),
 895                 }
 896         helper.process_sell_all__2_all_buy(market)
 897         prepare_trades.assert_called_with(market, base_currency="BTC",
 898                 debug=False)
 899         prepare_orders.assert_called_with()
 900         print_all_with_order.assert_called()
 901         move_balances.assert_called_with(market, debug=False)
 902         run_orders.assert_called()
 903         follow_orders.assert_called()
 904         self.assertRegex(stdout_mock.getvalue(), "Balance")
 905
 906
 907 @unittest.skipUnless("unit" in limits, "Unit skipped")
 908 class TradeStoreTest(WebMockTestCase):
 909     @mock.patch.object(portfolio.BalanceStore, "currencies")
 910     @mock.patch.object(portfolio.TradeStore, "add_trade_if_matching")
 911     def test_compute_trades(self, add_trade_if_matching, currencies):
 912         currencies.return_value = ["XMR", "DASH", "XVG", "BTC", "ETH"]
 913
 914         values_in_base = {
 915                 "XMR": portfolio.Amount("BTC", D("0.9")),
 916                 "DASH": portfolio.Amount("BTC", D("0.4")),
 917                 "XVG": portfolio.Amount("BTC", D("-0.5")),
 918                 "BTC": portfolio.Amount("BTC", D("0.5")),
 919                 }
 920         new_repartition = {
 921                 "DASH": portfolio.Amount("BTC", D("0.5")),
 922                 "XVG": portfolio.Amount("BTC", D("0.1")),
 923                 "BTC": portfolio.Amount("BTC", D("0.4")),
 924                 "ETH": portfolio.Amount("BTC", D("0.3")),
 925                 }
 926
 927         portfolio.TradeStore.compute_trades(values_in_base,
 928                 new_repartition, only="only", market="market")
 929
 930         self.assertEqual(5, add_trade_if_matching.call_count)
 931         add_trade_if_matching.assert_any_call(
 932                 portfolio.Amount("BTC", D("0.9")),
 933                 portfolio.Amount("BTC", 0),
 934                 "XMR", only="only", market="market"
 935                 )
 936         add_trade_if_matching.assert_any_call(
 937                 portfolio.Amount("BTC", D("0.4")),
 938                 portfolio.Amount("BTC", D("0.5")),
 939                 "DASH", only="only", market="market"
 940                 )
 941         add_trade_if_matching.assert_any_call(
 942                 portfolio.Amount("BTC", D("-0.5")),
 943                 portfolio.Amount("BTC", D("0")),
 944                 "XVG", only="only", market="market"
 945                 )
 946         add_trade_if_matching.assert_any_call(
 947                 portfolio.Amount("BTC", D("0")),
 948                 portfolio.Amount("BTC", D("0.1")),
 949                 "XVG", only="only", market="market"
 950                 )
 951         add_trade_if_matching.assert_any_call(
 952                 portfolio.Amount("BTC", D("0")),
 953                 portfolio.Amount("BTC", D("0.3")),
 954                 "ETH", only="only", market="market"
 955                 )
 956
 957     def test_add_trade_if_matching(self):
 958         result = portfolio.TradeStore.add_trade_if_matching(
 959                 portfolio.Amount("BTC", D("0")),
 960                 portfolio.Amount("BTC", D("0.3")),
 961                 "ETH", only="nope", market="market"
 962                 )
 963         self.assertEqual(0, len(portfolio.TradeStore.all))
 964         self.assertEqual(False, result)
 965
 966         portfolio.TradeStore.all = []
 967         result = portfolio.TradeStore.add_trade_if_matching(
 968                 portfolio.Amount("BTC", D("0")),
 969                 portfolio.Amount("BTC", D("0.3")),
 970                 "ETH", only=None, market="market"
 971                 )
 972         self.assertEqual(1, len(portfolio.TradeStore.all))
 973         self.assertEqual(True, result)
 974
 975         portfolio.TradeStore.all = []
 976         result = portfolio.TradeStore.add_trade_if_matching(
 977                 portfolio.Amount("BTC", D("0")),
 978                 portfolio.Amount("BTC", D("0.3")),
 979                 "ETH", only="acquire", market="market"
 980                 )
 981         self.assertEqual(1, len(portfolio.TradeStore.all))
 982         self.assertEqual(True, result)
 983
 984         portfolio.TradeStore.all = []
 985         result = portfolio.TradeStore.add_trade_if_matching(
 986                 portfolio.Amount("BTC", D("0")),
 987                 portfolio.Amount("BTC", D("0.3")),
 988                 "ETH", only="dispose", market="market"
 989                 )
 990         self.assertEqual(0, len(portfolio.TradeStore.all))
 991         self.assertEqual(False, result)
 992
 993     def test_prepare_orders(self):
 994         trade_mock1 = mock.Mock()
 995         trade_mock2 = mock.Mock()
 996
 997         portfolio.TradeStore.all.append(trade_mock1)
 998         portfolio.TradeStore.all.append(trade_mock2)
 999
1000         portfolio.TradeStore.prepare_orders()
1001         trade_mock1.prepare_order.assert_called_with(compute_value="default")
1002         trade_mock2.prepare_order.assert_called_with(compute_value="default")
1003
1004         portfolio.TradeStore.prepare_orders(compute_value="bla")
1005         trade_mock1.prepare_order.assert_called_with(compute_value="bla")
1006         trade_mock2.prepare_order.assert_called_with(compute_value="bla")
1007
1008         trade_mock1.prepare_order.reset_mock()
1009         trade_mock2.prepare_order.reset_mock()
1010
1011         trade_mock1.action = "foo"
1012         trade_mock2.action = "bar"
1013         portfolio.TradeStore.prepare_orders(only="bar")
1014         trade_mock1.prepare_order.assert_not_called()
1015         trade_mock2.prepare_order.assert_called_with(compute_value="default")
1016
1017     def test_print_all_with_order(self):
1018         trade_mock1 = mock.Mock()
1019         trade_mock2 = mock.Mock()
1020         trade_mock3 = mock.Mock()
1021         portfolio.TradeStore.all = [trade_mock1, trade_mock2, trade_mock3]
1022
1023         portfolio.TradeStore.print_all_with_order()
1024
1025         trade_mock1.print_with_order.assert_called()
1026         trade_mock2.print_with_order.assert_called()
1027         trade_mock3.print_with_order.assert_called()
1028
1029     @mock.patch.object(portfolio.TradeStore, "all_orders")
1030     def test_run_orders(self, all_orders):
1031         order_mock1 = mock.Mock()
1032         order_mock2 = mock.Mock()
1033         order_mock3 = mock.Mock()
1034         all_orders.return_value = [order_mock1, order_mock2, order_mock3]
1035         portfolio.TradeStore.run_orders()
1036         all_orders.assert_called_with(state="pending")
1037
1038         order_mock1.run.assert_called()
1039         order_mock2.run.assert_called()
1040         order_mock3.run.assert_called()
1041
1042     def test_all_orders(self):
1043         trade_mock1 = mock.Mock()
1044         trade_mock2 = mock.Mock()
1045
1046         order_mock1 = mock.Mock()
1047         order_mock2 = mock.Mock()
1048         order_mock3 = mock.Mock()
1049
1050         trade_mock1.orders = [order_mock1, order_mock2]
1051         trade_mock2.orders = [order_mock3]
1052
1053         order_mock1.status = "pending"
1054         order_mock2.status = "open"
1055         order_mock3.status = "open"
1056
1057         portfolio.TradeStore.all.append(trade_mock1)
1058         portfolio.TradeStore.all.append(trade_mock2)
1059
1060         orders = portfolio.TradeStore.all_orders()
1061         self.assertEqual(3, len(orders))
1062
1063         open_orders = portfolio.TradeStore.all_orders(state="open")
1064         self.assertEqual(2, len(open_orders))
1065         self.assertEqual([order_mock2, order_mock3], open_orders)
1066
1067     @mock.patch.object(portfolio.TradeStore, "all_orders")
1068     def test_update_all_orders_status(self, all_orders):
1069         order_mock1 = mock.Mock()
1070         order_mock2 = mock.Mock()
1071         order_mock3 = mock.Mock()
1072         all_orders.return_value = [order_mock1, order_mock2, order_mock3]
1073         portfolio.TradeStore.update_all_orders_status()
1074         all_orders.assert_called_with(state="open")
1075
1076         order_mock1.get_status.assert_called()
1077         order_mock2.get_status.assert_called()
1078         order_mock3.get_status.assert_called()
1079
1080 @unittest.skipUnless("unit" in limits, "Unit skipped")
1081 class BalanceStoreTest(WebMockTestCase):
1082     def setUp(self):
1083         super(BalanceStoreTest, self).setUp()
1084
1085         self.fetch_balance = {
1086                 "ETC": {
1087                     "exchange_free": 0,
1088                     "exchange_used": 0,
1089                     "exchange_total": 0,
1090                     "margin_total": 0,
1091                     },
1092                 "USDT": {
1093                     "exchange_free": D("6.0"),
1094                     "exchange_used": D("1.2"),
1095                     "exchange_total": D("7.2"),
1096                     "margin_total": 0,
1097                     },
1098                 "XVG": {
1099                     "exchange_free": 16,
1100                     "exchange_used": 0,
1101                     "exchange_total": 16,
1102                     "margin_total": 0,
1103                     },
1104                 "XMR": {
1105                     "exchange_free": 0,
1106                     "exchange_used": 0,
1107                     "exchange_total": 0,
1108                     "margin_total": D("-1.0"),
1109                     "margin_free": 0,
1110                     },
1111                 }
1112
1113     @mock.patch.object(helper, "get_ticker")
1114     def test_in_currency(self, get_ticker):
1115         portfolio.BalanceStore.all = {
1116                 "BTC": portfolio.Balance("BTC", {
1117                     "total": "0.65",
1118                     "exchange_total":"0.65",
1119                     "exchange_free": "0.35",
1120                     "exchange_used": "0.30"}),
1121                 "ETH": portfolio.Balance("ETH", {
1122                     "total": 3,
1123                     "exchange_total": 3,
1124                     "exchange_free": 3,
1125                     "exchange_used": 0}),
1126                 }
1127         market = mock.Mock()
1128         get_ticker.return_value = {
1129                 "bid": D("0.09"),
1130                 "ask": D("0.11"),
1131                 "average": D("0.1"),
1132                 }
1133
1134         amounts = portfolio.BalanceStore.in_currency("BTC", market)
1135         self.assertEqual("BTC", amounts["ETH"].currency)
1136         self.assertEqual(D("0.65"), amounts["BTC"].value)
1137         self.assertEqual(D("0.30"), amounts["ETH"].value)
1138
1139         amounts = portfolio.BalanceStore.in_currency("BTC", market, compute_value="bid")
1140         self.assertEqual(D("0.65"), amounts["BTC"].value)
1141         self.assertEqual(D("0.27"), amounts["ETH"].value)
1142
1143         amounts = portfolio.BalanceStore.in_currency("BTC", market, compute_value="bid", type="exchange_used")
1144         self.assertEqual(D("0.30"), amounts["BTC"].value)
1145         self.assertEqual(0, amounts["ETH"].value)
1146
1147     def test_fetch_balances(self):
1148         market = mock.Mock()
1149         market.fetch_all_balances.return_value = self.fetch_balance
1150
1151         portfolio.BalanceStore.fetch_balances(market)
1152         self.assertNotIn("ETC", portfolio.BalanceStore.currencies())
1153         self.assertListEqual(["USDT", "XVG", "XMR"], list(portfolio.BalanceStore.currencies()))
1154
1155         portfolio.BalanceStore.all["ETC"] = portfolio.Balance("ETC", {
1156             "exchange_total": "1", "exchange_free": "0",
1157             "exchange_used": "1" })
1158         portfolio.BalanceStore.fetch_balances(market)
1159         self.assertEqual(0, portfolio.BalanceStore.all["ETC"].total)
1160         self.assertListEqual(["USDT", "XVG", "XMR", "ETC"], list(portfolio.BalanceStore.currencies()))
1161
1162     @mock.patch.object(portfolio.Portfolio, "repartition")
1163     def test_dispatch_assets(self, repartition):
1164         market = mock.Mock()
1165         market.fetch_all_balances.return_value = self.fetch_balance
1166         portfolio.BalanceStore.fetch_balances(market)
1167
1168         self.assertNotIn("XEM", portfolio.BalanceStore.currencies())
1169
1170         repartition.return_value = {
1171                 "XEM": (D("0.75"), "long"),
1172                 "BTC": (D("0.26"), "long"),
1173                 "DASH": (D("0.10"), "short"),
1174                 }
1175
1176         amounts = portfolio.BalanceStore.dispatch_assets(portfolio.Amount("BTC", "11.1"))
1177         self.assertIn("XEM", portfolio.BalanceStore.currencies())
1178         self.assertEqual(D("2.6"), amounts["BTC"].value)
1179         self.assertEqual(D("7.5"), amounts["XEM"].value)
1180         self.assertEqual(D("-1.0"), amounts["DASH"].value)
1181
1182     def test_currencies(self):
1183         portfolio.BalanceStore.all = {
1184                 "BTC": portfolio.Balance("BTC", {
1185                     "total": "0.65",
1186                     "exchange_total":"0.65",
1187                     "exchange_free": "0.35",
1188                     "exchange_used": "0.30"}),
1189                 "ETH": portfolio.Balance("ETH", {
1190                     "total": 3,
1191                     "exchange_total": 3,
1192                     "exchange_free": 3,
1193                     "exchange_used": 0}),
1194                 }
1195         self.assertListEqual(["BTC", "ETH"], list(portfolio.BalanceStore.currencies()))
1196
1197 @unittest.skipUnless("unit" in limits, "Unit skipped")
1198 class ComputationTest(WebMockTestCase):
1199     def test_compute_value(self):
1200         compute = mock.Mock()
1201         portfolio.Computation.compute_value("foo", "buy", compute_value=compute)
1202         compute.assert_called_with("foo", "ask")
1203
1204         compute.reset_mock()
1205         portfolio.Computation.compute_value("foo", "sell", compute_value=compute)
1206         compute.assert_called_with("foo", "bid")
1207
1208         compute.reset_mock()
1209         portfolio.Computation.compute_value("foo", "ask", compute_value=compute)
1210         compute.assert_called_with("foo", "ask")
1211
1212         compute.reset_mock()
1213         portfolio.Computation.compute_value("foo", "bid", compute_value=compute)
1214         compute.assert_called_with("foo", "bid")
1215
1216         compute.reset_mock()
1217         portfolio.Computation.computations["test"] = compute
1218         portfolio.Computation.compute_value("foo", "bid", compute_value="test")
1219         compute.assert_called_with("foo", "bid")
1220
1221
1222 @unittest.skipUnless("unit" in limits, "Unit skipped")
1223 class TradeTest(WebMockTestCase):
1224
1225     def test_values_assertion(self):
1226         value_from = portfolio.Amount("BTC", "1.0")
1227         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1228         value_to = portfolio.Amount("BTC", "1.0")
1229         trade = portfolio.Trade(value_from, value_to, "ETH")
1230         self.assertEqual("BTC", trade.base_currency)
1231         self.assertEqual("ETH", trade.currency)
1232
1233         with self.assertRaises(AssertionError):
1234             portfolio.Trade(value_from, value_to, "ETC")
1235         with self.assertRaises(AssertionError):
1236             value_from.linked_to = None
1237             portfolio.Trade(value_from, value_to, "ETH")
1238         with self.assertRaises(AssertionError):
1239             value_from.currency = "ETH"
1240             portfolio.Trade(value_from, value_to, "ETH")
1241
1242         value_from = portfolio.Amount("BTC", 0)
1243         trade = portfolio.Trade(value_from, value_to, "ETH")
1244         self.assertEqual(0, trade.value_from.linked_to)
1245
1246     def test_action(self):
1247         value_from = portfolio.Amount("BTC", "1.0")
1248         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1249         value_to = portfolio.Amount("BTC", "1.0")
1250         trade = portfolio.Trade(value_from, value_to, "ETH")
1251
1252         self.assertIsNone(trade.action)
1253
1254         value_from = portfolio.Amount("BTC", "1.0")
1255         value_from.linked_to = portfolio.Amount("BTC", "1.0")
1256         value_to = portfolio.Amount("BTC", "2.0")
1257         trade = portfolio.Trade(value_from, value_to, "BTC")
1258
1259         self.assertIsNone(trade.action)
1260
1261         value_from = portfolio.Amount("BTC", "0.5")
1262         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1263         value_to = portfolio.Amount("BTC", "1.0")
1264         trade = portfolio.Trade(value_from, value_to, "ETH")
1265
1266         self.assertEqual("acquire", trade.action)
1267
1268         value_from = portfolio.Amount("BTC", "0")
1269         value_from.linked_to = portfolio.Amount("ETH", "0")
1270         value_to = portfolio.Amount("BTC", "-1.0")
1271         trade = portfolio.Trade(value_from, value_to, "ETH")
1272
1273         self.assertEqual("acquire", trade.action)
1274
1275     def test_order_action(self):
1276         value_from = portfolio.Amount("BTC", "0.5")
1277         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1278         value_to = portfolio.Amount("BTC", "1.0")
1279         trade = portfolio.Trade(value_from, value_to, "ETH")
1280
1281         self.assertEqual("buy", trade.order_action(False))
1282         self.assertEqual("sell", trade.order_action(True))
1283
1284         value_from = portfolio.Amount("BTC", "0")
1285         value_from.linked_to = portfolio.Amount("ETH", "0")
1286         value_to = portfolio.Amount("BTC", "-1.0")
1287         trade = portfolio.Trade(value_from, value_to, "ETH")
1288
1289         self.assertEqual("sell", trade.order_action(False))
1290         self.assertEqual("buy", trade.order_action(True))
1291
1292     def test_trade_type(self):
1293         value_from = portfolio.Amount("BTC", "0.5")
1294         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1295         value_to = portfolio.Amount("BTC", "1.0")
1296         trade = portfolio.Trade(value_from, value_to, "ETH")
1297
1298         self.assertEqual("long", trade.trade_type)
1299
1300         value_from = portfolio.Amount("BTC", "0")
1301         value_from.linked_to = portfolio.Amount("ETH", "0")
1302         value_to = portfolio.Amount("BTC", "-1.0")
1303         trade = portfolio.Trade(value_from, value_to, "ETH")
1304
1305         self.assertEqual("short", trade.trade_type)
1306
1307     def test_filled_amount(self):
1308         value_from = portfolio.Amount("BTC", "0.5")
1309         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1310         value_to = portfolio.Amount("BTC", "1.0")
1311         trade = portfolio.Trade(value_from, value_to, "ETH")
1312
1313         order1 = mock.Mock()
1314         order1.filled_amount.return_value = portfolio.Amount("ETH", "0.3")
1315
1316         order2 = mock.Mock()
1317         order2.filled_amount.return_value = portfolio.Amount("ETH", "0.01")
1318         trade.orders.append(order1)
1319         trade.orders.append(order2)
1320
1321         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount())
1322         order1.filled_amount.assert_called_with(in_base_currency=False)
1323         order2.filled_amount.assert_called_with(in_base_currency=False)
1324
1325         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount(in_base_currency=False))
1326         order1.filled_amount.assert_called_with(in_base_currency=False)
1327         order2.filled_amount.assert_called_with(in_base_currency=False)
1328
1329         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount(in_base_currency=True))
1330         order1.filled_amount.assert_called_with(in_base_currency=True)
1331         order2.filled_amount.assert_called_with(in_base_currency=True)
1332
1333     @mock.patch.object(helper, "get_ticker")
1334     @mock.patch.object(portfolio.Computation, "compute_value")
1335     @mock.patch.object(portfolio.Trade, "filled_amount")
1336     @mock.patch.object(portfolio, "Order")
1337     def test_prepare_order(self, Order, filled_amount, compute_value, get_ticker):
1338         Order.return_value = "Order"
1339
1340         with self.subTest(desc="Nothing to do"):
1341             value_from = portfolio.Amount("BTC", "10")
1342             value_from.rate = D("0.1")
1343             value_from.linked_to = portfolio.Amount("FOO", "100")
1344             value_to = portfolio.Amount("BTC", "10")
1345             trade = portfolio.Trade(value_from, value_to, "FOO", market="market")
1346
1347             trade.prepare_order()
1348
1349             filled_amount.assert_not_called()
1350             compute_value.assert_not_called()
1351             self.assertEqual(0, len(trade.orders))
1352             Order.assert_not_called()
1353
1354         get_ticker.return_value = { "inverted": False }
1355         with self.subTest(desc="Already filled"), mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
1356             filled_amount.return_value = portfolio.Amount("FOO", "100")
1357             compute_value.return_value = D("0.125")
1358
1359             value_from = portfolio.Amount("BTC", "10")
1360             value_from.rate = D("0.1")
1361             value_from.linked_to = portfolio.Amount("FOO", "100")
1362             value_to = portfolio.Amount("BTC", "0")
1363             trade = portfolio.Trade(value_from, value_to, "FOO", market="market")
1364
1365             trade.prepare_order()
1366
1367             filled_amount.assert_called_with(in_base_currency=False)
1368             compute_value.assert_called_with(get_ticker.return_value, "sell", compute_value="default")
1369             self.assertEqual(0, len(trade.orders))
1370             self.assertRegex(stdout_mock.getvalue(), "Less to do than already filled: ")
1371             Order.assert_not_called()
1372
1373         with self.subTest(action="dispose", inverted=False):
1374             filled_amount.return_value = portfolio.Amount("FOO", "60")
1375             compute_value.return_value = D("0.125")
1376
1377             value_from = portfolio.Amount("BTC", "10")
1378             value_from.rate = D("0.1")
1379             value_from.linked_to = portfolio.Amount("FOO", "100")
1380             value_to = portfolio.Amount("BTC", "1")
1381             trade = portfolio.Trade(value_from, value_to, "FOO", market="market")
1382
1383             trade.prepare_order()
1384
1385             filled_amount.assert_called_with(in_base_currency=False)
1386             compute_value.assert_called_with(get_ticker.return_value, "sell", compute_value="default")
1387             self.assertEqual(1, len(trade.orders))
1388             Order.assert_called_with("sell", portfolio.Amount("FOO", 30),
1389                     D("0.125"), "BTC", "long", "market",
1390                     trade, close_if_possible=False)
1391
1392         with self.subTest(action="acquire", inverted=False):
1393             filled_amount.return_value = portfolio.Amount("BTC", "3")
1394             compute_value.return_value = D("0.125")
1395
1396             value_from = portfolio.Amount("BTC", "1")
1397             value_from.rate = D("0.1")
1398             value_from.linked_to = portfolio.Amount("FOO", "10")
1399             value_to = portfolio.Amount("BTC", "10")
1400             trade = portfolio.Trade(value_from, value_to, "FOO", market="market")
1401
1402             trade.prepare_order()
1403
1404             filled_amount.assert_called_with(in_base_currency=True)
1405             compute_value.assert_called_with(get_ticker.return_value, "buy", compute_value="default")
1406             self.assertEqual(1, len(trade.orders))
1407
1408             Order.assert_called_with("buy", portfolio.Amount("FOO", 48),
1409                 D("0.125"), "BTC", "long", "market",
1410                 trade, close_if_possible=False)
1411
1412         with self.subTest(close_if_possible=True):
1413             filled_amount.return_value = portfolio.Amount("FOO", "0")
1414             compute_value.return_value = D("0.125")
1415
1416             value_from = portfolio.Amount("BTC", "10")
1417             value_from.rate = D("0.1")
1418             value_from.linked_to = portfolio.Amount("FOO", "100")
1419             value_to = portfolio.Amount("BTC", "0")
1420             trade = portfolio.Trade(value_from, value_to, "FOO", market="market")
1421
1422             trade.prepare_order()
1423
1424             filled_amount.assert_called_with(in_base_currency=False)
1425             compute_value.assert_called_with(get_ticker.return_value, "sell", compute_value="default")
1426             self.assertEqual(1, len(trade.orders))
1427             Order.assert_called_with("sell", portfolio.Amount("FOO", 100),
1428                     D("0.125"), "BTC", "long", "market",
1429                     trade, close_if_possible=True)
1430
1431         get_ticker.return_value = { "inverted": True, "original": {} }
1432         with self.subTest(action="dispose", inverted=True):
1433             filled_amount.return_value = portfolio.Amount("FOO", "300")
1434             compute_value.return_value = D("125")
1435
1436             value_from = portfolio.Amount("BTC", "10")
1437             value_from.rate = D("0.01")
1438             value_from.linked_to = portfolio.Amount("FOO", "1000")
1439             value_to = portfolio.Amount("BTC", "1")
1440             trade = portfolio.Trade(value_from, value_to, "FOO", market="market")
1441
1442             trade.prepare_order(compute_value="foo")
1443
1444             filled_amount.assert_called_with(in_base_currency=True)
1445             compute_value.assert_called_with(get_ticker.return_value["original"], "buy", compute_value="foo")
1446             self.assertEqual(1, len(trade.orders))
1447             Order.assert_called_with("buy", portfolio.Amount("BTC", D("4.8")),
1448                     D("125"), "FOO", "long", "market",
1449                     trade, close_if_possible=False)
1450
1451         with self.subTest(action="acquire", inverted=True):
1452             filled_amount.return_value = portfolio.Amount("BTC", "4")
1453             compute_value.return_value = D("125")
1454
1455             value_from = portfolio.Amount("BTC", "1")
1456             value_from.rate = D("0.01")
1457             value_from.linked_to = portfolio.Amount("FOO", "100")
1458             value_to = portfolio.Amount("BTC", "10")
1459             trade = portfolio.Trade(value_from, value_to, "FOO", market="market")
1460
1461             trade.prepare_order(compute_value="foo")
1462
1463             filled_amount.assert_called_with(in_base_currency=False)
1464             compute_value.assert_called_with(get_ticker.return_value["original"], "sell", compute_value="foo")
1465             self.assertEqual(1, len(trade.orders))
1466             Order.assert_called_with("sell", portfolio.Amount("BTC", D("5")),
1467                     D("125"), "FOO", "long", "market",
1468                     trade, close_if_possible=False)
1469
1470
1471     @mock.patch.object(portfolio.Trade, "prepare_order")
1472     def test_update_order(self, prepare_order):
1473         order_mock = mock.Mock()
1474         new_order_mock = mock.Mock()
1475
1476         value_from = portfolio.Amount("BTC", "0.5")
1477         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1478         value_to = portfolio.Amount("BTC", "1.0")
1479         trade = portfolio.Trade(value_from, value_to, "ETH")
1480         prepare_order.return_value = new_order_mock
1481
1482         for i in [0, 1, 3, 4, 6]:
1483             with self.subTest(tick=i), mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
1484                 trade.update_order(order_mock, i)
1485                 order_mock.cancel.assert_not_called()
1486                 new_order_mock.run.assert_not_called()
1487                 self.assertRegex(stdout_mock.getvalue(), "tick {}, waiting".format(i))
1488
1489             order_mock.reset_mock()
1490             new_order_mock.reset_mock()
1491             trade.orders = []
1492
1493         with mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
1494             trade.update_order(order_mock, 2)
1495             order_mock.cancel.assert_called()
1496             new_order_mock.run.assert_called()
1497             prepare_order.assert_called()
1498             self.assertRegex(stdout_mock.getvalue(), "tick 2, cancelling and adjusting")
1499
1500         order_mock.reset_mock()
1501         new_order_mock.reset_mock()
1502         trade.orders = []
1503
1504         with mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
1505             trade.update_order(order_mock, 5)
1506             order_mock.cancel.assert_called()
1507             new_order_mock.run.assert_called()
1508             prepare_order.assert_called()
1509             self.assertRegex(stdout_mock.getvalue(), "tick 5, cancelling and adjusting")
1510
1511         order_mock.reset_mock()
1512         new_order_mock.reset_mock()
1513         trade.orders = []
1514
1515         with mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
1516             trade.update_order(order_mock, 7)
1517             order_mock.cancel.assert_called()
1518             new_order_mock.run.assert_called()
1519             prepare_order.assert_called_with(compute_value="default")
1520             self.assertRegex(stdout_mock.getvalue(), "tick 7, fallbacking to market value")
1521             self.assertRegex(stdout_mock.getvalue(), "tick 7, market value, cancelling and adjusting to")
1522
1523         order_mock.reset_mock()
1524         new_order_mock.reset_mock()
1525         trade.orders = []
1526
1527         for i in [10, 13, 16]:
1528             with self.subTest(tick=i), mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
1529                 trade.update_order(order_mock, i)
1530                 order_mock.cancel.assert_called()
1531                 new_order_mock.run.assert_called()
1532                 prepare_order.assert_called_with(compute_value="default")
1533                 self.assertNotRegex(stdout_mock.getvalue(), "tick {}, fallbacking to market value".format(i))
1534                 self.assertRegex(stdout_mock.getvalue(), "tick {}, market value, cancelling and adjusting to".format(i))
1535
1536             order_mock.reset_mock()
1537             new_order_mock.reset_mock()
1538             trade.orders = []
1539
1540         for i in [8, 9, 11, 12]:
1541             with self.subTest(tick=i), mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
1542                 trade.update_order(order_mock, i)
1543                 order_mock.cancel.assert_not_called()
1544                 new_order_mock.run.assert_not_called()
1545                 self.assertEqual("", stdout_mock.getvalue())
1546
1547             order_mock.reset_mock()
1548             new_order_mock.reset_mock()
1549             trade.orders = []
1550
1551
1552     @mock.patch('sys.stdout', new_callable=StringIO)
1553     def test_print_with_order(self, mock_stdout):
1554         value_from = portfolio.Amount("BTC", "0.5")
1555         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1556         value_to = portfolio.Amount("BTC", "1.0")
1557         trade = portfolio.Trade(value_from, value_to, "ETH")
1558
1559         order_mock1 = mock.Mock()
1560         order_mock1.__repr__ = mock.Mock()
1561         order_mock1.__repr__.return_value = "Mock 1"
1562         order_mock2 = mock.Mock()
1563         order_mock2.__repr__ = mock.Mock()
1564         order_mock2.__repr__.return_value = "Mock 2"
1565         trade.orders.append(order_mock1)
1566         trade.orders.append(order_mock2)
1567
1568         trade.print_with_order()
1569
1570         out = mock_stdout.getvalue().split("\n")
1571         self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire)", out[0])
1572         self.assertEqual("\tMock 1", out[1])
1573         self.assertEqual("\tMock 2", out[2])
1574
1575     def test__repr(self):
1576         value_from = portfolio.Amount("BTC", "0.5")
1577         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1578         value_to = portfolio.Amount("BTC", "1.0")
1579         trade = portfolio.Trade(value_from, value_to, "ETH")
1580
1581         self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire)", str(trade))
1582
1583 @unittest.skipUnless("unit" in limits, "Unit skipped")
1584 class OrderTest(WebMockTestCase):
1585     def test_values(self):
1586         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1587                 D("0.1"), "BTC", "long", "market", "trade")
1588         self.assertEqual("buy", order.action)
1589         self.assertEqual(10, order.amount.value)
1590         self.assertEqual("ETH", order.amount.currency)
1591         self.assertEqual(D("0.1"), order.rate)
1592         self.assertEqual("BTC", order.base_currency)
1593         self.assertEqual("market", order.market)
1594         self.assertEqual("long", order.trade_type)
1595         self.assertEqual("pending", order.status)
1596         self.assertEqual("trade", order.trade)
1597         self.assertIsNone(order.id)
1598         self.assertFalse(order.close_if_possible)
1599
1600     def test__repr(self):
1601         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1602                 D("0.1"), "BTC", "long", "market", "trade")
1603         self.assertEqual("Order(buy long 10.00000000 ETH at 0.1 BTC [pending])", repr(order))
1604
1605         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1606                 D("0.1"), "BTC", "long", "market", "trade",
1607                 close_if_possible=True)
1608         self.assertEqual("Order(buy long 10.00000000 ETH at 0.1 BTC [pending] ✂)", repr(order))
1609
1610     def test_account(self):
1611         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1612                 D("0.1"), "BTC", "long", "market", "trade")
1613         self.assertEqual("exchange", order.account)
1614
1615         order = portfolio.Order("sell", portfolio.Amount("ETH", 10),
1616                 D("0.1"), "BTC", "short", "market", "trade")
1617         self.assertEqual("margin", order.account)
1618
1619     def test_pending(self):
1620         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1621                 D("0.1"), "BTC", "long", "market", "trade")
1622         self.assertTrue(order.pending)
1623         order.status = "open"
1624         self.assertFalse(order.pending)
1625
1626     def test_open(self):
1627         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1628                 D("0.1"), "BTC", "long", "market", "trade")
1629         self.assertFalse(order.open)
1630         order.status = "open"
1631         self.assertTrue(order.open)
1632
1633     def test_finished(self):
1634         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1635                 D("0.1"), "BTC", "long", "market", "trade")
1636         self.assertFalse(order.finished)
1637         order.status = "closed"
1638         self.assertTrue(order.finished)
1639         order.status = "canceled"
1640         self.assertTrue(order.finished)
1641         order.status = "error"
1642         self.assertTrue(order.finished)
1643
1644     @mock.patch.object(portfolio.Order, "fetch")
1645     def test_cancel(self, fetch):
1646         market = mock.Mock()
1647         portfolio.TradeStore.debug = True
1648         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1649                 D("0.1"), "BTC", "long", market, "trade")
1650         order.status = "open"
1651
1652         order.cancel()
1653         market.cancel_order.assert_not_called()
1654         self.assertEqual("canceled", order.status)
1655
1656         portfolio.TradeStore.debug = False
1657         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1658                 D("0.1"), "BTC", "long", market, "trade")
1659         order.status = "open"
1660         order.id = 42
1661
1662         order.cancel()
1663         market.cancel_order.assert_called_with(42)
1664         fetch.assert_called_once()
1665
1666     def test_dust_amount_remaining(self):
1667         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1668                 D("0.1"), "BTC", "long", "market", "trade")
1669         order.remaining_amount = mock.Mock(return_value=portfolio.Amount("ETH", 1))
1670         self.assertFalse(order.dust_amount_remaining())
1671
1672         order.remaining_amount = mock.Mock(return_value=portfolio.Amount("ETH", D("0.0001")))
1673         self.assertTrue(order.dust_amount_remaining())
1674
1675     @mock.patch.object(portfolio.Order, "fetch")
1676     @mock.patch.object(portfolio.Order, "filled_amount", return_value=portfolio.Amount("ETH", 1))
1677     def test_remaining_amount(self, filled_amount, fetch):
1678         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1679                 D("0.1"), "BTC", "long", "market", "trade")
1680
1681         self.assertEqual(9, order.remaining_amount().value)
1682         order.fetch.assert_not_called()
1683
1684         order.status = "open"
1685         self.assertEqual(9, order.remaining_amount().value)
1686         fetch.assert_called_once()
1687
1688     @mock.patch.object(portfolio.Order, "fetch")
1689     def test_filled_amount(self, fetch):
1690         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1691                 D("0.1"), "BTC", "long", "market", "trade")
1692         order.mouvements.append(portfolio.Mouvement("ETH", "BTC", {
1693             "tradeID": 42, "type": "buy", "fee": "0.0015",
1694             "date": "2017-12-30 12:00:12", "rate": "0.1",
1695             "amount": "3", "total": "0.3"
1696             }))
1697         order.mouvements.append(portfolio.Mouvement("ETH", "BTC", {
1698             "tradeID": 43, "type": "buy", "fee": "0.0015",
1699             "date": "2017-12-30 13:00:12", "rate": "0.2",
1700             "amount": "2", "total": "0.4"
1701             }))
1702         self.assertEqual(portfolio.Amount("ETH", 5), order.filled_amount())
1703         fetch.assert_not_called()
1704         order.status = "open"
1705         self.assertEqual(portfolio.Amount("ETH", 5), order.filled_amount(in_base_currency=False))
1706         fetch.assert_called_once()
1707         self.assertEqual(portfolio.Amount("BTC", "0.7"), order.filled_amount(in_base_currency=True))
1708
1709     def test_fetch_mouvements(self):
1710         market = mock.Mock()
1711         market.privatePostReturnOrderTrades.return_value = [
1712                 {
1713                     "tradeID": 42, "type": "buy", "fee": "0.0015",
1714                     "date": "2017-12-30 12:00:12", "rate": "0.1",
1715                     "amount": "3", "total": "0.3"
1716                     },
1717                 {
1718                     "tradeID": 43, "type": "buy", "fee": "0.0015",
1719                     "date": "2017-12-30 13:00:12", "rate": "0.2",
1720                     "amount": "2", "total": "0.4"
1721                     }
1722             ]
1723         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1724                 D("0.1"), "BTC", "long", market, "trade")
1725         order.id = 12
1726         order.mouvements = ["Foo", "Bar", "Baz"]
1727
1728         order.fetch_mouvements()
1729
1730         market.privatePostReturnOrderTrades.assert_called_with({"orderNumber": 12})
1731         self.assertEqual(2, len(order.mouvements))
1732         self.assertEqual(42, order.mouvements[0].id)
1733         self.assertEqual(43, order.mouvements[1].id)
1734
1735         market.privatePostReturnOrderTrades.side_effect = portfolio.ExchangeError
1736         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1737                 D("0.1"), "BTC", "long", market, "trade")
1738         order.fetch_mouvements()
1739         self.assertEqual(0, len(order.mouvements))
1740
1741     def test_mark_finished_order(self):
1742         market = mock.Mock()
1743         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1744                 D("0.1"), "BTC", "short", market, "trade",
1745                 close_if_possible=True)
1746         order.status = "closed"
1747         portfolio.TradeStore.debug = False
1748
1749         order.mark_finished_order()
1750         market.close_margin_position.assert_called_with("ETH", "BTC")
1751         market.close_margin_position.reset_mock()
1752
1753         order.status = "open"
1754         order.mark_finished_order()
1755         market.close_margin_position.assert_not_called()
1756
1757         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1758                 D("0.1"), "BTC", "short", market, "trade",
1759                 close_if_possible=False)
1760         order.status = "closed"
1761         order.mark_finished_order()
1762         market.close_margin_position.assert_not_called()
1763
1764         order = portfolio.Order("sell", portfolio.Amount("ETH", 10),
1765                 D("0.1"), "BTC", "short", market, "trade",
1766                 close_if_possible=True)
1767         order.status = "closed"
1768         order.mark_finished_order()
1769         market.close_margin_position.assert_not_called()
1770
1771         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1772                 D("0.1"), "BTC", "long", market, "trade",
1773                 close_if_possible=True)
1774         order.status = "closed"
1775         order.mark_finished_order()
1776         market.close_margin_position.assert_not_called()
1777
1778         portfolio.TradeStore.debug = True
1779
1780         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1781                 D("0.1"), "BTC", "short", market, "trade",
1782                 close_if_possible=True)
1783         order.status = "closed"
1784
1785         order.mark_finished_order()
1786         market.close_margin_position.assert_not_called()
1787
1788     @mock.patch.object(portfolio.Order, "fetch_mouvements")
1789     def test_fetch(self, fetch_mouvements):
1790         time = self.time.time()
1791         with mock.patch.object(portfolio.time, "time") as time_mock:
1792             market = mock.Mock()
1793             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1794                     D("0.1"), "BTC", "long", market, "trade")
1795             order.id = 45
1796             with self.subTest(debug=True):
1797                 portfolio.TradeStore.debug = True
1798                 order.fetch()
1799                 time_mock.assert_not_called()
1800                 order.fetch(force=True)
1801                 time_mock.assert_not_called()
1802                 market.fetch_order.assert_not_called()
1803                 fetch_mouvements.assert_not_called()
1804             self.assertIsNone(order.fetch_cache_timestamp)
1805
1806             with self.subTest(debug=False):
1807                 portfolio.TradeStore.debug = False
1808                 time_mock.return_value = time
1809                 market.fetch_order.return_value = {
1810                         "status": "foo",
1811                         "datetime": "timestamp"
1812                         }
1813                 order.fetch()
1814
1815                 market.fetch_order.assert_called_once()
1816                 fetch_mouvements.assert_called_once()
1817                 self.assertEqual("foo", order.status)
1818                 self.assertEqual("timestamp", order.timestamp)
1819                 self.assertEqual(time, order.fetch_cache_timestamp)
1820                 self.assertEqual(1, len(order.results))
1821
1822                 market.fetch_order.reset_mock()
1823                 fetch_mouvements.reset_mock()
1824
1825                 time_mock.return_value = time + 8
1826                 order.fetch()
1827                 market.fetch_order.assert_not_called()
1828                 fetch_mouvements.assert_not_called()
1829
1830                 order.fetch(force=True)
1831                 market.fetch_order.assert_called_once()
1832                 fetch_mouvements.assert_called_once()
1833
1834                 market.fetch_order.reset_mock()
1835                 fetch_mouvements.reset_mock()
1836
1837                 time_mock.return_value = time + 19
1838                 order.fetch()
1839                 market.fetch_order.assert_called_once()
1840                 fetch_mouvements.assert_called_once()
1841
1842     @mock.patch.object(portfolio.Order, "fetch")
1843     @mock.patch.object(portfolio.Order, "mark_finished_order")
1844     def test_get_status(self, mark_finished_order, fetch):
1845         with self.subTest(debug=True):
1846             portfolio.TradeStore.debug = True
1847             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1848                     D("0.1"), "BTC", "long", "market", "trade")
1849             self.assertEqual("pending", order.get_status())
1850             fetch.assert_not_called()
1851
1852         with self.subTest(debug=False, finished=False):
1853             portfolio.TradeStore.debug = False
1854             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1855                     D("0.1"), "BTC", "long", "market", "trade")
1856             def _fetch(order):
1857                 def update_status():
1858                     order.status = "open"
1859                 return update_status
1860             fetch.side_effect = _fetch(order)
1861             self.assertEqual("open", order.get_status())
1862             mark_finished_order.assert_not_called()
1863             fetch.assert_called_once()
1864
1865         mark_finished_order.reset_mock()
1866         fetch.reset_mock()
1867         with self.subTest(debug=False, finished=True):
1868             portfolio.TradeStore.debug = False
1869             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1870                     D("0.1"), "BTC", "long", "market", "trade")
1871             def _fetch(order):
1872                 def update_status():
1873                     order.status = "closed"
1874                 return update_status
1875             fetch.side_effect = _fetch(order)
1876             self.assertEqual("closed", order.get_status())
1877             mark_finished_order.assert_called_once()
1878             fetch.assert_called_once()
1879
1880     def test_run(self):
1881         market = mock.Mock()
1882
1883         market.order_precision.return_value = 4
1884         with self.subTest(debug=True),\
1885                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
1886             portfolio.TradeStore.debug = True
1887             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1888                     D("0.1"), "BTC", "long", market, "trade")
1889             order.run()
1890             market.create_order.assert_not_called()
1891             self.assertEqual("market.create_order('ETH/BTC', 'limit', 'buy', 10.0000, price=0.1, account=exchange)\n", stdout_mock.getvalue())
1892             self.assertEqual("open", order.status)
1893             self.assertEqual(1, len(order.results))
1894             self.assertEqual(-1, order.id)
1895
1896         market.create_order.reset_mock()
1897         with self.subTest(debug=False):
1898             portfolio.TradeStore.debug = False
1899             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1900                     D("0.1"), "BTC", "long", market, "trade")
1901             market.create_order.return_value = { "id": 123 }
1902             order.run()
1903             market.create_order.assert_called_once()
1904             self.assertEqual(1, len(order.results))
1905             self.assertEqual("open", order.status)
1906
1907         market.create_order.reset_mock()
1908         with self.subTest(exception=True),\
1909                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
1910             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1911                     D("0.1"), "BTC", "long", market, "trade")
1912             market.create_order.side_effect = Exception("bouh")
1913             order.run()
1914             market.create_order.assert_called_once()
1915             self.assertEqual(0, len(order.results))
1916             self.assertEqual("error", order.status)
1917             self.assertRegex(stdout_mock.getvalue(), "error when running market.create_order")
1918             self.assertRegex(stdout_mock.getvalue(), "Exception: bouh")
1919
1920         market.create_order.reset_mock()
1921         with self.subTest(dust_amount_exception=True),\
1922                 mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order:
1923             order = portfolio.Order("buy", portfolio.Amount("ETH", 0.001),
1924                     D("0.1"), "BTC", "long", market, "trade")
1925             market.create_order.side_effect = portfolio.ExchangeNotAvailable
1926             order.run()
1927             market.create_order.assert_called_once()
1928             self.assertEqual(0, len(order.results))
1929             self.assertEqual("closed", order.status)
1930             mark_finished_order.assert_called_once()
1931
1932
1933 @unittest.skipUnless("unit" in limits, "Unit skipped")
1934 class MouvementTest(WebMockTestCase):
1935     def test_values(self):
1936         mouvement = portfolio.Mouvement("ETH", "BTC", {
1937             "tradeID": 42, "type": "buy", "fee": "0.0015",
1938             "date": "2017-12-30 12:00:12", "rate": "0.1",
1939             "amount": "10", "total": "1"
1940             })
1941         self.assertEqual("ETH", mouvement.currency)
1942         self.assertEqual("BTC", mouvement.base_currency)
1943         self.assertEqual(42, mouvement.id)
1944         self.assertEqual("buy", mouvement.action)
1945         self.assertEqual(D("0.0015"), mouvement.fee_rate)
1946         self.assertEqual(portfolio.datetime(2017, 12, 30, 12, 0, 12), mouvement.date)
1947         self.assertEqual(D("0.1"), mouvement.rate)
1948         self.assertEqual(portfolio.Amount("ETH", "10"), mouvement.total)
1949         self.assertEqual(portfolio.Amount("BTC", "1"), mouvement.total_in_base)
1950
1951         mouvement = portfolio.Mouvement("ETH", "BTC", { "foo": "bar" })
1952         self.assertIsNone(mouvement.date)
1953         self.assertIsNone(mouvement.id)
1954         self.assertIsNone(mouvement.action)
1955         self.assertEqual(-1, mouvement.fee_rate)
1956         self.assertEqual(0, mouvement.rate)
1957         self.assertEqual(portfolio.Amount("ETH", 0), mouvement.total)
1958         self.assertEqual(portfolio.Amount("BTC", 0), mouvement.total_in_base)
1959
1960 @unittest.skipUnless("acceptance" in limits, "Acceptance skipped")
1961 class AcceptanceTest(WebMockTestCase):
1962     @unittest.expectedFailure
1963     def test_success_sell_only_necessary(self):
1964         fetch_balance = {
1965                 "ETH": {
1966                     "exchange_free": D("1.0"),
1967                     "exchange_used": D("0.0"),
1968                     "exchange_total": D("1.0"),
1969                     "total": D("1.0"),
1970                     },
1971                 "ETC": {
1972                     "exchange_free": D("4.0"),
1973                     "exchange_used": D("0.0"),
1974                     "exchange_total": D("4.0"),
1975                     "total": D("4.0"),
1976                     },
1977                 "XVG": {
1978                     "exchange_free": D("1000.0"),
1979                     "exchange_used": D("0.0"),
1980                     "exchange_total": D("1000.0"),
1981                     "total": D("1000.0"),
1982                     },
1983                 }
1984         repartition = {
1985                 "ETH":  (D("0.25"), "long"),
1986                 "ETC":  (D("0.25"), "long"),
1987                 "BTC":  (D("0.4"),  "long"),
1988                 "BTD":  (D("0.01"), "short"),
1989                 "B2X":  (D("0.04"), "long"),
1990                 "USDT": (D("0.05"), "long"),
1991                 }
1992
1993         def fetch_ticker(symbol):
1994             if symbol == "ETH/BTC":
1995                 return {
1996                         "symbol": "ETH/BTC",
1997                         "bid": D("0.14"),
1998                         "ask": D("0.16")
1999                         }
2000             if symbol == "ETC/BTC":
2001                 return {
2002                         "symbol": "ETC/BTC",
2003                         "bid": D("0.002"),
2004                         "ask": D("0.003")
2005                         }
2006             if symbol == "XVG/BTC":
2007                 return {
2008                         "symbol": "XVG/BTC",
2009                         "bid": D("0.00003"),
2010                         "ask": D("0.00005")
2011                         }
2012             if symbol == "BTD/BTC":
2013                 return {
2014                         "symbol": "BTD/BTC",
2015                         "bid": D("0.0008"),
2016                         "ask": D("0.0012")
2017                         }
2018             if symbol == "B2X/BTC":
2019                 return {
2020                         "symbol": "B2X/BTC",
2021                         "bid": D("0.0008"),
2022                         "ask": D("0.0012")
2023                         }
2024             if symbol == "USDT/BTC":
2025                 raise helper.ExchangeError
2026             if symbol == "BTC/USDT":
2027                 return {
2028                         "symbol": "BTC/USDT",
2029                         "bid": D("14000"),
2030                         "ask": D("16000")
2031                         }
2032             self.fail("Shouldn't have been called with {}".format(symbol))
2033
2034         market = mock.Mock()
2035         market.fetch_all_balances.return_value = fetch_balance
2036         market.fetch_ticker.side_effect = fetch_ticker
2037         with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
2038             # Action 1
2039             helper.prepare_trades(market)
2040
2041         balances = portfolio.BalanceStore.all
2042         self.assertEqual(portfolio.Amount("ETH", 1), balances["ETH"].total)
2043         self.assertEqual(portfolio.Amount("ETC", 4), balances["ETC"].total)
2044         self.assertEqual(portfolio.Amount("XVG", 1000), balances["XVG"].total)
2045
2046
2047         trades = portfolio.TradeStore.all
2048         self.assertEqual(portfolio.Amount("BTC", D("0.15")), trades[0].value_from)
2049         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[0].value_to)
2050         self.assertEqual("dispose", trades[0].action)
2051
2052         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[1].value_from)
2053         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[1].value_to)
2054         self.assertEqual("acquire", trades[1].action)
2055
2056         self.assertEqual(portfolio.Amount("BTC", D("0.04")), trades[2].value_from)
2057         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[2].value_to)
2058         self.assertEqual("dispose", trades[2].action)
2059
2060         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[3].value_from)
2061         self.assertEqual(portfolio.Amount("BTC", D("-0.002")), trades[3].value_to)
2062         self.assertEqual("acquire", trades[3].action)
2063
2064         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[4].value_from)
2065         self.assertEqual(portfolio.Amount("BTC", D("0.008")), trades[4].value_to)
2066         self.assertEqual("acquire", trades[4].action)
2067
2068         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[5].value_from)
2069         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[5].value_to)
2070         self.assertEqual("acquire", trades[5].action)
2071
2072         # Action 2
2073         portfolio.TradeStore.prepare_orders(only="dispose", compute_value=lambda x, y: x["bid"] * D("1.001"))
2074
2075         all_orders = portfolio.TradeStore.all_orders(state="pending")
2076         self.assertEqual(2, len(all_orders))
2077         self.assertEqual(2, 3*all_orders[0].amount.value)
2078         self.assertEqual(D("0.14014"), all_orders[0].rate)
2079         self.assertEqual(1000, all_orders[1].amount.value)
2080         self.assertEqual(D("0.00003003"), all_orders[1].rate)
2081
2082
2083         def create_order(symbol, type, action, amount, price=None, account="exchange"):
2084             self.assertEqual("limit", type)
2085             if symbol == "ETH/BTC":
2086                 self.assertEqual("sell", action)
2087                 self.assertEqual(D('0.66666666'), amount)
2088                 self.assertEqual(D("0.14014"), price)
2089             elif symbol == "XVG/BTC":
2090                 self.assertEqual("sell", action)
2091                 self.assertEqual(1000, amount)
2092                 self.assertEqual(D("0.00003003"), price)
2093             else:
2094                 self.fail("I shouldn't have been called")
2095
2096             return {
2097                     "id": symbol,
2098                     }
2099         market.create_order.side_effect = create_order
2100         market.order_precision.return_value = 8
2101
2102         # Action 3
2103         portfolio.TradeStore.run_orders()
2104
2105         self.assertEqual("open", all_orders[0].status)
2106         self.assertEqual("open", all_orders[1].status)
2107
2108         market.fetch_order.return_value = { "status": "closed", "datetime": "2018-01-20 13:40:00" }
2109         market.privatePostReturnOrderTrades.return_value = [
2110                 {
2111                     "tradeID": 42, "type": "buy", "fee": "0.0015",
2112                     "date": "2017-12-30 12:00:12", "rate": "0.1",
2113                     "amount": "10", "total": "1"
2114                     }
2115                 ]
2116         with mock.patch.object(portfolio.time, "sleep") as sleep:
2117             # Action 4
2118             helper.follow_orders(verbose=False)
2119
2120             sleep.assert_called_with(30)
2121
2122         for order in all_orders:
2123             self.assertEqual("closed", order.status)
2124
2125         fetch_balance = {
2126                 "ETH": {
2127                     "exchange_free": D("1.0") / 3,
2128                     "exchange_used": D("0.0"),
2129                     "exchange_total": D("1.0") / 3,
2130                     "margin_total": 0,
2131                     "total": D("1.0") / 3,
2132                     },
2133                 "BTC": {
2134                     "exchange_free": D("0.134"),
2135                     "exchange_used": D("0.0"),
2136                     "exchange_total": D("0.134"),
2137                     "margin_total": 0,
2138                     "total": D("0.134"),
2139                     },
2140                 "ETC": {
2141                     "exchange_free": D("4.0"),
2142                     "exchange_used": D("0.0"),
2143                     "exchange_total": D("4.0"),
2144                     "margin_total": 0,
2145                     "total": D("4.0"),
2146                     },
2147                 "XVG": {
2148                     "exchange_free": D("0.0"),
2149                     "exchange_used": D("0.0"),
2150                     "exchange_total": D("0.0"),
2151                     "margin_total": 0,
2152                     "total": D("0.0"),
2153                     },
2154                 }
2155         market.fetch_all_balances.return_value = fetch_balance
2156
2157         with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
2158             # Action 5
2159             helper.update_trades(market, only="acquire", compute_value="average")
2160
2161         balances = portfolio.BalanceStore.all
2162         self.assertEqual(portfolio.Amount("ETH", 1 / D("3")), balances["ETH"].total)
2163         self.assertEqual(portfolio.Amount("ETC", 4), balances["ETC"].total)
2164         self.assertEqual(portfolio.Amount("BTC", D("0.134")), balances["BTC"].total)
2165         self.assertEqual(portfolio.Amount("XVG", 0), balances["XVG"].total)
2166
2167
2168         trades = portfolio.TradeStore.all
2169         self.assertEqual(portfolio.Amount("BTC", D("0.15")), trades[0].value_from)
2170         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[0].value_to)
2171         self.assertEqual("dispose", trades[0].action)
2172
2173         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[1].value_from)
2174         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[1].value_to)
2175         self.assertEqual("acquire", trades[1].action)
2176
2177         self.assertNotIn("BTC", trades)
2178
2179         self.assertEqual(portfolio.Amount("BTC", D("0.04")), trades[2].value_from)
2180         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[2].value_to)
2181         self.assertEqual("dispose", trades[2].action)
2182
2183         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[3].value_from)
2184         self.assertEqual(portfolio.Amount("BTC", D("-0.002")), trades[3].value_to)
2185         self.assertEqual("acquire", trades[3].action)
2186
2187         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[4].value_from)
2188         self.assertEqual(portfolio.Amount("BTC", D("0.008")), trades[4].value_to)
2189         self.assertEqual("acquire", trades[4].action)
2190
2191         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[5].value_from)
2192         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[5].value_to)
2193         self.assertEqual("acquire", trades[5].action)
2194
2195         # Action 6
2196         portfolio.TradeStore.prepare_orders(only="acquire", compute_value=lambda x, y: x["ask"])
2197
2198         all_orders = portfolio.TradeStore.all_orders(state="pending")
2199         self.assertEqual(4, len(all_orders))
2200         self.assertEqual(portfolio.Amount("ETC", D("12.83333333")), round(all_orders[0].amount))
2201         self.assertEqual(D("0.003"), all_orders[0].rate)
2202         self.assertEqual("buy", all_orders[0].action)
2203         self.assertEqual("long", all_orders[0].trade_type)
2204
2205         self.assertEqual(portfolio.Amount("BTD", D("1.61666666")), round(all_orders[1].amount))
2206         self.assertEqual(D("0.0012"), all_orders[1].rate)
2207         self.assertEqual("sell", all_orders[1].action)
2208         self.assertEqual("short", all_orders[1].trade_type)
2209
2210         diff = portfolio.Amount("B2X", D("19.4")/3) - all_orders[2].amount
2211         self.assertAlmostEqual(0, diff.value)
2212         self.assertEqual(D("0.0012"), all_orders[2].rate)
2213         self.assertEqual("buy", all_orders[2].action)
2214         self.assertEqual("long", all_orders[2].trade_type)
2215
2216         self.assertEqual(portfolio.Amount("BTC", D("0.0097")), all_orders[3].amount)
2217         self.assertEqual(D("16000"), all_orders[3].rate)
2218         self.assertEqual("sell", all_orders[3].action)
2219         self.assertEqual("long", all_orders[3].trade_type)
2220
2221         # Action 6b
2222         # TODO:
2223         # Move balances to margin
2224
2225         # Action 7
2226         # TODO
2227         # portfolio.TradeStore.run_orders()
2228
2229         with mock.patch.object(portfolio.time, "sleep") as sleep:
2230             # Action 8
2231             helper.follow_orders(verbose=False)
2232
2233             sleep.assert_called_with(30)
2234
2235 if __name__ == '__main__':
2236     unittest.main()