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