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({"key": "key", "secred": "secret"})
 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({"key": "key", "secred": "secret"}, 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.InvalidOrder
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         self.m.ccxt.order_precision.return_value = 8
2084         self.m.ccxt.create_order.reset_mock()
2085         with self.subTest(insufficient_funds=True),\
2086                 mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order:
2087             order = portfolio.Order("buy", portfolio.Amount("ETH", "0.001"),
2088                     D("0.1"), "BTC", "long", self.m, "trade")
2089             self.m.ccxt.create_order.side_effect = [
2090                     portfolio.InsufficientFunds,
2091                     portfolio.InsufficientFunds,
2092                     portfolio.InsufficientFunds,
2093                     { "id": 123 },
2094                     ]
2095             order.run()
2096             self.m.ccxt.create_order.assert_has_calls([
2097                 mock.call('ETH/BTC', 'limit', 'buy', D('0.0010'), account='exchange', price=D('0.1')),
2098                 mock.call('ETH/BTC', 'limit', 'buy', D('0.00099'), account='exchange', price=D('0.1')),
2099                 mock.call('ETH/BTC', 'limit', 'buy', D('0.0009801'), account='exchange', price=D('0.1')),
2100                 mock.call('ETH/BTC', 'limit', 'buy', D('0.00097029'), account='exchange', price=D('0.1')),
2101                 ])
2102             self.assertEqual(4, self.m.ccxt.create_order.call_count)
2103             self.assertEqual(1, len(order.results))
2104             self.assertEqual("open", order.status)
2105             self.assertEqual(4, order.tries)
2106             self.m.report.log_error.assert_called()
2107             self.assertEqual(4, self.m.report.log_error.call_count)
2108
2109         self.m.ccxt.order_precision.return_value = 8
2110         self.m.ccxt.create_order.reset_mock()
2111         self.m.report.log_error.reset_mock()
2112         with self.subTest(insufficient_funds=True),\
2113                 mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order:
2114             order = portfolio.Order("buy", portfolio.Amount("ETH", "0.001"),
2115                     D("0.1"), "BTC", "long", self.m, "trade")
2116             self.m.ccxt.create_order.side_effect = [
2117                     portfolio.InsufficientFunds,
2118                     portfolio.InsufficientFunds,
2119                     portfolio.InsufficientFunds,
2120                     portfolio.InsufficientFunds,
2121                     portfolio.InsufficientFunds,
2122                     ]
2123             order.run()
2124             self.m.ccxt.create_order.assert_has_calls([
2125                 mock.call('ETH/BTC', 'limit', 'buy', D('0.0010'), account='exchange', price=D('0.1')),
2126                 mock.call('ETH/BTC', 'limit', 'buy', D('0.00099'), account='exchange', price=D('0.1')),
2127                 mock.call('ETH/BTC', 'limit', 'buy', D('0.0009801'), account='exchange', price=D('0.1')),
2128                 mock.call('ETH/BTC', 'limit', 'buy', D('0.00097029'), account='exchange', price=D('0.1')),
2129                 mock.call('ETH/BTC', 'limit', 'buy', D('0.00096059'), account='exchange', price=D('0.1')),
2130                 ])
2131             self.assertEqual(5, self.m.ccxt.create_order.call_count)
2132             self.assertEqual(0, len(order.results))
2133             self.assertEqual("error", order.status)
2134             self.assertEqual(5, order.tries)
2135             self.m.report.log_error.assert_called()
2136             self.assertEqual(5, self.m.report.log_error.call_count)
2137             self.m.report.log_error.assert_called_with(mock.ANY, message="Giving up Order(buy long 0.00096060 ETH at 0.1 BTC [pending])", exception=mock.ANY)
2138
2139
2140 @unittest.skipUnless("unit" in limits, "Unit skipped")
2141 class MouvementTest(WebMockTestCase):
2142     def test_values(self):
2143         mouvement = portfolio.Mouvement("ETH", "BTC", {
2144             "tradeID": 42, "type": "buy", "fee": "0.0015",
2145             "date": "2017-12-30 12:00:12", "rate": "0.1",
2146             "amount": "10", "total": "1"
2147             })
2148         self.assertEqual("ETH", mouvement.currency)
2149         self.assertEqual("BTC", mouvement.base_currency)
2150         self.assertEqual(42, mouvement.id)
2151         self.assertEqual("buy", mouvement.action)
2152         self.assertEqual(D("0.0015"), mouvement.fee_rate)
2153         self.assertEqual(portfolio.datetime(2017, 12, 30, 12, 0, 12), mouvement.date)
2154         self.assertEqual(D("0.1"), mouvement.rate)
2155         self.assertEqual(portfolio.Amount("ETH", "10"), mouvement.total)
2156         self.assertEqual(portfolio.Amount("BTC", "1"), mouvement.total_in_base)
2157
2158         mouvement = portfolio.Mouvement("ETH", "BTC", { "foo": "bar" })
2159         self.assertIsNone(mouvement.date)
2160         self.assertIsNone(mouvement.id)
2161         self.assertIsNone(mouvement.action)
2162         self.assertEqual(-1, mouvement.fee_rate)
2163         self.assertEqual(0, mouvement.rate)
2164         self.assertEqual(portfolio.Amount("ETH", 0), mouvement.total)
2165         self.assertEqual(portfolio.Amount("BTC", 0), mouvement.total_in_base)
2166
2167     def test__repr(self):
2168         mouvement = portfolio.Mouvement("ETH", "BTC", {
2169             "tradeID": 42, "type": "buy", "fee": "0.0015",
2170             "date": "2017-12-30 12:00:12", "rate": "0.1",
2171             "amount": "10", "total": "1"
2172             })
2173         self.assertEqual("Mouvement(2017-12-30 12:00:12 ; buy 10.00000000 ETH (1.00000000 BTC) fee: 0.1500%)", repr(mouvement))
2174
2175         mouvement = portfolio.Mouvement("ETH", "BTC", {
2176             "tradeID": 42, "type": "buy",
2177             "date": "garbage", "rate": "0.1",
2178             "amount": "10", "total": "1"
2179             })
2180         self.assertEqual("Mouvement(No date ; buy 10.00000000 ETH (1.00000000 BTC))", repr(mouvement))
2181
2182     def test_as_json(self):
2183         mouvement = portfolio.Mouvement("ETH", "BTC", {
2184             "tradeID": 42, "type": "buy", "fee": "0.0015",
2185             "date": "2017-12-30 12:00:12", "rate": "0.1",
2186             "amount": "10", "total": "1"
2187             })
2188         as_json = mouvement.as_json()
2189
2190         self.assertEqual(D("0.0015"), as_json["fee_rate"])
2191         self.assertEqual(portfolio.datetime(2017, 12, 30, 12, 0, 12), as_json["date"])
2192         self.assertEqual("buy", as_json["action"])
2193         self.assertEqual(D("10"), as_json["total"])
2194         self.assertEqual(D("1"), as_json["total_in_base"])
2195         self.assertEqual("BTC", as_json["base_currency"])
2196         self.assertEqual("ETH", as_json["currency"])
2197
2198 @unittest.skipUnless("unit" in limits, "Unit skipped")
2199 class ReportStoreTest(WebMockTestCase):
2200     def test_add_log(self):
2201         report_store = market.ReportStore(self.m)
2202         report_store.add_log({"foo": "bar"})
2203
2204         self.assertEqual({"foo": "bar", "date": mock.ANY}, report_store.logs[0])
2205
2206     def test_set_verbose(self):
2207         report_store = market.ReportStore(self.m)
2208         with self.subTest(verbose=True):
2209             report_store.set_verbose(True)
2210             self.assertTrue(report_store.verbose_print)
2211
2212         with self.subTest(verbose=False):
2213             report_store.set_verbose(False)
2214             self.assertFalse(report_store.verbose_print)
2215
2216     def test_print_log(self):
2217         report_store = market.ReportStore(self.m)
2218         with self.subTest(verbose=True),\
2219                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
2220             report_store.set_verbose(True)
2221             report_store.print_log("Coucou")
2222             report_store.print_log(portfolio.Amount("BTC", 1))
2223             self.assertEqual(stdout_mock.getvalue(), "Coucou\n1.00000000 BTC\n")
2224
2225         with self.subTest(verbose=False),\
2226                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
2227             report_store.set_verbose(False)
2228             report_store.print_log("Coucou")
2229             report_store.print_log(portfolio.Amount("BTC", 1))
2230             self.assertEqual(stdout_mock.getvalue(), "")
2231
2232     def test_to_json(self):
2233         report_store = market.ReportStore(self.m)
2234         report_store.logs.append({"foo": "bar"})
2235         self.assertEqual('[{"foo": "bar"}]', report_store.to_json())
2236         report_store.logs.append({"date": portfolio.datetime(2018, 2, 24)})
2237         self.assertEqual('[{"foo": "bar"}, {"date": "2018-02-24T00:00:00"}]', report_store.to_json())
2238         report_store.logs.append({"amount": portfolio.Amount("BTC", 1)})
2239         self.assertEqual('[{"foo": "bar"}, {"date": "2018-02-24T00:00:00"}, {"amount": "1.00000000 BTC"}]', report_store.to_json())
2240
2241     @mock.patch.object(market.ReportStore, "print_log")
2242     @mock.patch.object(market.ReportStore, "add_log")
2243     def test_log_stage(self, add_log, print_log):
2244         report_store = market.ReportStore(self.m)
2245         report_store.log_stage("foo")
2246         print_log.assert_has_calls([
2247             mock.call("-----------"),
2248             mock.call("[Stage] foo"),
2249             ])
2250         add_log.assert_called_once_with({'type': 'stage', 'stage': 'foo'})
2251
2252     @mock.patch.object(market.ReportStore, "print_log")
2253     @mock.patch.object(market.ReportStore, "add_log")
2254     def test_log_balances(self, add_log, print_log):
2255         report_store = market.ReportStore(self.m)
2256         self.m.balances.as_json.return_value = "json"
2257         self.m.balances.all = { "FOO": "bar", "BAR": "baz" }
2258
2259         report_store.log_balances(tag="tag")
2260         print_log.assert_has_calls([
2261             mock.call("[Balance]"),
2262             mock.call("\tbar"),
2263             mock.call("\tbaz"),
2264             ])
2265         add_log.assert_called_once_with({
2266             'type': 'balance',
2267             'balances': 'json',
2268             'tag': 'tag'
2269             })
2270
2271     @mock.patch.object(market.ReportStore, "print_log")
2272     @mock.patch.object(market.ReportStore, "add_log")
2273     def test_log_tickers(self, add_log, print_log):
2274         report_store = market.ReportStore(self.m)
2275         amounts = {
2276                 "BTC": portfolio.Amount("BTC", 10),
2277                 "ETH": portfolio.Amount("BTC", D("0.3"))
2278                 }
2279         amounts["ETH"].rate = D("0.1")
2280
2281         report_store.log_tickers(amounts, "BTC", "default", "total")
2282         print_log.assert_not_called()
2283         add_log.assert_called_once_with({
2284             'type': 'tickers',
2285             'compute_value': 'default',
2286             'balance_type': 'total',
2287             'currency': 'BTC',
2288             'balances': {
2289                 'BTC': D('10'),
2290                 'ETH': D('0.3')
2291                 },
2292             'rates': {
2293                 'BTC': None,
2294                 'ETH': D('0.1')
2295                 },
2296             'total': D('10.3')
2297             })
2298
2299     @mock.patch.object(market.ReportStore, "print_log")
2300     @mock.patch.object(market.ReportStore, "add_log")
2301     def test_log_dispatch(self, add_log, print_log):
2302         report_store = market.ReportStore(self.m)
2303         amount = portfolio.Amount("BTC", "10.3")
2304         amounts = {
2305                 "BTC": portfolio.Amount("BTC", 10),
2306                 "ETH": portfolio.Amount("BTC", D("0.3"))
2307                 }
2308         report_store.log_dispatch(amount, amounts, "medium", "repartition")
2309         print_log.assert_not_called()
2310         add_log.assert_called_once_with({
2311             'type': 'dispatch',
2312             'liquidity': 'medium',
2313             'repartition_ratio': 'repartition',
2314             'total_amount': {
2315                 'currency': 'BTC',
2316                 'value': D('10.3')
2317                 },
2318             'repartition': {
2319                 'BTC': D('10'),
2320                 'ETH': D('0.3')
2321                 }
2322             })
2323
2324     @mock.patch.object(market.ReportStore, "print_log")
2325     @mock.patch.object(market.ReportStore, "add_log")
2326     def test_log_trades(self, add_log, print_log):
2327         report_store = market.ReportStore(self.m)
2328         trade_mock1 = mock.Mock()
2329         trade_mock2 = mock.Mock()
2330         trade_mock1.as_json.return_value = { "trade": "1" }
2331         trade_mock2.as_json.return_value = { "trade": "2" }
2332
2333         matching_and_trades = [
2334                 (True, trade_mock1),
2335                 (False, trade_mock2),
2336                 ]
2337         report_store.log_trades(matching_and_trades, "only")
2338
2339         print_log.assert_not_called()
2340         add_log.assert_called_with({
2341             'type': 'trades',
2342             'only': 'only',
2343             'debug': False,
2344             'trades': [
2345                 {'trade': '1', 'skipped': False},
2346                 {'trade': '2', 'skipped': True}
2347                 ]
2348             })
2349
2350     @mock.patch.object(market.ReportStore, "print_log")
2351     @mock.patch.object(market.ReportStore, "add_log")
2352     def test_log_orders(self, add_log, print_log):
2353         report_store = market.ReportStore(self.m)
2354
2355         order_mock1 = mock.Mock()
2356         order_mock2 = mock.Mock()
2357
2358         order_mock1.as_json.return_value = "order1"
2359         order_mock2.as_json.return_value = "order2"
2360
2361         orders = [order_mock1, order_mock2]
2362
2363         report_store.log_orders(orders, tick="tick",
2364                 only="only", compute_value="compute_value")
2365
2366         print_log.assert_called_once_with("[Orders]")
2367         self.m.trades.print_all_with_order.assert_called_once_with(ind="\t")
2368
2369         add_log.assert_called_with({
2370             'type': 'orders',
2371             'only': 'only',
2372             'compute_value': 'compute_value',
2373             'tick': 'tick',
2374             'orders': ['order1', 'order2']
2375             })
2376
2377     @mock.patch.object(market.ReportStore, "print_log")
2378     @mock.patch.object(market.ReportStore, "add_log")
2379     def test_log_order(self, add_log, print_log):
2380         report_store = market.ReportStore(self.m)
2381         order_mock = mock.Mock()
2382         order_mock.as_json.return_value = "order"
2383         new_order_mock = mock.Mock()
2384         new_order_mock.as_json.return_value = "new_order"
2385         order_mock.__repr__ = mock.Mock()
2386         order_mock.__repr__.return_value = "Order Mock"
2387         new_order_mock.__repr__ = mock.Mock()
2388         new_order_mock.__repr__.return_value = "New order Mock"
2389
2390         with self.subTest(finished=True):
2391             report_store.log_order(order_mock, 1, finished=True)
2392             print_log.assert_called_once_with("[Order] Finished Order Mock")
2393             add_log.assert_called_once_with({
2394                 'type': 'order',
2395                 'tick': 1,
2396                 'update': None,
2397                 'order': 'order',
2398                 'compute_value': None,
2399                 'new_order': None
2400                 })
2401
2402         add_log.reset_mock()
2403         print_log.reset_mock()
2404
2405         with self.subTest(update="waiting"):
2406             report_store.log_order(order_mock, 1, update="waiting")
2407             print_log.assert_called_once_with("[Order] Order Mock, tick 1, waiting")
2408             add_log.assert_called_once_with({
2409                 'type': 'order',
2410                 'tick': 1,
2411                 'update': 'waiting',
2412                 'order': 'order',
2413                 'compute_value': None,
2414                 'new_order': None
2415                 })
2416
2417         add_log.reset_mock()
2418         print_log.reset_mock()
2419         with self.subTest(update="adjusting"):
2420             report_store.log_order(order_mock, 3,
2421                     update="adjusting", new_order=new_order_mock,
2422                     compute_value="default")
2423             print_log.assert_called_once_with("[Order] Order Mock, tick 3, cancelling and adjusting to New order Mock")
2424             add_log.assert_called_once_with({
2425                 'type': 'order',
2426                 'tick': 3,
2427                 'update': 'adjusting',
2428                 'order': 'order',
2429                 'compute_value': "default",
2430                 'new_order': 'new_order'
2431                 })
2432
2433         add_log.reset_mock()
2434         print_log.reset_mock()
2435         with self.subTest(update="market_fallback"):
2436             report_store.log_order(order_mock, 7,
2437                     update="market_fallback", new_order=new_order_mock)
2438             print_log.assert_called_once_with("[Order] Order Mock, tick 7, fallbacking to market value")
2439             add_log.assert_called_once_with({
2440                 'type': 'order',
2441                 'tick': 7,
2442                 'update': 'market_fallback',
2443                 'order': 'order',
2444                 'compute_value': None,
2445                 'new_order': 'new_order'
2446                 })
2447
2448         add_log.reset_mock()
2449         print_log.reset_mock()
2450         with self.subTest(update="market_adjusting"):
2451             report_store.log_order(order_mock, 17,
2452                     update="market_adjust", new_order=new_order_mock)
2453             print_log.assert_called_once_with("[Order] Order Mock, tick 17, market value, cancelling and adjusting to New order Mock")
2454             add_log.assert_called_once_with({
2455                 'type': 'order',
2456                 'tick': 17,
2457                 'update': 'market_adjust',
2458                 'order': 'order',
2459                 'compute_value': None,
2460                 'new_order': 'new_order'
2461                 })
2462
2463     @mock.patch.object(market.ReportStore, "print_log")
2464     @mock.patch.object(market.ReportStore, "add_log")
2465     def test_log_move_balances(self, add_log, print_log):
2466         report_store = market.ReportStore(self.m)
2467         needed = {
2468                 "BTC": portfolio.Amount("BTC", 10),
2469                 "USDT": 1
2470                 }
2471         moving = {
2472                 "BTC": portfolio.Amount("BTC", 3),
2473                 "USDT": -2
2474                 }
2475         report_store.log_move_balances(needed, moving)
2476         print_log.assert_not_called()
2477         add_log.assert_called_once_with({
2478             'type': 'move_balances',
2479             'debug': False,
2480             'needed': {
2481                 'BTC': D('10'),
2482                 'USDT': 1
2483                 },
2484             'moving': {
2485                 'BTC': D('3'),
2486                 'USDT': -2
2487                 }
2488             })
2489
2490     @mock.patch.object(market.ReportStore, "print_log")
2491     @mock.patch.object(market.ReportStore, "add_log")
2492     def test_log_http_request(self, add_log, print_log):
2493         report_store = market.ReportStore(self.m)
2494         response = mock.Mock()
2495         response.status_code = 200
2496         response.text = "Hey"
2497
2498         report_store.log_http_request("method", "url", "body",
2499                 "headers", response)
2500         print_log.assert_not_called()
2501         add_log.assert_called_once_with({
2502             'type': 'http_request',
2503             'method': 'method',
2504             'url': 'url',
2505             'body': 'body',
2506             'headers': 'headers',
2507             'status': 200,
2508             'response': 'Hey'
2509             })
2510
2511     @mock.patch.object(market.ReportStore, "print_log")
2512     @mock.patch.object(market.ReportStore, "add_log")
2513     def test_log_error(self, add_log, print_log):
2514         report_store = market.ReportStore(self.m)
2515         with self.subTest(message=None, exception=None):
2516             report_store.log_error("action")
2517             print_log.assert_called_once_with("[Error] action")
2518             add_log.assert_called_once_with({
2519                 'type': 'error',
2520                 'action': 'action',
2521                 'exception_class': None,
2522                 'exception_message': None,
2523                 'message': None
2524                 })
2525
2526         print_log.reset_mock()
2527         add_log.reset_mock()
2528         with self.subTest(message="Hey", exception=None):
2529             report_store.log_error("action", message="Hey")
2530             print_log.assert_has_calls([
2531                     mock.call("[Error] action"),
2532                     mock.call("\tHey")
2533                     ])
2534             add_log.assert_called_once_with({
2535                 'type': 'error',
2536                 'action': 'action',
2537                 'exception_class': None,
2538                 'exception_message': None,
2539                 'message': "Hey"
2540                 })
2541
2542         print_log.reset_mock()
2543         add_log.reset_mock()
2544         with self.subTest(message=None, exception=Exception("bouh")):
2545             report_store.log_error("action", exception=Exception("bouh"))
2546             print_log.assert_has_calls([
2547                     mock.call("[Error] action"),
2548                     mock.call("\tException: bouh")
2549                     ])
2550             add_log.assert_called_once_with({
2551                 'type': 'error',
2552                 'action': 'action',
2553                 'exception_class': "Exception",
2554                 'exception_message': "bouh",
2555                 'message': None
2556                 })
2557
2558         print_log.reset_mock()
2559         add_log.reset_mock()
2560         with self.subTest(message="Hey", exception=Exception("bouh")):
2561             report_store.log_error("action", message="Hey", exception=Exception("bouh"))
2562             print_log.assert_has_calls([
2563                     mock.call("[Error] action"),
2564                     mock.call("\tException: bouh"),
2565                     mock.call("\tHey")
2566                     ])
2567             add_log.assert_called_once_with({
2568                 'type': 'error',
2569                 'action': 'action',
2570                 'exception_class': "Exception",
2571                 'exception_message': "bouh",
2572                 'message': "Hey"
2573                 })
2574
2575     @mock.patch.object(market.ReportStore, "print_log")
2576     @mock.patch.object(market.ReportStore, "add_log")
2577     def test_log_debug_action(self, add_log, print_log):
2578         report_store = market.ReportStore(self.m)
2579         report_store.log_debug_action("Hey")
2580
2581         print_log.assert_called_once_with("[Debug] Hey")
2582         add_log.assert_called_once_with({
2583             'type': 'debug_action',
2584             'action': 'Hey'
2585             })
2586
2587 @unittest.skipUnless("unit" in limits, "Unit skipped")
2588 class HelperTest(WebMockTestCase):
2589     def test_main_store_report(self):
2590         file_open = mock.mock_open()
2591         with self.subTest(file=None), mock.patch("__main__.open", file_open):
2592             helper.main_store_report(None, 1, self.m)
2593             file_open.assert_not_called()
2594
2595         file_open = mock.mock_open()
2596         with self.subTest(file="present"), mock.patch("helper.open", file_open),\
2597                 mock.patch.object(helper, "datetime") as time_mock:
2598             time_mock.now.return_value = datetime.datetime(2018, 2, 25)
2599             self.m.report.to_json.return_value = "json_content"
2600
2601             helper.main_store_report("present", 1, self.m)
2602
2603             file_open.assert_any_call("present/2018-02-25T00:00:00_1.json", "w")
2604             file_open().write.assert_called_once_with("json_content")
2605             self.m.report.to_json.assert_called_once_with()
2606
2607         with self.subTest(file="error"),\
2608                 mock.patch("helper.open") as file_open,\
2609                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
2610             file_open.side_effect = FileNotFoundError
2611
2612             helper.main_store_report("error", 1, self.m)
2613
2614             self.assertRegex(stdout_mock.getvalue(), "impossible to store report file: FileNotFoundError;")
2615
2616     @mock.patch("helper.process_sell_all__1_all_sell")
2617     @mock.patch("helper.process_sell_all__2_all_buy")
2618     @mock.patch("portfolio.Portfolio.wait_for_recent")
2619     def test_main_process_market(self, wait, buy, sell):
2620         with self.subTest(before=False, after=False):
2621             helper.main_process_market("user", None)
2622
2623             wait.assert_not_called()
2624             buy.assert_not_called()
2625             sell.assert_not_called()
2626
2627         buy.reset_mock()
2628         wait.reset_mock()
2629         sell.reset_mock()
2630         with self.subTest(before=True, after=False):
2631             helper.main_process_market("user", None, before=True)
2632
2633             wait.assert_not_called()
2634             buy.assert_not_called()
2635             sell.assert_called_once_with("user")
2636
2637         buy.reset_mock()
2638         wait.reset_mock()
2639         sell.reset_mock()
2640         with self.subTest(before=False, after=True):
2641             helper.main_process_market("user", None, after=True)
2642
2643             wait.assert_called_once_with("user")
2644             buy.assert_called_once_with("user")
2645             sell.assert_not_called()
2646
2647         buy.reset_mock()
2648         wait.reset_mock()
2649         sell.reset_mock()
2650         with self.subTest(before=True, after=True):
2651             helper.main_process_market("user", None, before=True, after=True)
2652
2653             wait.assert_called_once_with("user")
2654             buy.assert_called_once_with("user")
2655             sell.assert_called_once_with("user")
2656
2657         buy.reset_mock()
2658         wait.reset_mock()
2659         sell.reset_mock()
2660         with self.subTest(action="print_balances"),\
2661                 mock.patch("helper.print_balances") as print_balances:
2662             helper.main_process_market("user", "print_balances")
2663
2664             buy.assert_not_called()
2665             wait.assert_not_called()
2666             sell.assert_not_called()
2667             print_balances.assert_called_once_with("user")
2668
2669         with self.subTest(action="print_orders"),\
2670                 mock.patch("helper.print_orders") as print_orders:
2671             helper.main_process_market("user", "print_orders")
2672
2673             buy.assert_not_called()
2674             wait.assert_not_called()
2675             sell.assert_not_called()
2676             print_orders.assert_called_once_with("user")
2677
2678         with self.subTest(action="unknown"),\
2679                 self.assertRaises(NotImplementedError):
2680             helper.main_process_market("user", "unknown")
2681
2682     @mock.patch.object(helper, "psycopg2")
2683     def test_fetch_markets(self, psycopg2):
2684         connect_mock = mock.Mock()
2685         cursor_mock = mock.MagicMock()
2686         cursor_mock.__iter__.return_value = ["row_1", "row_2"]
2687
2688         connect_mock.cursor.return_value = cursor_mock
2689         psycopg2.connect.return_value = connect_mock
2690
2691         with self.subTest(user=None):
2692             rows = list(helper.main_fetch_markets({"foo": "bar"}, None))
2693
2694             psycopg2.connect.assert_called_once_with(foo="bar")
2695             cursor_mock.execute.assert_called_once_with("SELECT config,user_id FROM market_configs")
2696
2697             self.assertEqual(["row_1", "row_2"], rows)
2698
2699         psycopg2.connect.reset_mock()
2700         cursor_mock.execute.reset_mock()
2701         with self.subTest(user=1):
2702             rows = list(helper.main_fetch_markets({"foo": "bar"}, 1))
2703
2704             psycopg2.connect.assert_called_once_with(foo="bar")
2705             cursor_mock.execute.assert_called_once_with("SELECT config,user_id FROM market_configs WHERE user_id = %s", 1)
2706
2707             self.assertEqual(["row_1", "row_2"], rows)
2708
2709     @mock.patch.object(helper.sys, "exit")
2710     def test_main_parse_args(self, exit):
2711         with self.subTest(config="config.ini"):
2712             args = helper.main_parse_args([])
2713             self.assertEqual("config.ini", args.config)
2714             self.assertFalse(args.before)
2715             self.assertFalse(args.after)
2716             self.assertFalse(args.debug)
2717
2718             args = helper.main_parse_args(["--before", "--after", "--debug"])
2719             self.assertTrue(args.before)
2720             self.assertTrue(args.after)
2721             self.assertTrue(args.debug)
2722
2723             exit.assert_not_called()
2724
2725         with self.subTest(config="inexistant"),\
2726                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
2727             args = helper.main_parse_args(["--config", "foo.bar"])
2728             exit.assert_called_once_with(1)
2729             self.assertEqual("no config file found, exiting\n", stdout_mock.getvalue())
2730
2731     @mock.patch.object(helper.sys, "exit")
2732     @mock.patch("helper.configparser")
2733     @mock.patch("helper.os")
2734     def test_main_parse_config(self, os, configparser, exit):
2735         with self.subTest(pg_config=True, report_path=None):
2736             config_mock = mock.MagicMock()
2737             configparser.ConfigParser.return_value = config_mock
2738             def config(element):
2739                 return element == "postgresql"
2740
2741             config_mock.__contains__.side_effect = config
2742             config_mock.__getitem__.return_value = "pg_config"
2743
2744             result = helper.main_parse_config("configfile")
2745
2746             config_mock.read.assert_called_with("configfile")
2747
2748             self.assertEqual(["pg_config", None], result)
2749
2750         with self.subTest(pg_config=True, report_path="present"):
2751             config_mock = mock.MagicMock()
2752             configparser.ConfigParser.return_value = config_mock
2753
2754             config_mock.__contains__.return_value = True
2755             config_mock.__getitem__.side_effect = [
2756                     {"report_path": "report_path"},
2757                     {"report_path": "report_path"},
2758                     "pg_config",
2759                     ]
2760
2761             os.path.exists.return_value = False
2762             result = helper.main_parse_config("configfile")
2763
2764             config_mock.read.assert_called_with("configfile")
2765             self.assertEqual(["pg_config", "report_path"], result)
2766             os.path.exists.assert_called_once_with("report_path")
2767             os.makedirs.assert_called_once_with("report_path")
2768
2769         with self.subTest(pg_config=False),\
2770                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
2771             config_mock = mock.MagicMock()
2772             configparser.ConfigParser.return_value = config_mock
2773             result = helper.main_parse_config("configfile")
2774
2775             config_mock.read.assert_called_with("configfile")
2776             exit.assert_called_once_with(1)
2777             self.assertEqual("no configuration for postgresql in config file\n", stdout_mock.getvalue())
2778
2779
2780     def test_print_orders(self):
2781         helper.print_orders(self.m)
2782
2783         self.m.report.log_stage.assert_called_with("print_orders")
2784         self.m.balances.fetch_balances.assert_called_with(tag="print_orders")
2785         self.m.prepare_trades.assert_called_with(base_currency="BTC",
2786                 compute_value="average")
2787         self.m.trades.prepare_orders.assert_called_with(compute_value="average")
2788
2789     def test_print_balances(self):
2790         self.m.balances.in_currency.return_value = {
2791                 "BTC": portfolio.Amount("BTC", "0.65"),
2792                 "ETH": portfolio.Amount("BTC", "0.3"),
2793         }
2794
2795         helper.print_balances(self.m)
2796
2797         self.m.report.log_stage.assert_called_once_with("print_balances")
2798         self.m.balances.fetch_balances.assert_called_with()
2799         self.m.report.print_log.assert_has_calls([
2800             mock.call("total:"),
2801             mock.call(portfolio.Amount("BTC", "0.95")),
2802             ])
2803
2804     def test_process_sell_needed__1_sell(self):
2805         helper.process_sell_needed__1_sell(self.m)
2806
2807         self.m.balances.fetch_balances.assert_has_calls([
2808             mock.call(tag="process_sell_needed__1_sell_begin"),
2809             mock.call(tag="process_sell_needed__1_sell_end"),
2810             ])
2811         self.m.prepare_trades.assert_called_with(base_currency="BTC",
2812                 liquidity="medium")
2813         self.m.trades.prepare_orders.assert_called_with(compute_value="average",
2814                 only="dispose")
2815         self.m.trades.run_orders.assert_called()
2816         self.m.follow_orders.assert_called()
2817         self.m.report.log_stage.assert_has_calls([
2818             mock.call("process_sell_needed__1_sell_begin"),
2819             mock.call("process_sell_needed__1_sell_end")
2820             ])
2821
2822     def test_process_sell_needed__2_buy(self):
2823         helper.process_sell_needed__2_buy(self.m)
2824
2825         self.m.balances.fetch_balances.assert_has_calls([
2826             mock.call(tag="process_sell_needed__2_buy_begin"),
2827             mock.call(tag="process_sell_needed__2_buy_end"),
2828             ])
2829         self.m.update_trades.assert_called_with(base_currency="BTC",
2830                 liquidity="medium", only="acquire")
2831         self.m.trades.prepare_orders.assert_called_with(compute_value="average",
2832                 only="acquire")
2833         self.m.move_balances.assert_called_with()
2834         self.m.trades.run_orders.assert_called()
2835         self.m.follow_orders.assert_called()
2836         self.m.report.log_stage.assert_has_calls([
2837             mock.call("process_sell_needed__2_buy_begin"),
2838             mock.call("process_sell_needed__2_buy_end")
2839             ])
2840
2841     def test_process_sell_all__1_sell(self):
2842         helper.process_sell_all__1_all_sell(self.m)
2843
2844         self.m.balances.fetch_balances.assert_has_calls([
2845             mock.call(tag="process_sell_all__1_all_sell_begin"),
2846             mock.call(tag="process_sell_all__1_all_sell_end"),
2847             ])
2848         self.m.prepare_trades_to_sell_all.assert_called_with(base_currency="BTC")
2849         self.m.trades.prepare_orders.assert_called_with(compute_value="average")
2850         self.m.trades.run_orders.assert_called()
2851         self.m.follow_orders.assert_called()
2852         self.m.report.log_stage.assert_has_calls([
2853             mock.call("process_sell_all__1_all_sell_begin"),
2854             mock.call("process_sell_all__1_all_sell_end")
2855             ])
2856
2857     def test_process_sell_all__2_all_buy(self):
2858         helper.process_sell_all__2_all_buy(self.m)
2859
2860         self.m.balances.fetch_balances.assert_has_calls([
2861             mock.call(tag="process_sell_all__2_all_buy_begin"),
2862             mock.call(tag="process_sell_all__2_all_buy_end"),
2863             ])
2864         self.m.prepare_trades.assert_called_with(base_currency="BTC",
2865                 liquidity="medium")
2866         self.m.trades.prepare_orders.assert_called_with(compute_value="average")
2867         self.m.move_balances.assert_called_with()
2868         self.m.trades.run_orders.assert_called()
2869         self.m.follow_orders.assert_called()
2870         self.m.report.log_stage.assert_has_calls([
2871             mock.call("process_sell_all__2_all_buy_begin"),
2872             mock.call("process_sell_all__2_all_buy_end")
2873             ])
2874
2875 @unittest.skipUnless("acceptance" in limits, "Acceptance skipped")
2876 class AcceptanceTest(WebMockTestCase):
2877     @unittest.expectedFailure
2878     def test_success_sell_only_necessary(self):
2879         # FIXME: catch stdout
2880         self.m.report.verbose_print = False
2881         fetch_balance = {
2882                 "ETH": {
2883                     "exchange_free": D("1.0"),
2884                     "exchange_used": D("0.0"),
2885                     "exchange_total": D("1.0"),
2886                     "total": D("1.0"),
2887                     },
2888                 "ETC": {
2889                     "exchange_free": D("4.0"),
2890                     "exchange_used": D("0.0"),
2891                     "exchange_total": D("4.0"),
2892                     "total": D("4.0"),
2893                     },
2894                 "XVG": {
2895                     "exchange_free": D("1000.0"),
2896                     "exchange_used": D("0.0"),
2897                     "exchange_total": D("1000.0"),
2898                     "total": D("1000.0"),
2899                     },
2900                 }
2901         repartition = {
2902                 "ETH":  (D("0.25"), "long"),
2903                 "ETC":  (D("0.25"), "long"),
2904                 "BTC":  (D("0.4"),  "long"),
2905                 "BTD":  (D("0.01"), "short"),
2906                 "B2X":  (D("0.04"), "long"),
2907                 "USDT": (D("0.05"), "long"),
2908                 }
2909
2910         def fetch_ticker(symbol):
2911             if symbol == "ETH/BTC":
2912                 return {
2913                         "symbol": "ETH/BTC",
2914                         "bid": D("0.14"),
2915                         "ask": D("0.16")
2916                         }
2917             if symbol == "ETC/BTC":
2918                 return {
2919                         "symbol": "ETC/BTC",
2920                         "bid": D("0.002"),
2921                         "ask": D("0.003")
2922                         }
2923             if symbol == "XVG/BTC":
2924                 return {
2925                         "symbol": "XVG/BTC",
2926                         "bid": D("0.00003"),
2927                         "ask": D("0.00005")
2928                         }
2929             if symbol == "BTD/BTC":
2930                 return {
2931                         "symbol": "BTD/BTC",
2932                         "bid": D("0.0008"),
2933                         "ask": D("0.0012")
2934                         }
2935             if symbol == "B2X/BTC":
2936                 return {
2937                         "symbol": "B2X/BTC",
2938                         "bid": D("0.0008"),
2939                         "ask": D("0.0012")
2940                         }
2941             if symbol == "USDT/BTC":
2942                 raise helper.ExchangeError
2943             if symbol == "BTC/USDT":
2944                 return {
2945                         "symbol": "BTC/USDT",
2946                         "bid": D("14000"),
2947                         "ask": D("16000")
2948                         }
2949             self.fail("Shouldn't have been called with {}".format(symbol))
2950
2951         market = mock.Mock()
2952         market.fetch_all_balances.return_value = fetch_balance
2953         market.fetch_ticker.side_effect = fetch_ticker
2954         with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
2955             # Action 1
2956             helper.prepare_trades(market)
2957
2958         balances = portfolio.BalanceStore.all
2959         self.assertEqual(portfolio.Amount("ETH", 1), balances["ETH"].total)
2960         self.assertEqual(portfolio.Amount("ETC", 4), balances["ETC"].total)
2961         self.assertEqual(portfolio.Amount("XVG", 1000), balances["XVG"].total)
2962
2963
2964         trades = portfolio.TradeStore.all
2965         self.assertEqual(portfolio.Amount("BTC", D("0.15")), trades[0].value_from)
2966         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[0].value_to)
2967         self.assertEqual("dispose", trades[0].action)
2968
2969         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[1].value_from)
2970         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[1].value_to)
2971         self.assertEqual("acquire", trades[1].action)
2972
2973         self.assertEqual(portfolio.Amount("BTC", D("0.04")), trades[2].value_from)
2974         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[2].value_to)
2975         self.assertEqual("dispose", trades[2].action)
2976
2977         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[3].value_from)
2978         self.assertEqual(portfolio.Amount("BTC", D("-0.002")), trades[3].value_to)
2979         self.assertEqual("acquire", trades[3].action)
2980
2981         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[4].value_from)
2982         self.assertEqual(portfolio.Amount("BTC", D("0.008")), trades[4].value_to)
2983         self.assertEqual("acquire", trades[4].action)
2984
2985         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[5].value_from)
2986         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[5].value_to)
2987         self.assertEqual("acquire", trades[5].action)
2988
2989         # Action 2
2990         portfolio.TradeStore.prepare_orders(only="dispose", compute_value=lambda x, y: x["bid"] * D("1.001"))
2991
2992         all_orders = portfolio.TradeStore.all_orders(state="pending")
2993         self.assertEqual(2, len(all_orders))
2994         self.assertEqual(2, 3*all_orders[0].amount.value)
2995         self.assertEqual(D("0.14014"), all_orders[0].rate)
2996         self.assertEqual(1000, all_orders[1].amount.value)
2997         self.assertEqual(D("0.00003003"), all_orders[1].rate)
2998
2999
3000         def create_order(symbol, type, action, amount, price=None, account="exchange"):
3001             self.assertEqual("limit", type)
3002             if symbol == "ETH/BTC":
3003                 self.assertEqual("sell", action)
3004                 self.assertEqual(D('0.66666666'), amount)
3005                 self.assertEqual(D("0.14014"), price)
3006             elif symbol == "XVG/BTC":
3007                 self.assertEqual("sell", action)
3008                 self.assertEqual(1000, amount)
3009                 self.assertEqual(D("0.00003003"), price)
3010             else:
3011                 self.fail("I shouldn't have been called")
3012
3013             return {
3014                     "id": symbol,
3015                     }
3016         market.create_order.side_effect = create_order
3017         market.order_precision.return_value = 8
3018
3019         # Action 3
3020         portfolio.TradeStore.run_orders()
3021
3022         self.assertEqual("open", all_orders[0].status)
3023         self.assertEqual("open", all_orders[1].status)
3024
3025         market.fetch_order.return_value = { "status": "closed", "datetime": "2018-01-20 13:40:00" }
3026         market.privatePostReturnOrderTrades.return_value = [
3027                 {
3028                     "tradeID": 42, "type": "buy", "fee": "0.0015",
3029                     "date": "2017-12-30 12:00:12", "rate": "0.1",
3030                     "amount": "10", "total": "1"
3031                     }
3032                 ]
3033         with mock.patch.object(portfolio.time, "sleep") as sleep:
3034             # Action 4
3035             helper.follow_orders(verbose=False)
3036
3037             sleep.assert_called_with(30)
3038
3039         for order in all_orders:
3040             self.assertEqual("closed", order.status)
3041
3042         fetch_balance = {
3043                 "ETH": {
3044                     "exchange_free": D("1.0") / 3,
3045                     "exchange_used": D("0.0"),
3046                     "exchange_total": D("1.0") / 3,
3047                     "margin_total": 0,
3048                     "total": D("1.0") / 3,
3049                     },
3050                 "BTC": {
3051                     "exchange_free": D("0.134"),
3052                     "exchange_used": D("0.0"),
3053                     "exchange_total": D("0.134"),
3054                     "margin_total": 0,
3055                     "total": D("0.134"),
3056                     },
3057                 "ETC": {
3058                     "exchange_free": D("4.0"),
3059                     "exchange_used": D("0.0"),
3060                     "exchange_total": D("4.0"),
3061                     "margin_total": 0,
3062                     "total": D("4.0"),
3063                     },
3064                 "XVG": {
3065                     "exchange_free": D("0.0"),
3066                     "exchange_used": D("0.0"),
3067                     "exchange_total": D("0.0"),
3068                     "margin_total": 0,
3069                     "total": D("0.0"),
3070                     },
3071                 }
3072         market.fetch_all_balances.return_value = fetch_balance
3073
3074         with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
3075             # Action 5
3076             helper.update_trades(market, only="acquire", compute_value="average")
3077
3078         balances = portfolio.BalanceStore.all
3079         self.assertEqual(portfolio.Amount("ETH", 1 / D("3")), balances["ETH"].total)
3080         self.assertEqual(portfolio.Amount("ETC", 4), balances["ETC"].total)
3081         self.assertEqual(portfolio.Amount("BTC", D("0.134")), balances["BTC"].total)
3082         self.assertEqual(portfolio.Amount("XVG", 0), balances["XVG"].total)
3083
3084
3085         trades = portfolio.TradeStore.all
3086         self.assertEqual(portfolio.Amount("BTC", D("0.15")), trades[0].value_from)
3087         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[0].value_to)
3088         self.assertEqual("dispose", trades[0].action)
3089
3090         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[1].value_from)
3091         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[1].value_to)
3092         self.assertEqual("acquire", trades[1].action)
3093
3094         self.assertNotIn("BTC", trades)
3095
3096         self.assertEqual(portfolio.Amount("BTC", D("0.04")), trades[2].value_from)
3097         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[2].value_to)
3098         self.assertEqual("dispose", trades[2].action)
3099
3100         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[3].value_from)
3101         self.assertEqual(portfolio.Amount("BTC", D("-0.002")), trades[3].value_to)
3102         self.assertEqual("acquire", trades[3].action)
3103
3104         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[4].value_from)
3105         self.assertEqual(portfolio.Amount("BTC", D("0.008")), trades[4].value_to)
3106         self.assertEqual("acquire", trades[4].action)
3107
3108         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[5].value_from)
3109         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[5].value_to)
3110         self.assertEqual("acquire", trades[5].action)
3111
3112         # Action 6
3113         portfolio.TradeStore.prepare_orders(only="acquire", compute_value=lambda x, y: x["ask"])
3114
3115         all_orders = portfolio.TradeStore.all_orders(state="pending")
3116         self.assertEqual(4, len(all_orders))
3117         self.assertEqual(portfolio.Amount("ETC", D("12.83333333")), round(all_orders[0].amount))
3118         self.assertEqual(D("0.003"), all_orders[0].rate)
3119         self.assertEqual("buy", all_orders[0].action)
3120         self.assertEqual("long", all_orders[0].trade_type)
3121
3122         self.assertEqual(portfolio.Amount("BTD", D("1.61666666")), round(all_orders[1].amount))
3123         self.assertEqual(D("0.0012"), all_orders[1].rate)
3124         self.assertEqual("sell", all_orders[1].action)
3125         self.assertEqual("short", all_orders[1].trade_type)
3126
3127         diff = portfolio.Amount("B2X", D("19.4")/3) - all_orders[2].amount
3128         self.assertAlmostEqual(0, diff.value)
3129         self.assertEqual(D("0.0012"), all_orders[2].rate)
3130         self.assertEqual("buy", all_orders[2].action)
3131         self.assertEqual("long", all_orders[2].trade_type)
3132
3133         self.assertEqual(portfolio.Amount("BTC", D("0.0097")), all_orders[3].amount)
3134         self.assertEqual(D("16000"), all_orders[3].rate)
3135         self.assertEqual("sell", all_orders[3].action)
3136         self.assertEqual("long", all_orders[3].trade_type)
3137
3138         # Action 6b
3139         # TODO:
3140         # Move balances to margin
3141
3142         # Action 7
3143         # TODO
3144         # portfolio.TradeStore.run_orders()
3145
3146         with mock.patch.object(portfolio.time, "sleep") as sleep:
3147             # Action 8
3148             helper.follow_orders(verbose=False)
3149
3150             sleep.assert_called_with(30)
3151
3152 if __name__ == '__main__':
3153     unittest.main()