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