test.py

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