test.py

   1 import sys
   2 import portfolio
   3 import unittest
   4 import datetime
   5 from decimal import Decimal as D
   6 from unittest import mock
   7 import requests
   8 import requests_mock
   9 from io import StringIO
  10 import portfolio, helper, market
  11
  12 limits = ["acceptance", "unit"]
  13 for test_type in limits:
  14     if "--no{}".format(test_type) in sys.argv:
  15         sys.argv.remove("--no{}".format(test_type))
  16         limits.remove(test_type)
  17     if "--only{}".format(test_type) in sys.argv:
  18         sys.argv.remove("--only{}".format(test_type))
  19         limits = [test_type]
  20         break
  21
  22 class WebMockTestCase(unittest.TestCase):
  23     import time
  24
  25     def setUp(self):
  26         super(WebMockTestCase, self).setUp()
  27         self.wm = requests_mock.Mocker()
  28         self.wm.start()
  29
  30         # market
  31         self.m = mock.Mock(name="Market", spec=market.Market)
  32         self.m.debug = False
  33
  34         self.patchers = [
  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(market.Market,
  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(self.m)
  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         self.m.report.log_error.assert_not_called()
  78         self.m.report.log_http_request.assert_called_once()
  79         self.m.report.log_http_request.reset_mock()
  80
  81         portfolio.Portfolio.get_cryptoportfolio(self.m)
  82         self.assertIsNone(portfolio.Portfolio.data)
  83         self.assertEqual(2, self.wm.call_count)
  84         self.m.report.log_error.assert_not_called()
  85         self.m.report.log_http_request.assert_called_once()
  86         self.m.report.log_http_request.reset_mock()
  87
  88
  89         portfolio.Portfolio.data = "Foo"
  90         portfolio.Portfolio.get_cryptoportfolio(self.m)
  91         self.assertEqual("Foo", portfolio.Portfolio.data)
  92         self.assertEqual(3, self.wm.call_count)
  93         self.m.report.log_error.assert_called_once_with("get_cryptoportfolio",
  94                 exception=mock.ANY)
  95         self.m.report.log_http_request.assert_not_called()
  96
  97     def test_parse_cryptoportfolio(self):
  98         portfolio.Portfolio.parse_cryptoportfolio(self.m)
  99
 100         self.assertListEqual(
 101                 ["medium", "high"],
 102                 list(portfolio.Portfolio.liquidities.keys()))
 103
 104         liquidities = portfolio.Portfolio.liquidities
 105         self.assertEqual(10, len(liquidities["medium"].keys()))
 106         self.assertEqual(10, len(liquidities["high"].keys()))
 107
 108         expected = {
 109                 'BTC':  (D("0.2857"), "long"),
 110                 'DGB':  (D("0.1015"), "long"),
 111                 'DOGE': (D("0.1805"), "long"),
 112                 'SC':   (D("0.0623"), "long"),
 113                 'ZEC':  (D("0.3701"), "long"),
 114                 }
 115         date = portfolio.datetime(2018, 1, 8)
 116         self.assertDictEqual(expected, liquidities["high"][date])
 117
 118         expected = {
 119                 'BTC':  (D("1.1102e-16"), "long"),
 120                 'ETC':  (D("0.1"), "long"),
 121                 'FCT':  (D("0.1"), "long"),
 122                 'GAS':  (D("0.1"), "long"),
 123                 'NAV':  (D("0.1"), "long"),
 124                 'OMG':  (D("0.1"), "long"),
 125                 'OMNI': (D("0.1"), "long"),
 126                 'PPC':  (D("0.1"), "long"),
 127                 'RIC':  (D("0.1"), "long"),
 128                 'VIA':  (D("0.1"), "long"),
 129                 'XCP':  (D("0.1"), "long"),
 130                 }
 131         self.assertDictEqual(expected, liquidities["medium"][date])
 132         self.assertEqual(portfolio.datetime(2018, 1, 15), portfolio.Portfolio.last_date)
 133
 134         self.m.report.log_http_request.assert_called_once_with("GET",
 135                 portfolio.Portfolio.URL, None, mock.ANY, mock.ANY)
 136         self.m.report.log_http_request.reset_mock()
 137
 138         # It doesn't refetch the data when available
 139         portfolio.Portfolio.parse_cryptoportfolio(self.m)
 140         self.m.report.log_http_request.assert_not_called()
 141
 142         self.assertEqual(1, self.wm.call_count)
 143
 144         portfolio.Portfolio.parse_cryptoportfolio(self.m, refetch=True)
 145         self.assertEqual(2, self.wm.call_count)
 146         self.m.report.log_http_request.assert_called_once()
 147
 148     def test_repartition(self):
 149         expected_medium = {
 150                 'BTC':   (D("1.1102e-16"), "long"),
 151                 'USDT':  (D("0.1"), "long"),
 152                 'ETC':   (D("0.1"), "long"),
 153                 'FCT':   (D("0.1"), "long"),
 154                 'OMG':   (D("0.1"), "long"),
 155                 'STEEM': (D("0.1"), "long"),
 156                 'STRAT': (D("0.1"), "long"),
 157                 'XEM':   (D("0.1"), "long"),
 158                 'XMR':   (D("0.1"), "long"),
 159                 'XVC':   (D("0.1"), "long"),
 160                 'ZRX':   (D("0.1"), "long"),
 161                 }
 162         expected_high = {
 163                 'USDT': (D("0.1226"), "long"),
 164                 'BTC':  (D("0.1429"), "long"),
 165                 'ETC':  (D("0.1127"), "long"),
 166                 'ETH':  (D("0.1569"), "long"),
 167                 'FCT':  (D("0.3341"), "long"),
 168                 'GAS':  (D("0.1308"), "long"),
 169                 }
 170
 171         self.assertEqual(expected_medium, portfolio.Portfolio.repartition(self.m))
 172         self.assertEqual(expected_medium, portfolio.Portfolio.repartition(self.m, liquidity="medium"))
 173         self.assertEqual(expected_high, portfolio.Portfolio.repartition(self.m, liquidity="high"))
 174
 175         self.assertEqual(1, self.wm.call_count)
 176
 177         portfolio.Portfolio.repartition(self.m)
 178         self.assertEqual(1, self.wm.call_count)
 179
 180         portfolio.Portfolio.repartition(self.m, refetch=True)
 181         self.assertEqual(2, self.wm.call_count)
 182         self.m.report.log_http_request.assert_called()
 183         self.assertEqual(2, self.m.report.log_http_request.call_count)
 184
 185     @mock.patch.object(portfolio.time, "sleep")
 186     @mock.patch.object(portfolio.Portfolio, "repartition")
 187     def test_wait_for_recent(self, repartition, sleep):
 188         self.call_count = 0
 189         def _repartition(market, refetch):
 190             self.assertEqual(self.m, market)
 191             self.assertTrue(refetch)
 192             self.call_count += 1
 193             portfolio.Portfolio.last_date = portfolio.datetime.now()\
 194                 - portfolio.timedelta(10)\
 195                 + portfolio.timedelta(self.call_count)
 196         repartition.side_effect = _repartition
 197
 198         portfolio.Portfolio.wait_for_recent(self.m)
 199         sleep.assert_called_with(30)
 200         self.assertEqual(6, sleep.call_count)
 201         self.assertEqual(7, repartition.call_count)
 202         self.m.report.print_log.assert_called_with("Attempt to fetch up-to-date cryptoportfolio")
 203
 204         sleep.reset_mock()
 205         repartition.reset_mock()
 206         portfolio.Portfolio.last_date = None
 207         self.call_count = 0
 208         portfolio.Portfolio.wait_for_recent(self.m, delta=15)
 209         sleep.assert_not_called()
 210         self.assertEqual(1, repartition.call_count)
 211
 212         sleep.reset_mock()
 213         repartition.reset_mock()
 214         portfolio.Portfolio.last_date = None
 215         self.call_count = 0
 216         portfolio.Portfolio.wait_for_recent(self.m, delta=1)
 217         sleep.assert_called_with(30)
 218         self.assertEqual(9, sleep.call_count)
 219         self.assertEqual(10, repartition.call_count)
 220
 221 @unittest.skipUnless("unit" in limits, "Unit skipped")
 222 class AmountTest(WebMockTestCase):
 223     def test_values(self):
 224         amount = portfolio.Amount("BTC", "0.65")
 225         self.assertEqual(D("0.65"), amount.value)
 226         self.assertEqual("BTC", amount.currency)
 227
 228     def test_in_currency(self):
 229         amount = portfolio.Amount("ETC", 10)
 230
 231         self.assertEqual(amount, amount.in_currency("ETC", self.m))
 232
 233         with self.subTest(desc="no ticker for currency"):
 234             self.m.get_ticker.return_value = None
 235
 236             self.assertRaises(Exception, amount.in_currency, "ETH", self.m)
 237
 238         with self.subTest(desc="nominal case"):
 239             self.m.get_ticker.return_value = {
 240                     "bid": D("0.2"),
 241                     "ask": D("0.4"),
 242                     "average": D("0.3"),
 243                     "foo": "bar",
 244                     }
 245             converted_amount = amount.in_currency("ETH", self.m)
 246
 247             self.assertEqual(D("3.0"), converted_amount.value)
 248             self.assertEqual("ETH", converted_amount.currency)
 249             self.assertEqual(amount, converted_amount.linked_to)
 250             self.assertEqual("bar", converted_amount.ticker["foo"])
 251
 252             converted_amount = amount.in_currency("ETH", self.m, action="bid", compute_value="default")
 253             self.assertEqual(D("2"), converted_amount.value)
 254
 255             converted_amount = amount.in_currency("ETH", self.m, compute_value="ask")
 256             self.assertEqual(D("4"), converted_amount.value)
 257
 258         converted_amount = amount.in_currency("ETH", self.m, rate=D("0.02"))
 259         self.assertEqual(D("0.2"), converted_amount.value)
 260
 261     def test__round(self):
 262         amount = portfolio.Amount("BAR", portfolio.D("1.23456789876"))
 263         self.assertEqual(D("1.23456789"), round(amount).value)
 264         self.assertEqual(D("1.23"), round(amount, 2).value)
 265
 266     def test__abs(self):
 267         amount = portfolio.Amount("SC", -120)
 268         self.assertEqual(120, abs(amount).value)
 269         self.assertEqual("SC", abs(amount).currency)
 270
 271         amount = portfolio.Amount("SC", 10)
 272         self.assertEqual(10, abs(amount).value)
 273         self.assertEqual("SC", abs(amount).currency)
 274
 275     def test__add(self):
 276         amount1 = portfolio.Amount("XVG", "12.9")
 277         amount2 = portfolio.Amount("XVG", "13.1")
 278
 279         self.assertEqual(26, (amount1 + amount2).value)
 280         self.assertEqual("XVG", (amount1 + amount2).currency)
 281
 282         amount3 = portfolio.Amount("ETH", "1.6")
 283         with self.assertRaises(Exception):
 284             amount1 + amount3
 285
 286         amount4 = portfolio.Amount("ETH", 0.0)
 287         self.assertEqual(amount1, amount1 + amount4)
 288
 289         self.assertEqual(amount1, amount1 + 0)
 290
 291     def test__radd(self):
 292         amount = portfolio.Amount("XVG", "12.9")
 293
 294         self.assertEqual(amount, 0 + amount)
 295         with self.assertRaises(Exception):
 296             4 + amount
 297
 298     def test__sub(self):
 299         amount1 = portfolio.Amount("XVG", "13.3")
 300         amount2 = portfolio.Amount("XVG", "13.1")
 301
 302         self.assertEqual(D("0.2"), (amount1 - amount2).value)
 303         self.assertEqual("XVG", (amount1 - amount2).currency)
 304
 305         amount3 = portfolio.Amount("ETH", "1.6")
 306         with self.assertRaises(Exception):
 307             amount1 - amount3
 308
 309         amount4 = portfolio.Amount("ETH", 0.0)
 310         self.assertEqual(amount1, amount1 - amount4)
 311
 312     def test__rsub(self):
 313         amount = portfolio.Amount("ETH", "1.6")
 314         with self.assertRaises(Exception):
 315             3 - amount
 316
 317         self.assertEqual(portfolio.Amount("ETH", "-1.6"), 0-amount)
 318
 319     def test__mul(self):
 320         amount = portfolio.Amount("XEM", 11)
 321
 322         self.assertEqual(D("38.5"), (amount * D("3.5")).value)
 323         self.assertEqual(D("33"), (amount * 3).value)
 324
 325         with self.assertRaises(Exception):
 326             amount * amount
 327
 328     def test__rmul(self):
 329         amount = portfolio.Amount("XEM", 11)
 330
 331         self.assertEqual(D("38.5"), (D("3.5") * amount).value)
 332         self.assertEqual(D("33"), (3 * amount).value)
 333
 334     def test__floordiv(self):
 335         amount = portfolio.Amount("XEM", 11)
 336
 337         self.assertEqual(D("5.5"), (amount / 2).value)
 338         self.assertEqual(D("4.4"), (amount / D("2.5")).value)
 339
 340         with self.assertRaises(Exception):
 341             amount / amount
 342
 343     def test__truediv(self):
 344         amount = portfolio.Amount("XEM", 11)
 345
 346         self.assertEqual(D("5.5"), (amount / 2).value)
 347         self.assertEqual(D("4.4"), (amount / D("2.5")).value)
 348
 349     def test__lt(self):
 350         amount1 = portfolio.Amount("BTD", 11.3)
 351         amount2 = portfolio.Amount("BTD", 13.1)
 352
 353         self.assertTrue(amount1 < amount2)
 354         self.assertFalse(amount2 < amount1)
 355         self.assertFalse(amount1 < amount1)
 356
 357         amount3 = portfolio.Amount("BTC", 1.6)
 358         with self.assertRaises(Exception):
 359             amount1 < amount3
 360
 361     def test__le(self):
 362         amount1 = portfolio.Amount("BTD", 11.3)
 363         amount2 = portfolio.Amount("BTD", 13.1)
 364
 365         self.assertTrue(amount1 <= amount2)
 366         self.assertFalse(amount2 <= amount1)
 367         self.assertTrue(amount1 <= amount1)
 368
 369         amount3 = portfolio.Amount("BTC", 1.6)
 370         with self.assertRaises(Exception):
 371             amount1 <= amount3
 372
 373     def test__gt(self):
 374         amount1 = portfolio.Amount("BTD", 11.3)
 375         amount2 = portfolio.Amount("BTD", 13.1)
 376
 377         self.assertTrue(amount2 > amount1)
 378         self.assertFalse(amount1 > amount2)
 379         self.assertFalse(amount1 > amount1)
 380
 381         amount3 = portfolio.Amount("BTC", 1.6)
 382         with self.assertRaises(Exception):
 383             amount3 > amount1
 384
 385     def test__ge(self):
 386         amount1 = portfolio.Amount("BTD", 11.3)
 387         amount2 = portfolio.Amount("BTD", 13.1)
 388
 389         self.assertTrue(amount2 >= amount1)
 390         self.assertFalse(amount1 >= amount2)
 391         self.assertTrue(amount1 >= amount1)
 392
 393         amount3 = portfolio.Amount("BTC", 1.6)
 394         with self.assertRaises(Exception):
 395             amount3 >= amount1
 396
 397     def test__eq(self):
 398         amount1 = portfolio.Amount("BTD", 11.3)
 399         amount2 = portfolio.Amount("BTD", 13.1)
 400         amount3 = portfolio.Amount("BTD", 11.3)
 401
 402         self.assertFalse(amount1 == amount2)
 403         self.assertFalse(amount2 == amount1)
 404         self.assertTrue(amount1 == amount3)
 405         self.assertFalse(amount2 == 0)
 406
 407         amount4 = portfolio.Amount("BTC", 1.6)
 408         with self.assertRaises(Exception):
 409             amount1 == amount4
 410
 411         amount5 = portfolio.Amount("BTD", 0)
 412         self.assertTrue(amount5 == 0)
 413
 414     def test__ne(self):
 415         amount1 = portfolio.Amount("BTD", 11.3)
 416         amount2 = portfolio.Amount("BTD", 13.1)
 417         amount3 = portfolio.Amount("BTD", 11.3)
 418
 419         self.assertTrue(amount1 != amount2)
 420         self.assertTrue(amount2 != amount1)
 421         self.assertFalse(amount1 != amount3)
 422         self.assertTrue(amount2 != 0)
 423
 424         amount4 = portfolio.Amount("BTC", 1.6)
 425         with self.assertRaises(Exception):
 426             amount1 != amount4
 427
 428         amount5 = portfolio.Amount("BTD", 0)
 429         self.assertFalse(amount5 != 0)
 430
 431     def test__neg(self):
 432         amount1 = portfolio.Amount("BTD", "11.3")
 433
 434         self.assertEqual(portfolio.D("-11.3"), (-amount1).value)
 435
 436     def test__str(self):
 437         amount1 = portfolio.Amount("BTX", 32)
 438         self.assertEqual("32.00000000 BTX", str(amount1))
 439
 440         amount2 = portfolio.Amount("USDT", 12000)
 441         amount1.linked_to = amount2
 442         self.assertEqual("32.00000000 BTX [12000.00000000 USDT]", str(amount1))
 443
 444     def test__repr(self):
 445         amount1 = portfolio.Amount("BTX", 32)
 446         self.assertEqual("Amount(32.00000000 BTX)", repr(amount1))
 447
 448         amount2 = portfolio.Amount("USDT", 12000)
 449         amount1.linked_to = amount2
 450         self.assertEqual("Amount(32.00000000 BTX -> Amount(12000.00000000 USDT))", repr(amount1))
 451
 452         amount3 = portfolio.Amount("BTC", 0.1)
 453         amount2.linked_to = amount3
 454         self.assertEqual("Amount(32.00000000 BTX -> Amount(12000.00000000 USDT -> Amount(0.10000000 BTC)))", repr(amount1))
 455
 456     def test_as_json(self):
 457         amount = portfolio.Amount("BTX", 32)
 458         self.assertEqual({"currency": "BTX", "value": D("32")}, amount.as_json())
 459
 460         amount = portfolio.Amount("BTX", "1E-10")
 461         self.assertEqual({"currency": "BTX", "value": D("0")}, amount.as_json())
 462
 463         amount = portfolio.Amount("BTX", "1E-5")
 464         self.assertEqual({"currency": "BTX", "value": D("0.00001")}, amount.as_json())
 465         self.assertEqual("0.00001", str(amount.as_json()["value"]))
 466
 467 @unittest.skipUnless("unit" in limits, "Unit skipped")
 468 class BalanceTest(WebMockTestCase):
 469     def test_values(self):
 470         balance = portfolio.Balance("BTC", {
 471             "exchange_total": "0.65",
 472             "exchange_free": "0.35",
 473             "exchange_used": "0.30",
 474             "margin_total": "-10",
 475             "margin_borrowed": "-10",
 476             "margin_free": "0",
 477             "margin_position_type": "short",
 478             "margin_borrowed_base_currency": "USDT",
 479             "margin_liquidation_price": "1.20",
 480             "margin_pending_gain": "10",
 481             "margin_lending_fees": "0.4",
 482             "margin_borrowed_base_price": "0.15",
 483             })
 484         self.assertEqual(portfolio.D("0.65"), balance.exchange_total.value)
 485         self.assertEqual(portfolio.D("0.35"), balance.exchange_free.value)
 486         self.assertEqual(portfolio.D("0.30"), balance.exchange_used.value)
 487         self.assertEqual("BTC", balance.exchange_total.currency)
 488         self.assertEqual("BTC", balance.exchange_free.currency)
 489         self.assertEqual("BTC", balance.exchange_total.currency)
 490
 491         self.assertEqual(portfolio.D("-10"), balance.margin_total.value)
 492         self.assertEqual(portfolio.D("-10"), balance.margin_borrowed.value)
 493         self.assertEqual(portfolio.D("0"), balance.margin_free.value)
 494         self.assertEqual("BTC", balance.margin_total.currency)
 495         self.assertEqual("BTC", balance.margin_borrowed.currency)
 496         self.assertEqual("BTC", balance.margin_free.currency)
 497
 498         self.assertEqual("BTC", balance.currency)
 499
 500         self.assertEqual(portfolio.D("0.4"), balance.margin_lending_fees.value)
 501         self.assertEqual("USDT", balance.margin_lending_fees.currency)
 502
 503     def test__repr(self):
 504         self.assertEqual("Balance(BTX Exch: [✔2.00000000 BTX])",
 505                 repr(portfolio.Balance("BTX", { "exchange_free": 2, "exchange_total": 2 })))
 506         balance = portfolio.Balance("BTX", { "exchange_total": 3,
 507             "exchange_used": 1, "exchange_free": 2 })
 508         self.assertEqual("Balance(BTX Exch: [✔2.00000000 BTX + ❌1.00000000 BTX = 3.00000000 BTX])", repr(balance))
 509
 510         balance = portfolio.Balance("BTX", { "exchange_total": 1, "exchange_used": 1})
 511         self.assertEqual("Balance(BTX Exch: [❌1.00000000 BTX])", repr(balance))
 512
 513         balance = portfolio.Balance("BTX", { "margin_total": 3,
 514             "margin_borrowed": 1, "margin_free": 2 })
 515         self.assertEqual("Balance(BTX Margin: [✔2.00000000 BTX + borrowed 1.00000000 BTX = 3.00000000 BTX])", repr(balance))
 516
 517         balance = portfolio.Balance("BTX", { "margin_total": 2, "margin_free": 2 })
 518         self.assertEqual("Balance(BTX Margin: [✔2.00000000 BTX])", repr(balance))
 519
 520         balance = portfolio.Balance("BTX", { "margin_total": -3,
 521             "margin_borrowed_base_price": D("0.1"),
 522             "margin_borrowed_base_currency": "BTC",
 523             "margin_lending_fees": D("0.002") })
 524         self.assertEqual("Balance(BTX Margin: [-3.00000000 BTX @@ 0.10000000 BTC/0.00200000 BTC])", repr(balance))
 525
 526         balance = portfolio.Balance("BTX", { "margin_total": 1,
 527             "margin_borrowed": 1, "exchange_free": 2, "exchange_total": 2})
 528         self.assertEqual("Balance(BTX Exch: [✔2.00000000 BTX] Margin: [borrowed 1.00000000 BTX] Total: [0.00000000 BTX])", repr(balance))
 529
 530     def test_as_json(self):
 531         balance = portfolio.Balance("BTX", { "exchange_free": 2, "exchange_total": 2 })
 532         as_json = balance.as_json()
 533         self.assertEqual(set(portfolio.Balance.base_keys), set(as_json.keys()))
 534         self.assertEqual(D(0), as_json["total"])
 535         self.assertEqual(D(2), as_json["exchange_total"])
 536         self.assertEqual(D(2), as_json["exchange_free"])
 537         self.assertEqual(D(0), as_json["exchange_used"])
 538         self.assertEqual(D(0), as_json["margin_total"])
 539         self.assertEqual(D(0), as_json["margin_free"])
 540         self.assertEqual(D(0), as_json["margin_borrowed"])
 541
 542 @unittest.skipUnless("unit" in limits, "Unit skipped")
 543 class MarketTest(WebMockTestCase):
 544     def setUp(self):
 545         super(MarketTest, self).setUp()
 546
 547         self.ccxt = mock.Mock(spec=market.ccxt.poloniexE)
 548
 549     def test_values(self):
 550         m = market.Market(self.ccxt)
 551
 552         self.assertEqual(self.ccxt, m.ccxt)
 553         self.assertFalse(m.debug)
 554         self.assertIsInstance(m.report, market.ReportStore)
 555         self.assertIsInstance(m.trades, market.TradeStore)
 556         self.assertIsInstance(m.balances, market.BalanceStore)
 557         self.assertEqual(m, m.report.market)
 558         self.assertEqual(m, m.trades.market)
 559         self.assertEqual(m, m.balances.market)
 560         self.assertEqual(m, m.ccxt._market)
 561
 562         m = market.Market(self.ccxt, debug=True)
 563         self.assertTrue(m.debug)
 564
 565         m = market.Market(self.ccxt, debug=False)
 566         self.assertFalse(m.debug)
 567
 568     @mock.patch("market.ccxt")
 569     def test_from_config(self, ccxt):
 570         with mock.patch("market.ReportStore"):
 571             ccxt.poloniexE.return_value = self.ccxt
 572             self.ccxt.session.request.return_value = "response"
 573
 574             m = market.Market.from_config("config")
 575
 576             self.assertEqual(self.ccxt, m.ccxt)
 577
 578             self.ccxt.session.request("GET", "URL", data="data",
 579                     headers="headers")
 580             m.report.log_http_request.assert_called_with('GET', 'URL', 'data',
 581                     'headers', 'response')
 582
 583         m = market.Market.from_config("config", debug=True)
 584         self.assertEqual(True, m.debug)
 585
 586     def test_get_ticker(self):
 587         m = market.Market(self.ccxt)
 588         self.ccxt.fetch_ticker.side_effect = [
 589                 { "bid": 1, "ask": 3 },
 590                 market.ExchangeError("foo"),
 591                 { "bid": 10, "ask": 40 },
 592                 market.ExchangeError("foo"),
 593                 market.ExchangeError("foo"),
 594                 ]
 595
 596         ticker = m.get_ticker("ETH", "ETC")
 597         self.ccxt.fetch_ticker.assert_called_with("ETH/ETC")
 598         self.assertEqual(1, ticker["bid"])
 599         self.assertEqual(3, ticker["ask"])
 600         self.assertEqual(2, ticker["average"])
 601         self.assertFalse(ticker["inverted"])
 602
 603         ticker = m.get_ticker("ETH", "XVG")
 604         self.assertEqual(0.0625, ticker["average"])
 605         self.assertTrue(ticker["inverted"])
 606         self.assertIn("original", ticker)
 607         self.assertEqual(10, ticker["original"]["bid"])
 608
 609         ticker = m.get_ticker("XVG", "XMR")
 610         self.assertIsNone(ticker)
 611
 612         self.ccxt.fetch_ticker.assert_has_calls([
 613             mock.call("ETH/ETC"),
 614             mock.call("ETH/XVG"),
 615             mock.call("XVG/ETH"),
 616             mock.call("XVG/XMR"),
 617             mock.call("XMR/XVG"),
 618             ])
 619
 620         self.ccxt = mock.Mock(spec=market.ccxt.poloniexE)
 621         m1b = market.Market(self.ccxt)
 622         m1b.get_ticker("ETH", "ETC")
 623         self.ccxt.fetch_ticker.assert_not_called()
 624
 625         self.ccxt = mock.Mock(spec=market.ccxt.poloniex)
 626         m2 = market.Market(self.ccxt)
 627         self.ccxt.fetch_ticker.side_effect = [
 628                 { "bid": 1, "ask": 3 },
 629                 { "bid": 1.2, "ask": 3.5 },
 630                 ]
 631         ticker1 = m2.get_ticker("ETH", "ETC")
 632         ticker2 = m2.get_ticker("ETH", "ETC")
 633         ticker3 = m2.get_ticker("ETC", "ETH")
 634         self.ccxt.fetch_ticker.assert_called_once_with("ETH/ETC")
 635         self.assertEqual(1, ticker1["bid"])
 636         self.assertDictEqual(ticker1, ticker2)
 637         self.assertDictEqual(ticker1, ticker3["original"])
 638
 639         ticker4 = m2.get_ticker("ETH", "ETC", refresh=True)
 640         ticker5 = m2.get_ticker("ETH", "ETC")
 641         self.assertEqual(1.2, ticker4["bid"])
 642         self.assertDictEqual(ticker4, ticker5)
 643
 644         self.ccxt = mock.Mock(spec=market.ccxt.binance)
 645         m3 = market.Market(self.ccxt)
 646         self.ccxt.fetch_ticker.side_effect = [
 647                 { "bid": 1, "ask": 3 },
 648                 { "bid": 1.2, "ask": 3.5 },
 649                 ]
 650         ticker6 = m3.get_ticker("ETH", "ETC")
 651         m3.ticker_cache_timestamp -= 4
 652         ticker7 = m3.get_ticker("ETH", "ETC")
 653         m3.ticker_cache_timestamp -= 2
 654         ticker8 = m3.get_ticker("ETH", "ETC")
 655         self.assertDictEqual(ticker6, ticker7)
 656         self.assertEqual(1.2, ticker8["bid"])
 657
 658     def test_fetch_fees(self):
 659         m = market.Market(self.ccxt)
 660         self.ccxt.fetch_fees.return_value = "Foo"
 661         self.assertEqual("Foo", m.fetch_fees())
 662         self.ccxt.fetch_fees.assert_called_once()
 663         self.ccxt.reset_mock()
 664         self.assertEqual("Foo", m.fetch_fees())
 665         self.ccxt.fetch_fees.assert_not_called()
 666
 667     @mock.patch.object(portfolio.Portfolio, "repartition")
 668     @mock.patch.object(market.Market, "get_ticker")
 669     @mock.patch.object(market.TradeStore, "compute_trades")
 670     def test_prepare_trades(self, compute_trades, get_ticker, repartition):
 671         repartition.return_value = {
 672                 "XEM": (D("0.75"), "long"),
 673                 "BTC": (D("0.25"), "long"),
 674                 }
 675         def _get_ticker(c1, c2):
 676             if c1 == "USDT" and c2 == "BTC":
 677                 return { "average": D("0.0001") }
 678             if c1 == "XVG" and c2 == "BTC":
 679                 return { "average": D("0.000001") }
 680             if c1 == "XEM" and c2 == "BTC":
 681                 return { "average": D("0.001") }
 682             self.fail("Should be called with {}, {}".format(c1, c2))
 683         get_ticker.side_effect = _get_ticker
 684
 685         with mock.patch("market.ReportStore"):
 686             m = market.Market(self.ccxt)
 687             self.ccxt.fetch_all_balances.return_value = {
 688                     "USDT": {
 689                         "exchange_free": D("10000.0"),
 690                         "exchange_used": D("0.0"),
 691                         "exchange_total": D("10000.0"),
 692                         "total": D("10000.0")
 693                         },
 694                     "XVG": {
 695                         "exchange_free": D("10000.0"),
 696                         "exchange_used": D("0.0"),
 697                         "exchange_total": D("10000.0"),
 698                         "total": D("10000.0")
 699                         },
 700                     }
 701
 702             m.balances.fetch_balances(tag="tag")
 703
 704             m.prepare_trades()
 705             compute_trades.assert_called()
 706
 707             call = compute_trades.call_args
 708             self.assertEqual(1, call[0][0]["USDT"].value)
 709             self.assertEqual(D("0.01"), call[0][0]["XVG"].value)
 710             self.assertEqual(D("0.2525"), call[0][1]["BTC"].value)
 711             self.assertEqual(D("0.7575"), call[0][1]["XEM"].value)
 712             m.report.log_stage.assert_called_once_with("prepare_trades")
 713             m.report.log_balances.assert_called_once_with(tag="tag")
 714
 715     @mock.patch.object(portfolio.Portfolio, "repartition")
 716     @mock.patch.object(market.Market, "get_ticker")
 717     @mock.patch.object(market.TradeStore, "compute_trades")
 718     def test_update_trades(self, compute_trades, get_ticker, repartition):
 719         repartition.return_value = {
 720                 "XEM": (D("0.75"), "long"),
 721                 "BTC": (D("0.25"), "long"),
 722                 }
 723         def _get_ticker(c1, c2):
 724             if c1 == "USDT" and c2 == "BTC":
 725                 return { "average": D("0.0001") }
 726             if c1 == "XVG" and c2 == "BTC":
 727                 return { "average": D("0.000001") }
 728             if c1 == "XEM" and c2 == "BTC":
 729                 return { "average": D("0.001") }
 730             self.fail("Should be called with {}, {}".format(c1, c2))
 731         get_ticker.side_effect = _get_ticker
 732
 733         with mock.patch("market.ReportStore"):
 734             m = market.Market(self.ccxt)
 735             self.ccxt.fetch_all_balances.return_value = {
 736                     "USDT": {
 737                         "exchange_free": D("10000.0"),
 738                         "exchange_used": D("0.0"),
 739                         "exchange_total": D("10000.0"),
 740                         "total": D("10000.0")
 741                         },
 742                     "XVG": {
 743                         "exchange_free": D("10000.0"),
 744                         "exchange_used": D("0.0"),
 745                         "exchange_total": D("10000.0"),
 746                         "total": D("10000.0")
 747                         },
 748                     }
 749
 750             m.balances.fetch_balances(tag="tag")
 751
 752             m.update_trades()
 753             compute_trades.assert_called()
 754
 755             call = compute_trades.call_args
 756             self.assertEqual(1, call[0][0]["USDT"].value)
 757             self.assertEqual(D("0.01"), call[0][0]["XVG"].value)
 758             self.assertEqual(D("0.2525"), call[0][1]["BTC"].value)
 759             self.assertEqual(D("0.7575"), call[0][1]["XEM"].value)
 760             m.report.log_stage.assert_called_once_with("update_trades")
 761             m.report.log_balances.assert_called_once_with(tag="tag")
 762
 763     @mock.patch.object(portfolio.Portfolio, "repartition")
 764     @mock.patch.object(market.Market, "get_ticker")
 765     @mock.patch.object(market.TradeStore, "compute_trades")
 766     def test_prepare_trades_to_sell_all(self, compute_trades, get_ticker, repartition):
 767         def _get_ticker(c1, c2):
 768             if c1 == "USDT" and c2 == "BTC":
 769                 return { "average": D("0.0001") }
 770             if c1 == "XVG" and c2 == "BTC":
 771                 return { "average": D("0.000001") }
 772             self.fail("Should be called with {}, {}".format(c1, c2))
 773         get_ticker.side_effect = _get_ticker
 774
 775         with mock.patch("market.ReportStore"):
 776             m = market.Market(self.ccxt)
 777             self.ccxt.fetch_all_balances.return_value = {
 778                     "USDT": {
 779                         "exchange_free": D("10000.0"),
 780                         "exchange_used": D("0.0"),
 781                         "exchange_total": D("10000.0"),
 782                         "total": D("10000.0")
 783                         },
 784                     "XVG": {
 785                         "exchange_free": D("10000.0"),
 786                         "exchange_used": D("0.0"),
 787                         "exchange_total": D("10000.0"),
 788                         "total": D("10000.0")
 789                         },
 790                     }
 791
 792             m.balances.fetch_balances(tag="tag")
 793
 794             m.prepare_trades_to_sell_all()
 795
 796             repartition.assert_not_called()
 797             compute_trades.assert_called()
 798
 799             call = compute_trades.call_args
 800             self.assertEqual(1, call[0][0]["USDT"].value)
 801             self.assertEqual(D("0.01"), call[0][0]["XVG"].value)
 802             self.assertEqual(D("1.01"), call[0][1]["BTC"].value)
 803             m.report.log_stage.assert_called_once_with("prepare_trades_to_sell_all")
 804             m.report.log_balances.assert_called_once_with(tag="tag")
 805
 806     @mock.patch.object(portfolio.time, "sleep")
 807     @mock.patch.object(market.TradeStore, "all_orders")
 808     def test_follow_orders(self, all_orders, time_mock):
 809         for debug, sleep in [
 810                 (False, None), (True, None),
 811                 (False, 12), (True, 12)]:
 812             with self.subTest(sleep=sleep, debug=debug), \
 813                     mock.patch("market.ReportStore"):
 814                 m = market.Market(self.ccxt, debug=debug)
 815
 816                 order_mock1 = mock.Mock()
 817                 order_mock2 = mock.Mock()
 818                 order_mock3 = mock.Mock()
 819                 all_orders.side_effect = [
 820                         [order_mock1, order_mock2],
 821                         [order_mock1, order_mock2],
 822
 823                         [order_mock1, order_mock3],
 824                         [order_mock1, order_mock3],
 825
 826                         [order_mock1, order_mock3],
 827                         [order_mock1, order_mock3],
 828
 829                         []
 830                         ]
 831
 832                 order_mock1.get_status.side_effect = ["open", "open", "closed"]
 833                 order_mock2.get_status.side_effect = ["open"]
 834                 order_mock3.get_status.side_effect = ["open", "closed"]
 835
 836                 order_mock1.trade = mock.Mock()
 837                 order_mock2.trade = mock.Mock()
 838                 order_mock3.trade = mock.Mock()
 839
 840                 m.follow_orders(sleep=sleep)
 841
 842                 order_mock1.trade.update_order.assert_any_call(order_mock1, 1)
 843                 order_mock1.trade.update_order.assert_any_call(order_mock1, 2)
 844                 self.assertEqual(2, order_mock1.trade.update_order.call_count)
 845                 self.assertEqual(3, order_mock1.get_status.call_count)
 846
 847                 order_mock2.trade.update_order.assert_any_call(order_mock2, 1)
 848                 self.assertEqual(1, order_mock2.trade.update_order.call_count)
 849                 self.assertEqual(1, order_mock2.get_status.call_count)
 850
 851                 order_mock3.trade.update_order.assert_any_call(order_mock3, 2)
 852                 self.assertEqual(1, order_mock3.trade.update_order.call_count)
 853                 self.assertEqual(2, order_mock3.get_status.call_count)
 854                 m.report.log_stage.assert_called()
 855                 calls = [
 856                         mock.call("follow_orders_begin"),
 857                         mock.call("follow_orders_tick_1"),
 858                         mock.call("follow_orders_tick_2"),
 859                         mock.call("follow_orders_tick_3"),
 860                         mock.call("follow_orders_end"),
 861                         ]
 862                 m.report.log_stage.assert_has_calls(calls)
 863                 m.report.log_orders.assert_called()
 864                 self.assertEqual(3, m.report.log_orders.call_count)
 865                 calls = [
 866                         mock.call([order_mock1, order_mock2], tick=1),
 867                         mock.call([order_mock1, order_mock3], tick=2),
 868                         mock.call([order_mock1, order_mock3], tick=3),
 869                         ]
 870                 m.report.log_orders.assert_has_calls(calls)
 871                 calls = [
 872                         mock.call(order_mock1, 3, finished=True),
 873                         mock.call(order_mock3, 3, finished=True),
 874                         ]
 875                 m.report.log_order.assert_has_calls(calls)
 876
 877                 if sleep is None:
 878                     if debug:
 879                         m.report.log_debug_action.assert_called_with("Set follow_orders tick to 7s")
 880                         time_mock.assert_called_with(7)
 881                     else:
 882                         time_mock.assert_called_with(30)
 883                 else:
 884                     time_mock.assert_called_with(sleep)
 885
 886     @mock.patch.object(market.BalanceStore, "fetch_balances")
 887     def test_move_balance(self, fetch_balances):
 888         for debug in [True, False]:
 889             with self.subTest(debug=debug),\
 890                     mock.patch("market.ReportStore"):
 891                 m = market.Market(self.ccxt, debug=debug)
 892
 893                 value_from = portfolio.Amount("BTC", "1.0")
 894                 value_from.linked_to = portfolio.Amount("ETH", "10.0")
 895                 value_to = portfolio.Amount("BTC", "10.0")
 896                 trade1 = portfolio.Trade(value_from, value_to, "ETH", m)
 897
 898                 value_from = portfolio.Amount("BTC", "0.0")
 899                 value_from.linked_to = portfolio.Amount("ETH", "0.0")
 900                 value_to = portfolio.Amount("BTC", "-3.0")
 901                 trade2 = portfolio.Trade(value_from, value_to, "ETH", m)
 902
 903                 value_from = portfolio.Amount("USDT", "0.0")
 904                 value_from.linked_to = portfolio.Amount("XVG", "0.0")
 905                 value_to = portfolio.Amount("USDT", "-50.0")
 906                 trade3 = portfolio.Trade(value_from, value_to, "XVG", m)
 907
 908                 m.trades.all = [trade1, trade2, trade3]
 909                 balance1 = portfolio.Balance("BTC", { "margin_free": "0" })
 910                 balance2 = portfolio.Balance("USDT", { "margin_free": "100" })
 911                 balance3 = portfolio.Balance("ETC", { "margin_free": "10" })
 912                 m.balances.all = {"BTC": balance1, "USDT": balance2, "ETC": balance3}
 913
 914                 m.move_balances()
 915
 916                 fetch_balances.assert_called_with()
 917                 m.report.log_move_balances.assert_called_once()
 918
 919                 if debug:
 920                     m.report.log_debug_action.assert_called()
 921                     self.assertEqual(3, m.report.log_debug_action.call_count)
 922                 else:
 923                     self.ccxt.transfer_balance.assert_any_call("BTC", 3, "exchange", "margin")
 924                     self.ccxt.transfer_balance.assert_any_call("USDT", 50, "margin", "exchange")
 925                     self.ccxt.transfer_balance.assert_any_call("ETC", 10, "margin", "exchange")
 926
 927 @unittest.skipUnless("unit" in limits, "Unit skipped")
 928 class TradeStoreTest(WebMockTestCase):
 929     def test_compute_trades(self):
 930         self.m.balances.currencies.return_value = ["XMR", "DASH", "XVG", "BTC", "ETH"]
 931
 932         values_in_base = {
 933                 "XMR": portfolio.Amount("BTC", D("0.9")),
 934                 "DASH": portfolio.Amount("BTC", D("0.4")),
 935                 "XVG": portfolio.Amount("BTC", D("-0.5")),
 936                 "BTC": portfolio.Amount("BTC", D("0.5")),
 937                 }
 938         new_repartition = {
 939                 "DASH": portfolio.Amount("BTC", D("0.5")),
 940                 "XVG": portfolio.Amount("BTC", D("0.1")),
 941                 "BTC": portfolio.Amount("BTC", D("0.4")),
 942                 "ETH": portfolio.Amount("BTC", D("0.3")),
 943                 }
 944         side_effect = [
 945                 (True, 1),
 946                 (False, 2),
 947                 (False, 3),
 948                 (True, 4),
 949                 (True, 5)
 950                 ]
 951
 952         with mock.patch.object(market.TradeStore, "trade_if_matching") as trade_if_matching:
 953             trade_store = market.TradeStore(self.m)
 954             trade_if_matching.side_effect = side_effect
 955
 956             trade_store.compute_trades(values_in_base,
 957                     new_repartition, only="only")
 958
 959             self.assertEqual(5, trade_if_matching.call_count)
 960             self.assertEqual(3, len(trade_store.all))
 961             self.assertEqual([1, 4, 5], trade_store.all)
 962             self.m.report.log_trades.assert_called_with(side_effect, "only")
 963
 964     def test_trade_if_matching(self):
 965
 966         with self.subTest(only="nope"):
 967             trade_store = market.TradeStore(self.m)
 968             result = trade_store.trade_if_matching(
 969                     portfolio.Amount("BTC", D("0")),
 970                     portfolio.Amount("BTC", D("0.3")),
 971                     "ETH", only="nope")
 972             self.assertEqual(False, result[0])
 973             self.assertIsInstance(result[1], portfolio.Trade)
 974
 975         with self.subTest(only=None):
 976             trade_store = market.TradeStore(self.m)
 977             result = trade_store.trade_if_matching(
 978                     portfolio.Amount("BTC", D("0")),
 979                     portfolio.Amount("BTC", D("0.3")),
 980                     "ETH", only=None)
 981             self.assertEqual(True, result[0])
 982
 983         with self.subTest(only="acquire"):
 984             trade_store = market.TradeStore(self.m)
 985             result = trade_store.trade_if_matching(
 986                     portfolio.Amount("BTC", D("0")),
 987                     portfolio.Amount("BTC", D("0.3")),
 988                     "ETH", only="acquire")
 989             self.assertEqual(True, result[0])
 990
 991         with self.subTest(only="dispose"):
 992             trade_store = market.TradeStore(self.m)
 993             result = trade_store.trade_if_matching(
 994                     portfolio.Amount("BTC", D("0")),
 995                     portfolio.Amount("BTC", D("0.3")),
 996                     "ETH", only="dispose")
 997             self.assertEqual(False, result[0])
 998
 999     def test_prepare_orders(self):
1000         trade_store = market.TradeStore(self.m)
1001
1002         trade_mock1 = mock.Mock()
1003         trade_mock2 = mock.Mock()
1004
1005         trade_mock1.prepare_order.return_value = 1
1006         trade_mock2.prepare_order.return_value = 2
1007
1008         trade_store.all.append(trade_mock1)
1009         trade_store.all.append(trade_mock2)
1010
1011         trade_store.prepare_orders()
1012         trade_mock1.prepare_order.assert_called_with(compute_value="default")
1013         trade_mock2.prepare_order.assert_called_with(compute_value="default")
1014         self.m.report.log_orders.assert_called_once_with([1, 2], None, "default")
1015
1016         self.m.report.log_orders.reset_mock()
1017
1018         trade_store.prepare_orders(compute_value="bla")
1019         trade_mock1.prepare_order.assert_called_with(compute_value="bla")
1020         trade_mock2.prepare_order.assert_called_with(compute_value="bla")
1021         self.m.report.log_orders.assert_called_once_with([1, 2], None, "bla")
1022
1023         trade_mock1.prepare_order.reset_mock()
1024         trade_mock2.prepare_order.reset_mock()
1025         self.m.report.log_orders.reset_mock()
1026
1027         trade_mock1.action = "foo"
1028         trade_mock2.action = "bar"
1029         trade_store.prepare_orders(only="bar")
1030         trade_mock1.prepare_order.assert_not_called()
1031         trade_mock2.prepare_order.assert_called_with(compute_value="default")
1032         self.m.report.log_orders.assert_called_once_with([2], "bar", "default")
1033
1034     def test_print_all_with_order(self):
1035         trade_mock1 = mock.Mock()
1036         trade_mock2 = mock.Mock()
1037         trade_mock3 = mock.Mock()
1038         trade_store = market.TradeStore(self.m)
1039         trade_store.all = [trade_mock1, trade_mock2, trade_mock3]
1040
1041         trade_store.print_all_with_order()
1042
1043         trade_mock1.print_with_order.assert_called()
1044         trade_mock2.print_with_order.assert_called()
1045         trade_mock3.print_with_order.assert_called()
1046
1047     def test_run_orders(self):
1048         with mock.patch.object(market.TradeStore, "all_orders") as all_orders:
1049             order_mock1 = mock.Mock()
1050             order_mock2 = mock.Mock()
1051             order_mock3 = mock.Mock()
1052             trade_store = market.TradeStore(self.m)
1053
1054             all_orders.return_value = [order_mock1, order_mock2, order_mock3]
1055
1056             trade_store.run_orders()
1057
1058             all_orders.assert_called_with(state="pending")
1059
1060         order_mock1.run.assert_called()
1061         order_mock2.run.assert_called()
1062         order_mock3.run.assert_called()
1063
1064         self.m.report.log_stage.assert_called_with("run_orders")
1065         self.m.report.log_orders.assert_called_with([order_mock1, order_mock2,
1066             order_mock3])
1067
1068     def test_all_orders(self):
1069         trade_mock1 = mock.Mock()
1070         trade_mock2 = mock.Mock()
1071
1072         order_mock1 = mock.Mock()
1073         order_mock2 = mock.Mock()
1074         order_mock3 = mock.Mock()
1075
1076         trade_mock1.orders = [order_mock1, order_mock2]
1077         trade_mock2.orders = [order_mock3]
1078
1079         order_mock1.status = "pending"
1080         order_mock2.status = "open"
1081         order_mock3.status = "open"
1082
1083         trade_store = market.TradeStore(self.m)
1084         trade_store.all.append(trade_mock1)
1085         trade_store.all.append(trade_mock2)
1086
1087         orders = trade_store.all_orders()
1088         self.assertEqual(3, len(orders))
1089
1090         open_orders = trade_store.all_orders(state="open")
1091         self.assertEqual(2, len(open_orders))
1092         self.assertEqual([order_mock2, order_mock3], open_orders)
1093
1094     def test_update_all_orders_status(self):
1095         with mock.patch.object(market.TradeStore, "all_orders") as all_orders:
1096             order_mock1 = mock.Mock()
1097             order_mock2 = mock.Mock()
1098             order_mock3 = mock.Mock()
1099
1100             all_orders.return_value = [order_mock1, order_mock2, order_mock3]
1101
1102             trade_store = market.TradeStore(self.m)
1103
1104             trade_store.update_all_orders_status()
1105             all_orders.assert_called_with(state="open")
1106
1107             order_mock1.get_status.assert_called()
1108             order_mock2.get_status.assert_called()
1109             order_mock3.get_status.assert_called()
1110
1111
1112 @unittest.skipUnless("unit" in limits, "Unit skipped")
1113 class BalanceStoreTest(WebMockTestCase):
1114     def setUp(self):
1115         super(BalanceStoreTest, self).setUp()
1116
1117         self.fetch_balance = {
1118                 "ETC": {
1119                     "exchange_free": 0,
1120                     "exchange_used": 0,
1121                     "exchange_total": 0,
1122                     "margin_total": 0,
1123                     },
1124                 "USDT": {
1125                     "exchange_free": D("6.0"),
1126                     "exchange_used": D("1.2"),
1127                     "exchange_total": D("7.2"),
1128                     "margin_total": 0,
1129                     },
1130                 "XVG": {
1131                     "exchange_free": 16,
1132                     "exchange_used": 0,
1133                     "exchange_total": 16,
1134                     "margin_total": 0,
1135                     },
1136                 "XMR": {
1137                     "exchange_free": 0,
1138                     "exchange_used": 0,
1139                     "exchange_total": 0,
1140                     "margin_total": D("-1.0"),
1141                     "margin_free": 0,
1142                     },
1143                 }
1144
1145     def test_in_currency(self):
1146         self.m.get_ticker.return_value = {
1147                 "bid": D("0.09"),
1148                 "ask": D("0.11"),
1149                 "average": D("0.1"),
1150                 }
1151
1152         balance_store = market.BalanceStore(self.m)
1153         balance_store.all = {
1154                 "BTC": portfolio.Balance("BTC", {
1155                     "total": "0.65",
1156                     "exchange_total":"0.65",
1157                     "exchange_free": "0.35",
1158                     "exchange_used": "0.30"}),
1159                 "ETH": portfolio.Balance("ETH", {
1160                     "total": 3,
1161                     "exchange_total": 3,
1162                     "exchange_free": 3,
1163                     "exchange_used": 0}),
1164                 }
1165
1166         amounts = balance_store.in_currency("BTC")
1167         self.assertEqual("BTC", amounts["ETH"].currency)
1168         self.assertEqual(D("0.65"), amounts["BTC"].value)
1169         self.assertEqual(D("0.30"), amounts["ETH"].value)
1170         self.m.report.log_tickers.assert_called_once_with(amounts, "BTC",
1171                 "average", "total")
1172         self.m.report.log_tickers.reset_mock()
1173
1174         amounts = balance_store.in_currency("BTC", compute_value="bid")
1175         self.assertEqual(D("0.65"), amounts["BTC"].value)
1176         self.assertEqual(D("0.27"), amounts["ETH"].value)
1177         self.m.report.log_tickers.assert_called_once_with(amounts, "BTC",
1178                 "bid", "total")
1179         self.m.report.log_tickers.reset_mock()
1180
1181         amounts = balance_store.in_currency("BTC", compute_value="bid", type="exchange_used")
1182         self.assertEqual(D("0.30"), amounts["BTC"].value)
1183         self.assertEqual(0, amounts["ETH"].value)
1184         self.m.report.log_tickers.assert_called_once_with(amounts, "BTC",
1185                 "bid", "exchange_used")
1186         self.m.report.log_tickers.reset_mock()
1187
1188     def test_fetch_balances(self):
1189         self.m.ccxt.fetch_all_balances.return_value = self.fetch_balance
1190
1191         balance_store = market.BalanceStore(self.m)
1192
1193         balance_store.fetch_balances()
1194         self.assertNotIn("ETC", balance_store.currencies())
1195         self.assertListEqual(["USDT", "XVG", "XMR"], list(balance_store.currencies()))
1196
1197         balance_store.all["ETC"] = portfolio.Balance("ETC", {
1198             "exchange_total": "1", "exchange_free": "0",
1199             "exchange_used": "1" })
1200         balance_store.fetch_balances(tag="foo")
1201         self.assertEqual(0, balance_store.all["ETC"].total)
1202         self.assertListEqual(["USDT", "XVG", "XMR", "ETC"], list(balance_store.currencies()))
1203         self.m.report.log_balances.assert_called_with(tag="foo")
1204
1205     @mock.patch.object(portfolio.Portfolio, "repartition")
1206     def test_dispatch_assets(self, repartition):
1207         self.m.ccxt.fetch_all_balances.return_value = self.fetch_balance
1208
1209         balance_store = market.BalanceStore(self.m)
1210         balance_store.fetch_balances()
1211
1212         self.assertNotIn("XEM", balance_store.currencies())
1213
1214         repartition_hash = {
1215                 "XEM": (D("0.75"), "long"),
1216                 "BTC": (D("0.26"), "long"),
1217                 "DASH": (D("0.10"), "short"),
1218                 }
1219         repartition.return_value = repartition_hash
1220
1221         amounts = balance_store.dispatch_assets(portfolio.Amount("BTC", "11.1"))
1222         repartition.assert_called_with(self.m, liquidity="medium")
1223         self.assertIn("XEM", balance_store.currencies())
1224         self.assertEqual(D("2.6"), amounts["BTC"].value)
1225         self.assertEqual(D("7.5"), amounts["XEM"].value)
1226         self.assertEqual(D("-1.0"), amounts["DASH"].value)
1227         self.m.report.log_balances.assert_called_with(tag=None)
1228         self.m.report.log_dispatch.assert_called_once_with(portfolio.Amount("BTC",
1229             "11.1"), amounts, "medium", repartition_hash)
1230
1231     def test_currencies(self):
1232         balance_store = market.BalanceStore(self.m)
1233
1234         balance_store.all = {
1235                 "BTC": portfolio.Balance("BTC", {
1236                     "total": "0.65",
1237                     "exchange_total":"0.65",
1238                     "exchange_free": "0.35",
1239                     "exchange_used": "0.30"}),
1240                 "ETH": portfolio.Balance("ETH", {
1241                     "total": 3,
1242                     "exchange_total": 3,
1243                     "exchange_free": 3,
1244                     "exchange_used": 0}),
1245                 }
1246         self.assertListEqual(["BTC", "ETH"], list(balance_store.currencies()))
1247
1248     def test_as_json(self):
1249         balance_mock1 = mock.Mock()
1250         balance_mock1.as_json.return_value = 1
1251
1252         balance_mock2 = mock.Mock()
1253         balance_mock2.as_json.return_value = 2
1254
1255         balance_store = market.BalanceStore(self.m)
1256         balance_store.all = {
1257                 "BTC": balance_mock1,
1258                 "ETH": balance_mock2,
1259                 }
1260
1261         as_json = balance_store.as_json()
1262         self.assertEqual(1, as_json["BTC"])
1263         self.assertEqual(2, as_json["ETH"])
1264
1265
1266 @unittest.skipUnless("unit" in limits, "Unit skipped")
1267 class ComputationTest(WebMockTestCase):
1268     def test_compute_value(self):
1269         compute = mock.Mock()
1270         portfolio.Computation.compute_value("foo", "buy", compute_value=compute)
1271         compute.assert_called_with("foo", "ask")
1272
1273         compute.reset_mock()
1274         portfolio.Computation.compute_value("foo", "sell", compute_value=compute)
1275         compute.assert_called_with("foo", "bid")
1276
1277         compute.reset_mock()
1278         portfolio.Computation.compute_value("foo", "ask", compute_value=compute)
1279         compute.assert_called_with("foo", "ask")
1280
1281         compute.reset_mock()
1282         portfolio.Computation.compute_value("foo", "bid", compute_value=compute)
1283         compute.assert_called_with("foo", "bid")
1284
1285         compute.reset_mock()
1286         portfolio.Computation.computations["test"] = compute
1287         portfolio.Computation.compute_value("foo", "bid", compute_value="test")
1288         compute.assert_called_with("foo", "bid")
1289
1290
1291 @unittest.skipUnless("unit" in limits, "Unit skipped")
1292 class TradeTest(WebMockTestCase):
1293
1294     def test_values_assertion(self):
1295         value_from = portfolio.Amount("BTC", "1.0")
1296         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1297         value_to = portfolio.Amount("BTC", "1.0")
1298         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1299         self.assertEqual("BTC", trade.base_currency)
1300         self.assertEqual("ETH", trade.currency)
1301         self.assertEqual(self.m, trade.market)
1302
1303         with self.assertRaises(AssertionError):
1304             portfolio.Trade(value_from, value_to, "ETC", self.m)
1305         with self.assertRaises(AssertionError):
1306             value_from.linked_to = None
1307             portfolio.Trade(value_from, value_to, "ETH", self.m)
1308         with self.assertRaises(AssertionError):
1309             value_from.currency = "ETH"
1310             portfolio.Trade(value_from, value_to, "ETH", self.m)
1311
1312         value_from = portfolio.Amount("BTC", 0)
1313         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1314         self.assertEqual(0, trade.value_from.linked_to)
1315
1316     def test_action(self):
1317         value_from = portfolio.Amount("BTC", "1.0")
1318         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1319         value_to = portfolio.Amount("BTC", "1.0")
1320         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1321
1322         self.assertIsNone(trade.action)
1323
1324         value_from = portfolio.Amount("BTC", "1.0")
1325         value_from.linked_to = portfolio.Amount("BTC", "1.0")
1326         value_to = portfolio.Amount("BTC", "2.0")
1327         trade = portfolio.Trade(value_from, value_to, "BTC", self.m)
1328
1329         self.assertIsNone(trade.action)
1330
1331         value_from = portfolio.Amount("BTC", "0.5")
1332         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1333         value_to = portfolio.Amount("BTC", "1.0")
1334         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1335
1336         self.assertEqual("acquire", trade.action)
1337
1338         value_from = portfolio.Amount("BTC", "0")
1339         value_from.linked_to = portfolio.Amount("ETH", "0")
1340         value_to = portfolio.Amount("BTC", "-1.0")
1341         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1342
1343         self.assertEqual("acquire", trade.action)
1344
1345     def test_order_action(self):
1346         value_from = portfolio.Amount("BTC", "0.5")
1347         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1348         value_to = portfolio.Amount("BTC", "1.0")
1349         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1350
1351         self.assertEqual("buy", trade.order_action(False))
1352         self.assertEqual("sell", trade.order_action(True))
1353
1354         value_from = portfolio.Amount("BTC", "0")
1355         value_from.linked_to = portfolio.Amount("ETH", "0")
1356         value_to = portfolio.Amount("BTC", "-1.0")
1357         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1358
1359         self.assertEqual("sell", trade.order_action(False))
1360         self.assertEqual("buy", trade.order_action(True))
1361
1362     def test_trade_type(self):
1363         value_from = portfolio.Amount("BTC", "0.5")
1364         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1365         value_to = portfolio.Amount("BTC", "1.0")
1366         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1367
1368         self.assertEqual("long", trade.trade_type)
1369
1370         value_from = portfolio.Amount("BTC", "0")
1371         value_from.linked_to = portfolio.Amount("ETH", "0")
1372         value_to = portfolio.Amount("BTC", "-1.0")
1373         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1374
1375         self.assertEqual("short", trade.trade_type)
1376
1377     def test_filled_amount(self):
1378         value_from = portfolio.Amount("BTC", "0.5")
1379         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1380         value_to = portfolio.Amount("BTC", "1.0")
1381         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1382
1383         order1 = mock.Mock()
1384         order1.filled_amount.return_value = portfolio.Amount("ETH", "0.3")
1385
1386         order2 = mock.Mock()
1387         order2.filled_amount.return_value = portfolio.Amount("ETH", "0.01")
1388         trade.orders.append(order1)
1389         trade.orders.append(order2)
1390
1391         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount())
1392         order1.filled_amount.assert_called_with(in_base_currency=False)
1393         order2.filled_amount.assert_called_with(in_base_currency=False)
1394
1395         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount(in_base_currency=False))
1396         order1.filled_amount.assert_called_with(in_base_currency=False)
1397         order2.filled_amount.assert_called_with(in_base_currency=False)
1398
1399         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount(in_base_currency=True))
1400         order1.filled_amount.assert_called_with(in_base_currency=True)
1401         order2.filled_amount.assert_called_with(in_base_currency=True)
1402
1403     @mock.patch.object(portfolio.Computation, "compute_value")
1404     @mock.patch.object(portfolio.Trade, "filled_amount")
1405     @mock.patch.object(portfolio, "Order")
1406     def test_prepare_order(self, Order, filled_amount, compute_value):
1407         Order.return_value = "Order"
1408
1409         with self.subTest(desc="Nothing to do"):
1410             value_from = portfolio.Amount("BTC", "10")
1411             value_from.rate = D("0.1")
1412             value_from.linked_to = portfolio.Amount("FOO", "100")
1413             value_to = portfolio.Amount("BTC", "10")
1414             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
1415
1416             trade.prepare_order()
1417
1418             filled_amount.assert_not_called()
1419             compute_value.assert_not_called()
1420             self.assertEqual(0, len(trade.orders))
1421             Order.assert_not_called()
1422
1423         self.m.get_ticker.return_value = { "inverted": False }
1424         with self.subTest(desc="Already filled"):
1425             filled_amount.return_value = portfolio.Amount("FOO", "100")
1426             compute_value.return_value = D("0.125")
1427
1428             value_from = portfolio.Amount("BTC", "10")
1429             value_from.rate = D("0.1")
1430             value_from.linked_to = portfolio.Amount("FOO", "100")
1431             value_to = portfolio.Amount("BTC", "0")
1432             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
1433
1434             trade.prepare_order()
1435
1436             filled_amount.assert_called_with(in_base_currency=False)
1437             compute_value.assert_called_with(self.m.get_ticker.return_value, "sell", compute_value="default")
1438             self.assertEqual(0, len(trade.orders))
1439             self.m.report.log_error.assert_called_with("prepare_order", message=mock.ANY)
1440             Order.assert_not_called()
1441
1442         with self.subTest(action="dispose", inverted=False):
1443             filled_amount.return_value = portfolio.Amount("FOO", "60")
1444             compute_value.return_value = D("0.125")
1445
1446             value_from = portfolio.Amount("BTC", "10")
1447             value_from.rate = D("0.1")
1448             value_from.linked_to = portfolio.Amount("FOO", "100")
1449             value_to = portfolio.Amount("BTC", "1")
1450             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
1451
1452             trade.prepare_order()
1453
1454             filled_amount.assert_called_with(in_base_currency=False)
1455             compute_value.assert_called_with(self.m.get_ticker.return_value, "sell", compute_value="default")
1456             self.assertEqual(1, len(trade.orders))
1457             Order.assert_called_with("sell", portfolio.Amount("FOO", 30),
1458                     D("0.125"), "BTC", "long", self.m,
1459                     trade, close_if_possible=False)
1460
1461         with self.subTest(action="acquire", inverted=False):
1462             filled_amount.return_value = portfolio.Amount("BTC", "3")
1463             compute_value.return_value = D("0.125")
1464
1465             value_from = portfolio.Amount("BTC", "1")
1466             value_from.rate = D("0.1")
1467             value_from.linked_to = portfolio.Amount("FOO", "10")
1468             value_to = portfolio.Amount("BTC", "10")
1469             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
1470
1471             trade.prepare_order()
1472
1473             filled_amount.assert_called_with(in_base_currency=True)
1474             compute_value.assert_called_with(self.m.get_ticker.return_value, "buy", compute_value="default")
1475             self.assertEqual(1, len(trade.orders))
1476
1477             Order.assert_called_with("buy", portfolio.Amount("FOO", 48),
1478                 D("0.125"), "BTC", "long", self.m,
1479                 trade, close_if_possible=False)
1480
1481         with self.subTest(close_if_possible=True):
1482             filled_amount.return_value = portfolio.Amount("FOO", "0")
1483             compute_value.return_value = D("0.125")
1484
1485             value_from = portfolio.Amount("BTC", "10")
1486             value_from.rate = D("0.1")
1487             value_from.linked_to = portfolio.Amount("FOO", "100")
1488             value_to = portfolio.Amount("BTC", "0")
1489             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
1490
1491             trade.prepare_order()
1492
1493             filled_amount.assert_called_with(in_base_currency=False)
1494             compute_value.assert_called_with(self.m.get_ticker.return_value, "sell", compute_value="default")
1495             self.assertEqual(1, len(trade.orders))
1496             Order.assert_called_with("sell", portfolio.Amount("FOO", 100),
1497                     D("0.125"), "BTC", "long", self.m,
1498                     trade, close_if_possible=True)
1499
1500         self.m.get_ticker.return_value = { "inverted": True, "original": {} }
1501         with self.subTest(action="dispose", inverted=True):
1502             filled_amount.return_value = portfolio.Amount("FOO", "300")
1503             compute_value.return_value = D("125")
1504
1505             value_from = portfolio.Amount("BTC", "10")
1506             value_from.rate = D("0.01")
1507             value_from.linked_to = portfolio.Amount("FOO", "1000")
1508             value_to = portfolio.Amount("BTC", "1")
1509             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
1510
1511             trade.prepare_order(compute_value="foo")
1512
1513             filled_amount.assert_called_with(in_base_currency=True)
1514             compute_value.assert_called_with(self.m.get_ticker.return_value["original"], "buy", compute_value="foo")
1515             self.assertEqual(1, len(trade.orders))
1516             Order.assert_called_with("buy", portfolio.Amount("BTC", D("4.8")),
1517                     D("125"), "FOO", "long", self.m,
1518                     trade, close_if_possible=False)
1519
1520         with self.subTest(action="acquire", inverted=True):
1521             filled_amount.return_value = portfolio.Amount("BTC", "4")
1522             compute_value.return_value = D("125")
1523
1524             value_from = portfolio.Amount("BTC", "1")
1525             value_from.rate = D("0.01")
1526             value_from.linked_to = portfolio.Amount("FOO", "100")
1527             value_to = portfolio.Amount("BTC", "10")
1528             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
1529
1530             trade.prepare_order(compute_value="foo")
1531
1532             filled_amount.assert_called_with(in_base_currency=False)
1533             compute_value.assert_called_with(self.m.get_ticker.return_value["original"], "sell", compute_value="foo")
1534             self.assertEqual(1, len(trade.orders))
1535             Order.assert_called_with("sell", portfolio.Amount("BTC", D("5")),
1536                     D("125"), "FOO", "long", self.m,
1537                     trade, close_if_possible=False)
1538
1539
1540     @mock.patch.object(portfolio.Trade, "prepare_order")
1541     def test_update_order(self, prepare_order):
1542         order_mock = mock.Mock()
1543         new_order_mock = mock.Mock()
1544
1545         value_from = portfolio.Amount("BTC", "0.5")
1546         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1547         value_to = portfolio.Amount("BTC", "1.0")
1548         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1549         prepare_order.return_value = new_order_mock
1550
1551         for i in [0, 1, 3, 4, 6]:
1552             with self.subTest(tick=i):
1553                 trade.update_order(order_mock, i)
1554                 order_mock.cancel.assert_not_called()
1555                 new_order_mock.run.assert_not_called()
1556                 self.m.report.log_order.assert_called_once_with(order_mock, i,
1557                         update="waiting", compute_value=None, new_order=None)
1558
1559             order_mock.reset_mock()
1560             new_order_mock.reset_mock()
1561             trade.orders = []
1562             self.m.report.log_order.reset_mock()
1563
1564         trade.update_order(order_mock, 2)
1565         order_mock.cancel.assert_called()
1566         new_order_mock.run.assert_called()
1567         prepare_order.assert_called()
1568         self.m.report.log_order.assert_called()
1569         self.assertEqual(2, self.m.report.log_order.call_count)
1570         calls = [
1571                 mock.call(order_mock, 2, update="adjusting",
1572                     compute_value='lambda x, y: (x[y] + x["average"]) / 2',
1573                     new_order=new_order_mock),
1574                 mock.call(order_mock, 2, new_order=new_order_mock),
1575                 ]
1576         self.m.report.log_order.assert_has_calls(calls)
1577
1578         order_mock.reset_mock()
1579         new_order_mock.reset_mock()
1580         trade.orders = []
1581         self.m.report.log_order.reset_mock()
1582
1583         trade.update_order(order_mock, 5)
1584         order_mock.cancel.assert_called()
1585         new_order_mock.run.assert_called()
1586         prepare_order.assert_called()
1587         self.assertEqual(2, self.m.report.log_order.call_count)
1588         self.m.report.log_order.assert_called()
1589         calls = [
1590                 mock.call(order_mock, 5, update="adjusting",
1591                     compute_value='lambda x, y: (x[y]*2 + x["average"]) / 3',
1592                     new_order=new_order_mock),
1593                 mock.call(order_mock, 5, new_order=new_order_mock),
1594                 ]
1595         self.m.report.log_order.assert_has_calls(calls)
1596
1597         order_mock.reset_mock()
1598         new_order_mock.reset_mock()
1599         trade.orders = []
1600         self.m.report.log_order.reset_mock()
1601
1602         trade.update_order(order_mock, 7)
1603         order_mock.cancel.assert_called()
1604         new_order_mock.run.assert_called()
1605         prepare_order.assert_called_with(compute_value="default")
1606         self.m.report.log_order.assert_called()
1607         self.assertEqual(2, self.m.report.log_order.call_count)
1608         calls = [
1609                 mock.call(order_mock, 7, update="market_fallback",
1610                     compute_value='default',
1611                     new_order=new_order_mock),
1612                 mock.call(order_mock, 7, new_order=new_order_mock),
1613                 ]
1614         self.m.report.log_order.assert_has_calls(calls)
1615
1616         order_mock.reset_mock()
1617         new_order_mock.reset_mock()
1618         trade.orders = []
1619         self.m.report.log_order.reset_mock()
1620
1621         for i in [10, 13, 16]:
1622             with self.subTest(tick=i):
1623                 trade.update_order(order_mock, i)
1624                 order_mock.cancel.assert_called()
1625                 new_order_mock.run.assert_called()
1626                 prepare_order.assert_called_with(compute_value="default")
1627                 self.m.report.log_order.assert_called()
1628                 self.assertEqual(2, self.m.report.log_order.call_count)
1629                 calls = [
1630                         mock.call(order_mock, i, update="market_adjust",
1631                             compute_value='default',
1632                             new_order=new_order_mock),
1633                         mock.call(order_mock, i, new_order=new_order_mock),
1634                         ]
1635                 self.m.report.log_order.assert_has_calls(calls)
1636
1637             order_mock.reset_mock()
1638             new_order_mock.reset_mock()
1639             trade.orders = []
1640             self.m.report.log_order.reset_mock()
1641
1642         for i in [8, 9, 11, 12]:
1643             with self.subTest(tick=i):
1644                 trade.update_order(order_mock, i)
1645                 order_mock.cancel.assert_not_called()
1646                 new_order_mock.run.assert_not_called()
1647                 self.m.report.log_order.assert_called_once_with(order_mock, i, update="waiting",
1648                         compute_value=None, new_order=None)
1649
1650             order_mock.reset_mock()
1651             new_order_mock.reset_mock()
1652             trade.orders = []
1653             self.m.report.log_order.reset_mock()
1654
1655
1656     def test_print_with_order(self):
1657         value_from = portfolio.Amount("BTC", "0.5")
1658         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1659         value_to = portfolio.Amount("BTC", "1.0")
1660         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1661
1662         order_mock1 = mock.Mock()
1663         order_mock1.__repr__ = mock.Mock()
1664         order_mock1.__repr__.return_value = "Mock 1"
1665         order_mock2 = mock.Mock()
1666         order_mock2.__repr__ = mock.Mock()
1667         order_mock2.__repr__.return_value = "Mock 2"
1668         order_mock1.mouvements = []
1669         mouvement_mock1 = mock.Mock()
1670         mouvement_mock1.__repr__ = mock.Mock()
1671         mouvement_mock1.__repr__.return_value = "Mouvement 1"
1672         mouvement_mock2 = mock.Mock()
1673         mouvement_mock2.__repr__ = mock.Mock()
1674         mouvement_mock2.__repr__.return_value = "Mouvement 2"
1675         order_mock2.mouvements = [
1676                 mouvement_mock1, mouvement_mock2
1677                 ]
1678         trade.orders.append(order_mock1)
1679         trade.orders.append(order_mock2)
1680
1681         trade.print_with_order()
1682
1683         self.m.report.print_log.assert_called()
1684         calls = self.m.report.print_log.mock_calls
1685         self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire)", str(calls[0][1][0]))
1686         self.assertEqual("\tMock 1", str(calls[1][1][0]))
1687         self.assertEqual("\tMock 2", str(calls[2][1][0]))
1688         self.assertEqual("\t\tMouvement 1", str(calls[3][1][0]))
1689         self.assertEqual("\t\tMouvement 2", str(calls[4][1][0]))
1690
1691     def test__repr(self):
1692         value_from = portfolio.Amount("BTC", "0.5")
1693         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1694         value_to = portfolio.Amount("BTC", "1.0")
1695         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1696
1697         self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire)", str(trade))
1698
1699     def test_as_json(self):
1700         value_from = portfolio.Amount("BTC", "0.5")
1701         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1702         value_to = portfolio.Amount("BTC", "1.0")
1703         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1704
1705         as_json = trade.as_json()
1706         self.assertEqual("acquire", as_json["action"])
1707         self.assertEqual(D("0.5"), as_json["from"])
1708         self.assertEqual(D("1.0"), as_json["to"])
1709         self.assertEqual("ETH", as_json["currency"])
1710         self.assertEqual("BTC", as_json["base_currency"])
1711
1712 @unittest.skipUnless("unit" in limits, "Unit skipped")
1713 class OrderTest(WebMockTestCase):
1714     def test_values(self):
1715         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1716                 D("0.1"), "BTC", "long", "market", "trade")
1717         self.assertEqual("buy", order.action)
1718         self.assertEqual(10, order.amount.value)
1719         self.assertEqual("ETH", order.amount.currency)
1720         self.assertEqual(D("0.1"), order.rate)
1721         self.assertEqual("BTC", order.base_currency)
1722         self.assertEqual("market", order.market)
1723         self.assertEqual("long", order.trade_type)
1724         self.assertEqual("pending", order.status)
1725         self.assertEqual("trade", order.trade)
1726         self.assertIsNone(order.id)
1727         self.assertFalse(order.close_if_possible)
1728
1729     def test__repr(self):
1730         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1731                 D("0.1"), "BTC", "long", "market", "trade")
1732         self.assertEqual("Order(buy long 10.00000000 ETH at 0.1 BTC [pending])", repr(order))
1733
1734         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1735                 D("0.1"), "BTC", "long", "market", "trade",
1736                 close_if_possible=True)
1737         self.assertEqual("Order(buy long 10.00000000 ETH at 0.1 BTC [pending] ✂)", repr(order))
1738
1739     def test_as_json(self):
1740         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1741                 D("0.1"), "BTC", "long", "market", "trade")
1742         mouvement_mock1 = mock.Mock()
1743         mouvement_mock1.as_json.return_value = 1
1744         mouvement_mock2 = mock.Mock()
1745         mouvement_mock2.as_json.return_value = 2
1746
1747         order.mouvements = [mouvement_mock1, mouvement_mock2]
1748         as_json = order.as_json()
1749         self.assertEqual("buy", as_json["action"])
1750         self.assertEqual("long", as_json["trade_type"])
1751         self.assertEqual(10, as_json["amount"])
1752         self.assertEqual("ETH", as_json["currency"])
1753         self.assertEqual("BTC", as_json["base_currency"])
1754         self.assertEqual(D("0.1"), as_json["rate"])
1755         self.assertEqual("pending", as_json["status"])
1756         self.assertEqual(False, as_json["close_if_possible"])
1757         self.assertIsNone(as_json["id"])
1758         self.assertEqual([1, 2], as_json["mouvements"])
1759
1760     def test_account(self):
1761         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1762                 D("0.1"), "BTC", "long", "market", "trade")
1763         self.assertEqual("exchange", order.account)
1764
1765         order = portfolio.Order("sell", portfolio.Amount("ETH", 10),
1766                 D("0.1"), "BTC", "short", "market", "trade")
1767         self.assertEqual("margin", order.account)
1768
1769     def test_pending(self):
1770         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1771                 D("0.1"), "BTC", "long", "market", "trade")
1772         self.assertTrue(order.pending)
1773         order.status = "open"
1774         self.assertFalse(order.pending)
1775
1776     def test_open(self):
1777         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1778                 D("0.1"), "BTC", "long", "market", "trade")
1779         self.assertFalse(order.open)
1780         order.status = "open"
1781         self.assertTrue(order.open)
1782
1783     def test_finished(self):
1784         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1785                 D("0.1"), "BTC", "long", "market", "trade")
1786         self.assertFalse(order.finished)
1787         order.status = "closed"
1788         self.assertTrue(order.finished)
1789         order.status = "canceled"
1790         self.assertTrue(order.finished)
1791         order.status = "error"
1792         self.assertTrue(order.finished)
1793
1794     @mock.patch.object(portfolio.Order, "fetch")
1795     def test_cancel(self, fetch):
1796         self.m.debug = True
1797         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1798                 D("0.1"), "BTC", "long", self.m, "trade")
1799         order.status = "open"
1800
1801         order.cancel()
1802         self.m.ccxt.cancel_order.assert_not_called()
1803         self.m.report.log_debug_action.assert_called_once()
1804         self.m.report.log_debug_action.reset_mock()
1805         self.assertEqual("canceled", order.status)
1806
1807         self.m.debug = False
1808         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1809                 D("0.1"), "BTC", "long", self.m, "trade")
1810         order.status = "open"
1811         order.id = 42
1812
1813         order.cancel()
1814         self.m.ccxt.cancel_order.assert_called_with(42)
1815         fetch.assert_called_once()
1816         self.m.report.log_debug_action.assert_not_called()
1817
1818     def test_dust_amount_remaining(self):
1819         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1820                 D("0.1"), "BTC", "long", self.m, "trade")
1821         order.remaining_amount = mock.Mock(return_value=portfolio.Amount("ETH", 1))
1822         self.assertFalse(order.dust_amount_remaining())
1823
1824         order.remaining_amount = mock.Mock(return_value=portfolio.Amount("ETH", D("0.0001")))
1825         self.assertTrue(order.dust_amount_remaining())
1826
1827     @mock.patch.object(portfolio.Order, "fetch")
1828     @mock.patch.object(portfolio.Order, "filled_amount", return_value=portfolio.Amount("ETH", 1))
1829     def test_remaining_amount(self, filled_amount, fetch):
1830         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1831                 D("0.1"), "BTC", "long", self.m, "trade")
1832
1833         self.assertEqual(9, order.remaining_amount().value)
1834         order.fetch.assert_not_called()
1835
1836         order.status = "open"
1837         self.assertEqual(9, order.remaining_amount().value)
1838         fetch.assert_called_once()
1839
1840     @mock.patch.object(portfolio.Order, "fetch")
1841     def test_filled_amount(self, fetch):
1842         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1843                 D("0.1"), "BTC", "long", self.m, "trade")
1844         order.mouvements.append(portfolio.Mouvement("ETH", "BTC", {
1845             "tradeID": 42, "type": "buy", "fee": "0.0015",
1846             "date": "2017-12-30 12:00:12", "rate": "0.1",
1847             "amount": "3", "total": "0.3"
1848             }))
1849         order.mouvements.append(portfolio.Mouvement("ETH", "BTC", {
1850             "tradeID": 43, "type": "buy", "fee": "0.0015",
1851             "date": "2017-12-30 13:00:12", "rate": "0.2",
1852             "amount": "2", "total": "0.4"
1853             }))
1854         self.assertEqual(portfolio.Amount("ETH", 5), order.filled_amount())
1855         fetch.assert_not_called()
1856         order.status = "open"
1857         self.assertEqual(portfolio.Amount("ETH", 5), order.filled_amount(in_base_currency=False))
1858         fetch.assert_called_once()
1859         self.assertEqual(portfolio.Amount("BTC", "0.7"), order.filled_amount(in_base_currency=True))
1860
1861     def test_fetch_mouvements(self):
1862         self.m.ccxt.privatePostReturnOrderTrades.return_value = [
1863                 {
1864                     "tradeID": 42, "type": "buy", "fee": "0.0015",
1865                     "date": "2017-12-30 12:00:12", "rate": "0.1",
1866                     "amount": "3", "total": "0.3"
1867                     },
1868                 {
1869                     "tradeID": 43, "type": "buy", "fee": "0.0015",
1870                     "date": "2017-12-30 13:00:12", "rate": "0.2",
1871                     "amount": "2", "total": "0.4"
1872                     }
1873             ]
1874         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1875                 D("0.1"), "BTC", "long", self.m, "trade")
1876         order.id = 12
1877         order.mouvements = ["Foo", "Bar", "Baz"]
1878
1879         order.fetch_mouvements()
1880
1881         self.m.ccxt.privatePostReturnOrderTrades.assert_called_with({"orderNumber": 12})
1882         self.assertEqual(2, len(order.mouvements))
1883         self.assertEqual(42, order.mouvements[0].id)
1884         self.assertEqual(43, order.mouvements[1].id)
1885
1886         self.m.ccxt.privatePostReturnOrderTrades.side_effect = portfolio.ExchangeError
1887         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1888                 D("0.1"), "BTC", "long", self.m, "trade")
1889         order.fetch_mouvements()
1890         self.assertEqual(0, len(order.mouvements))
1891
1892     def test_mark_finished_order(self):
1893         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1894                 D("0.1"), "BTC", "short", self.m, "trade",
1895                 close_if_possible=True)
1896         order.status = "closed"
1897         self.m.debug = False
1898
1899         order.mark_finished_order()
1900         self.m.ccxt.close_margin_position.assert_called_with("ETH", "BTC")
1901         self.m.ccxt.close_margin_position.reset_mock()
1902
1903         order.status = "open"
1904         order.mark_finished_order()
1905         self.m.ccxt.close_margin_position.assert_not_called()
1906
1907         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1908                 D("0.1"), "BTC", "short", self.m, "trade",
1909                 close_if_possible=False)
1910         order.status = "closed"
1911         order.mark_finished_order()
1912         self.m.ccxt.close_margin_position.assert_not_called()
1913
1914         order = portfolio.Order("sell", portfolio.Amount("ETH", 10),
1915                 D("0.1"), "BTC", "short", self.m, "trade",
1916                 close_if_possible=True)
1917         order.status = "closed"
1918         order.mark_finished_order()
1919         self.m.ccxt.close_margin_position.assert_not_called()
1920
1921         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1922                 D("0.1"), "BTC", "long", self.m, "trade",
1923                 close_if_possible=True)
1924         order.status = "closed"
1925         order.mark_finished_order()
1926         self.m.ccxt.close_margin_position.assert_not_called()
1927
1928         self.m.debug = True
1929
1930         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1931                 D("0.1"), "BTC", "short", self.m, "trade",
1932                 close_if_possible=True)
1933         order.status = "closed"
1934
1935         order.mark_finished_order()
1936         self.m.ccxt.close_margin_position.assert_not_called()
1937         self.m.report.log_debug_action.assert_called_once()
1938
1939     @mock.patch.object(portfolio.Order, "fetch_mouvements")
1940     def test_fetch(self, fetch_mouvements):
1941         time = self.time.time()
1942         with mock.patch.object(portfolio.time, "time") as time_mock:
1943             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
1944                     D("0.1"), "BTC", "long", self.m, "trade")
1945             order.id = 45
1946             with self.subTest(debug=True):
1947                 self.m.debug = True
1948                 order.fetch()
1949                 time_mock.assert_not_called()
1950                 self.m.report.log_debug_action.assert_called_once()
1951                 self.m.report.log_debug_action.reset_mock()
1952                 order.fetch(force=True)
1953                 time_mock.assert_not_called()
1954                 self.m.ccxt.fetch_order.assert_not_called()
1955                 fetch_mouvements.assert_not_called()
1956                 self.m.report.log_debug_action.assert_called_once()
1957                 self.m.report.log_debug_action.reset_mock()
1958             self.assertIsNone(order.fetch_cache_timestamp)
1959
1960             with self.subTest(debug=False):
1961                 self.m.debug = False
1962                 time_mock.return_value = time
1963                 self.m.ccxt.fetch_order.return_value = {
1964                         "status": "foo",
1965                         "datetime": "timestamp"
1966                         }
1967                 order.fetch()
1968
1969                 self.m.ccxt.fetch_order.assert_called_once()
1970                 fetch_mouvements.assert_called_once()
1971                 self.assertEqual("foo", order.status)
1972                 self.assertEqual("timestamp", order.timestamp)
1973                 self.assertEqual(time, order.fetch_cache_timestamp)
1974                 self.assertEqual(1, len(order.results))
1975
1976                 self.m.ccxt.fetch_order.reset_mock()
1977                 fetch_mouvements.reset_mock()
1978
1979                 time_mock.return_value = time + 8
1980                 order.fetch()
1981                 self.m.ccxt.fetch_order.assert_not_called()
1982                 fetch_mouvements.assert_not_called()
1983
1984                 order.fetch(force=True)
1985                 self.m.ccxt.fetch_order.assert_called_once()
1986                 fetch_mouvements.assert_called_once()
1987
1988                 self.m.ccxt.fetch_order.reset_mock()
1989                 fetch_mouvements.reset_mock()
1990
1991                 time_mock.return_value = time + 19
1992                 order.fetch()
1993                 self.m.ccxt.fetch_order.assert_called_once()
1994                 fetch_mouvements.assert_called_once()
1995                 self.m.report.log_debug_action.assert_not_called()
1996
1997     @mock.patch.object(portfolio.Order, "fetch")
1998     @mock.patch.object(portfolio.Order, "mark_finished_order")
1999     def test_get_status(self, mark_finished_order, fetch):
2000         with self.subTest(debug=True):
2001             self.m.debug = True
2002             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2003                     D("0.1"), "BTC", "long", self.m, "trade")
2004             self.assertEqual("pending", order.get_status())
2005             fetch.assert_not_called()
2006             self.m.report.log_debug_action.assert_called_once()
2007
2008         with self.subTest(debug=False, finished=False):
2009             self.m.debug = False
2010             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2011                     D("0.1"), "BTC", "long", self.m, "trade")
2012             def _fetch(order):
2013                 def update_status():
2014                     order.status = "open"
2015                 return update_status
2016             fetch.side_effect = _fetch(order)
2017             self.assertEqual("open", order.get_status())
2018             mark_finished_order.assert_not_called()
2019             fetch.assert_called_once()
2020
2021         mark_finished_order.reset_mock()
2022         fetch.reset_mock()
2023         with self.subTest(debug=False, finished=True):
2024             self.m.debug = False
2025             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2026                     D("0.1"), "BTC", "long", self.m, "trade")
2027             def _fetch(order):
2028                 def update_status():
2029                     order.status = "closed"
2030                 return update_status
2031             fetch.side_effect = _fetch(order)
2032             self.assertEqual("closed", order.get_status())
2033             mark_finished_order.assert_called_once()
2034             fetch.assert_called_once()
2035
2036     def test_run(self):
2037         self.m.ccxt.order_precision.return_value = 4
2038         with self.subTest(debug=True):
2039             self.m.debug = True
2040             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2041                     D("0.1"), "BTC", "long", self.m, "trade")
2042             order.run()
2043             self.m.ccxt.create_order.assert_not_called()
2044             self.m.report.log_debug_action.assert_called_with("market.ccxt.create_order('ETH/BTC', 'limit', 'buy', 10.0000, price=0.1, account=exchange)")
2045             self.assertEqual("open", order.status)
2046             self.assertEqual(1, len(order.results))
2047             self.assertEqual(-1, order.id)
2048
2049         self.m.ccxt.create_order.reset_mock()
2050         with self.subTest(debug=False):
2051             self.m.debug = False
2052             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2053                     D("0.1"), "BTC", "long", self.m, "trade")
2054             self.m.ccxt.create_order.return_value = { "id": 123 }
2055             order.run()
2056             self.m.ccxt.create_order.assert_called_once()
2057             self.assertEqual(1, len(order.results))
2058             self.assertEqual("open", order.status)
2059
2060         self.m.ccxt.create_order.reset_mock()
2061         with self.subTest(exception=True):
2062             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2063                     D("0.1"), "BTC", "long", self.m, "trade")
2064             self.m.ccxt.create_order.side_effect = Exception("bouh")
2065             order.run()
2066             self.m.ccxt.create_order.assert_called_once()
2067             self.assertEqual(0, len(order.results))
2068             self.assertEqual("error", order.status)
2069             self.m.report.log_error.assert_called_once()
2070
2071         self.m.ccxt.create_order.reset_mock()
2072         with self.subTest(dust_amount_exception=True),\
2073                 mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order:
2074             order = portfolio.Order("buy", portfolio.Amount("ETH", 0.001),
2075                     D("0.1"), "BTC", "long", self.m, "trade")
2076             self.m.ccxt.create_order.side_effect = portfolio.ExchangeNotAvailable
2077             order.run()
2078             self.m.ccxt.create_order.assert_called_once()
2079             self.assertEqual(0, len(order.results))
2080             self.assertEqual("closed", order.status)
2081             mark_finished_order.assert_called_once()
2082
2083
2084 @unittest.skipUnless("unit" in limits, "Unit skipped")
2085 class MouvementTest(WebMockTestCase):
2086     def test_values(self):
2087         mouvement = portfolio.Mouvement("ETH", "BTC", {
2088             "tradeID": 42, "type": "buy", "fee": "0.0015",
2089             "date": "2017-12-30 12:00:12", "rate": "0.1",
2090             "amount": "10", "total": "1"
2091             })
2092         self.assertEqual("ETH", mouvement.currency)
2093         self.assertEqual("BTC", mouvement.base_currency)
2094         self.assertEqual(42, mouvement.id)
2095         self.assertEqual("buy", mouvement.action)
2096         self.assertEqual(D("0.0015"), mouvement.fee_rate)
2097         self.assertEqual(portfolio.datetime(2017, 12, 30, 12, 0, 12), mouvement.date)
2098         self.assertEqual(D("0.1"), mouvement.rate)
2099         self.assertEqual(portfolio.Amount("ETH", "10"), mouvement.total)
2100         self.assertEqual(portfolio.Amount("BTC", "1"), mouvement.total_in_base)
2101
2102         mouvement = portfolio.Mouvement("ETH", "BTC", { "foo": "bar" })
2103         self.assertIsNone(mouvement.date)
2104         self.assertIsNone(mouvement.id)
2105         self.assertIsNone(mouvement.action)
2106         self.assertEqual(-1, mouvement.fee_rate)
2107         self.assertEqual(0, mouvement.rate)
2108         self.assertEqual(portfolio.Amount("ETH", 0), mouvement.total)
2109         self.assertEqual(portfolio.Amount("BTC", 0), mouvement.total_in_base)
2110
2111     def test__repr(self):
2112         mouvement = portfolio.Mouvement("ETH", "BTC", {
2113             "tradeID": 42, "type": "buy", "fee": "0.0015",
2114             "date": "2017-12-30 12:00:12", "rate": "0.1",
2115             "amount": "10", "total": "1"
2116             })
2117         self.assertEqual("Mouvement(2017-12-30 12:00:12 ; buy 10.00000000 ETH (1.00000000 BTC) fee: 0.1500%)", repr(mouvement))
2118
2119         mouvement = portfolio.Mouvement("ETH", "BTC", {
2120             "tradeID": 42, "type": "buy",
2121             "date": "garbage", "rate": "0.1",
2122             "amount": "10", "total": "1"
2123             })
2124         self.assertEqual("Mouvement(No date ; buy 10.00000000 ETH (1.00000000 BTC))", repr(mouvement))
2125
2126     def test_as_json(self):
2127         mouvement = portfolio.Mouvement("ETH", "BTC", {
2128             "tradeID": 42, "type": "buy", "fee": "0.0015",
2129             "date": "2017-12-30 12:00:12", "rate": "0.1",
2130             "amount": "10", "total": "1"
2131             })
2132         as_json = mouvement.as_json()
2133
2134         self.assertEqual(D("0.0015"), as_json["fee_rate"])
2135         self.assertEqual(portfolio.datetime(2017, 12, 30, 12, 0, 12), as_json["date"])
2136         self.assertEqual("buy", as_json["action"])
2137         self.assertEqual(D("10"), as_json["total"])
2138         self.assertEqual(D("1"), as_json["total_in_base"])
2139         self.assertEqual("BTC", as_json["base_currency"])
2140         self.assertEqual("ETH", as_json["currency"])
2141
2142 @unittest.skipUnless("unit" in limits, "Unit skipped")
2143 class ReportStoreTest(WebMockTestCase):
2144     def test_add_log(self):
2145         report_store = market.ReportStore(self.m)
2146         report_store.add_log({"foo": "bar"})
2147
2148         self.assertEqual({"foo": "bar", "date": mock.ANY}, report_store.logs[0])
2149
2150     def test_set_verbose(self):
2151         report_store = market.ReportStore(self.m)
2152         with self.subTest(verbose=True):
2153             report_store.set_verbose(True)
2154             self.assertTrue(report_store.verbose_print)
2155
2156         with self.subTest(verbose=False):
2157             report_store.set_verbose(False)
2158             self.assertFalse(report_store.verbose_print)
2159
2160     def test_print_log(self):
2161         report_store = market.ReportStore(self.m)
2162         with self.subTest(verbose=True),\
2163                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
2164             report_store.set_verbose(True)
2165             report_store.print_log("Coucou")
2166             report_store.print_log(portfolio.Amount("BTC", 1))
2167             self.assertEqual(stdout_mock.getvalue(), "Coucou\n1.00000000 BTC\n")
2168
2169         with self.subTest(verbose=False),\
2170                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
2171             report_store.set_verbose(False)
2172             report_store.print_log("Coucou")
2173             report_store.print_log(portfolio.Amount("BTC", 1))
2174             self.assertEqual(stdout_mock.getvalue(), "")
2175
2176     def test_to_json(self):
2177         report_store = market.ReportStore(self.m)
2178         report_store.logs.append({"foo": "bar"})
2179         self.assertEqual('[{"foo": "bar"}]', report_store.to_json())
2180         report_store.logs.append({"date": portfolio.datetime(2018, 2, 24)})
2181         self.assertEqual('[{"foo": "bar"}, {"date": "2018-02-24T00:00:00"}]', report_store.to_json())
2182         report_store.logs.append({"amount": portfolio.Amount("BTC", 1)})
2183         self.assertEqual('[{"foo": "bar"}, {"date": "2018-02-24T00:00:00"}, {"amount": "1.00000000 BTC"}]', report_store.to_json())
2184
2185     @mock.patch.object(market.ReportStore, "print_log")
2186     @mock.patch.object(market.ReportStore, "add_log")
2187     def test_log_stage(self, add_log, print_log):
2188         report_store = market.ReportStore(self.m)
2189         report_store.log_stage("foo")
2190         print_log.assert_has_calls([
2191             mock.call("-----------"),
2192             mock.call("[Stage] foo"),
2193             ])
2194         add_log.assert_called_once_with({'type': 'stage', 'stage': 'foo'})
2195
2196     @mock.patch.object(market.ReportStore, "print_log")
2197     @mock.patch.object(market.ReportStore, "add_log")
2198     def test_log_balances(self, add_log, print_log):
2199         report_store = market.ReportStore(self.m)
2200         self.m.balances.as_json.return_value = "json"
2201         self.m.balances.all = { "FOO": "bar", "BAR": "baz" }
2202
2203         report_store.log_balances(tag="tag")
2204         print_log.assert_has_calls([
2205             mock.call("[Balance]"),
2206             mock.call("\tbar"),
2207             mock.call("\tbaz"),
2208             ])
2209         add_log.assert_called_once_with({
2210             'type': 'balance',
2211             'balances': 'json',
2212             'tag': 'tag'
2213             })
2214
2215     @mock.patch.object(market.ReportStore, "print_log")
2216     @mock.patch.object(market.ReportStore, "add_log")
2217     def test_log_tickers(self, add_log, print_log):
2218         report_store = market.ReportStore(self.m)
2219         amounts = {
2220                 "BTC": portfolio.Amount("BTC", 10),
2221                 "ETH": portfolio.Amount("BTC", D("0.3"))
2222                 }
2223         amounts["ETH"].rate = D("0.1")
2224
2225         report_store.log_tickers(amounts, "BTC", "default", "total")
2226         print_log.assert_not_called()
2227         add_log.assert_called_once_with({
2228             'type': 'tickers',
2229             'compute_value': 'default',
2230             'balance_type': 'total',
2231             'currency': 'BTC',
2232             'balances': {
2233                 'BTC': D('10'),
2234                 'ETH': D('0.3')
2235                 },
2236             'rates': {
2237                 'BTC': None,
2238                 'ETH': D('0.1')
2239                 },
2240             'total': D('10.3')
2241             })
2242
2243     @mock.patch.object(market.ReportStore, "print_log")
2244     @mock.patch.object(market.ReportStore, "add_log")
2245     def test_log_dispatch(self, add_log, print_log):
2246         report_store = market.ReportStore(self.m)
2247         amount = portfolio.Amount("BTC", "10.3")
2248         amounts = {
2249                 "BTC": portfolio.Amount("BTC", 10),
2250                 "ETH": portfolio.Amount("BTC", D("0.3"))
2251                 }
2252         report_store.log_dispatch(amount, amounts, "medium", "repartition")
2253         print_log.assert_not_called()
2254         add_log.assert_called_once_with({
2255             'type': 'dispatch',
2256             'liquidity': 'medium',
2257             'repartition_ratio': 'repartition',
2258             'total_amount': {
2259                 'currency': 'BTC',
2260                 'value': D('10.3')
2261                 },
2262             'repartition': {
2263                 'BTC': D('10'),
2264                 'ETH': D('0.3')
2265                 }
2266             })
2267
2268     @mock.patch.object(market.ReportStore, "print_log")
2269     @mock.patch.object(market.ReportStore, "add_log")
2270     def test_log_trades(self, add_log, print_log):
2271         report_store = market.ReportStore(self.m)
2272         trade_mock1 = mock.Mock()
2273         trade_mock2 = mock.Mock()
2274         trade_mock1.as_json.return_value = { "trade": "1" }
2275         trade_mock2.as_json.return_value = { "trade": "2" }
2276
2277         matching_and_trades = [
2278                 (True, trade_mock1),
2279                 (False, trade_mock2),
2280                 ]
2281         report_store.log_trades(matching_and_trades, "only")
2282
2283         print_log.assert_not_called()
2284         add_log.assert_called_with({
2285             'type': 'trades',
2286             'only': 'only',
2287             'debug': False,
2288             'trades': [
2289                 {'trade': '1', 'skipped': False},
2290                 {'trade': '2', 'skipped': True}
2291                 ]
2292             })
2293
2294     @mock.patch.object(market.ReportStore, "print_log")
2295     @mock.patch.object(market.ReportStore, "add_log")
2296     def test_log_orders(self, add_log, print_log):
2297         report_store = market.ReportStore(self.m)
2298
2299         order_mock1 = mock.Mock()
2300         order_mock2 = mock.Mock()
2301
2302         order_mock1.as_json.return_value = "order1"
2303         order_mock2.as_json.return_value = "order2"
2304
2305         orders = [order_mock1, order_mock2]
2306
2307         report_store.log_orders(orders, tick="tick",
2308                 only="only", compute_value="compute_value")
2309
2310         print_log.assert_called_once_with("[Orders]")
2311         self.m.trades.print_all_with_order.assert_called_once_with(ind="\t")
2312
2313         add_log.assert_called_with({
2314             'type': 'orders',
2315             'only': 'only',
2316             'compute_value': 'compute_value',
2317             'tick': 'tick',
2318             'orders': ['order1', 'order2']
2319             })
2320
2321     @mock.patch.object(market.ReportStore, "print_log")
2322     @mock.patch.object(market.ReportStore, "add_log")
2323     def test_log_order(self, add_log, print_log):
2324         report_store = market.ReportStore(self.m)
2325         order_mock = mock.Mock()
2326         order_mock.as_json.return_value = "order"
2327         new_order_mock = mock.Mock()
2328         new_order_mock.as_json.return_value = "new_order"
2329         order_mock.__repr__ = mock.Mock()
2330         order_mock.__repr__.return_value = "Order Mock"
2331         new_order_mock.__repr__ = mock.Mock()
2332         new_order_mock.__repr__.return_value = "New order Mock"
2333
2334         with self.subTest(finished=True):
2335             report_store.log_order(order_mock, 1, finished=True)
2336             print_log.assert_called_once_with("[Order] Finished Order Mock")
2337             add_log.assert_called_once_with({
2338                 'type': 'order',
2339                 'tick': 1,
2340                 'update': None,
2341                 'order': 'order',
2342                 'compute_value': None,
2343                 'new_order': None
2344                 })
2345
2346         add_log.reset_mock()
2347         print_log.reset_mock()
2348
2349         with self.subTest(update="waiting"):
2350             report_store.log_order(order_mock, 1, update="waiting")
2351             print_log.assert_called_once_with("[Order] Order Mock, tick 1, waiting")
2352             add_log.assert_called_once_with({
2353                 'type': 'order',
2354                 'tick': 1,
2355                 'update': 'waiting',
2356                 'order': 'order',
2357                 'compute_value': None,
2358                 'new_order': None
2359                 })
2360
2361         add_log.reset_mock()
2362         print_log.reset_mock()
2363         with self.subTest(update="adjusting"):
2364             report_store.log_order(order_mock, 3,
2365                     update="adjusting", new_order=new_order_mock,
2366                     compute_value="default")
2367             print_log.assert_called_once_with("[Order] Order Mock, tick 3, cancelling and adjusting to New order Mock")
2368             add_log.assert_called_once_with({
2369                 'type': 'order',
2370                 'tick': 3,
2371                 'update': 'adjusting',
2372                 'order': 'order',
2373                 'compute_value': "default",
2374                 'new_order': 'new_order'
2375                 })
2376
2377         add_log.reset_mock()
2378         print_log.reset_mock()
2379         with self.subTest(update="market_fallback"):
2380             report_store.log_order(order_mock, 7,
2381                     update="market_fallback", new_order=new_order_mock)
2382             print_log.assert_called_once_with("[Order] Order Mock, tick 7, fallbacking to market value")
2383             add_log.assert_called_once_with({
2384                 'type': 'order',
2385                 'tick': 7,
2386                 'update': 'market_fallback',
2387                 'order': 'order',
2388                 'compute_value': None,
2389                 'new_order': 'new_order'
2390                 })
2391
2392         add_log.reset_mock()
2393         print_log.reset_mock()
2394         with self.subTest(update="market_adjusting"):
2395             report_store.log_order(order_mock, 17,
2396                     update="market_adjust", new_order=new_order_mock)
2397             print_log.assert_called_once_with("[Order] Order Mock, tick 17, market value, cancelling and adjusting to New order Mock")
2398             add_log.assert_called_once_with({
2399                 'type': 'order',
2400                 'tick': 17,
2401                 'update': 'market_adjust',
2402                 'order': 'order',
2403                 'compute_value': None,
2404                 'new_order': 'new_order'
2405                 })
2406
2407     @mock.patch.object(market.ReportStore, "print_log")
2408     @mock.patch.object(market.ReportStore, "add_log")
2409     def test_log_move_balances(self, add_log, print_log):
2410         report_store = market.ReportStore(self.m)
2411         needed = {
2412                 "BTC": portfolio.Amount("BTC", 10),
2413                 "USDT": 1
2414                 }
2415         moving = {
2416                 "BTC": portfolio.Amount("BTC", 3),
2417                 "USDT": -2
2418                 }
2419         report_store.log_move_balances(needed, moving)
2420         print_log.assert_not_called()
2421         add_log.assert_called_once_with({
2422             'type': 'move_balances',
2423             'debug': False,
2424             'needed': {
2425                 'BTC': D('10'),
2426                 'USDT': 1
2427                 },
2428             'moving': {
2429                 'BTC': D('3'),
2430                 'USDT': -2
2431                 }
2432             })
2433
2434     @mock.patch.object(market.ReportStore, "print_log")
2435     @mock.patch.object(market.ReportStore, "add_log")
2436     def test_log_http_request(self, add_log, print_log):
2437         report_store = market.ReportStore(self.m)
2438         response = mock.Mock()
2439         response.status_code = 200
2440         response.text = "Hey"
2441
2442         report_store.log_http_request("method", "url", "body",
2443                 "headers", response)
2444         print_log.assert_not_called()
2445         add_log.assert_called_once_with({
2446             'type': 'http_request',
2447             'method': 'method',
2448             'url': 'url',
2449             'body': 'body',
2450             'headers': 'headers',
2451             'status': 200,
2452             'response': 'Hey'
2453             })
2454
2455     @mock.patch.object(market.ReportStore, "print_log")
2456     @mock.patch.object(market.ReportStore, "add_log")
2457     def test_log_error(self, add_log, print_log):
2458         report_store = market.ReportStore(self.m)
2459         with self.subTest(message=None, exception=None):
2460             report_store.log_error("action")
2461             print_log.assert_called_once_with("[Error] action")
2462             add_log.assert_called_once_with({
2463                 'type': 'error',
2464                 'action': 'action',
2465                 'exception_class': None,
2466                 'exception_message': None,
2467                 'message': None
2468                 })
2469
2470         print_log.reset_mock()
2471         add_log.reset_mock()
2472         with self.subTest(message="Hey", exception=None):
2473             report_store.log_error("action", message="Hey")
2474             print_log.assert_has_calls([
2475                     mock.call("[Error] action"),
2476                     mock.call("\tHey")
2477                     ])
2478             add_log.assert_called_once_with({
2479                 'type': 'error',
2480                 'action': 'action',
2481                 'exception_class': None,
2482                 'exception_message': None,
2483                 'message': "Hey"
2484                 })
2485
2486         print_log.reset_mock()
2487         add_log.reset_mock()
2488         with self.subTest(message=None, exception=Exception("bouh")):
2489             report_store.log_error("action", exception=Exception("bouh"))
2490             print_log.assert_has_calls([
2491                     mock.call("[Error] action"),
2492                     mock.call("\tException: bouh")
2493                     ])
2494             add_log.assert_called_once_with({
2495                 'type': 'error',
2496                 'action': 'action',
2497                 'exception_class': "Exception",
2498                 'exception_message': "bouh",
2499                 'message': None
2500                 })
2501
2502         print_log.reset_mock()
2503         add_log.reset_mock()
2504         with self.subTest(message="Hey", exception=Exception("bouh")):
2505             report_store.log_error("action", message="Hey", exception=Exception("bouh"))
2506             print_log.assert_has_calls([
2507                     mock.call("[Error] action"),
2508                     mock.call("\tException: bouh"),
2509                     mock.call("\tHey")
2510                     ])
2511             add_log.assert_called_once_with({
2512                 'type': 'error',
2513                 'action': 'action',
2514                 'exception_class': "Exception",
2515                 'exception_message': "bouh",
2516                 'message': "Hey"
2517                 })
2518
2519     @mock.patch.object(market.ReportStore, "print_log")
2520     @mock.patch.object(market.ReportStore, "add_log")
2521     def test_log_debug_action(self, add_log, print_log):
2522         report_store = market.ReportStore(self.m)
2523         report_store.log_debug_action("Hey")
2524
2525         print_log.assert_called_once_with("[Debug] Hey")
2526         add_log.assert_called_once_with({
2527             'type': 'debug_action',
2528             'action': 'Hey'
2529             })
2530
2531 @unittest.skipUnless("unit" in limits, "Unit skipped")
2532 class HelperTest(WebMockTestCase):
2533     def test_main_store_report(self):
2534         file_open = mock.mock_open()
2535         with self.subTest(file=None), mock.patch("__main__.open", file_open):
2536             helper.main_store_report(None, 1, self.m)
2537             file_open.assert_not_called()
2538
2539         file_open = mock.mock_open()
2540         with self.subTest(file="present"), mock.patch("helper.open", file_open),\
2541                 mock.patch.object(helper, "datetime") as time_mock:
2542             time_mock.now.return_value = datetime.datetime(2018, 2, 25)
2543             self.m.report.to_json.return_value = "json_content"
2544
2545             helper.main_store_report("present", 1, self.m)
2546
2547             file_open.assert_any_call("present/2018-02-25T00:00:00_1.json", "w")
2548             file_open().write.assert_called_once_with("json_content")
2549             self.m.report.to_json.assert_called_once_with()
2550
2551         with self.subTest(file="error"),\
2552                 mock.patch("helper.open") as file_open,\
2553                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
2554             file_open.side_effect = FileNotFoundError
2555
2556             helper.main_store_report("error", 1, self.m)
2557
2558             self.assertRegex(stdout_mock.getvalue(), "impossible to store report file: FileNotFoundError;")
2559
2560     @mock.patch("helper.process_sell_all__1_all_sell")
2561     @mock.patch("helper.process_sell_all__2_all_buy")
2562     @mock.patch("portfolio.Portfolio.wait_for_recent")
2563     def test_main_process_market(self, wait, buy, sell):
2564         with self.subTest(before=False, after=False):
2565             helper.main_process_market("user", None)
2566
2567             wait.assert_not_called()
2568             buy.assert_not_called()
2569             sell.assert_not_called()
2570
2571         buy.reset_mock()
2572         wait.reset_mock()
2573         sell.reset_mock()
2574         with self.subTest(before=True, after=False):
2575             helper.main_process_market("user", None, before=True)
2576
2577             wait.assert_not_called()
2578             buy.assert_not_called()
2579             sell.assert_called_once_with("user")
2580
2581         buy.reset_mock()
2582         wait.reset_mock()
2583         sell.reset_mock()
2584         with self.subTest(before=False, after=True):
2585             helper.main_process_market("user", None, after=True)
2586
2587             wait.assert_called_once_with("user")
2588             buy.assert_called_once_with("user")
2589             sell.assert_not_called()
2590
2591         buy.reset_mock()
2592         wait.reset_mock()
2593         sell.reset_mock()
2594         with self.subTest(before=True, after=True):
2595             helper.main_process_market("user", None, before=True, after=True)
2596
2597             wait.assert_called_once_with("user")
2598             buy.assert_called_once_with("user")
2599             sell.assert_called_once_with("user")
2600
2601         buy.reset_mock()
2602         wait.reset_mock()
2603         sell.reset_mock()
2604         with self.subTest(action="print_balances"),\
2605                 mock.patch("helper.print_balances") as print_balances:
2606             helper.main_process_market("user", "print_balances")
2607
2608             buy.assert_not_called()
2609             wait.assert_not_called()
2610             sell.assert_not_called()
2611             print_balances.assert_called_once_with("user")
2612
2613         with self.subTest(action="print_orders"),\
2614                 mock.patch("helper.print_orders") as print_orders:
2615             helper.main_process_market("user", "print_orders")
2616
2617             buy.assert_not_called()
2618             wait.assert_not_called()
2619             sell.assert_not_called()
2620             print_orders.assert_called_once_with("user")
2621
2622         with self.subTest(action="unknown"),\
2623                 self.assertRaises(NotImplementedError):
2624             helper.main_process_market("user", "unknown")
2625
2626     @mock.patch.object(helper, "psycopg2")
2627     def test_fetch_markets(self, psycopg2):
2628         connect_mock = mock.Mock()
2629         cursor_mock = mock.MagicMock()
2630         cursor_mock.__iter__.return_value = ["row_1", "row_2"]
2631
2632         connect_mock.cursor.return_value = cursor_mock
2633         psycopg2.connect.return_value = connect_mock
2634
2635         with self.subTest(user=None):
2636             rows = list(helper.main_fetch_markets({"foo": "bar"}, None))
2637
2638             psycopg2.connect.assert_called_once_with(foo="bar")
2639             cursor_mock.execute.assert_called_once_with("SELECT config,user_id FROM market_configs")
2640
2641             self.assertEqual(["row_1", "row_2"], rows)
2642
2643         psycopg2.connect.reset_mock()
2644         cursor_mock.execute.reset_mock()
2645         with self.subTest(user=1):
2646             rows = list(helper.main_fetch_markets({"foo": "bar"}, 1))
2647
2648             psycopg2.connect.assert_called_once_with(foo="bar")
2649             cursor_mock.execute.assert_called_once_with("SELECT config,user_id FROM market_configs WHERE user_id = %s", 1)
2650
2651             self.assertEqual(["row_1", "row_2"], rows)
2652
2653     @mock.patch.object(helper.sys, "exit")
2654     def test_main_parse_args(self, exit):
2655         with self.subTest(config="config.ini"):
2656             args = helper.main_parse_args([])
2657             self.assertEqual("config.ini", args.config)
2658             self.assertFalse(args.before)
2659             self.assertFalse(args.after)
2660             self.assertFalse(args.debug)
2661
2662             args = helper.main_parse_args(["--before", "--after", "--debug"])
2663             self.assertTrue(args.before)
2664             self.assertTrue(args.after)
2665             self.assertTrue(args.debug)
2666
2667             exit.assert_not_called()
2668
2669         with self.subTest(config="inexistant"),\
2670                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
2671             args = helper.main_parse_args(["--config", "foo.bar"])
2672             exit.assert_called_once_with(1)
2673             self.assertEqual("no config file found, exiting\n", stdout_mock.getvalue())
2674
2675     @mock.patch.object(helper.sys, "exit")
2676     @mock.patch("helper.configparser")
2677     @mock.patch("helper.os")
2678     def test_main_parse_config(self, os, configparser, exit):
2679         with self.subTest(pg_config=True, report_path=None):
2680             config_mock = mock.MagicMock()
2681             configparser.ConfigParser.return_value = config_mock
2682             def config(element):
2683                 return element == "postgresql"
2684
2685             config_mock.__contains__.side_effect = config
2686             config_mock.__getitem__.return_value = "pg_config"
2687
2688             result = helper.main_parse_config("configfile")
2689
2690             config_mock.read.assert_called_with("configfile")
2691
2692             self.assertEqual(["pg_config", None], result)
2693
2694         with self.subTest(pg_config=True, report_path="present"):
2695             config_mock = mock.MagicMock()
2696             configparser.ConfigParser.return_value = config_mock
2697
2698             config_mock.__contains__.return_value = True
2699             config_mock.__getitem__.side_effect = [
2700                     {"report_path": "report_path"},
2701                     {"report_path": "report_path"},
2702                     "pg_config",
2703                     ]
2704
2705             os.path.exists.return_value = False
2706             result = helper.main_parse_config("configfile")
2707
2708             config_mock.read.assert_called_with("configfile")
2709             self.assertEqual(["pg_config", "report_path"], result)
2710             os.path.exists.assert_called_once_with("report_path")
2711             os.makedirs.assert_called_once_with("report_path")
2712
2713         with self.subTest(pg_config=False),\
2714                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
2715             config_mock = mock.MagicMock()
2716             configparser.ConfigParser.return_value = config_mock
2717             result = helper.main_parse_config("configfile")
2718
2719             config_mock.read.assert_called_with("configfile")
2720             exit.assert_called_once_with(1)
2721             self.assertEqual("no configuration for postgresql in config file\n", stdout_mock.getvalue())
2722
2723
2724     def test_print_orders(self):
2725         helper.print_orders(self.m)
2726
2727         self.m.report.log_stage.assert_called_with("print_orders")
2728         self.m.balances.fetch_balances.assert_called_with(tag="print_orders")
2729         self.m.prepare_trades.assert_called_with(base_currency="BTC",
2730                 compute_value="average")
2731         self.m.trades.prepare_orders.assert_called_with(compute_value="average")
2732
2733     def test_print_balances(self):
2734         self.m.balances.in_currency.return_value = {
2735                 "BTC": portfolio.Amount("BTC", "0.65"),
2736                 "ETH": portfolio.Amount("BTC", "0.3"),
2737         }
2738
2739         helper.print_balances(self.m)
2740
2741         self.m.balances.fetch_balances.assert_called_with()
2742         self.m.report.print_log.assert_has_calls([
2743             mock.call("total:"),
2744             mock.call(portfolio.Amount("BTC", "0.95")),
2745             ])
2746
2747     def test_process_sell_needed__1_sell(self):
2748         helper.process_sell_needed__1_sell(self.m)
2749
2750         self.m.balances.fetch_balances.assert_has_calls([
2751             mock.call(tag="process_sell_needed__1_sell_begin"),
2752             mock.call(tag="process_sell_needed__1_sell_end"),
2753             ])
2754         self.m.prepare_trades.assert_called_with(base_currency="BTC",
2755                 liquidity="medium")
2756         self.m.trades.prepare_orders.assert_called_with(compute_value="average",
2757                 only="dispose")
2758         self.m.trades.run_orders.assert_called()
2759         self.m.follow_orders.assert_called()
2760         self.m.report.log_stage.assert_has_calls([
2761             mock.call("process_sell_needed__1_sell_begin"),
2762             mock.call("process_sell_needed__1_sell_end")
2763             ])
2764
2765     def test_process_sell_needed__2_buy(self):
2766         helper.process_sell_needed__2_buy(self.m)
2767
2768         self.m.balances.fetch_balances.assert_has_calls([
2769             mock.call(tag="process_sell_needed__2_buy_begin"),
2770             mock.call(tag="process_sell_needed__2_buy_end"),
2771             ])
2772         self.m.update_trades.assert_called_with(base_currency="BTC",
2773                 liquidity="medium", only="acquire")
2774         self.m.trades.prepare_orders.assert_called_with(compute_value="average",
2775                 only="acquire")
2776         self.m.move_balances.assert_called_with()
2777         self.m.trades.run_orders.assert_called()
2778         self.m.follow_orders.assert_called()
2779         self.m.report.log_stage.assert_has_calls([
2780             mock.call("process_sell_needed__2_buy_begin"),
2781             mock.call("process_sell_needed__2_buy_end")
2782             ])
2783
2784     def test_process_sell_all__1_sell(self):
2785         helper.process_sell_all__1_all_sell(self.m)
2786
2787         self.m.balances.fetch_balances.assert_has_calls([
2788             mock.call(tag="process_sell_all__1_all_sell_begin"),
2789             mock.call(tag="process_sell_all__1_all_sell_end"),
2790             ])
2791         self.m.prepare_trades_to_sell_all.assert_called_with(base_currency="BTC")
2792         self.m.trades.prepare_orders.assert_called_with(compute_value="average")
2793         self.m.trades.run_orders.assert_called()
2794         self.m.follow_orders.assert_called()
2795         self.m.report.log_stage.assert_has_calls([
2796             mock.call("process_sell_all__1_all_sell_begin"),
2797             mock.call("process_sell_all__1_all_sell_end")
2798             ])
2799
2800     def test_process_sell_all__2_all_buy(self):
2801         helper.process_sell_all__2_all_buy(self.m)
2802
2803         self.m.balances.fetch_balances.assert_has_calls([
2804             mock.call(tag="process_sell_all__2_all_buy_begin"),
2805             mock.call(tag="process_sell_all__2_all_buy_end"),
2806             ])
2807         self.m.prepare_trades.assert_called_with(base_currency="BTC",
2808                 liquidity="medium")
2809         self.m.trades.prepare_orders.assert_called_with(compute_value="average")
2810         self.m.move_balances.assert_called_with()
2811         self.m.trades.run_orders.assert_called()
2812         self.m.follow_orders.assert_called()
2813         self.m.report.log_stage.assert_has_calls([
2814             mock.call("process_sell_all__2_all_buy_begin"),
2815             mock.call("process_sell_all__2_all_buy_end")
2816             ])
2817
2818 @unittest.skipUnless("acceptance" in limits, "Acceptance skipped")
2819 class AcceptanceTest(WebMockTestCase):
2820     @unittest.expectedFailure
2821     def test_success_sell_only_necessary(self):
2822         # FIXME: catch stdout
2823         self.m.report.verbose_print = False
2824         fetch_balance = {
2825                 "ETH": {
2826                     "exchange_free": D("1.0"),
2827                     "exchange_used": D("0.0"),
2828                     "exchange_total": D("1.0"),
2829                     "total": D("1.0"),
2830                     },
2831                 "ETC": {
2832                     "exchange_free": D("4.0"),
2833                     "exchange_used": D("0.0"),
2834                     "exchange_total": D("4.0"),
2835                     "total": D("4.0"),
2836                     },
2837                 "XVG": {
2838                     "exchange_free": D("1000.0"),
2839                     "exchange_used": D("0.0"),
2840                     "exchange_total": D("1000.0"),
2841                     "total": D("1000.0"),
2842                     },
2843                 }
2844         repartition = {
2845                 "ETH":  (D("0.25"), "long"),
2846                 "ETC":  (D("0.25"), "long"),
2847                 "BTC":  (D("0.4"),  "long"),
2848                 "BTD":  (D("0.01"), "short"),
2849                 "B2X":  (D("0.04"), "long"),
2850                 "USDT": (D("0.05"), "long"),
2851                 }
2852
2853         def fetch_ticker(symbol):
2854             if symbol == "ETH/BTC":
2855                 return {
2856                         "symbol": "ETH/BTC",
2857                         "bid": D("0.14"),
2858                         "ask": D("0.16")
2859                         }
2860             if symbol == "ETC/BTC":
2861                 return {
2862                         "symbol": "ETC/BTC",
2863                         "bid": D("0.002"),
2864                         "ask": D("0.003")
2865                         }
2866             if symbol == "XVG/BTC":
2867                 return {
2868                         "symbol": "XVG/BTC",
2869                         "bid": D("0.00003"),
2870                         "ask": D("0.00005")
2871                         }
2872             if symbol == "BTD/BTC":
2873                 return {
2874                         "symbol": "BTD/BTC",
2875                         "bid": D("0.0008"),
2876                         "ask": D("0.0012")
2877                         }
2878             if symbol == "B2X/BTC":
2879                 return {
2880                         "symbol": "B2X/BTC",
2881                         "bid": D("0.0008"),
2882                         "ask": D("0.0012")
2883                         }
2884             if symbol == "USDT/BTC":
2885                 raise helper.ExchangeError
2886             if symbol == "BTC/USDT":
2887                 return {
2888                         "symbol": "BTC/USDT",
2889                         "bid": D("14000"),
2890                         "ask": D("16000")
2891                         }
2892             self.fail("Shouldn't have been called with {}".format(symbol))
2893
2894         market = mock.Mock()
2895         market.fetch_all_balances.return_value = fetch_balance
2896         market.fetch_ticker.side_effect = fetch_ticker
2897         with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
2898             # Action 1
2899             helper.prepare_trades(market)
2900
2901         balances = portfolio.BalanceStore.all
2902         self.assertEqual(portfolio.Amount("ETH", 1), balances["ETH"].total)
2903         self.assertEqual(portfolio.Amount("ETC", 4), balances["ETC"].total)
2904         self.assertEqual(portfolio.Amount("XVG", 1000), balances["XVG"].total)
2905
2906
2907         trades = portfolio.TradeStore.all
2908         self.assertEqual(portfolio.Amount("BTC", D("0.15")), trades[0].value_from)
2909         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[0].value_to)
2910         self.assertEqual("dispose", trades[0].action)
2911
2912         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[1].value_from)
2913         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[1].value_to)
2914         self.assertEqual("acquire", trades[1].action)
2915
2916         self.assertEqual(portfolio.Amount("BTC", D("0.04")), trades[2].value_from)
2917         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[2].value_to)
2918         self.assertEqual("dispose", trades[2].action)
2919
2920         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[3].value_from)
2921         self.assertEqual(portfolio.Amount("BTC", D("-0.002")), trades[3].value_to)
2922         self.assertEqual("acquire", trades[3].action)
2923
2924         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[4].value_from)
2925         self.assertEqual(portfolio.Amount("BTC", D("0.008")), trades[4].value_to)
2926         self.assertEqual("acquire", trades[4].action)
2927
2928         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[5].value_from)
2929         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[5].value_to)
2930         self.assertEqual("acquire", trades[5].action)
2931
2932         # Action 2
2933         portfolio.TradeStore.prepare_orders(only="dispose", compute_value=lambda x, y: x["bid"] * D("1.001"))
2934
2935         all_orders = portfolio.TradeStore.all_orders(state="pending")
2936         self.assertEqual(2, len(all_orders))
2937         self.assertEqual(2, 3*all_orders[0].amount.value)
2938         self.assertEqual(D("0.14014"), all_orders[0].rate)
2939         self.assertEqual(1000, all_orders[1].amount.value)
2940         self.assertEqual(D("0.00003003"), all_orders[1].rate)
2941
2942
2943         def create_order(symbol, type, action, amount, price=None, account="exchange"):
2944             self.assertEqual("limit", type)
2945             if symbol == "ETH/BTC":
2946                 self.assertEqual("sell", action)
2947                 self.assertEqual(D('0.66666666'), amount)
2948                 self.assertEqual(D("0.14014"), price)
2949             elif symbol == "XVG/BTC":
2950                 self.assertEqual("sell", action)
2951                 self.assertEqual(1000, amount)
2952                 self.assertEqual(D("0.00003003"), price)
2953             else:
2954                 self.fail("I shouldn't have been called")
2955
2956             return {
2957                     "id": symbol,
2958                     }
2959         market.create_order.side_effect = create_order
2960         market.order_precision.return_value = 8
2961
2962         # Action 3
2963         portfolio.TradeStore.run_orders()
2964
2965         self.assertEqual("open", all_orders[0].status)
2966         self.assertEqual("open", all_orders[1].status)
2967
2968         market.fetch_order.return_value = { "status": "closed", "datetime": "2018-01-20 13:40:00" }
2969         market.privatePostReturnOrderTrades.return_value = [
2970                 {
2971                     "tradeID": 42, "type": "buy", "fee": "0.0015",
2972                     "date": "2017-12-30 12:00:12", "rate": "0.1",
2973                     "amount": "10", "total": "1"
2974                     }
2975                 ]
2976         with mock.patch.object(portfolio.time, "sleep") as sleep:
2977             # Action 4
2978             helper.follow_orders(verbose=False)
2979
2980             sleep.assert_called_with(30)
2981
2982         for order in all_orders:
2983             self.assertEqual("closed", order.status)
2984
2985         fetch_balance = {
2986                 "ETH": {
2987                     "exchange_free": D("1.0") / 3,
2988                     "exchange_used": D("0.0"),
2989                     "exchange_total": D("1.0") / 3,
2990                     "margin_total": 0,
2991                     "total": D("1.0") / 3,
2992                     },
2993                 "BTC": {
2994                     "exchange_free": D("0.134"),
2995                     "exchange_used": D("0.0"),
2996                     "exchange_total": D("0.134"),
2997                     "margin_total": 0,
2998                     "total": D("0.134"),
2999                     },
3000                 "ETC": {
3001                     "exchange_free": D("4.0"),
3002                     "exchange_used": D("0.0"),
3003                     "exchange_total": D("4.0"),
3004                     "margin_total": 0,
3005                     "total": D("4.0"),
3006                     },
3007                 "XVG": {
3008                     "exchange_free": D("0.0"),
3009                     "exchange_used": D("0.0"),
3010                     "exchange_total": D("0.0"),
3011                     "margin_total": 0,
3012                     "total": D("0.0"),
3013                     },
3014                 }
3015         market.fetch_all_balances.return_value = fetch_balance
3016
3017         with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
3018             # Action 5
3019             helper.update_trades(market, only="acquire", compute_value="average")
3020
3021         balances = portfolio.BalanceStore.all
3022         self.assertEqual(portfolio.Amount("ETH", 1 / D("3")), balances["ETH"].total)
3023         self.assertEqual(portfolio.Amount("ETC", 4), balances["ETC"].total)
3024         self.assertEqual(portfolio.Amount("BTC", D("0.134")), balances["BTC"].total)
3025         self.assertEqual(portfolio.Amount("XVG", 0), balances["XVG"].total)
3026
3027
3028         trades = portfolio.TradeStore.all
3029         self.assertEqual(portfolio.Amount("BTC", D("0.15")), trades[0].value_from)
3030         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[0].value_to)
3031         self.assertEqual("dispose", trades[0].action)
3032
3033         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[1].value_from)
3034         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[1].value_to)
3035         self.assertEqual("acquire", trades[1].action)
3036
3037         self.assertNotIn("BTC", trades)
3038
3039         self.assertEqual(portfolio.Amount("BTC", D("0.04")), trades[2].value_from)
3040         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[2].value_to)
3041         self.assertEqual("dispose", trades[2].action)
3042
3043         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[3].value_from)
3044         self.assertEqual(portfolio.Amount("BTC", D("-0.002")), trades[3].value_to)
3045         self.assertEqual("acquire", trades[3].action)
3046
3047         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[4].value_from)
3048         self.assertEqual(portfolio.Amount("BTC", D("0.008")), trades[4].value_to)
3049         self.assertEqual("acquire", trades[4].action)
3050
3051         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[5].value_from)
3052         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[5].value_to)
3053         self.assertEqual("acquire", trades[5].action)
3054
3055         # Action 6
3056         portfolio.TradeStore.prepare_orders(only="acquire", compute_value=lambda x, y: x["ask"])
3057
3058         all_orders = portfolio.TradeStore.all_orders(state="pending")
3059         self.assertEqual(4, len(all_orders))
3060         self.assertEqual(portfolio.Amount("ETC", D("12.83333333")), round(all_orders[0].amount))
3061         self.assertEqual(D("0.003"), all_orders[0].rate)
3062         self.assertEqual("buy", all_orders[0].action)
3063         self.assertEqual("long", all_orders[0].trade_type)
3064
3065         self.assertEqual(portfolio.Amount("BTD", D("1.61666666")), round(all_orders[1].amount))
3066         self.assertEqual(D("0.0012"), all_orders[1].rate)
3067         self.assertEqual("sell", all_orders[1].action)
3068         self.assertEqual("short", all_orders[1].trade_type)
3069
3070         diff = portfolio.Amount("B2X", D("19.4")/3) - all_orders[2].amount
3071         self.assertAlmostEqual(0, diff.value)
3072         self.assertEqual(D("0.0012"), all_orders[2].rate)
3073         self.assertEqual("buy", all_orders[2].action)
3074         self.assertEqual("long", all_orders[2].trade_type)
3075
3076         self.assertEqual(portfolio.Amount("BTC", D("0.0097")), all_orders[3].amount)
3077         self.assertEqual(D("16000"), all_orders[3].rate)
3078         self.assertEqual("sell", all_orders[3].action)
3079         self.assertEqual("long", all_orders[3].trade_type)
3080
3081         # Action 6b
3082         # TODO:
3083         # Move balances to margin
3084
3085         # Action 7
3086         # TODO
3087         # portfolio.TradeStore.run_orders()
3088
3089         with mock.patch.object(portfolio.time, "sleep") as sleep:
3090             # Action 8
3091             helper.follow_orders(verbose=False)
3092
3093             sleep.assert_called_with(30)
3094
3095 if __name__ == '__main__':
3096     unittest.main()