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_report(self):
1390
1391         file_open = mock.mock_open()
1392         m = market.Market(self.ccxt, self.market_args(), user_id=1)
1393         with self.subTest(file=None),\
1394                 mock.patch.object(m, "report") as report,\
1395                 mock.patch("market.open", file_open):
1396             m.store_report()
1397             report.merge.assert_called_with(store.Portfolio.report)
1398             file_open.assert_not_called()
1399
1400         report.reset_mock()
1401         file_open = mock.mock_open()
1402         m = market.Market(self.ccxt, self.market_args(), report_path="present", user_id=1)
1403         with self.subTest(file="present"),\
1404                 mock.patch("market.open", file_open),\
1405                 mock.patch.object(m, "report") as report,\
1406                 mock.patch.object(market, "datetime") as time_mock:
1407
1408             time_mock.now.return_value = datetime.datetime(2018, 2, 25)
1409             report.print_logs = [[time_mock.now(), "Foo"], [time_mock.now(), "Bar"]]
1410             report.to_json.return_value = "json_content"
1411
1412             m.store_report()
1413
1414             file_open.assert_any_call("present/2018-02-25T00:00:00_1.json", "w")
1415             file_open.assert_any_call("present/2018-02-25T00:00:00_1.log", "w")
1416             file_open().write.assert_any_call("json_content")
1417             file_open().write.assert_any_call("Foo\nBar")
1418             m.report.to_json.assert_called_once_with()
1419             report.merge.assert_called_with(store.Portfolio.report)
1420
1421         report.reset_mock()
1422
1423         m = market.Market(self.ccxt, self.market_args(), report_path="error", user_id=1)
1424         with self.subTest(file="error"),\
1425                 mock.patch("market.open") as file_open,\
1426                 mock.patch.object(m, "report") as report,\
1427                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
1428             file_open.side_effect = FileNotFoundError
1429
1430             m.store_report()
1431
1432             report.merge.assert_called_with(store.Portfolio.report)
1433             self.assertRegex(stdout_mock.getvalue(), "impossible to store report file: FileNotFoundError;")
1434
1435     def test_print_orders(self):
1436         m = market.Market(self.ccxt, self.market_args())
1437         with mock.patch.object(m.report, "log_stage") as log_stage,\
1438                 mock.patch.object(m.balances, "fetch_balances") as fetch_balances,\
1439                 mock.patch.object(m, "prepare_trades") as prepare_trades,\
1440                 mock.patch.object(m.trades, "prepare_orders") as prepare_orders:
1441             m.print_orders()
1442
1443             log_stage.assert_called_with("print_orders")
1444             fetch_balances.assert_called_with(tag="print_orders")
1445             prepare_trades.assert_called_with(base_currency="BTC",
1446                     compute_value="average")
1447             prepare_orders.assert_called_with(compute_value="average")
1448
1449     def test_print_balances(self):
1450         m = market.Market(self.ccxt, self.market_args())
1451
1452         with mock.patch.object(m.balances, "in_currency") as in_currency,\
1453                 mock.patch.object(m.report, "log_stage") as log_stage,\
1454                 mock.patch.object(m.balances, "fetch_balances") as fetch_balances,\
1455                 mock.patch.object(m.report, "print_log") as print_log:
1456
1457             in_currency.return_value = {
1458                     "BTC": portfolio.Amount("BTC", "0.65"),
1459                     "ETH": portfolio.Amount("BTC", "0.3"),
1460                     }
1461
1462             m.print_balances()
1463
1464             log_stage.assert_called_once_with("print_balances")
1465             fetch_balances.assert_called_with()
1466             print_log.assert_has_calls([
1467                 mock.call("total:"),
1468                 mock.call(portfolio.Amount("BTC", "0.95")),
1469                 ])
1470
1471     @mock.patch("market.Processor.process")
1472     @mock.patch("market.ReportStore.log_error")
1473     @mock.patch("market.Market.store_report")
1474     def test_process(self, store_report, log_error, process):
1475         m = market.Market(self.ccxt, self.market_args())
1476         with self.subTest(before=False, after=False):
1477             m.process(None)
1478
1479             process.assert_not_called()
1480             store_report.assert_called_once()
1481             log_error.assert_not_called()
1482
1483         process.reset_mock()
1484         log_error.reset_mock()
1485         store_report.reset_mock()
1486         with self.subTest(before=True, after=False):
1487             m.process(None, before=True)
1488
1489             process.assert_called_once_with("sell_all", steps="before")
1490             store_report.assert_called_once()
1491             log_error.assert_not_called()
1492
1493         process.reset_mock()
1494         log_error.reset_mock()
1495         store_report.reset_mock()
1496         with self.subTest(before=False, after=True):
1497             m.process(None, after=True)
1498
1499             process.assert_called_once_with("sell_all", steps="after")
1500             store_report.assert_called_once()
1501             log_error.assert_not_called()
1502
1503         process.reset_mock()
1504         log_error.reset_mock()
1505         store_report.reset_mock()
1506         with self.subTest(before=True, after=True):
1507             m.process(None, before=True, after=True)
1508
1509             process.assert_has_calls([
1510                 mock.call("sell_all", steps="before"),
1511                 mock.call("sell_all", steps="after"),
1512                 ])
1513             store_report.assert_called_once()
1514             log_error.assert_not_called()
1515
1516         process.reset_mock()
1517         log_error.reset_mock()
1518         store_report.reset_mock()
1519         with self.subTest(action="print_balances"),\
1520                 mock.patch.object(m, "print_balances") as print_balances:
1521             m.process(["print_balances"])
1522
1523             process.assert_not_called()
1524             log_error.assert_not_called()
1525             store_report.assert_called_once()
1526             print_balances.assert_called_once_with()
1527
1528         log_error.reset_mock()
1529         store_report.reset_mock()
1530         with self.subTest(action="print_orders"),\
1531                 mock.patch.object(m, "print_orders") as print_orders,\
1532                 mock.patch.object(m, "print_balances") as print_balances:
1533             m.process(["print_orders", "print_balances"])
1534
1535             process.assert_not_called()
1536             log_error.assert_not_called()
1537             store_report.assert_called_once()
1538             print_orders.assert_called_once_with()
1539             print_balances.assert_called_once_with()
1540
1541         log_error.reset_mock()
1542         store_report.reset_mock()
1543         with self.subTest(action="unknown"):
1544             m.process(["unknown"])
1545             log_error.assert_called_once_with("market_process", message="Unknown action unknown")
1546             store_report.assert_called_once()
1547
1548         log_error.reset_mock()
1549         store_report.reset_mock()
1550         with self.subTest(unhandled_exception=True):
1551             process.side_effect = Exception("bouh")
1552
1553             m.process(None, before=True)
1554             log_error.assert_called_with("market_process", exception=mock.ANY)
1555             store_report.assert_called_once()
1556
1557 @unittest.skipUnless("unit" in limits, "Unit skipped")
1558 class TradeStoreTest(WebMockTestCase):
1559     def test_compute_trades(self):
1560         self.m.balances.currencies.return_value = ["XMR", "DASH", "XVG", "BTC", "ETH"]
1561
1562         values_in_base = {
1563                 "XMR": portfolio.Amount("BTC", D("0.9")),
1564                 "DASH": portfolio.Amount("BTC", D("0.4")),
1565                 "XVG": portfolio.Amount("BTC", D("-0.5")),
1566                 "BTC": portfolio.Amount("BTC", D("0.5")),
1567                 }
1568         new_repartition = {
1569                 "DASH": portfolio.Amount("BTC", D("0.5")),
1570                 "XVG": portfolio.Amount("BTC", D("0.1")),
1571                 "BTC": portfolio.Amount("BTC", D("0.4")),
1572                 "ETH": portfolio.Amount("BTC", D("0.3")),
1573                 }
1574         side_effect = [
1575                 (True, 1),
1576                 (False, 2),
1577                 (False, 3),
1578                 (True, 4),
1579                 (True, 5)
1580                 ]
1581
1582         with mock.patch.object(market.TradeStore, "trade_if_matching") as trade_if_matching:
1583             trade_store = market.TradeStore(self.m)
1584             trade_if_matching.side_effect = side_effect
1585
1586             trade_store.compute_trades(values_in_base,
1587                     new_repartition, only="only")
1588
1589             self.assertEqual(5, trade_if_matching.call_count)
1590             self.assertEqual(3, len(trade_store.all))
1591             self.assertEqual([1, 4, 5], trade_store.all)
1592             self.m.report.log_trades.assert_called_with(side_effect, "only")
1593
1594     def test_trade_if_matching(self):
1595
1596         with self.subTest(only="nope"):
1597             trade_store = market.TradeStore(self.m)
1598             result = trade_store.trade_if_matching(
1599                     portfolio.Amount("BTC", D("0")),
1600                     portfolio.Amount("BTC", D("0.3")),
1601                     "ETH", only="nope")
1602             self.assertEqual(False, result[0])
1603             self.assertIsInstance(result[1], portfolio.Trade)
1604
1605         with self.subTest(only=None):
1606             trade_store = market.TradeStore(self.m)
1607             result = trade_store.trade_if_matching(
1608                     portfolio.Amount("BTC", D("0")),
1609                     portfolio.Amount("BTC", D("0.3")),
1610                     "ETH", only=None)
1611             self.assertEqual(True, result[0])
1612
1613         with self.subTest(only="acquire"):
1614             trade_store = market.TradeStore(self.m)
1615             result = trade_store.trade_if_matching(
1616                     portfolio.Amount("BTC", D("0")),
1617                     portfolio.Amount("BTC", D("0.3")),
1618                     "ETH", only="acquire")
1619             self.assertEqual(True, result[0])
1620
1621         with self.subTest(only="dispose"):
1622             trade_store = market.TradeStore(self.m)
1623             result = trade_store.trade_if_matching(
1624                     portfolio.Amount("BTC", D("0")),
1625                     portfolio.Amount("BTC", D("0.3")),
1626                     "ETH", only="dispose")
1627             self.assertEqual(False, result[0])
1628
1629     def test_prepare_orders(self):
1630         trade_store = market.TradeStore(self.m)
1631
1632         trade_mock1 = mock.Mock()
1633         trade_mock2 = mock.Mock()
1634         trade_mock3 = mock.Mock()
1635
1636         trade_mock1.prepare_order.return_value = 1
1637         trade_mock2.prepare_order.return_value = 2
1638         trade_mock3.prepare_order.return_value = 3
1639
1640         trade_mock1.pending = True
1641         trade_mock2.pending = True
1642         trade_mock3.pending = False
1643
1644         trade_store.all.append(trade_mock1)
1645         trade_store.all.append(trade_mock2)
1646         trade_store.all.append(trade_mock3)
1647
1648         trade_store.prepare_orders()
1649         trade_mock1.prepare_order.assert_called_with(compute_value="default")
1650         trade_mock2.prepare_order.assert_called_with(compute_value="default")
1651         trade_mock3.prepare_order.assert_not_called()
1652         self.m.report.log_orders.assert_called_once_with([1, 2], None, "default")
1653
1654         self.m.report.log_orders.reset_mock()
1655
1656         trade_store.prepare_orders(compute_value="bla")
1657         trade_mock1.prepare_order.assert_called_with(compute_value="bla")
1658         trade_mock2.prepare_order.assert_called_with(compute_value="bla")
1659         self.m.report.log_orders.assert_called_once_with([1, 2], None, "bla")
1660
1661         trade_mock1.prepare_order.reset_mock()
1662         trade_mock2.prepare_order.reset_mock()
1663         self.m.report.log_orders.reset_mock()
1664
1665         trade_mock1.action = "foo"
1666         trade_mock2.action = "bar"
1667         trade_store.prepare_orders(only="bar")
1668         trade_mock1.prepare_order.assert_not_called()
1669         trade_mock2.prepare_order.assert_called_with(compute_value="default")
1670         self.m.report.log_orders.assert_called_once_with([2], "bar", "default")
1671
1672     def test_print_all_with_order(self):
1673         trade_mock1 = mock.Mock()
1674         trade_mock2 = mock.Mock()
1675         trade_mock3 = mock.Mock()
1676         trade_store = market.TradeStore(self.m)
1677         trade_store.all = [trade_mock1, trade_mock2, trade_mock3]
1678
1679         trade_store.print_all_with_order()
1680
1681         trade_mock1.print_with_order.assert_called()
1682         trade_mock2.print_with_order.assert_called()
1683         trade_mock3.print_with_order.assert_called()
1684
1685     def test_run_orders(self):
1686         with mock.patch.object(market.TradeStore, "all_orders") as all_orders:
1687             order_mock1 = mock.Mock()
1688             order_mock2 = mock.Mock()
1689             order_mock3 = mock.Mock()
1690             trade_store = market.TradeStore(self.m)
1691
1692             all_orders.return_value = [order_mock1, order_mock2, order_mock3]
1693
1694             trade_store.run_orders()
1695
1696             all_orders.assert_called_with(state="pending")
1697
1698         order_mock1.run.assert_called()
1699         order_mock2.run.assert_called()
1700         order_mock3.run.assert_called()
1701
1702         self.m.report.log_stage.assert_called_with("run_orders")
1703         self.m.report.log_orders.assert_called_with([order_mock1, order_mock2,
1704             order_mock3])
1705
1706     def test_all_orders(self):
1707         trade_mock1 = mock.Mock()
1708         trade_mock2 = mock.Mock()
1709
1710         order_mock1 = mock.Mock()
1711         order_mock2 = mock.Mock()
1712         order_mock3 = mock.Mock()
1713
1714         trade_mock1.orders = [order_mock1, order_mock2]
1715         trade_mock2.orders = [order_mock3]
1716
1717         order_mock1.status = "pending"
1718         order_mock2.status = "open"
1719         order_mock3.status = "open"
1720
1721         trade_store = market.TradeStore(self.m)
1722         trade_store.all.append(trade_mock1)
1723         trade_store.all.append(trade_mock2)
1724
1725         orders = trade_store.all_orders()
1726         self.assertEqual(3, len(orders))
1727
1728         open_orders = trade_store.all_orders(state="open")
1729         self.assertEqual(2, len(open_orders))
1730         self.assertEqual([order_mock2, order_mock3], open_orders)
1731
1732     def test_update_all_orders_status(self):
1733         with mock.patch.object(market.TradeStore, "all_orders") as all_orders:
1734             order_mock1 = mock.Mock()
1735             order_mock2 = mock.Mock()
1736             order_mock3 = mock.Mock()
1737
1738             all_orders.return_value = [order_mock1, order_mock2, order_mock3]
1739
1740             trade_store = market.TradeStore(self.m)
1741
1742             trade_store.update_all_orders_status()
1743             all_orders.assert_called_with(state="open")
1744
1745             order_mock1.get_status.assert_called()
1746             order_mock2.get_status.assert_called()
1747             order_mock3.get_status.assert_called()
1748
1749     def test_close_trades(self):
1750         trade_mock1 = mock.Mock()
1751         trade_mock2 = mock.Mock()
1752         trade_mock3 = mock.Mock()
1753
1754         trade_store = market.TradeStore(self.m)
1755
1756         trade_store.all.append(trade_mock1)
1757         trade_store.all.append(trade_mock2)
1758         trade_store.all.append(trade_mock3)
1759
1760         trade_store.close_trades()
1761
1762         trade_mock1.close.assert_called_once_with()
1763         trade_mock2.close.assert_called_once_with()
1764         trade_mock3.close.assert_called_once_with()
1765
1766     def test_pending(self):
1767         trade_mock1 = mock.Mock()
1768         trade_mock1.pending = True
1769         trade_mock2 = mock.Mock()
1770         trade_mock2.pending = True
1771         trade_mock3 = mock.Mock()
1772         trade_mock3.pending = False
1773
1774         trade_store = market.TradeStore(self.m)
1775
1776         trade_store.all.append(trade_mock1)
1777         trade_store.all.append(trade_mock2)
1778         trade_store.all.append(trade_mock3)
1779
1780         self.assertEqual([trade_mock1, trade_mock2], trade_store.pending)
1781
1782 @unittest.skipUnless("unit" in limits, "Unit skipped")
1783 class BalanceStoreTest(WebMockTestCase):
1784     def setUp(self):
1785         super(BalanceStoreTest, self).setUp()
1786
1787         self.fetch_balance = {
1788                 "ETC": {
1789                     "exchange_free": 0,
1790                     "exchange_used": 0,
1791                     "exchange_total": 0,
1792                     "margin_total": 0,
1793                     },
1794                 "USDT": {
1795                     "exchange_free": D("6.0"),
1796                     "exchange_used": D("1.2"),
1797                     "exchange_total": D("7.2"),
1798                     "margin_total": 0,
1799                     },
1800                 "XVG": {
1801                     "exchange_free": 16,
1802                     "exchange_used": 0,
1803                     "exchange_total": 16,
1804                     "margin_total": 0,
1805                     },
1806                 "XMR": {
1807                     "exchange_free": 0,
1808                     "exchange_used": 0,
1809                     "exchange_total": 0,
1810                     "margin_total": D("-1.0"),
1811                     "margin_free": 0,
1812                     },
1813                 }
1814
1815     def test_in_currency(self):
1816         self.m.get_ticker.return_value = {
1817                 "bid": D("0.09"),
1818                 "ask": D("0.11"),
1819                 "average": D("0.1"),
1820                 }
1821
1822         balance_store = market.BalanceStore(self.m)
1823         balance_store.all = {
1824                 "BTC": portfolio.Balance("BTC", {
1825                     "total": "0.65",
1826                     "exchange_total":"0.65",
1827                     "exchange_free": "0.35",
1828                     "exchange_used": "0.30"}),
1829                 "ETH": portfolio.Balance("ETH", {
1830                     "total": 3,
1831                     "exchange_total": 3,
1832                     "exchange_free": 3,
1833                     "exchange_used": 0}),
1834                 }
1835
1836         amounts = balance_store.in_currency("BTC")
1837         self.assertEqual("BTC", amounts["ETH"].currency)
1838         self.assertEqual(D("0.65"), amounts["BTC"].value)
1839         self.assertEqual(D("0.30"), amounts["ETH"].value)
1840         self.m.report.log_tickers.assert_called_once_with(amounts, "BTC",
1841                 "average", "total")
1842         self.m.report.log_tickers.reset_mock()
1843
1844         amounts = balance_store.in_currency("BTC", compute_value="bid")
1845         self.assertEqual(D("0.65"), amounts["BTC"].value)
1846         self.assertEqual(D("0.27"), amounts["ETH"].value)
1847         self.m.report.log_tickers.assert_called_once_with(amounts, "BTC",
1848                 "bid", "total")
1849         self.m.report.log_tickers.reset_mock()
1850
1851         amounts = balance_store.in_currency("BTC", compute_value="bid", type="exchange_used")
1852         self.assertEqual(D("0.30"), amounts["BTC"].value)
1853         self.assertEqual(0, amounts["ETH"].value)
1854         self.m.report.log_tickers.assert_called_once_with(amounts, "BTC",
1855                 "bid", "exchange_used")
1856         self.m.report.log_tickers.reset_mock()
1857
1858     def test_fetch_balances(self):
1859         self.m.ccxt.fetch_all_balances.return_value = self.fetch_balance
1860
1861         balance_store = market.BalanceStore(self.m)
1862
1863         balance_store.fetch_balances()
1864         self.assertNotIn("ETC", balance_store.currencies())
1865         self.assertListEqual(["USDT", "XVG", "XMR"], list(balance_store.currencies()))
1866
1867         balance_store.all["ETC"] = portfolio.Balance("ETC", {
1868             "exchange_total": "1", "exchange_free": "0",
1869             "exchange_used": "1" })
1870         balance_store.fetch_balances(tag="foo")
1871         self.assertEqual(0, balance_store.all["ETC"].total)
1872         self.assertListEqual(["USDT", "XVG", "XMR", "ETC"], list(balance_store.currencies()))
1873         self.m.report.log_balances.assert_called_with(tag="foo")
1874
1875     @mock.patch.object(market.Portfolio, "repartition")
1876     def test_dispatch_assets(self, repartition):
1877         self.m.ccxt.fetch_all_balances.return_value = self.fetch_balance
1878
1879         balance_store = market.BalanceStore(self.m)
1880         balance_store.fetch_balances()
1881
1882         self.assertNotIn("XEM", balance_store.currencies())
1883
1884         repartition_hash = {
1885                 "XEM": (D("0.75"), "long"),
1886                 "BTC": (D("0.26"), "long"),
1887                 "DASH": (D("0.10"), "short"),
1888                 }
1889         repartition.return_value = repartition_hash
1890
1891         amounts = balance_store.dispatch_assets(portfolio.Amount("BTC", "11.1"))
1892         repartition.assert_called_with(liquidity="medium")
1893         self.assertIn("XEM", balance_store.currencies())
1894         self.assertEqual(D("2.6"), amounts["BTC"].value)
1895         self.assertEqual(D("7.5"), amounts["XEM"].value)
1896         self.assertEqual(D("-1.0"), amounts["DASH"].value)
1897         self.m.report.log_balances.assert_called_with(tag=None)
1898         self.m.report.log_dispatch.assert_called_once_with(portfolio.Amount("BTC",
1899             "11.1"), amounts, "medium", repartition_hash)
1900
1901     def test_currencies(self):
1902         balance_store = market.BalanceStore(self.m)
1903
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         self.assertListEqual(["BTC", "ETH"], list(balance_store.currencies()))
1917
1918     def test_as_json(self):
1919         balance_mock1 = mock.Mock()
1920         balance_mock1.as_json.return_value = 1
1921
1922         balance_mock2 = mock.Mock()
1923         balance_mock2.as_json.return_value = 2
1924
1925         balance_store = market.BalanceStore(self.m)
1926         balance_store.all = {
1927                 "BTC": balance_mock1,
1928                 "ETH": balance_mock2,
1929                 }
1930
1931         as_json = balance_store.as_json()
1932         self.assertEqual(1, as_json["BTC"])
1933         self.assertEqual(2, as_json["ETH"])
1934
1935
1936 @unittest.skipUnless("unit" in limits, "Unit skipped")
1937 class ComputationTest(WebMockTestCase):
1938     def test_compute_value(self):
1939         compute = mock.Mock()
1940         portfolio.Computation.compute_value("foo", "buy", compute_value=compute)
1941         compute.assert_called_with("foo", "ask")
1942
1943         compute.reset_mock()
1944         portfolio.Computation.compute_value("foo", "sell", compute_value=compute)
1945         compute.assert_called_with("foo", "bid")
1946
1947         compute.reset_mock()
1948         portfolio.Computation.compute_value("foo", "ask", compute_value=compute)
1949         compute.assert_called_with("foo", "ask")
1950
1951         compute.reset_mock()
1952         portfolio.Computation.compute_value("foo", "bid", compute_value=compute)
1953         compute.assert_called_with("foo", "bid")
1954
1955         compute.reset_mock()
1956         portfolio.Computation.computations["test"] = compute
1957         portfolio.Computation.compute_value("foo", "bid", compute_value="test")
1958         compute.assert_called_with("foo", "bid")
1959
1960
1961 @unittest.skipUnless("unit" in limits, "Unit skipped")
1962 class TradeTest(WebMockTestCase):
1963
1964     def test_values_assertion(self):
1965         value_from = portfolio.Amount("BTC", "1.0")
1966         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1967         value_to = portfolio.Amount("BTC", "1.0")
1968         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1969         self.assertEqual("BTC", trade.base_currency)
1970         self.assertEqual("ETH", trade.currency)
1971         self.assertEqual(self.m, trade.market)
1972
1973         with self.assertRaises(AssertionError):
1974             portfolio.Trade(value_from, -value_to, "ETH", self.m)
1975         with self.assertRaises(AssertionError):
1976             portfolio.Trade(value_from, value_to, "ETC", self.m)
1977         with self.assertRaises(AssertionError):
1978             value_from.currency = "ETH"
1979             portfolio.Trade(value_from, value_to, "ETH", self.m)
1980             value_from.currency = "BTC"
1981         with self.assertRaises(AssertionError):
1982             value_from2 = portfolio.Amount("BTC", "1.0")
1983             portfolio.Trade(value_from2, value_to, "ETH", self.m)
1984
1985         value_from = portfolio.Amount("BTC", 0)
1986         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1987         self.assertEqual(0, trade.value_from.linked_to)
1988
1989     def test_action(self):
1990         value_from = portfolio.Amount("BTC", "1.0")
1991         value_from.linked_to = portfolio.Amount("ETH", "10.0")
1992         value_to = portfolio.Amount("BTC", "1.0")
1993         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
1994
1995         self.assertIsNone(trade.action)
1996
1997         value_from = portfolio.Amount("BTC", "1.0")
1998         value_from.linked_to = portfolio.Amount("BTC", "1.0")
1999         value_to = portfolio.Amount("BTC", "2.0")
2000         trade = portfolio.Trade(value_from, value_to, "BTC", self.m)
2001
2002         self.assertIsNone(trade.action)
2003
2004         value_from = portfolio.Amount("BTC", "0.5")
2005         value_from.linked_to = portfolio.Amount("ETH", "10.0")
2006         value_to = portfolio.Amount("BTC", "1.0")
2007         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2008
2009         self.assertEqual("acquire", trade.action)
2010
2011         value_from = portfolio.Amount("BTC", "0")
2012         value_from.linked_to = portfolio.Amount("ETH", "0")
2013         value_to = portfolio.Amount("BTC", "-1.0")
2014         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2015
2016         self.assertEqual("acquire", trade.action)
2017
2018     def test_order_action(self):
2019         value_from = portfolio.Amount("BTC", "0.5")
2020         value_from.linked_to = portfolio.Amount("ETH", "10.0")
2021         value_to = portfolio.Amount("BTC", "1.0")
2022         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2023
2024         trade.inverted = False
2025         self.assertEqual("buy", trade.order_action())
2026         trade.inverted = True
2027         self.assertEqual("sell", trade.order_action())
2028
2029         value_from = portfolio.Amount("BTC", "0")
2030         value_from.linked_to = portfolio.Amount("ETH", "0")
2031         value_to = portfolio.Amount("BTC", "-1.0")
2032         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2033
2034         trade.inverted = False
2035         self.assertEqual("sell", trade.order_action())
2036         trade.inverted = True
2037         self.assertEqual("buy", trade.order_action())
2038
2039     def test_trade_type(self):
2040         value_from = portfolio.Amount("BTC", "0.5")
2041         value_from.linked_to = portfolio.Amount("ETH", "10.0")
2042         value_to = portfolio.Amount("BTC", "1.0")
2043         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2044
2045         self.assertEqual("long", trade.trade_type)
2046
2047         value_from = portfolio.Amount("BTC", "0")
2048         value_from.linked_to = portfolio.Amount("ETH", "0")
2049         value_to = portfolio.Amount("BTC", "-1.0")
2050         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2051
2052         self.assertEqual("short", trade.trade_type)
2053
2054     def test_is_fullfiled(self):
2055         with self.subTest(inverted=False):
2056             value_from = portfolio.Amount("BTC", "0.5")
2057             value_from.linked_to = portfolio.Amount("ETH", "10.0")
2058             value_to = portfolio.Amount("BTC", "1.0")
2059             trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2060
2061             order1 = mock.Mock()
2062             order1.filled_amount.return_value = portfolio.Amount("BTC", "0.3")
2063
2064             order2 = mock.Mock()
2065             order2.filled_amount.return_value = portfolio.Amount("BTC", "0.01")
2066             trade.orders.append(order1)
2067             trade.orders.append(order2)
2068
2069             self.assertFalse(trade.is_fullfiled)
2070
2071             order3 = mock.Mock()
2072             order3.filled_amount.return_value = portfolio.Amount("BTC", "0.19")
2073             trade.orders.append(order3)
2074
2075             self.assertTrue(trade.is_fullfiled)
2076
2077             order1.filled_amount.assert_called_with(in_base_currency=True)
2078             order2.filled_amount.assert_called_with(in_base_currency=True)
2079             order3.filled_amount.assert_called_with(in_base_currency=True)
2080
2081         with self.subTest(inverted=True):
2082             value_from = portfolio.Amount("BTC", "0.5")
2083             value_from.linked_to = portfolio.Amount("USDT", "1000.0")
2084             value_to = portfolio.Amount("BTC", "1.0")
2085             trade = portfolio.Trade(value_from, value_to, "USDT", self.m)
2086             trade.inverted = True
2087
2088             order1 = mock.Mock()
2089             order1.filled_amount.return_value = portfolio.Amount("BTC", "0.3")
2090
2091             order2 = mock.Mock()
2092             order2.filled_amount.return_value = portfolio.Amount("BTC", "0.01")
2093             trade.orders.append(order1)
2094             trade.orders.append(order2)
2095
2096             self.assertFalse(trade.is_fullfiled)
2097
2098             order3 = mock.Mock()
2099             order3.filled_amount.return_value = portfolio.Amount("BTC", "0.19")
2100             trade.orders.append(order3)
2101
2102             self.assertTrue(trade.is_fullfiled)
2103
2104             order1.filled_amount.assert_called_with(in_base_currency=False)
2105             order2.filled_amount.assert_called_with(in_base_currency=False)
2106             order3.filled_amount.assert_called_with(in_base_currency=False)
2107
2108
2109     def test_filled_amount(self):
2110         value_from = portfolio.Amount("BTC", "0.5")
2111         value_from.linked_to = portfolio.Amount("ETH", "10.0")
2112         value_to = portfolio.Amount("BTC", "1.0")
2113         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2114
2115         order1 = mock.Mock()
2116         order1.filled_amount.return_value = portfolio.Amount("ETH", "0.3")
2117
2118         order2 = mock.Mock()
2119         order2.filled_amount.return_value = portfolio.Amount("ETH", "0.01")
2120         trade.orders.append(order1)
2121         trade.orders.append(order2)
2122
2123         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount())
2124         order1.filled_amount.assert_called_with(in_base_currency=False)
2125         order2.filled_amount.assert_called_with(in_base_currency=False)
2126
2127         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount(in_base_currency=False))
2128         order1.filled_amount.assert_called_with(in_base_currency=False)
2129         order2.filled_amount.assert_called_with(in_base_currency=False)
2130
2131         self.assertEqual(portfolio.Amount("ETH", "0.31"), trade.filled_amount(in_base_currency=True))
2132         order1.filled_amount.assert_called_with(in_base_currency=True)
2133         order2.filled_amount.assert_called_with(in_base_currency=True)
2134
2135     @mock.patch.object(portfolio.Computation, "compute_value")
2136     @mock.patch.object(portfolio.Trade, "filled_amount")
2137     @mock.patch.object(portfolio, "Order")
2138     def test_prepare_order(self, Order, filled_amount, compute_value):
2139         Order.return_value = "Order"
2140
2141         with self.subTest(desc="Nothing to do"):
2142             value_from = portfolio.Amount("BTC", "10")
2143             value_from.rate = D("0.1")
2144             value_from.linked_to = portfolio.Amount("FOO", "100")
2145             value_to = portfolio.Amount("BTC", "10")
2146             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
2147
2148             trade.prepare_order()
2149
2150             filled_amount.assert_not_called()
2151             compute_value.assert_not_called()
2152             self.assertEqual(0, len(trade.orders))
2153             Order.assert_not_called()
2154
2155         self.m.get_ticker.return_value = { "inverted": False }
2156         with self.subTest(desc="Already filled"):
2157             filled_amount.return_value = portfolio.Amount("FOO", "100")
2158             compute_value.return_value = D("0.125")
2159
2160             value_from = portfolio.Amount("BTC", "10")
2161             value_from.rate = D("0.1")
2162             value_from.linked_to = portfolio.Amount("FOO", "100")
2163             value_to = portfolio.Amount("BTC", "0")
2164             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
2165
2166             trade.prepare_order()
2167
2168             filled_amount.assert_called_with(in_base_currency=False)
2169             compute_value.assert_called_with(self.m.get_ticker.return_value, "sell", compute_value="default")
2170             self.assertEqual(0, len(trade.orders))
2171             self.m.report.log_error.assert_called_with("prepare_order", message=mock.ANY)
2172             Order.assert_not_called()
2173
2174         with self.subTest(action="dispose", inverted=False):
2175             filled_amount.return_value = portfolio.Amount("FOO", "60")
2176             compute_value.return_value = D("0.125")
2177
2178             value_from = portfolio.Amount("BTC", "10")
2179             value_from.rate = D("0.1")
2180             value_from.linked_to = portfolio.Amount("FOO", "100")
2181             value_to = portfolio.Amount("BTC", "1")
2182             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
2183
2184             trade.prepare_order()
2185
2186             filled_amount.assert_called_with(in_base_currency=False)
2187             compute_value.assert_called_with(self.m.get_ticker.return_value, "sell", compute_value="default")
2188             self.assertEqual(1, len(trade.orders))
2189             Order.assert_called_with("sell", portfolio.Amount("FOO", 30),
2190                     D("0.125"), "BTC", "long", self.m,
2191                     trade, close_if_possible=False)
2192
2193         with self.subTest(action="dispose", inverted=False, close_if_possible=True):
2194             filled_amount.return_value = portfolio.Amount("FOO", "60")
2195             compute_value.return_value = D("0.125")
2196
2197             value_from = portfolio.Amount("BTC", "10")
2198             value_from.rate = D("0.1")
2199             value_from.linked_to = portfolio.Amount("FOO", "100")
2200             value_to = portfolio.Amount("BTC", "1")
2201             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
2202
2203             trade.prepare_order(close_if_possible=True)
2204
2205             filled_amount.assert_called_with(in_base_currency=False)
2206             compute_value.assert_called_with(self.m.get_ticker.return_value, "sell", compute_value="default")
2207             self.assertEqual(1, len(trade.orders))
2208             Order.assert_called_with("sell", portfolio.Amount("FOO", 30),
2209                     D("0.125"), "BTC", "long", self.m,
2210                     trade, close_if_possible=True)
2211
2212         with self.subTest(action="acquire", inverted=False):
2213             filled_amount.return_value = portfolio.Amount("BTC", "3")
2214             compute_value.return_value = D("0.125")
2215
2216             value_from = portfolio.Amount("BTC", "1")
2217             value_from.rate = D("0.1")
2218             value_from.linked_to = portfolio.Amount("FOO", "10")
2219             value_to = portfolio.Amount("BTC", "10")
2220             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
2221
2222             trade.prepare_order()
2223
2224             filled_amount.assert_called_with(in_base_currency=True)
2225             compute_value.assert_called_with(self.m.get_ticker.return_value, "buy", compute_value="default")
2226             self.assertEqual(1, len(trade.orders))
2227
2228             Order.assert_called_with("buy", portfolio.Amount("FOO", 48),
2229                 D("0.125"), "BTC", "long", self.m,
2230                 trade, close_if_possible=False)
2231
2232         with self.subTest(close_if_possible=True):
2233             filled_amount.return_value = portfolio.Amount("FOO", "0")
2234             compute_value.return_value = D("0.125")
2235
2236             value_from = portfolio.Amount("BTC", "10")
2237             value_from.rate = D("0.1")
2238             value_from.linked_to = portfolio.Amount("FOO", "100")
2239             value_to = portfolio.Amount("BTC", "0")
2240             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
2241
2242             trade.prepare_order()
2243
2244             filled_amount.assert_called_with(in_base_currency=False)
2245             compute_value.assert_called_with(self.m.get_ticker.return_value, "sell", compute_value="default")
2246             self.assertEqual(1, len(trade.orders))
2247             Order.assert_called_with("sell", portfolio.Amount("FOO", 100),
2248                     D("0.125"), "BTC", "long", self.m,
2249                     trade, close_if_possible=True)
2250
2251         self.m.get_ticker.return_value = { "inverted": True, "original": {} }
2252         with self.subTest(action="dispose", inverted=True):
2253             filled_amount.return_value = portfolio.Amount("FOO", "300")
2254             compute_value.return_value = D("125")
2255
2256             value_from = portfolio.Amount("BTC", "10")
2257             value_from.rate = D("0.01")
2258             value_from.linked_to = portfolio.Amount("FOO", "1000")
2259             value_to = portfolio.Amount("BTC", "1")
2260             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
2261
2262             trade.prepare_order(compute_value="foo")
2263
2264             filled_amount.assert_called_with(in_base_currency=True)
2265             compute_value.assert_called_with(self.m.get_ticker.return_value["original"], "buy", compute_value="foo")
2266             self.assertEqual(1, len(trade.orders))
2267             Order.assert_called_with("buy", portfolio.Amount("BTC", D("4.8")),
2268                     D("125"), "FOO", "long", self.m,
2269                     trade, close_if_possible=False)
2270
2271         with self.subTest(action="acquire", inverted=True):
2272             filled_amount.return_value = portfolio.Amount("BTC", "4")
2273             compute_value.return_value = D("125")
2274
2275             value_from = portfolio.Amount("BTC", "1")
2276             value_from.rate = D("0.01")
2277             value_from.linked_to = portfolio.Amount("FOO", "100")
2278             value_to = portfolio.Amount("BTC", "10")
2279             trade = portfolio.Trade(value_from, value_to, "FOO", self.m)
2280
2281             trade.prepare_order(compute_value="foo")
2282
2283             filled_amount.assert_called_with(in_base_currency=False)
2284             compute_value.assert_called_with(self.m.get_ticker.return_value["original"], "sell", compute_value="foo")
2285             self.assertEqual(1, len(trade.orders))
2286             Order.assert_called_with("sell", portfolio.Amount("BTC", D("5")),
2287                     D("125"), "FOO", "long", self.m,
2288                     trade, close_if_possible=False)
2289
2290
2291     @mock.patch.object(portfolio.Trade, "prepare_order")
2292     def test_update_order(self, prepare_order):
2293         order_mock = mock.Mock()
2294         new_order_mock = mock.Mock()
2295
2296         value_from = portfolio.Amount("BTC", "0.5")
2297         value_from.linked_to = portfolio.Amount("ETH", "10.0")
2298         value_to = portfolio.Amount("BTC", "1.0")
2299         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2300         prepare_order.return_value = new_order_mock
2301
2302         for i in [0, 1, 3, 4, 6]:
2303             with self.subTest(tick=i):
2304                 trade.update_order(order_mock, i)
2305                 order_mock.cancel.assert_not_called()
2306                 new_order_mock.run.assert_not_called()
2307                 self.m.report.log_order.assert_called_once_with(order_mock, i,
2308                         update="waiting", compute_value=None, new_order=None)
2309
2310             order_mock.reset_mock()
2311             new_order_mock.reset_mock()
2312             trade.orders = []
2313             self.m.report.log_order.reset_mock()
2314
2315         trade.update_order(order_mock, 2)
2316         order_mock.cancel.assert_called()
2317         new_order_mock.run.assert_called()
2318         prepare_order.assert_called()
2319         self.m.report.log_order.assert_called()
2320         self.assertEqual(2, self.m.report.log_order.call_count)
2321         calls = [
2322                 mock.call(order_mock, 2, update="adjusting",
2323                     compute_value=mock.ANY,
2324                     new_order=new_order_mock),
2325                 mock.call(order_mock, 2, new_order=new_order_mock),
2326                 ]
2327         self.m.report.log_order.assert_has_calls(calls)
2328
2329         order_mock.reset_mock()
2330         new_order_mock.reset_mock()
2331         trade.orders = []
2332         self.m.report.log_order.reset_mock()
2333
2334         trade.update_order(order_mock, 5)
2335         order_mock.cancel.assert_called()
2336         new_order_mock.run.assert_called()
2337         prepare_order.assert_called()
2338         self.assertEqual(2, self.m.report.log_order.call_count)
2339         self.m.report.log_order.assert_called()
2340         calls = [
2341                 mock.call(order_mock, 5, update="adjusting",
2342                     compute_value=mock.ANY,
2343                     new_order=new_order_mock),
2344                 mock.call(order_mock, 5, new_order=new_order_mock),
2345                 ]
2346         self.m.report.log_order.assert_has_calls(calls)
2347
2348         order_mock.reset_mock()
2349         new_order_mock.reset_mock()
2350         trade.orders = []
2351         self.m.report.log_order.reset_mock()
2352
2353         trade.update_order(order_mock, 7)
2354         order_mock.cancel.assert_called()
2355         new_order_mock.run.assert_called()
2356         prepare_order.assert_called_with(compute_value="default")
2357         self.m.report.log_order.assert_called()
2358         self.assertEqual(2, self.m.report.log_order.call_count)
2359         calls = [
2360                 mock.call(order_mock, 7, update="market_fallback",
2361                     compute_value='default',
2362                     new_order=new_order_mock),
2363                 mock.call(order_mock, 7, new_order=new_order_mock),
2364                 ]
2365         self.m.report.log_order.assert_has_calls(calls)
2366
2367         order_mock.reset_mock()
2368         new_order_mock.reset_mock()
2369         trade.orders = []
2370         self.m.report.log_order.reset_mock()
2371
2372         for i in [10, 13, 16]:
2373             with self.subTest(tick=i):
2374                 trade.update_order(order_mock, i)
2375                 order_mock.cancel.assert_called()
2376                 new_order_mock.run.assert_called()
2377                 prepare_order.assert_called_with(compute_value="default")
2378                 self.m.report.log_order.assert_called()
2379                 self.assertEqual(2, self.m.report.log_order.call_count)
2380                 calls = [
2381                         mock.call(order_mock, i, update="market_adjust",
2382                             compute_value='default',
2383                             new_order=new_order_mock),
2384                         mock.call(order_mock, i, new_order=new_order_mock),
2385                         ]
2386                 self.m.report.log_order.assert_has_calls(calls)
2387
2388             order_mock.reset_mock()
2389             new_order_mock.reset_mock()
2390             trade.orders = []
2391             self.m.report.log_order.reset_mock()
2392
2393         for i in [8, 9, 11, 12]:
2394             with self.subTest(tick=i):
2395                 trade.update_order(order_mock, i)
2396                 order_mock.cancel.assert_not_called()
2397                 new_order_mock.run.assert_not_called()
2398                 self.m.report.log_order.assert_called_once_with(order_mock, i, update="waiting",
2399                         compute_value=None, new_order=None)
2400
2401             order_mock.reset_mock()
2402             new_order_mock.reset_mock()
2403             trade.orders = []
2404             self.m.report.log_order.reset_mock()
2405
2406
2407     def test_print_with_order(self):
2408         value_from = portfolio.Amount("BTC", "0.5")
2409         value_from.linked_to = portfolio.Amount("ETH", "10.0")
2410         value_to = portfolio.Amount("BTC", "1.0")
2411         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2412
2413         order_mock1 = mock.Mock()
2414         order_mock1.__repr__ = mock.Mock()
2415         order_mock1.__repr__.return_value = "Mock 1"
2416         order_mock2 = mock.Mock()
2417         order_mock2.__repr__ = mock.Mock()
2418         order_mock2.__repr__.return_value = "Mock 2"
2419         order_mock1.mouvements = []
2420         mouvement_mock1 = mock.Mock()
2421         mouvement_mock1.__repr__ = mock.Mock()
2422         mouvement_mock1.__repr__.return_value = "Mouvement 1"
2423         mouvement_mock2 = mock.Mock()
2424         mouvement_mock2.__repr__ = mock.Mock()
2425         mouvement_mock2.__repr__.return_value = "Mouvement 2"
2426         order_mock2.mouvements = [
2427                 mouvement_mock1, mouvement_mock2
2428                 ]
2429         trade.orders.append(order_mock1)
2430         trade.orders.append(order_mock2)
2431
2432         with mock.patch.object(trade, "filled_amount") as filled:
2433             filled.return_value = portfolio.Amount("BTC", "0.1")
2434
2435             trade.print_with_order()
2436
2437             self.m.report.print_log.assert_called()
2438             calls = self.m.report.print_log.mock_calls
2439             self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire)", str(calls[0][1][0]))
2440             self.assertEqual("\tMock 1", str(calls[1][1][0]))
2441             self.assertEqual("\tMock 2", str(calls[2][1][0]))
2442             self.assertEqual("\t\tMouvement 1", str(calls[3][1][0]))
2443             self.assertEqual("\t\tMouvement 2", str(calls[4][1][0]))
2444
2445             self.m.report.print_log.reset_mock()
2446
2447             filled.return_value = portfolio.Amount("BTC", "0.5")
2448             trade.print_with_order()
2449             calls = self.m.report.print_log.mock_calls
2450             self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire ✔)", str(calls[0][1][0]))
2451
2452             self.m.report.print_log.reset_mock()
2453
2454             filled.return_value = portfolio.Amount("BTC", "0.1")
2455             trade.closed = True
2456             trade.print_with_order()
2457             calls = self.m.report.print_log.mock_calls
2458             self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire ❌)", str(calls[0][1][0]))
2459
2460     def test_close(self):
2461         value_from = portfolio.Amount("BTC", "0.5")
2462         value_from.linked_to = portfolio.Amount("ETH", "10.0")
2463         value_to = portfolio.Amount("BTC", "1.0")
2464         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2465         order1 = mock.Mock()
2466         trade.orders.append(order1)
2467
2468         trade.close()
2469
2470         self.assertEqual(True, trade.closed)
2471         order1.cancel.assert_called_once_with()
2472
2473     def test_pending(self):
2474         value_from = portfolio.Amount("BTC", "0.5")
2475         value_from.linked_to = portfolio.Amount("ETH", "10.0")
2476         value_to = portfolio.Amount("BTC", "1.0")
2477         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2478
2479         trade.closed = True
2480         self.assertEqual(False, trade.pending)
2481
2482         trade.closed = False
2483         self.assertEqual(True, trade.pending)
2484
2485         order1 = mock.Mock()
2486         order1.filled_amount.return_value = portfolio.Amount("BTC", "0.5")
2487         trade.orders.append(order1)
2488         self.assertEqual(False, trade.pending)
2489
2490     def test__repr(self):
2491         value_from = portfolio.Amount("BTC", "0.5")
2492         value_from.linked_to = portfolio.Amount("ETH", "10.0")
2493         value_to = portfolio.Amount("BTC", "1.0")
2494         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2495
2496         self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire)", str(trade))
2497
2498     def test_as_json(self):
2499         value_from = portfolio.Amount("BTC", "0.5")
2500         value_from.linked_to = portfolio.Amount("ETH", "10.0")
2501         value_to = portfolio.Amount("BTC", "1.0")
2502         trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
2503
2504         as_json = trade.as_json()
2505         self.assertEqual("acquire", as_json["action"])
2506         self.assertEqual(D("0.5"), as_json["from"])
2507         self.assertEqual(D("1.0"), as_json["to"])
2508         self.assertEqual("ETH", as_json["currency"])
2509         self.assertEqual("BTC", as_json["base_currency"])
2510
2511 @unittest.skipUnless("unit" in limits, "Unit skipped")
2512 class OrderTest(WebMockTestCase):
2513     def test_values(self):
2514         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2515                 D("0.1"), "BTC", "long", "market", "trade")
2516         self.assertEqual("buy", order.action)
2517         self.assertEqual(10, order.amount.value)
2518         self.assertEqual("ETH", order.amount.currency)
2519         self.assertEqual(D("0.1"), order.rate)
2520         self.assertEqual("BTC", order.base_currency)
2521         self.assertEqual("market", order.market)
2522         self.assertEqual("long", order.trade_type)
2523         self.assertEqual("pending", order.status)
2524         self.assertEqual("trade", order.trade)
2525         self.assertIsNone(order.id)
2526         self.assertFalse(order.close_if_possible)
2527
2528     def test__repr(self):
2529         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2530                 D("0.1"), "BTC", "long", "market", "trade")
2531         self.assertEqual("Order(buy long 10.00000000 ETH at 0.1 BTC [pending])", repr(order))
2532
2533         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2534                 D("0.1"), "BTC", "long", "market", "trade",
2535                 close_if_possible=True)
2536         self.assertEqual("Order(buy long 10.00000000 ETH at 0.1 BTC [pending] ✂)", repr(order))
2537
2538     def test_as_json(self):
2539         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2540                 D("0.1"), "BTC", "long", "market", "trade")
2541         mouvement_mock1 = mock.Mock()
2542         mouvement_mock1.as_json.return_value = 1
2543         mouvement_mock2 = mock.Mock()
2544         mouvement_mock2.as_json.return_value = 2
2545
2546         order.mouvements = [mouvement_mock1, mouvement_mock2]
2547         as_json = order.as_json()
2548         self.assertEqual("buy", as_json["action"])
2549         self.assertEqual("long", as_json["trade_type"])
2550         self.assertEqual(10, as_json["amount"])
2551         self.assertEqual("ETH", as_json["currency"])
2552         self.assertEqual("BTC", as_json["base_currency"])
2553         self.assertEqual(D("0.1"), as_json["rate"])
2554         self.assertEqual("pending", as_json["status"])
2555         self.assertEqual(False, as_json["close_if_possible"])
2556         self.assertIsNone(as_json["id"])
2557         self.assertEqual([1, 2], as_json["mouvements"])
2558
2559     def test_account(self):
2560         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2561                 D("0.1"), "BTC", "long", "market", "trade")
2562         self.assertEqual("exchange", order.account)
2563
2564         order = portfolio.Order("sell", portfolio.Amount("ETH", 10),
2565                 D("0.1"), "BTC", "short", "market", "trade")
2566         self.assertEqual("margin", order.account)
2567
2568     def test_pending(self):
2569         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2570                 D("0.1"), "BTC", "long", "market", "trade")
2571         self.assertTrue(order.pending)
2572         order.status = "open"
2573         self.assertFalse(order.pending)
2574
2575     def test_open(self):
2576         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2577                 D("0.1"), "BTC", "long", "market", "trade")
2578         self.assertFalse(order.open)
2579         order.status = "open"
2580         self.assertTrue(order.open)
2581
2582     def test_finished(self):
2583         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2584                 D("0.1"), "BTC", "long", "market", "trade")
2585         self.assertFalse(order.finished)
2586         order.status = "closed"
2587         self.assertTrue(order.finished)
2588         order.status = "canceled"
2589         self.assertTrue(order.finished)
2590         order.status = "error"
2591         self.assertTrue(order.finished)
2592
2593     @mock.patch.object(portfolio.Order, "fetch")
2594     def test_cancel(self, fetch):
2595         with self.subTest(debug=True):
2596             self.m.debug = True
2597             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2598                     D("0.1"), "BTC", "long", self.m, "trade")
2599             order.status = "open"
2600
2601             order.cancel()
2602             self.m.ccxt.cancel_order.assert_not_called()
2603             self.m.report.log_debug_action.assert_called_once()
2604             self.m.report.log_debug_action.reset_mock()
2605             self.assertEqual("canceled", order.status)
2606
2607         with self.subTest(desc="Nominal case"):
2608             self.m.debug = False
2609             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2610                     D("0.1"), "BTC", "long", self.m, "trade")
2611             order.status = "open"
2612             order.id = 42
2613
2614             order.cancel()
2615             self.m.ccxt.cancel_order.assert_called_with(42)
2616             fetch.assert_called_once_with()
2617             self.m.report.log_debug_action.assert_not_called()
2618
2619         with self.subTest(exception=True):
2620             self.m.ccxt.cancel_order.side_effect = portfolio.OrderNotFound
2621             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2622                     D("0.1"), "BTC", "long", self.m, "trade")
2623             order.status = "open"
2624             order.id = 42
2625             order.cancel()
2626             self.m.ccxt.cancel_order.assert_called_with(42)
2627             self.m.report.log_error.assert_called_once()
2628
2629         self.m.reset_mock()
2630         with self.subTest(id=None):
2631             self.m.ccxt.cancel_order.side_effect = portfolio.OrderNotFound
2632             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2633                     D("0.1"), "BTC", "long", self.m, "trade")
2634             order.status = "open"
2635             order.cancel()
2636             self.m.ccxt.cancel_order.assert_not_called()
2637
2638         self.m.reset_mock()
2639         with self.subTest(open=False):
2640             self.m.ccxt.cancel_order.side_effect = portfolio.OrderNotFound
2641             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2642                     D("0.1"), "BTC", "long", self.m, "trade")
2643             order.status = "closed"
2644             order.cancel()
2645             self.m.ccxt.cancel_order.assert_not_called()
2646
2647     def test_dust_amount_remaining(self):
2648         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2649                 D("0.1"), "BTC", "long", self.m, "trade")
2650         order.remaining_amount = mock.Mock(return_value=portfolio.Amount("ETH", 1))
2651         self.assertFalse(order.dust_amount_remaining())
2652
2653         order.remaining_amount = mock.Mock(return_value=portfolio.Amount("ETH", D("0.0001")))
2654         self.assertTrue(order.dust_amount_remaining())
2655
2656     @mock.patch.object(portfolio.Order, "fetch")
2657     @mock.patch.object(portfolio.Order, "filled_amount", return_value=portfolio.Amount("ETH", 1))
2658     def test_remaining_amount(self, filled_amount, fetch):
2659         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2660                 D("0.1"), "BTC", "long", self.m, "trade")
2661
2662         self.assertEqual(9, order.remaining_amount().value)
2663
2664         order.status = "open"
2665         self.assertEqual(9, order.remaining_amount().value)
2666
2667     @mock.patch.object(portfolio.Order, "fetch")
2668     def test_filled_amount(self, fetch):
2669         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2670                 D("0.1"), "BTC", "long", self.m, "trade")
2671         order.mouvements.append(portfolio.Mouvement("ETH", "BTC", {
2672             "tradeID": 42, "type": "buy", "fee": "0.0015",
2673             "date": "2017-12-30 12:00:12", "rate": "0.1",
2674             "amount": "3", "total": "0.3"
2675             }))
2676         order.mouvements.append(portfolio.Mouvement("ETH", "BTC", {
2677             "tradeID": 43, "type": "buy", "fee": "0.0015",
2678             "date": "2017-12-30 13:00:12", "rate": "0.2",
2679             "amount": "2", "total": "0.4"
2680             }))
2681         self.assertEqual(portfolio.Amount("ETH", 5), order.filled_amount())
2682         fetch.assert_not_called()
2683         order.status = "open"
2684         self.assertEqual(portfolio.Amount("ETH", 5), order.filled_amount(in_base_currency=False))
2685         fetch.assert_called_once()
2686         self.assertEqual(portfolio.Amount("BTC", "0.7"), order.filled_amount(in_base_currency=True))
2687
2688     def test_fetch_mouvements(self):
2689         self.m.ccxt.privatePostReturnOrderTrades.return_value = [
2690                 {
2691                     "tradeID": 42, "type": "buy", "fee": "0.0015",
2692                     "date": "2017-12-30 12:00:12", "rate": "0.1",
2693                     "amount": "3", "total": "0.3"
2694                     },
2695                 {
2696                     "tradeID": 43, "type": "buy", "fee": "0.0015",
2697                     "date": "2017-12-30 13:00:12", "rate": "0.2",
2698                     "amount": "2", "total": "0.4"
2699                     }
2700             ]
2701         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2702                 D("0.1"), "BTC", "long", self.m, "trade")
2703         order.id = 12
2704         order.mouvements = ["Foo", "Bar", "Baz"]
2705
2706         order.fetch_mouvements()
2707
2708         self.m.ccxt.privatePostReturnOrderTrades.assert_called_with({"orderNumber": 12})
2709         self.assertEqual(2, len(order.mouvements))
2710         self.assertEqual(42, order.mouvements[0].id)
2711         self.assertEqual(43, order.mouvements[1].id)
2712
2713         self.m.ccxt.privatePostReturnOrderTrades.side_effect = portfolio.ExchangeError
2714         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2715                 D("0.1"), "BTC", "long", self.m, "trade")
2716         order.fetch_mouvements()
2717         self.assertEqual(0, len(order.mouvements))
2718
2719     def test_mark_finished_order(self):
2720         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2721                 D("0.1"), "BTC", "short", self.m, "trade",
2722                 close_if_possible=True)
2723         order.status = "closed"
2724         self.m.debug = False
2725
2726         order.mark_finished_order()
2727         self.m.ccxt.close_margin_position.assert_called_with("ETH", "BTC")
2728         self.m.ccxt.close_margin_position.reset_mock()
2729
2730         order.status = "open"
2731         order.mark_finished_order()
2732         self.m.ccxt.close_margin_position.assert_not_called()
2733
2734         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2735                 D("0.1"), "BTC", "short", self.m, "trade",
2736                 close_if_possible=False)
2737         order.status = "closed"
2738         order.mark_finished_order()
2739         self.m.ccxt.close_margin_position.assert_not_called()
2740
2741         order = portfolio.Order("sell", portfolio.Amount("ETH", 10),
2742                 D("0.1"), "BTC", "short", self.m, "trade",
2743                 close_if_possible=True)
2744         order.status = "closed"
2745         order.mark_finished_order()
2746         self.m.ccxt.close_margin_position.assert_not_called()
2747
2748         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2749                 D("0.1"), "BTC", "long", self.m, "trade",
2750                 close_if_possible=True)
2751         order.status = "closed"
2752         order.mark_finished_order()
2753         self.m.ccxt.close_margin_position.assert_not_called()
2754
2755         self.m.debug = True
2756
2757         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2758                 D("0.1"), "BTC", "short", self.m, "trade",
2759                 close_if_possible=True)
2760         order.status = "closed"
2761
2762         order.mark_finished_order()
2763         self.m.ccxt.close_margin_position.assert_not_called()
2764         self.m.report.log_debug_action.assert_called_once()
2765
2766     @mock.patch.object(portfolio.Order, "fetch_mouvements")
2767     @mock.patch.object(portfolio.Order, "mark_finished_order")
2768     def test_fetch(self, mark_finished_order, fetch_mouvements):
2769         order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2770                 D("0.1"), "BTC", "long", self.m, "trade")
2771         order.id = 45
2772         with self.subTest(debug=True):
2773             self.m.debug = True
2774             order.fetch()
2775             self.m.report.log_debug_action.assert_called_once()
2776             self.m.report.log_debug_action.reset_mock()
2777             self.m.ccxt.fetch_order.assert_not_called()
2778             mark_finished_order.assert_not_called()
2779             fetch_mouvements.assert_not_called()
2780
2781         with self.subTest(debug=False):
2782             self.m.debug = False
2783             self.m.ccxt.fetch_order.return_value = {
2784                     "status": "foo",
2785                     "datetime": "timestamp"
2786                     }
2787             order.fetch()
2788
2789             self.m.ccxt.fetch_order.assert_called_once_with(45)
2790             fetch_mouvements.assert_called_once()
2791             self.assertEqual("foo", order.status)
2792             self.assertEqual("timestamp", order.timestamp)
2793             self.assertEqual(1, len(order.results))
2794             self.m.report.log_debug_action.assert_not_called()
2795             mark_finished_order.assert_called_once()
2796
2797             mark_finished_order.reset_mock()
2798             with self.subTest(missing_order=True):
2799                 self.m.ccxt.fetch_order.side_effect = [
2800                         portfolio.OrderNotCached,
2801                         ]
2802                 order.fetch()
2803                 self.assertEqual("closed_unknown", order.status)
2804                 mark_finished_order.assert_called_once()
2805
2806     @mock.patch.object(portfolio.Order, "fetch")
2807     def test_get_status(self, fetch):
2808         with self.subTest(debug=True):
2809             self.m.debug = True
2810             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2811                     D("0.1"), "BTC", "long", self.m, "trade")
2812             self.assertEqual("pending", order.get_status())
2813             fetch.assert_not_called()
2814             self.m.report.log_debug_action.assert_called_once()
2815
2816         with self.subTest(debug=False, finished=False):
2817             self.m.debug = False
2818             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2819                     D("0.1"), "BTC", "long", self.m, "trade")
2820             def _fetch(order):
2821                 def update_status():
2822                     order.status = "open"
2823                 return update_status
2824             fetch.side_effect = _fetch(order)
2825             self.assertEqual("open", order.get_status())
2826             fetch.assert_called_once()
2827
2828         fetch.reset_mock()
2829         with self.subTest(debug=False, finished=True):
2830             self.m.debug = False
2831             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2832                     D("0.1"), "BTC", "long", self.m, "trade")
2833             def _fetch(order):
2834                 def update_status():
2835                     order.status = "closed"
2836                 return update_status
2837             fetch.side_effect = _fetch(order)
2838             self.assertEqual("closed", order.get_status())
2839             fetch.assert_called_once()
2840
2841     def test_run(self):
2842         self.m.ccxt.order_precision.return_value = 4
2843         with self.subTest(debug=True):
2844             self.m.debug = True
2845             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2846                     D("0.1"), "BTC", "long", self.m, "trade")
2847             order.run()
2848             self.m.ccxt.create_order.assert_not_called()
2849             self.m.report.log_debug_action.assert_called_with("market.ccxt.create_order('ETH/BTC', 'limit', 'buy', 10.0000, price=0.1, account=exchange)")
2850             self.assertEqual("open", order.status)
2851             self.assertEqual(1, len(order.results))
2852             self.assertEqual(-1, order.id)
2853
2854         self.m.ccxt.create_order.reset_mock()
2855         with self.subTest(debug=False):
2856             self.m.debug = False
2857             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2858                     D("0.1"), "BTC", "long", self.m, "trade")
2859             self.m.ccxt.create_order.return_value = { "id": 123 }
2860             order.run()
2861             self.m.ccxt.create_order.assert_called_once()
2862             self.assertEqual(1, len(order.results))
2863             self.assertEqual("open", order.status)
2864
2865         self.m.ccxt.create_order.reset_mock()
2866         with self.subTest(exception=True):
2867             order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
2868                     D("0.1"), "BTC", "long", self.m, "trade")
2869             self.m.ccxt.create_order.side_effect = Exception("bouh")
2870             order.run()
2871             self.m.ccxt.create_order.assert_called_once()
2872             self.assertEqual(0, len(order.results))
2873             self.assertEqual("error", order.status)
2874             self.m.report.log_error.assert_called_once()
2875
2876         self.m.ccxt.create_order.reset_mock()
2877         with self.subTest(dust_amount_exception=True),\
2878                 mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order:
2879             order = portfolio.Order("buy", portfolio.Amount("ETH", 0.001),
2880                     D("0.1"), "BTC", "long", self.m, "trade")
2881             self.m.ccxt.create_order.side_effect = portfolio.InvalidOrder
2882             order.run()
2883             self.m.ccxt.create_order.assert_called_once()
2884             self.assertEqual(0, len(order.results))
2885             self.assertEqual("closed", order.status)
2886             mark_finished_order.assert_called_once()
2887
2888         self.m.ccxt.order_precision.return_value = 8
2889         self.m.ccxt.create_order.reset_mock()
2890         with self.subTest(insufficient_funds=True),\
2891                 mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order:
2892             order = portfolio.Order("buy", portfolio.Amount("ETH", "0.001"),
2893                     D("0.1"), "BTC", "long", self.m, "trade")
2894             self.m.ccxt.create_order.side_effect = [
2895                     portfolio.InsufficientFunds,
2896                     portfolio.InsufficientFunds,
2897                     portfolio.InsufficientFunds,
2898                     { "id": 123 },
2899                     ]
2900             order.run()
2901             self.m.ccxt.create_order.assert_has_calls([
2902                 mock.call('ETH/BTC', 'limit', 'buy', D('0.0010'), account='exchange', price=D('0.1')),
2903                 mock.call('ETH/BTC', 'limit', 'buy', D('0.00099'), account='exchange', price=D('0.1')),
2904                 mock.call('ETH/BTC', 'limit', 'buy', D('0.0009801'), account='exchange', price=D('0.1')),
2905                 mock.call('ETH/BTC', 'limit', 'buy', D('0.00097029'), account='exchange', price=D('0.1')),
2906                 ])
2907             self.assertEqual(4, self.m.ccxt.create_order.call_count)
2908             self.assertEqual(1, len(order.results))
2909             self.assertEqual("open", order.status)
2910             self.assertEqual(4, order.tries)
2911             self.m.report.log_error.assert_called()
2912             self.assertEqual(4, self.m.report.log_error.call_count)
2913
2914         self.m.ccxt.order_precision.return_value = 8
2915         self.m.ccxt.create_order.reset_mock()
2916         self.m.report.log_error.reset_mock()
2917         with self.subTest(insufficient_funds=True),\
2918                 mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order:
2919             order = portfolio.Order("buy", portfolio.Amount("ETH", "0.001"),
2920                     D("0.1"), "BTC", "long", self.m, "trade")
2921             self.m.ccxt.create_order.side_effect = [
2922                     portfolio.InsufficientFunds,
2923                     portfolio.InsufficientFunds,
2924                     portfolio.InsufficientFunds,
2925                     portfolio.InsufficientFunds,
2926                     portfolio.InsufficientFunds,
2927                     ]
2928             order.run()
2929             self.m.ccxt.create_order.assert_has_calls([
2930                 mock.call('ETH/BTC', 'limit', 'buy', D('0.0010'), account='exchange', price=D('0.1')),
2931                 mock.call('ETH/BTC', 'limit', 'buy', D('0.00099'), account='exchange', price=D('0.1')),
2932                 mock.call('ETH/BTC', 'limit', 'buy', D('0.0009801'), account='exchange', price=D('0.1')),
2933                 mock.call('ETH/BTC', 'limit', 'buy', D('0.00097029'), account='exchange', price=D('0.1')),
2934                 mock.call('ETH/BTC', 'limit', 'buy', D('0.00096059'), account='exchange', price=D('0.1')),
2935                 ])
2936             self.assertEqual(5, self.m.ccxt.create_order.call_count)
2937             self.assertEqual(0, len(order.results))
2938             self.assertEqual("error", order.status)
2939             self.assertEqual(5, order.tries)
2940             self.m.report.log_error.assert_called()
2941             self.assertEqual(5, self.m.report.log_error.call_count)
2942             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)
2943
2944
2945 @unittest.skipUnless("unit" in limits, "Unit skipped")
2946 class MouvementTest(WebMockTestCase):
2947     def test_values(self):
2948         mouvement = portfolio.Mouvement("ETH", "BTC", {
2949             "tradeID": 42, "type": "buy", "fee": "0.0015",
2950             "date": "2017-12-30 12:00:12", "rate": "0.1",
2951             "amount": "10", "total": "1"
2952             })
2953         self.assertEqual("ETH", mouvement.currency)
2954         self.assertEqual("BTC", mouvement.base_currency)
2955         self.assertEqual(42, mouvement.id)
2956         self.assertEqual("buy", mouvement.action)
2957         self.assertEqual(D("0.0015"), mouvement.fee_rate)
2958         self.assertEqual(portfolio.datetime(2017, 12, 30, 12, 0, 12), mouvement.date)
2959         self.assertEqual(D("0.1"), mouvement.rate)
2960         self.assertEqual(portfolio.Amount("ETH", "10"), mouvement.total)
2961         self.assertEqual(portfolio.Amount("BTC", "1"), mouvement.total_in_base)
2962
2963         mouvement = portfolio.Mouvement("ETH", "BTC", { "foo": "bar" })
2964         self.assertIsNone(mouvement.date)
2965         self.assertIsNone(mouvement.id)
2966         self.assertIsNone(mouvement.action)
2967         self.assertEqual(-1, mouvement.fee_rate)
2968         self.assertEqual(0, mouvement.rate)
2969         self.assertEqual(portfolio.Amount("ETH", 0), mouvement.total)
2970         self.assertEqual(portfolio.Amount("BTC", 0), mouvement.total_in_base)
2971
2972     def test__repr(self):
2973         mouvement = portfolio.Mouvement("ETH", "BTC", {
2974             "tradeID": 42, "type": "buy", "fee": "0.0015",
2975             "date": "2017-12-30 12:00:12", "rate": "0.1",
2976             "amount": "10", "total": "1"
2977             })
2978         self.assertEqual("Mouvement(2017-12-30 12:00:12 ; buy 10.00000000 ETH (1.00000000 BTC) fee: 0.1500%)", repr(mouvement))
2979
2980         mouvement = portfolio.Mouvement("ETH", "BTC", {
2981             "tradeID": 42, "type": "buy",
2982             "date": "garbage", "rate": "0.1",
2983             "amount": "10", "total": "1"
2984             })
2985         self.assertEqual("Mouvement(No date ; buy 10.00000000 ETH (1.00000000 BTC))", repr(mouvement))
2986
2987     def test_as_json(self):
2988         mouvement = portfolio.Mouvement("ETH", "BTC", {
2989             "tradeID": 42, "type": "buy", "fee": "0.0015",
2990             "date": "2017-12-30 12:00:12", "rate": "0.1",
2991             "amount": "10", "total": "1"
2992             })
2993         as_json = mouvement.as_json()
2994
2995         self.assertEqual(D("0.0015"), as_json["fee_rate"])
2996         self.assertEqual(portfolio.datetime(2017, 12, 30, 12, 0, 12), as_json["date"])
2997         self.assertEqual("buy", as_json["action"])
2998         self.assertEqual(D("10"), as_json["total"])
2999         self.assertEqual(D("1"), as_json["total_in_base"])
3000         self.assertEqual("BTC", as_json["base_currency"])
3001         self.assertEqual("ETH", as_json["currency"])
3002
3003 @unittest.skipUnless("unit" in limits, "Unit skipped")
3004 class ReportStoreTest(WebMockTestCase):
3005     def test_add_log(self):
3006         report_store = market.ReportStore(self.m)
3007         report_store.add_log({"foo": "bar"})
3008
3009         self.assertEqual({"foo": "bar", "date": mock.ANY}, report_store.logs[0])
3010
3011     def test_set_verbose(self):
3012         report_store = market.ReportStore(self.m)
3013         with self.subTest(verbose=True):
3014             report_store.set_verbose(True)
3015             self.assertTrue(report_store.verbose_print)
3016
3017         with self.subTest(verbose=False):
3018             report_store.set_verbose(False)
3019             self.assertFalse(report_store.verbose_print)
3020
3021     def test_merge(self):
3022         report_store1 = market.ReportStore(self.m, verbose_print=False)
3023         report_store2 = market.ReportStore(None, verbose_print=False)
3024
3025         report_store2.log_stage("1")
3026         report_store1.log_stage("2")
3027         report_store2.log_stage("3")
3028
3029         report_store1.merge(report_store2)
3030
3031         self.assertEqual(3, len(report_store1.logs))
3032         self.assertEqual(["1", "2", "3"], list(map(lambda x: x["stage"], report_store1.logs)))
3033         self.assertEqual(6, len(report_store1.print_logs))
3034
3035     def test_print_log(self):
3036         report_store = market.ReportStore(self.m)
3037         with self.subTest(verbose=True),\
3038                 mock.patch.object(store, "datetime") as time_mock,\
3039                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
3040             time_mock.now.return_value = datetime.datetime(2018, 2, 25, 2, 20, 10)
3041             report_store.set_verbose(True)
3042             report_store.print_log("Coucou")
3043             report_store.print_log(portfolio.Amount("BTC", 1))
3044             self.assertEqual(stdout_mock.getvalue(), "2018-02-25 02:20:10: Coucou\n2018-02-25 02:20:10: 1.00000000 BTC\n")
3045
3046         with self.subTest(verbose=False),\
3047                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
3048             report_store.set_verbose(False)
3049             report_store.print_log("Coucou")
3050             report_store.print_log(portfolio.Amount("BTC", 1))
3051             self.assertEqual(stdout_mock.getvalue(), "")
3052
3053     def test_to_json(self):
3054         report_store = market.ReportStore(self.m)
3055         report_store.logs.append({"foo": "bar"})
3056         self.assertEqual('[\n  {\n    "foo": "bar"\n  }\n]', report_store.to_json())
3057         report_store.logs.append({"date": portfolio.datetime(2018, 2, 24)})
3058         self.assertEqual('[\n  {\n    "foo": "bar"\n  },\n  {\n    "date": "2018-02-24T00:00:00"\n  }\n]', report_store.to_json())
3059         report_store.logs.append({"amount": portfolio.Amount("BTC", 1)})
3060         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())
3061
3062     @mock.patch.object(market.ReportStore, "print_log")
3063     @mock.patch.object(market.ReportStore, "add_log")
3064     def test_log_stage(self, add_log, print_log):
3065         report_store = market.ReportStore(self.m)
3066         c = lambda x: x
3067         report_store.log_stage("foo", bar="baz", c=c, d=portfolio.Amount("BTC", 1))
3068         print_log.assert_has_calls([
3069             mock.call("-----------"),
3070             mock.call("[Stage] foo bar=baz, c=c = lambda x: x, d={'currency': 'BTC', 'value': Decimal('1')}"),
3071             ])
3072         add_log.assert_called_once_with({
3073             'type': 'stage',
3074             'stage': 'foo',
3075             'args': {
3076                 'bar': 'baz',
3077                 'c': 'c = lambda x: x',
3078                 'd': {
3079                     'currency': 'BTC',
3080                     'value': D('1')
3081                     }
3082                 }
3083             })
3084
3085     @mock.patch.object(market.ReportStore, "print_log")
3086     @mock.patch.object(market.ReportStore, "add_log")
3087     def test_log_balances(self, add_log, print_log):
3088         report_store = market.ReportStore(self.m)
3089         self.m.balances.as_json.return_value = "json"
3090         self.m.balances.all = { "FOO": "bar", "BAR": "baz" }
3091
3092         report_store.log_balances(tag="tag")
3093         print_log.assert_has_calls([
3094             mock.call("[Balance]"),
3095             mock.call("\tbar"),
3096             mock.call("\tbaz"),
3097             ])
3098         add_log.assert_called_once_with({
3099             'type': 'balance',
3100             'balances': 'json',
3101             'tag': 'tag'
3102             })
3103
3104     @mock.patch.object(market.ReportStore, "print_log")
3105     @mock.patch.object(market.ReportStore, "add_log")
3106     def test_log_tickers(self, add_log, print_log):
3107         report_store = market.ReportStore(self.m)
3108         amounts = {
3109                 "BTC": portfolio.Amount("BTC", 10),
3110                 "ETH": portfolio.Amount("BTC", D("0.3"))
3111                 }
3112         amounts["ETH"].rate = D("0.1")
3113
3114         report_store.log_tickers(amounts, "BTC", "default", "total")
3115         print_log.assert_not_called()
3116         add_log.assert_called_once_with({
3117             'type': 'tickers',
3118             'compute_value': 'default',
3119             'balance_type': 'total',
3120             'currency': 'BTC',
3121             'balances': {
3122                 'BTC': D('10'),
3123                 'ETH': D('0.3')
3124                 },
3125             'rates': {
3126                 'BTC': None,
3127                 'ETH': D('0.1')
3128                 },
3129             'total': D('10.3')
3130             })
3131
3132         add_log.reset_mock()
3133         compute_value = lambda x: x["bid"]
3134         report_store.log_tickers(amounts, "BTC", compute_value, "total")
3135         add_log.assert_called_once_with({
3136             'type': 'tickers',
3137             'compute_value': 'compute_value = lambda x: x["bid"]',
3138             'balance_type': 'total',
3139             'currency': 'BTC',
3140             'balances': {
3141                 'BTC': D('10'),
3142                 'ETH': D('0.3')
3143                 },
3144             'rates': {
3145                 'BTC': None,
3146                 'ETH': D('0.1')
3147                 },
3148             'total': D('10.3')
3149             })
3150
3151     @mock.patch.object(market.ReportStore, "print_log")
3152     @mock.patch.object(market.ReportStore, "add_log")
3153     def test_log_dispatch(self, add_log, print_log):
3154         report_store = market.ReportStore(self.m)
3155         amount = portfolio.Amount("BTC", "10.3")
3156         amounts = {
3157                 "BTC": portfolio.Amount("BTC", 10),
3158                 "ETH": portfolio.Amount("BTC", D("0.3"))
3159                 }
3160         report_store.log_dispatch(amount, amounts, "medium", "repartition")
3161         print_log.assert_not_called()
3162         add_log.assert_called_once_with({
3163             'type': 'dispatch',
3164             'liquidity': 'medium',
3165             'repartition_ratio': 'repartition',
3166             'total_amount': {
3167                 'currency': 'BTC',
3168                 'value': D('10.3')
3169                 },
3170             'repartition': {
3171                 'BTC': D('10'),
3172                 'ETH': D('0.3')
3173                 }
3174             })
3175
3176     @mock.patch.object(market.ReportStore, "print_log")
3177     @mock.patch.object(market.ReportStore, "add_log")
3178     def test_log_trades(self, add_log, print_log):
3179         report_store = market.ReportStore(self.m)
3180         trade_mock1 = mock.Mock()
3181         trade_mock2 = mock.Mock()
3182         trade_mock1.as_json.return_value = { "trade": "1" }
3183         trade_mock2.as_json.return_value = { "trade": "2" }
3184
3185         matching_and_trades = [
3186                 (True, trade_mock1),
3187                 (False, trade_mock2),
3188                 ]
3189         report_store.log_trades(matching_and_trades, "only")
3190
3191         print_log.assert_not_called()
3192         add_log.assert_called_with({
3193             'type': 'trades',
3194             'only': 'only',
3195             'debug': False,
3196             'trades': [
3197                 {'trade': '1', 'skipped': False},
3198                 {'trade': '2', 'skipped': True}
3199                 ]
3200             })
3201
3202     @mock.patch.object(market.ReportStore, "print_log")
3203     @mock.patch.object(market.ReportStore, "add_log")
3204     def test_log_orders(self, add_log, print_log):
3205         report_store = market.ReportStore(self.m)
3206
3207         order_mock1 = mock.Mock()
3208         order_mock2 = mock.Mock()
3209
3210         order_mock1.as_json.return_value = "order1"
3211         order_mock2.as_json.return_value = "order2"
3212
3213         orders = [order_mock1, order_mock2]
3214
3215         report_store.log_orders(orders, tick="tick",
3216                 only="only", compute_value="compute_value")
3217
3218         print_log.assert_called_once_with("[Orders]")
3219         self.m.trades.print_all_with_order.assert_called_once_with(ind="\t")
3220
3221         add_log.assert_called_with({
3222             'type': 'orders',
3223             'only': 'only',
3224             'compute_value': 'compute_value',
3225             'tick': 'tick',
3226             'orders': ['order1', 'order2']
3227             })
3228
3229         add_log.reset_mock()
3230         def compute_value(x, y):
3231             return x[y]
3232         report_store.log_orders(orders, tick="tick",
3233                 only="only", compute_value=compute_value)
3234         add_log.assert_called_with({
3235             'type': 'orders',
3236             'only': 'only',
3237             'compute_value': 'def compute_value(x, y):\n            return x[y]',
3238             'tick': 'tick',
3239             'orders': ['order1', 'order2']
3240             })
3241
3242
3243     @mock.patch.object(market.ReportStore, "print_log")
3244     @mock.patch.object(market.ReportStore, "add_log")
3245     def test_log_order(self, add_log, print_log):
3246         report_store = market.ReportStore(self.m)
3247         order_mock = mock.Mock()
3248         order_mock.as_json.return_value = "order"
3249         new_order_mock = mock.Mock()
3250         new_order_mock.as_json.return_value = "new_order"
3251         order_mock.__repr__ = mock.Mock()
3252         order_mock.__repr__.return_value = "Order Mock"
3253         new_order_mock.__repr__ = mock.Mock()
3254         new_order_mock.__repr__.return_value = "New order Mock"
3255
3256         with self.subTest(finished=True):
3257             report_store.log_order(order_mock, 1, finished=True)
3258             print_log.assert_called_once_with("[Order] Finished Order Mock")
3259             add_log.assert_called_once_with({
3260                 'type': 'order',
3261                 'tick': 1,
3262                 'update': None,
3263                 'order': 'order',
3264                 'compute_value': None,
3265                 'new_order': None
3266                 })
3267
3268         add_log.reset_mock()
3269         print_log.reset_mock()
3270
3271         with self.subTest(update="waiting"):
3272             report_store.log_order(order_mock, 1, update="waiting")
3273             print_log.assert_called_once_with("[Order] Order Mock, tick 1, waiting")
3274             add_log.assert_called_once_with({
3275                 'type': 'order',
3276                 'tick': 1,
3277                 'update': 'waiting',
3278                 'order': 'order',
3279                 'compute_value': None,
3280                 'new_order': None
3281                 })
3282
3283         add_log.reset_mock()
3284         print_log.reset_mock()
3285         with self.subTest(update="adjusting"):
3286             compute_value = lambda x: (x["bid"] + x["ask"]*2)/3
3287             report_store.log_order(order_mock, 3,
3288                     update="adjusting", new_order=new_order_mock,
3289                     compute_value=compute_value)
3290             print_log.assert_called_once_with("[Order] Order Mock, tick 3, cancelling and adjusting to New order Mock")
3291             add_log.assert_called_once_with({
3292                 'type': 'order',
3293                 'tick': 3,
3294                 'update': 'adjusting',
3295                 'order': 'order',
3296                 'compute_value': 'compute_value = lambda x: (x["bid"] + x["ask"]*2)/3',
3297                 'new_order': 'new_order'
3298                 })
3299
3300         add_log.reset_mock()
3301         print_log.reset_mock()
3302         with self.subTest(update="market_fallback"):
3303             report_store.log_order(order_mock, 7,
3304                     update="market_fallback", new_order=new_order_mock)
3305             print_log.assert_called_once_with("[Order] Order Mock, tick 7, fallbacking to market value")
3306             add_log.assert_called_once_with({
3307                 'type': 'order',
3308                 'tick': 7,
3309                 'update': 'market_fallback',
3310                 'order': 'order',
3311                 'compute_value': None,
3312                 'new_order': 'new_order'
3313                 })
3314
3315         add_log.reset_mock()
3316         print_log.reset_mock()
3317         with self.subTest(update="market_adjusting"):
3318             report_store.log_order(order_mock, 17,
3319                     update="market_adjust", new_order=new_order_mock)
3320             print_log.assert_called_once_with("[Order] Order Mock, tick 17, market value, cancelling and adjusting to New order Mock")
3321             add_log.assert_called_once_with({
3322                 'type': 'order',
3323                 'tick': 17,
3324                 'update': 'market_adjust',
3325                 'order': 'order',
3326                 'compute_value': None,
3327                 'new_order': 'new_order'
3328                 })
3329
3330     @mock.patch.object(market.ReportStore, "print_log")
3331     @mock.patch.object(market.ReportStore, "add_log")
3332     def test_log_move_balances(self, add_log, print_log):
3333         report_store = market.ReportStore(self.m)
3334         needed = {
3335                 "BTC": portfolio.Amount("BTC", 10),
3336                 "USDT": 1
3337                 }
3338         moving = {
3339                 "BTC": portfolio.Amount("BTC", 3),
3340                 "USDT": -2
3341                 }
3342         report_store.log_move_balances(needed, moving)
3343         print_log.assert_not_called()
3344         add_log.assert_called_once_with({
3345             'type': 'move_balances',
3346             'debug': False,
3347             'needed': {
3348                 'BTC': D('10'),
3349                 'USDT': 1
3350                 },
3351             'moving': {
3352                 'BTC': D('3'),
3353                 'USDT': -2
3354                 }
3355             })
3356
3357     @mock.patch.object(market.ReportStore, "print_log")
3358     @mock.patch.object(market.ReportStore, "add_log")
3359     def test_log_http_request(self, add_log, print_log):
3360         report_store = market.ReportStore(self.m)
3361         response = mock.Mock()
3362         response.status_code = 200
3363         response.text = "Hey"
3364
3365         report_store.log_http_request("method", "url", "body",
3366                 "headers", response)
3367         print_log.assert_not_called()
3368         add_log.assert_called_once_with({
3369             'type': 'http_request',
3370             'method': 'method',
3371             'url': 'url',
3372             'body': 'body',
3373             'headers': 'headers',
3374             'status': 200,
3375             'response': 'Hey'
3376             })
3377
3378     @mock.patch.object(market.ReportStore, "print_log")
3379     @mock.patch.object(market.ReportStore, "add_log")
3380     def test_log_error(self, add_log, print_log):
3381         report_store = market.ReportStore(self.m)
3382         with self.subTest(message=None, exception=None):
3383             report_store.log_error("action")
3384             print_log.assert_called_once_with("[Error] action")
3385             add_log.assert_called_once_with({
3386                 'type': 'error',
3387                 'action': 'action',
3388                 'exception_class': None,
3389                 'exception_message': None,
3390                 'message': None
3391                 })
3392
3393         print_log.reset_mock()
3394         add_log.reset_mock()
3395         with self.subTest(message="Hey", exception=None):
3396             report_store.log_error("action", message="Hey")
3397             print_log.assert_has_calls([
3398                     mock.call("[Error] action"),
3399                     mock.call("\tHey")
3400                     ])
3401             add_log.assert_called_once_with({
3402                 'type': 'error',
3403                 'action': 'action',
3404                 'exception_class': None,
3405                 'exception_message': None,
3406                 'message': "Hey"
3407                 })
3408
3409         print_log.reset_mock()
3410         add_log.reset_mock()
3411         with self.subTest(message=None, exception=Exception("bouh")):
3412             report_store.log_error("action", exception=Exception("bouh"))
3413             print_log.assert_has_calls([
3414                     mock.call("[Error] action"),
3415                     mock.call("\tException: bouh")
3416                     ])
3417             add_log.assert_called_once_with({
3418                 'type': 'error',
3419                 'action': 'action',
3420                 'exception_class': "Exception",
3421                 'exception_message': "bouh",
3422                 'message': None
3423                 })
3424
3425         print_log.reset_mock()
3426         add_log.reset_mock()
3427         with self.subTest(message="Hey", exception=Exception("bouh")):
3428             report_store.log_error("action", message="Hey", exception=Exception("bouh"))
3429             print_log.assert_has_calls([
3430                     mock.call("[Error] action"),
3431                     mock.call("\tException: bouh"),
3432                     mock.call("\tHey")
3433                     ])
3434             add_log.assert_called_once_with({
3435                 'type': 'error',
3436                 'action': 'action',
3437                 'exception_class': "Exception",
3438                 'exception_message': "bouh",
3439                 'message': "Hey"
3440                 })
3441
3442     @mock.patch.object(market.ReportStore, "print_log")
3443     @mock.patch.object(market.ReportStore, "add_log")
3444     def test_log_debug_action(self, add_log, print_log):
3445         report_store = market.ReportStore(self.m)
3446         report_store.log_debug_action("Hey")
3447
3448         print_log.assert_called_once_with("[Debug] Hey")
3449         add_log.assert_called_once_with({
3450             'type': 'debug_action',
3451             'action': 'Hey'
3452             })
3453
3454 @unittest.skipUnless("unit" in limits, "Unit skipped")
3455 class MainTest(WebMockTestCase):
3456     def test_make_order(self):
3457         self.m.get_ticker.return_value = {
3458                 "inverted": False,
3459                 "average": D("0.1"),
3460                 "bid": D("0.09"),
3461                 "ask": D("0.11"),
3462                 }
3463
3464         with self.subTest(description="nominal case"):
3465             main.make_order(self.m, 10, "ETH")
3466
3467             self.m.report.log_stage.assert_has_calls([
3468                 mock.call("make_order_begin"),
3469                 mock.call("make_order_end"),
3470                 ])
3471             self.m.balances.fetch_balances.assert_has_calls([
3472                 mock.call(tag="make_order_begin"),
3473                 mock.call(tag="make_order_end"),
3474                 ])
3475             self.m.trades.all.append.assert_called_once()
3476             trade = self.m.trades.all.append.mock_calls[0][1][0]
3477             self.assertEqual(False, trade.orders[0].close_if_possible)
3478             self.assertEqual(0, trade.value_from)
3479             self.assertEqual("ETH", trade.currency)
3480             self.assertEqual("BTC", trade.base_currency)
3481             self.m.report.log_orders.assert_called_once_with([trade.orders[0]], None, "average")
3482             self.m.trades.run_orders.assert_called_once_with()
3483             self.m.follow_orders.assert_called_once_with()
3484
3485             order = trade.orders[0]
3486             self.assertEqual(D("0.10"), order.rate)
3487
3488             self.m.reset_mock()
3489             with self.subTest(compute_value="default"):
3490                 main.make_order(self.m, 10, "ETH", action="dispose",
3491                         compute_value="ask")
3492
3493                 trade = self.m.trades.all.append.mock_calls[0][1][0]
3494                 order = trade.orders[0]
3495                 self.assertEqual(D("0.11"), order.rate)
3496
3497         self.m.reset_mock()
3498         with self.subTest(follow=False):
3499             result = main.make_order(self.m, 10, "ETH", follow=False)
3500
3501             self.m.report.log_stage.assert_has_calls([
3502                 mock.call("make_order_begin"),
3503                 mock.call("make_order_end_not_followed"),
3504                 ])
3505             self.m.balances.fetch_balances.assert_called_once_with(tag="make_order_begin")
3506
3507             self.m.trades.all.append.assert_called_once()
3508             trade = self.m.trades.all.append.mock_calls[0][1][0]
3509             self.assertEqual(0, trade.value_from)
3510             self.assertEqual("ETH", trade.currency)
3511             self.assertEqual("BTC", trade.base_currency)
3512             self.m.report.log_orders.assert_called_once_with([trade.orders[0]], None, "average")
3513             self.m.trades.run_orders.assert_called_once_with()
3514             self.m.follow_orders.assert_not_called()
3515             self.assertEqual(trade.orders[0], result)
3516
3517         self.m.reset_mock()
3518         with self.subTest(base_currency="USDT"):
3519             main.make_order(self.m, 1, "BTC", base_currency="USDT")
3520
3521             trade = self.m.trades.all.append.mock_calls[0][1][0]
3522             self.assertEqual("BTC", trade.currency)
3523             self.assertEqual("USDT", trade.base_currency)
3524
3525         self.m.reset_mock()
3526         with self.subTest(close_if_possible=True):
3527             main.make_order(self.m, 10, "ETH", close_if_possible=True)
3528
3529             trade = self.m.trades.all.append.mock_calls[0][1][0]
3530             self.assertEqual(True, trade.orders[0].close_if_possible)
3531
3532         self.m.reset_mock()
3533         with self.subTest(action="dispose"):
3534             main.make_order(self.m, 10, "ETH", action="dispose")
3535
3536             trade = self.m.trades.all.append.mock_calls[0][1][0]
3537             self.assertEqual(0, trade.value_to)
3538             self.assertEqual(1, trade.value_from.value)
3539             self.assertEqual("ETH", trade.currency)
3540             self.assertEqual("BTC", trade.base_currency)
3541
3542             self.m.reset_mock()
3543             with self.subTest(compute_value="default"):
3544                 main.make_order(self.m, 10, "ETH", action="dispose",
3545                         compute_value="bid")
3546
3547                 trade = self.m.trades.all.append.mock_calls[0][1][0]
3548                 self.assertEqual(D("0.9"), trade.value_from.value)
3549
3550     def test_get_user_market(self):
3551         with mock.patch("main.fetch_markets") as main_fetch_markets,\
3552                 mock.patch("main.parse_config") as main_parse_config:
3553             with self.subTest(debug=False):
3554                 main_parse_config.return_value = ["pg_config", "report_path"]
3555                 main_fetch_markets.return_value = [({"key": "market_config"},)]
3556                 m = main.get_user_market("config_path.ini", 1)
3557
3558                 self.assertIsInstance(m, market.Market)
3559                 self.assertFalse(m.debug)
3560
3561             with self.subTest(debug=True):
3562                 main_parse_config.return_value = ["pg_config", "report_path"]
3563                 main_fetch_markets.return_value = [({"key": "market_config"},)]
3564                 m = main.get_user_market("config_path.ini", 1, debug=True)
3565
3566                 self.assertIsInstance(m, market.Market)
3567                 self.assertTrue(m.debug)
3568
3569     def test_process(self):
3570         with mock.patch("market.Market") as market_mock,\
3571                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
3572
3573             args_mock = mock.Mock()
3574             args_mock.action = "action"
3575             args_mock.config = "config"
3576             args_mock.user = "user"
3577             args_mock.debug = "debug"
3578             args_mock.before = "before"
3579             args_mock.after = "after"
3580             self.assertEqual("", stdout_mock.getvalue())
3581
3582             main.process("config", 1, "report_path", args_mock)
3583
3584             market_mock.from_config.assert_has_calls([
3585                 mock.call("config", args_mock, user_id=1, report_path="report_path"),
3586                 mock.call().process("action", before="before", after="after"),
3587                 ])
3588
3589             with self.subTest(exception=True):
3590                 market_mock.from_config.side_effect = Exception("boo")
3591                 main.process("config", 1, "report_path", args_mock)
3592                 self.assertEqual("Exception: boo\n", stdout_mock.getvalue())
3593
3594     def test_main(self):
3595         with self.subTest(parallel=False):
3596             with mock.patch("main.parse_args") as parse_args,\
3597                     mock.patch("main.parse_config") as parse_config,\
3598                     mock.patch("main.fetch_markets") as fetch_markets,\
3599                     mock.patch("main.process") as process:
3600
3601                 args_mock = mock.Mock()
3602                 args_mock.parallel = False
3603                 args_mock.config = "config"
3604                 args_mock.user = "user"
3605                 parse_args.return_value = args_mock
3606
3607                 parse_config.return_value = ["pg_config", "report_path"]
3608
3609                 fetch_markets.return_value = [["config1", 1], ["config2", 2]]
3610
3611                 main.main(["Foo", "Bar"])
3612
3613                 parse_args.assert_called_with(["Foo", "Bar"])
3614                 parse_config.assert_called_with("config")
3615                 fetch_markets.assert_called_with("pg_config", "user")
3616
3617                 self.assertEqual(2, process.call_count)
3618                 process.assert_has_calls([
3619                     mock.call("config1", 1, "report_path", args_mock),
3620                     mock.call("config2", 2, "report_path", args_mock),
3621                     ])
3622         with self.subTest(parallel=True):
3623             with mock.patch("main.parse_args") as parse_args,\
3624                     mock.patch("main.parse_config") as parse_config,\
3625                     mock.patch("main.fetch_markets") as fetch_markets,\
3626                     mock.patch("main.process") as process,\
3627                     mock.patch("store.Portfolio.start_worker") as start:
3628
3629                 args_mock = mock.Mock()
3630                 args_mock.parallel = True
3631                 args_mock.config = "config"
3632                 args_mock.user = "user"
3633                 parse_args.return_value = args_mock
3634
3635                 parse_config.return_value = ["pg_config", "report_path"]
3636
3637                 fetch_markets.return_value = [["config1", 1], ["config2", 2]]
3638
3639                 main.main(["Foo", "Bar"])
3640
3641                 parse_args.assert_called_with(["Foo", "Bar"])
3642                 parse_config.assert_called_with("config")
3643                 fetch_markets.assert_called_with("pg_config", "user")
3644
3645                 start.assert_called_once_with()
3646                 self.assertEqual(2, process.call_count)
3647                 process.assert_has_calls([
3648                     mock.call.__bool__(),
3649                     mock.call("config1", 1, "report_path", args_mock),
3650                     mock.call.__bool__(),
3651                     mock.call("config2", 2, "report_path", args_mock),
3652                     ])
3653
3654     @mock.patch.object(main.sys, "exit")
3655     @mock.patch("main.configparser")
3656     @mock.patch("main.os")
3657     def test_parse_config(self, os, configparser, exit):
3658         with self.subTest(pg_config=True, report_path=None):
3659             config_mock = mock.MagicMock()
3660             configparser.ConfigParser.return_value = config_mock
3661             def config(element):
3662                 return element == "postgresql"
3663
3664             config_mock.__contains__.side_effect = config
3665             config_mock.__getitem__.return_value = "pg_config"
3666
3667             result = main.parse_config("configfile")
3668
3669             config_mock.read.assert_called_with("configfile")
3670
3671             self.assertEqual(["pg_config", None], result)
3672
3673         with self.subTest(pg_config=True, report_path="present"):
3674             config_mock = mock.MagicMock()
3675             configparser.ConfigParser.return_value = config_mock
3676
3677             config_mock.__contains__.return_value = True
3678             config_mock.__getitem__.side_effect = [
3679                     {"report_path": "report_path"},
3680                     {"report_path": "report_path"},
3681                     "pg_config",
3682                     ]
3683
3684             os.path.exists.return_value = False
3685             result = main.parse_config("configfile")
3686
3687             config_mock.read.assert_called_with("configfile")
3688             self.assertEqual(["pg_config", "report_path"], result)
3689             os.path.exists.assert_called_once_with("report_path")
3690             os.makedirs.assert_called_once_with("report_path")
3691
3692         with self.subTest(pg_config=False),\
3693                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
3694             config_mock = mock.MagicMock()
3695             configparser.ConfigParser.return_value = config_mock
3696             result = main.parse_config("configfile")
3697
3698             config_mock.read.assert_called_with("configfile")
3699             exit.assert_called_once_with(1)
3700             self.assertEqual("no configuration for postgresql in config file\n", stdout_mock.getvalue())
3701
3702     @mock.patch.object(main.sys, "exit")
3703     def test_parse_args(self, exit):
3704         with self.subTest(config="config.ini"):
3705             args = main.parse_args([])
3706             self.assertEqual("config.ini", args.config)
3707             self.assertFalse(args.before)
3708             self.assertFalse(args.after)
3709             self.assertFalse(args.debug)
3710
3711             args = main.parse_args(["--before", "--after", "--debug"])
3712             self.assertTrue(args.before)
3713             self.assertTrue(args.after)
3714             self.assertTrue(args.debug)
3715
3716             exit.assert_not_called()
3717
3718         with self.subTest(config="inexistant"),\
3719                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
3720             args = main.parse_args(["--config", "foo.bar"])
3721             exit.assert_called_once_with(1)
3722             self.assertEqual("no config file found, exiting\n", stdout_mock.getvalue())
3723
3724     @mock.patch.object(main, "psycopg2")
3725     def test_fetch_markets(self, psycopg2):
3726         connect_mock = mock.Mock()
3727         cursor_mock = mock.MagicMock()
3728         cursor_mock.__iter__.return_value = ["row_1", "row_2"]
3729
3730         connect_mock.cursor.return_value = cursor_mock
3731         psycopg2.connect.return_value = connect_mock
3732
3733         with self.subTest(user=None):
3734             rows = list(main.fetch_markets({"foo": "bar"}, None))
3735
3736             psycopg2.connect.assert_called_once_with(foo="bar")
3737             cursor_mock.execute.assert_called_once_with("SELECT config,user_id FROM market_configs")
3738
3739             self.assertEqual(["row_1", "row_2"], rows)
3740
3741         psycopg2.connect.reset_mock()
3742         cursor_mock.execute.reset_mock()
3743         with self.subTest(user=1):
3744             rows = list(main.fetch_markets({"foo": "bar"}, 1))
3745
3746             psycopg2.connect.assert_called_once_with(foo="bar")
3747             cursor_mock.execute.assert_called_once_with("SELECT config,user_id FROM market_configs WHERE user_id = %s", 1)
3748
3749             self.assertEqual(["row_1", "row_2"], rows)
3750
3751
3752 @unittest.skipUnless("unit" in limits, "Unit skipped")
3753 class ProcessorTest(WebMockTestCase):
3754     def test_values(self):
3755         processor = market.Processor(self.m)
3756
3757         self.assertEqual(self.m, processor.market)
3758
3759     def test_run_action(self):
3760         processor = market.Processor(self.m)
3761
3762         with mock.patch.object(processor, "parse_args") as parse_args:
3763             method_mock = mock.Mock()
3764             parse_args.return_value = [method_mock, { "foo": "bar" }]
3765
3766             processor.run_action("foo", "bar", "baz")
3767
3768             parse_args.assert_called_with("foo", "bar", "baz")
3769
3770             method_mock.assert_called_with(foo="bar")
3771
3772             processor.run_action("wait_for_recent", "bar", "baz")
3773
3774             method_mock.assert_called_with(foo="bar")
3775
3776     def test_select_step(self):
3777         processor = market.Processor(self.m)
3778
3779         scenario = processor.scenarios["sell_all"]
3780
3781         self.assertEqual(scenario, processor.select_steps(scenario, "all"))
3782         self.assertEqual(["all_sell"], list(map(lambda x: x["name"], processor.select_steps(scenario, "before"))))
3783         self.assertEqual(["wait", "all_buy"], list(map(lambda x: x["name"], processor.select_steps(scenario, "after"))))
3784         self.assertEqual(["wait"], list(map(lambda x: x["name"], processor.select_steps(scenario, 2))))
3785         self.assertEqual(["wait"], list(map(lambda x: x["name"], processor.select_steps(scenario, "wait"))))
3786
3787         with self.assertRaises(TypeError):
3788             processor.select_steps(scenario, ["wait"])
3789
3790     @mock.patch("market.Processor.process_step")
3791     def test_process(self, process_step):
3792         processor = market.Processor(self.m)
3793
3794         processor.process("sell_all", foo="bar")
3795         self.assertEqual(3, process_step.call_count)
3796
3797         steps = list(map(lambda x: x[1][1]["name"], process_step.mock_calls))
3798         scenario_names = list(map(lambda x: x[1][0], process_step.mock_calls))
3799         kwargs = list(map(lambda x: x[1][2], process_step.mock_calls))
3800         self.assertEqual(["all_sell", "wait", "all_buy"], steps)
3801         self.assertEqual(["sell_all", "sell_all", "sell_all"], scenario_names)
3802         self.assertEqual([{"foo":"bar"}, {"foo":"bar"}, {"foo":"bar"}], kwargs)
3803
3804         process_step.reset_mock()
3805
3806         processor.process("sell_needed", steps=["before", "after"])
3807         self.assertEqual(3, process_step.call_count)
3808
3809     def test_method_arguments(self):
3810         ccxt = mock.Mock(spec=market.ccxt.poloniexE)
3811         m = market.Market(ccxt, self.market_args())
3812
3813         processor = market.Processor(m)
3814
3815         method, arguments = processor.method_arguments("wait_for_recent")
3816         self.assertEqual(market.Portfolio.wait_for_recent, method)
3817         self.assertEqual(["delta", "poll"], arguments)
3818
3819         method, arguments = processor.method_arguments("prepare_trades")
3820         self.assertEqual(m.prepare_trades, method)
3821         self.assertEqual(['base_currency', 'liquidity', 'compute_value', 'repartition', 'only'], arguments)
3822
3823         method, arguments = processor.method_arguments("prepare_orders")
3824         self.assertEqual(m.trades.prepare_orders, method)
3825
3826         method, arguments = processor.method_arguments("move_balances")
3827         self.assertEqual(m.move_balances, method)
3828
3829         method, arguments = processor.method_arguments("run_orders")
3830         self.assertEqual(m.trades.run_orders, method)
3831
3832         method, arguments = processor.method_arguments("follow_orders")
3833         self.assertEqual(m.follow_orders, method)
3834
3835         method, arguments = processor.method_arguments("close_trades")
3836         self.assertEqual(m.trades.close_trades, method)
3837
3838     def test_process_step(self):
3839         processor = market.Processor(self.m)
3840
3841         with mock.patch.object(processor, "run_action") as run_action:
3842             step = processor.scenarios["sell_needed"][1]
3843
3844             processor.process_step("foo", step, {"foo":"bar"})
3845
3846             self.m.report.log_stage.assert_has_calls([
3847                 mock.call("process_foo__1_sell_begin"),
3848                 mock.call("process_foo__1_sell_end"),
3849                 ])
3850             self.m.balances.fetch_balances.assert_has_calls([
3851                 mock.call(tag="process_foo__1_sell_begin"),
3852                 mock.call(tag="process_foo__1_sell_end"),
3853                 ])
3854
3855             self.assertEqual(5, run_action.call_count)
3856
3857             run_action.assert_has_calls([
3858                 mock.call('prepare_trades', {}, {'foo': 'bar'}),
3859                 mock.call('prepare_orders', {'only': 'dispose', 'compute_value': 'average'}, {'foo': 'bar'}),
3860                 mock.call('run_orders', {}, {'foo': 'bar'}),
3861                 mock.call('follow_orders', {}, {'foo': 'bar'}),
3862                 mock.call('close_trades', {}, {'foo': 'bar'}),
3863                 ])
3864
3865         self.m.reset_mock()
3866         with mock.patch.object(processor, "run_action") as run_action:
3867             step = processor.scenarios["sell_needed"][0]
3868
3869             processor.process_step("foo", step, {"foo":"bar"})
3870             self.m.balances.fetch_balances.assert_not_called()
3871
3872     def test_parse_args(self):
3873         processor = market.Processor(self.m)
3874
3875         with mock.patch.object(processor, "method_arguments") as method_arguments:
3876             method_mock = mock.Mock()
3877             method_arguments.return_value = [
3878                     method_mock,
3879                     ["foo2", "foo"]
3880                     ]
3881             method, args = processor.parse_args("action", {"foo": "bar", "foo2": "bar"}, {"foo": "bar2", "bla": "bla"})
3882
3883             self.assertEqual(method_mock, method)
3884             self.assertEqual({"foo": "bar2", "foo2": "bar"}, args)
3885
3886         with mock.patch.object(processor, "method_arguments") as method_arguments:
3887             method_mock = mock.Mock()
3888             method_arguments.return_value = [
3889                     method_mock,
3890                     ["repartition"]
3891                     ]
3892             method, args = processor.parse_args("action", {"repartition": { "base_currency": 1 }}, {})
3893
3894             self.assertEqual(1, len(args["repartition"]))
3895             self.assertIn("BTC", args["repartition"])
3896
3897         with mock.patch.object(processor, "method_arguments") as method_arguments:
3898             method_mock = mock.Mock()
3899             method_arguments.return_value = [
3900                     method_mock,
3901                     ["repartition", "base_currency"]
3902                     ]
3903             method, args = processor.parse_args("action", {"repartition": { "base_currency": 1 }}, {"base_currency": "USDT"})
3904
3905             self.assertEqual(1, len(args["repartition"]))
3906             self.assertIn("USDT", args["repartition"])
3907
3908         with mock.patch.object(processor, "method_arguments") as method_arguments:
3909             method_mock = mock.Mock()
3910             method_arguments.return_value = [
3911                     method_mock,
3912                     ["repartition", "base_currency"]
3913                     ]
3914             method, args = processor.parse_args("action", {"repartition": { "ETH": 1 }}, {"base_currency": "USDT"})
3915
3916             self.assertEqual(1, len(args["repartition"]))
3917             self.assertIn("ETH", args["repartition"])
3918
3919
3920 @unittest.skipUnless("acceptance" in limits, "Acceptance skipped")
3921 class AcceptanceTest(WebMockTestCase):
3922     @unittest.expectedFailure
3923     def test_success_sell_only_necessary(self):
3924         # FIXME: catch stdout
3925         self.m.report.verbose_print = False
3926         fetch_balance = {
3927                 "ETH": {
3928                     "exchange_free": D("1.0"),
3929                     "exchange_used": D("0.0"),
3930                     "exchange_total": D("1.0"),
3931                     "total": D("1.0"),
3932                     },
3933                 "ETC": {
3934                     "exchange_free": D("4.0"),
3935                     "exchange_used": D("0.0"),
3936                     "exchange_total": D("4.0"),
3937                     "total": D("4.0"),
3938                     },
3939                 "XVG": {
3940                     "exchange_free": D("1000.0"),
3941                     "exchange_used": D("0.0"),
3942                     "exchange_total": D("1000.0"),
3943                     "total": D("1000.0"),
3944                     },
3945                 }
3946         repartition = {
3947                 "ETH":  (D("0.25"), "long"),
3948                 "ETC":  (D("0.25"), "long"),
3949                 "BTC":  (D("0.4"),  "long"),
3950                 "BTD":  (D("0.01"), "short"),
3951                 "B2X":  (D("0.04"), "long"),
3952                 "USDT": (D("0.05"), "long"),
3953                 }
3954
3955         def fetch_ticker(symbol):
3956             if symbol == "ETH/BTC":
3957                 return {
3958                         "symbol": "ETH/BTC",
3959                         "bid": D("0.14"),
3960                         "ask": D("0.16")
3961                         }
3962             if symbol == "ETC/BTC":
3963                 return {
3964                         "symbol": "ETC/BTC",
3965                         "bid": D("0.002"),
3966                         "ask": D("0.003")
3967                         }
3968             if symbol == "XVG/BTC":
3969                 return {
3970                         "symbol": "XVG/BTC",
3971                         "bid": D("0.00003"),
3972                         "ask": D("0.00005")
3973                         }
3974             if symbol == "BTD/BTC":
3975                 return {
3976                         "symbol": "BTD/BTC",
3977                         "bid": D("0.0008"),
3978                         "ask": D("0.0012")
3979                         }
3980             if symbol == "B2X/BTC":
3981                 return {
3982                         "symbol": "B2X/BTC",
3983                         "bid": D("0.0008"),
3984                         "ask": D("0.0012")
3985                         }
3986             if symbol == "USDT/BTC":
3987                 raise helper.ExchangeError
3988             if symbol == "BTC/USDT":
3989                 return {
3990                         "symbol": "BTC/USDT",
3991                         "bid": D("14000"),
3992                         "ask": D("16000")
3993                         }
3994             self.fail("Shouldn't have been called with {}".format(symbol))
3995
3996         market = mock.Mock()
3997         market.fetch_all_balances.return_value = fetch_balance
3998         market.fetch_ticker.side_effect = fetch_ticker
3999         with mock.patch.object(market.Portfolio, "repartition", return_value=repartition):
4000             # Action 1
4001             helper.prepare_trades(market)
4002
4003         balances = portfolio.BalanceStore.all
4004         self.assertEqual(portfolio.Amount("ETH", 1), balances["ETH"].total)
4005         self.assertEqual(portfolio.Amount("ETC", 4), balances["ETC"].total)
4006         self.assertEqual(portfolio.Amount("XVG", 1000), balances["XVG"].total)
4007
4008
4009         trades = portfolio.TradeStore.all
4010         self.assertEqual(portfolio.Amount("BTC", D("0.15")), trades[0].value_from)
4011         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[0].value_to)
4012         self.assertEqual("dispose", trades[0].action)
4013
4014         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[1].value_from)
4015         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[1].value_to)
4016         self.assertEqual("acquire", trades[1].action)
4017
4018         self.assertEqual(portfolio.Amount("BTC", D("0.04")), trades[2].value_from)
4019         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[2].value_to)
4020         self.assertEqual("dispose", trades[2].action)
4021
4022         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[3].value_from)
4023         self.assertEqual(portfolio.Amount("BTC", D("-0.002")), trades[3].value_to)
4024         self.assertEqual("acquire", trades[3].action)
4025
4026         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[4].value_from)
4027         self.assertEqual(portfolio.Amount("BTC", D("0.008")), trades[4].value_to)
4028         self.assertEqual("acquire", trades[4].action)
4029
4030         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[5].value_from)
4031         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[5].value_to)
4032         self.assertEqual("acquire", trades[5].action)
4033
4034         # Action 2
4035         portfolio.TradeStore.prepare_orders(only="dispose", compute_value=lambda x, y: x["bid"] * D("1.001"))
4036
4037         all_orders = portfolio.TradeStore.all_orders(state="pending")
4038         self.assertEqual(2, len(all_orders))
4039         self.assertEqual(2, 3*all_orders[0].amount.value)
4040         self.assertEqual(D("0.14014"), all_orders[0].rate)
4041         self.assertEqual(1000, all_orders[1].amount.value)
4042         self.assertEqual(D("0.00003003"), all_orders[1].rate)
4043
4044
4045         def create_order(symbol, type, action, amount, price=None, account="exchange"):
4046             self.assertEqual("limit", type)
4047             if symbol == "ETH/BTC":
4048                 self.assertEqual("sell", action)
4049                 self.assertEqual(D('0.66666666'), amount)
4050                 self.assertEqual(D("0.14014"), price)
4051             elif symbol == "XVG/BTC":
4052                 self.assertEqual("sell", action)
4053                 self.assertEqual(1000, amount)
4054                 self.assertEqual(D("0.00003003"), price)
4055             else:
4056                 self.fail("I shouldn't have been called")
4057
4058             return {
4059                     "id": symbol,
4060                     }
4061         market.create_order.side_effect = create_order
4062         market.order_precision.return_value = 8
4063
4064         # Action 3
4065         portfolio.TradeStore.run_orders()
4066
4067         self.assertEqual("open", all_orders[0].status)
4068         self.assertEqual("open", all_orders[1].status)
4069
4070         market.fetch_order.return_value = { "status": "closed", "datetime": "2018-01-20 13:40:00" }
4071         market.privatePostReturnOrderTrades.return_value = [
4072                 {
4073                     "tradeID": 42, "type": "buy", "fee": "0.0015",
4074                     "date": "2017-12-30 12:00:12", "rate": "0.1",
4075                     "amount": "10", "total": "1"
4076                     }
4077                 ]
4078         with mock.patch.object(market.time, "sleep") as sleep:
4079             # Action 4
4080             helper.follow_orders(verbose=False)
4081
4082             sleep.assert_called_with(30)
4083
4084         for order in all_orders:
4085             self.assertEqual("closed", order.status)
4086
4087         fetch_balance = {
4088                 "ETH": {
4089                     "exchange_free": D("1.0") / 3,
4090                     "exchange_used": D("0.0"),
4091                     "exchange_total": D("1.0") / 3,
4092                     "margin_total": 0,
4093                     "total": D("1.0") / 3,
4094                     },
4095                 "BTC": {
4096                     "exchange_free": D("0.134"),
4097                     "exchange_used": D("0.0"),
4098                     "exchange_total": D("0.134"),
4099                     "margin_total": 0,
4100                     "total": D("0.134"),
4101                     },
4102                 "ETC": {
4103                     "exchange_free": D("4.0"),
4104                     "exchange_used": D("0.0"),
4105                     "exchange_total": D("4.0"),
4106                     "margin_total": 0,
4107                     "total": D("4.0"),
4108                     },
4109                 "XVG": {
4110                     "exchange_free": D("0.0"),
4111                     "exchange_used": D("0.0"),
4112                     "exchange_total": D("0.0"),
4113                     "margin_total": 0,
4114                     "total": D("0.0"),
4115                     },
4116                 }
4117         market.fetch_all_balances.return_value = fetch_balance
4118
4119         with mock.patch.object(market.Portfolio, "repartition", return_value=repartition):
4120             # Action 5
4121             helper.prepare_trades(market, only="acquire", compute_value="average")
4122
4123         balances = portfolio.BalanceStore.all
4124         self.assertEqual(portfolio.Amount("ETH", 1 / D("3")), balances["ETH"].total)
4125         self.assertEqual(portfolio.Amount("ETC", 4), balances["ETC"].total)
4126         self.assertEqual(portfolio.Amount("BTC", D("0.134")), balances["BTC"].total)
4127         self.assertEqual(portfolio.Amount("XVG", 0), balances["XVG"].total)
4128
4129
4130         trades = portfolio.TradeStore.all
4131         self.assertEqual(portfolio.Amount("BTC", D("0.15")), trades[0].value_from)
4132         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[0].value_to)
4133         self.assertEqual("dispose", trades[0].action)
4134
4135         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[1].value_from)
4136         self.assertEqual(portfolio.Amount("BTC", D("0.05")), trades[1].value_to)
4137         self.assertEqual("acquire", trades[1].action)
4138
4139         self.assertNotIn("BTC", trades)
4140
4141         self.assertEqual(portfolio.Amount("BTC", D("0.04")), trades[2].value_from)
4142         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[2].value_to)
4143         self.assertEqual("dispose", trades[2].action)
4144
4145         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[3].value_from)
4146         self.assertEqual(portfolio.Amount("BTC", D("-0.002")), trades[3].value_to)
4147         self.assertEqual("acquire", trades[3].action)
4148
4149         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[4].value_from)
4150         self.assertEqual(portfolio.Amount("BTC", D("0.008")), trades[4].value_to)
4151         self.assertEqual("acquire", trades[4].action)
4152
4153         self.assertEqual(portfolio.Amount("BTC", D("0.00")), trades[5].value_from)
4154         self.assertEqual(portfolio.Amount("BTC", D("0.01")), trades[5].value_to)
4155         self.assertEqual("acquire", trades[5].action)
4156
4157         # Action 6
4158         portfolio.TradeStore.prepare_orders(only="acquire", compute_value=lambda x, y: x["ask"])
4159
4160         all_orders = portfolio.TradeStore.all_orders(state="pending")
4161         self.assertEqual(4, len(all_orders))
4162         self.assertEqual(portfolio.Amount("ETC", D("12.83333333")), round(all_orders[0].amount))
4163         self.assertEqual(D("0.003"), all_orders[0].rate)
4164         self.assertEqual("buy", all_orders[0].action)
4165         self.assertEqual("long", all_orders[0].trade_type)
4166
4167         self.assertEqual(portfolio.Amount("BTD", D("1.61666666")), round(all_orders[1].amount))
4168         self.assertEqual(D("0.0012"), all_orders[1].rate)
4169         self.assertEqual("sell", all_orders[1].action)
4170         self.assertEqual("short", all_orders[1].trade_type)
4171
4172         diff = portfolio.Amount("B2X", D("19.4")/3) - all_orders[2].amount
4173         self.assertAlmostEqual(0, diff.value)
4174         self.assertEqual(D("0.0012"), all_orders[2].rate)
4175         self.assertEqual("buy", all_orders[2].action)
4176         self.assertEqual("long", all_orders[2].trade_type)
4177
4178         self.assertEqual(portfolio.Amount("BTC", D("0.0097")), all_orders[3].amount)
4179         self.assertEqual(D("16000"), all_orders[3].rate)
4180         self.assertEqual("sell", all_orders[3].action)
4181         self.assertEqual("long", all_orders[3].trade_type)
4182
4183         # Action 6b
4184         # TODO:
4185         # Move balances to margin
4186
4187         # Action 7
4188         # TODO
4189         # portfolio.TradeStore.run_orders()
4190
4191         with mock.patch.object(market.time, "sleep") as sleep:
4192             # Action 8
4193             helper.follow_orders(verbose=False)
4194
4195             sleep.assert_called_with(30)
4196
4197 if __name__ == '__main__':
4198     unittest.main()