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