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