tests/test_store.py

   1 from .helper import *
   2 import requests
   3 import datetime
   4 import threading
   5 import market, portfolio, store
   6
   7 @unittest.skipUnless("unit" in limits, "Unit skipped")
   8 class NoopLockTest(unittest.TestCase):
   9     def test_with(self):
  10         noop_lock = store.NoopLock()
  11         with noop_lock:
  12             self.assertTrue(True)
  13
  14 @unittest.skipUnless("unit" in limits, "Unit skipped")
  15 class LockedVarTest(unittest.TestCase):
  16
  17     def test_values(self):
  18         locked_var = store.LockedVar("Foo")
  19         self.assertIsInstance(locked_var.lock, store.NoopLock)
  20         self.assertEqual("Foo", locked_var.val)
  21
  22     def test_get(self):
  23         with self.subTest(desc="Normal case"):
  24             locked_var = store.LockedVar("Foo")
  25             self.assertEqual("Foo", locked_var.get())
  26         with self.subTest(desc="Dict"):
  27             locked_var = store.LockedVar({"foo": "bar"})
  28             self.assertEqual({"foo": "bar"}, locked_var.get())
  29             self.assertEqual("bar", locked_var.get("foo"))
  30             self.assertIsNone(locked_var.get("other"))
  31
  32     def test_set(self):
  33         locked_var = store.LockedVar("Foo")
  34         locked_var.set("Bar")
  35         self.assertEqual("Bar", locked_var.get())
  36
  37     def test__getattr(self):
  38         dummy = type('Dummy', (object,), {})()
  39         dummy.attribute = "Hey"
  40
  41         locked_var = store.LockedVar(dummy)
  42         self.assertEqual("Hey", locked_var.attribute)
  43         with self.assertRaises(AttributeError):
  44             locked_var.other
  45
  46     def test_start_lock(self):
  47         locked_var = store.LockedVar("Foo")
  48         locked_var.start_lock()
  49         self.assertEqual("lock", locked_var.lock.__class__.__name__)
  50
  51         thread1 = threading.Thread(target=locked_var.set, args=["Bar1"])
  52         thread2 = threading.Thread(target=locked_var.set, args=["Bar2"])
  53         thread3 = threading.Thread(target=locked_var.set, args=["Bar3"])
  54
  55         with locked_var.lock:
  56             thread1.start()
  57             thread2.start()
  58             thread3.start()
  59
  60             self.assertEqual("Foo", locked_var.val)
  61         thread1.join()
  62         thread2.join()
  63         thread3.join()
  64         self.assertEqual("Bar", locked_var.get()[0:3])
  65
  66 @unittest.skipUnless("unit" in limits, "Unit skipped")
  67 class TradeStoreTest(WebMockTestCase):
  68     def test_compute_trades(self):
  69         self.m.balances.currencies.return_value = ["XMR", "DASH", "XVG", "BTC", "ETH"]
  70
  71         values_in_base = {
  72                 "XMR": portfolio.Amount("BTC", D("0.9")),
  73                 "DASH": portfolio.Amount("BTC", D("0.4")),
  74                 "XVG": portfolio.Amount("BTC", D("-0.5")),
  75                 "BTC": portfolio.Amount("BTC", D("0.5")),
  76                 }
  77         new_repartition = {
  78                 "DASH": portfolio.Amount("BTC", D("0.5")),
  79                 "XVG": portfolio.Amount("BTC", D("0.1")),
  80                 "BTC": portfolio.Amount("BTC", D("0.4")),
  81                 "ETH": portfolio.Amount("BTC", D("0.3")),
  82                 }
  83         side_effect = [
  84                 (True, 1),
  85                 (False, 2),
  86                 (False, 3),
  87                 (True, 4),
  88                 (True, 5)
  89                 ]
  90
  91         with mock.patch.object(market.TradeStore, "trade_if_matching") as trade_if_matching:
  92             trade_store = market.TradeStore(self.m)
  93             trade_if_matching.side_effect = side_effect
  94
  95             trade_store.compute_trades(values_in_base,
  96                     new_repartition, only="only")
  97
  98             self.assertEqual(5, trade_if_matching.call_count)
  99             self.assertEqual(3, len(trade_store.all))
 100             self.assertEqual([1, 4, 5], trade_store.all)
 101             self.m.report.log_trades.assert_called_with(side_effect, "only")
 102
 103     def test_trade_if_matching(self):
 104
 105         with self.subTest(only="nope"):
 106             trade_store = market.TradeStore(self.m)
 107             result = trade_store.trade_if_matching(
 108                     portfolio.Amount("BTC", D("0")),
 109                     portfolio.Amount("BTC", D("0.3")),
 110                     "ETH", only="nope")
 111             self.assertEqual(False, result[0])
 112             self.assertIsInstance(result[1], portfolio.Trade)
 113
 114         with self.subTest(only=None):
 115             trade_store = market.TradeStore(self.m)
 116             result = trade_store.trade_if_matching(
 117                     portfolio.Amount("BTC", D("0")),
 118                     portfolio.Amount("BTC", D("0.3")),
 119                     "ETH", only=None)
 120             self.assertEqual(True, result[0])
 121
 122         with self.subTest(only="acquire"):
 123             trade_store = market.TradeStore(self.m)
 124             result = trade_store.trade_if_matching(
 125                     portfolio.Amount("BTC", D("0")),
 126                     portfolio.Amount("BTC", D("0.3")),
 127                     "ETH", only="acquire")
 128             self.assertEqual(True, result[0])
 129
 130         with self.subTest(only="dispose"):
 131             trade_store = market.TradeStore(self.m)
 132             result = trade_store.trade_if_matching(
 133                     portfolio.Amount("BTC", D("0")),
 134                     portfolio.Amount("BTC", D("0.3")),
 135                     "ETH", only="dispose")
 136             self.assertEqual(False, result[0])
 137
 138     def test_prepare_orders(self):
 139         trade_store = market.TradeStore(self.m)
 140
 141         trade_mock1 = mock.Mock()
 142         trade_mock2 = mock.Mock()
 143         trade_mock3 = mock.Mock()
 144
 145         trade_mock1.prepare_order.return_value = 1
 146         trade_mock2.prepare_order.return_value = 2
 147         trade_mock3.prepare_order.return_value = 3
 148
 149         trade_mock1.pending = True
 150         trade_mock2.pending = True
 151         trade_mock3.pending = False
 152
 153         trade_store.all.append(trade_mock1)
 154         trade_store.all.append(trade_mock2)
 155         trade_store.all.append(trade_mock3)
 156
 157         trade_store.prepare_orders()
 158         trade_mock1.prepare_order.assert_called_with(compute_value="default")
 159         trade_mock2.prepare_order.assert_called_with(compute_value="default")
 160         trade_mock3.prepare_order.assert_not_called()
 161         self.m.report.log_orders.assert_called_once_with([1, 2], None, "default")
 162
 163         self.m.report.log_orders.reset_mock()
 164
 165         trade_store.prepare_orders(compute_value="bla")
 166         trade_mock1.prepare_order.assert_called_with(compute_value="bla")
 167         trade_mock2.prepare_order.assert_called_with(compute_value="bla")
 168         self.m.report.log_orders.assert_called_once_with([1, 2], None, "bla")
 169
 170         trade_mock1.prepare_order.reset_mock()
 171         trade_mock2.prepare_order.reset_mock()
 172         self.m.report.log_orders.reset_mock()
 173
 174         trade_mock1.action = "foo"
 175         trade_mock2.action = "bar"
 176         trade_store.prepare_orders(only="bar")
 177         trade_mock1.prepare_order.assert_not_called()
 178         trade_mock2.prepare_order.assert_called_with(compute_value="default")
 179         self.m.report.log_orders.assert_called_once_with([2], "bar", "default")
 180
 181     def test_print_all_with_order(self):
 182         trade_mock1 = mock.Mock()
 183         trade_mock2 = mock.Mock()
 184         trade_mock3 = mock.Mock()
 185         trade_store = market.TradeStore(self.m)
 186         trade_store.all = [trade_mock1, trade_mock2, trade_mock3]
 187
 188         trade_store.print_all_with_order()
 189
 190         trade_mock1.print_with_order.assert_called()
 191         trade_mock2.print_with_order.assert_called()
 192         trade_mock3.print_with_order.assert_called()
 193
 194     def test_run_orders(self):
 195         with mock.patch.object(market.TradeStore, "all_orders") as all_orders:
 196             order_mock1 = mock.Mock()
 197             order_mock2 = mock.Mock()
 198             order_mock3 = mock.Mock()
 199             trade_store = market.TradeStore(self.m)
 200
 201             all_orders.return_value = [order_mock1, order_mock2, order_mock3]
 202
 203             trade_store.run_orders()
 204
 205             all_orders.assert_called_with(state="pending")
 206
 207         order_mock1.run.assert_called()
 208         order_mock2.run.assert_called()
 209         order_mock3.run.assert_called()
 210
 211         self.m.report.log_stage.assert_called_with("run_orders")
 212         self.m.report.log_orders.assert_called_with([order_mock1, order_mock2,
 213             order_mock3])
 214
 215     def test_all_orders(self):
 216         trade_mock1 = mock.Mock()
 217         trade_mock2 = mock.Mock()
 218
 219         order_mock1 = mock.Mock()
 220         order_mock2 = mock.Mock()
 221         order_mock3 = mock.Mock()
 222
 223         trade_mock1.orders = [order_mock1, order_mock2]
 224         trade_mock2.orders = [order_mock3]
 225
 226         order_mock1.status = "pending"
 227         order_mock2.status = "open"
 228         order_mock3.status = "open"
 229
 230         trade_store = market.TradeStore(self.m)
 231         trade_store.all.append(trade_mock1)
 232         trade_store.all.append(trade_mock2)
 233
 234         orders = trade_store.all_orders()
 235         self.assertEqual(3, len(orders))
 236
 237         open_orders = trade_store.all_orders(state="open")
 238         self.assertEqual(2, len(open_orders))
 239         self.assertEqual([order_mock2, order_mock3], open_orders)
 240
 241     def test_update_all_orders_status(self):
 242         with mock.patch.object(market.TradeStore, "all_orders") as all_orders:
 243             order_mock1 = mock.Mock()
 244             order_mock2 = mock.Mock()
 245             order_mock3 = mock.Mock()
 246
 247             all_orders.return_value = [order_mock1, order_mock2, order_mock3]
 248
 249             trade_store = market.TradeStore(self.m)
 250
 251             trade_store.update_all_orders_status()
 252             all_orders.assert_called_with(state="open")
 253
 254             order_mock1.get_status.assert_called()
 255             order_mock2.get_status.assert_called()
 256             order_mock3.get_status.assert_called()
 257
 258     def test_close_trades(self):
 259         trade_mock1 = mock.Mock()
 260         trade_mock2 = mock.Mock()
 261         trade_mock3 = mock.Mock()
 262
 263         trade_store = market.TradeStore(self.m)
 264
 265         trade_store.all.append(trade_mock1)
 266         trade_store.all.append(trade_mock2)
 267         trade_store.all.append(trade_mock3)
 268
 269         trade_store.close_trades()
 270
 271         trade_mock1.close.assert_called_once_with()
 272         trade_mock2.close.assert_called_once_with()
 273         trade_mock3.close.assert_called_once_with()
 274
 275     def test_pending(self):
 276         trade_mock1 = mock.Mock()
 277         trade_mock1.pending = True
 278         trade_mock2 = mock.Mock()
 279         trade_mock2.pending = True
 280         trade_mock3 = mock.Mock()
 281         trade_mock3.pending = False
 282
 283         trade_store = market.TradeStore(self.m)
 284
 285         trade_store.all.append(trade_mock1)
 286         trade_store.all.append(trade_mock2)
 287         trade_store.all.append(trade_mock3)
 288
 289         self.assertEqual([trade_mock1, trade_mock2], trade_store.pending)
 290
 291 @unittest.skipUnless("unit" in limits, "Unit skipped")
 292 class BalanceStoreTest(WebMockTestCase):
 293     def setUp(self):
 294         super().setUp()
 295
 296         self.fetch_balance = {
 297                 "ETC": {
 298                     "exchange_free": 0,
 299                     "exchange_used": 0,
 300                     "exchange_total": 0,
 301                     "margin_total": 0,
 302                     },
 303                 "USDT": {
 304                     "exchange_free": D("6.0"),
 305                     "exchange_used": D("1.2"),
 306                     "exchange_total": D("7.2"),
 307                     "margin_total": 0,
 308                     },
 309                 "XVG": {
 310                     "exchange_free": 16,
 311                     "exchange_used": 0,
 312                     "exchange_total": 16,
 313                     "margin_total": 0,
 314                     },
 315                 "XMR": {
 316                     "exchange_free": 0,
 317                     "exchange_used": 0,
 318                     "exchange_total": 0,
 319                     "margin_total": D("-1.0"),
 320                     "margin_free": 0,
 321                     },
 322                 }
 323
 324     def test_in_currency(self):
 325         self.m.get_ticker.return_value = {
 326                 "bid": D("0.09"),
 327                 "ask": D("0.11"),
 328                 "average": D("0.1"),
 329                 }
 330
 331         balance_store = market.BalanceStore(self.m)
 332         balance_store.all = {
 333                 "BTC": portfolio.Balance("BTC", {
 334                     "total": "0.65",
 335                     "exchange_total":"0.65",
 336                     "exchange_free": "0.35",
 337                     "exchange_used": "0.30"}),
 338                 "ETH": portfolio.Balance("ETH", {
 339                     "total": 3,
 340                     "exchange_total": 3,
 341                     "exchange_free": 3,
 342                     "exchange_used": 0}),
 343                 }
 344
 345         amounts = balance_store.in_currency("BTC")
 346         self.assertEqual("BTC", amounts["ETH"].currency)
 347         self.assertEqual(D("0.65"), amounts["BTC"].value)
 348         self.assertEqual(D("0.30"), amounts["ETH"].value)
 349         self.m.report.log_tickers.assert_called_once_with(amounts, "BTC",
 350                 "average", "total")
 351         self.m.report.log_tickers.reset_mock()
 352
 353         amounts = balance_store.in_currency("BTC", compute_value="bid")
 354         self.assertEqual(D("0.65"), amounts["BTC"].value)
 355         self.assertEqual(D("0.27"), amounts["ETH"].value)
 356         self.m.report.log_tickers.assert_called_once_with(amounts, "BTC",
 357                 "bid", "total")
 358         self.m.report.log_tickers.reset_mock()
 359
 360         amounts = balance_store.in_currency("BTC", compute_value="bid", type="exchange_used")
 361         self.assertEqual(D("0.30"), amounts["BTC"].value)
 362         self.assertEqual(0, amounts["ETH"].value)
 363         self.m.report.log_tickers.assert_called_once_with(amounts, "BTC",
 364                 "bid", "exchange_used")
 365         self.m.report.log_tickers.reset_mock()
 366
 367     def test_fetch_balances(self):
 368         self.m.ccxt.fetch_all_balances.return_value = self.fetch_balance
 369
 370         balance_store = market.BalanceStore(self.m)
 371
 372         with self.subTest(log_tickers=False):
 373             balance_store.fetch_balances()
 374             self.assertNotIn("ETC", balance_store.currencies())
 375             self.assertListEqual(["USDT", "XVG", "XMR"], list(balance_store.currencies()))
 376
 377             balance_store.all["ETC"] = portfolio.Balance("ETC", {
 378                 "exchange_total": "1", "exchange_free": "0",
 379                 "exchange_used": "1" })
 380             balance_store.fetch_balances(tag="foo")
 381             self.assertEqual(0, balance_store.all["ETC"].total)
 382             self.assertListEqual(["USDT", "XVG", "XMR", "ETC"], list(balance_store.currencies()))
 383             self.m.report.log_balances.assert_called_with(tag="foo", checkpoint=None)
 384
 385         with self.subTest(log_tickers=True),\
 386                 mock.patch.object(balance_store, "in_currency") as in_currency:
 387             in_currency.return_value = "tickers"
 388             balance_store.fetch_balances(log_tickers=True, ticker_currency="FOO",
 389                     ticker_compute_value="compute", ticker_type="type")
 390             self.m.report.log_balances.assert_called_with(compute_value='compute',
 391                     tag=None, checkpoint=None, ticker_currency='FOO', tickers='tickers',
 392                     type='type')
 393
 394         balance_store = market.BalanceStore(self.m)
 395
 396         with self.subTest(add_portfolio=True),\
 397                 mock.patch.object(market.Portfolio, "repartition") as repartition:
 398             repartition.return_value = {
 399                     "DOGE": D("0.5"),
 400                     "USDT": D("0.5"),
 401                     }
 402             balance_store.fetch_balances(add_portfolio=True)
 403             self.assertListEqual(["USDT", "XVG", "XMR", "DOGE"], list(balance_store.currencies()))
 404
 405
 406     @mock.patch.object(market.Portfolio, "repartition")
 407     def test_dispatch_assets(self, repartition):
 408         self.m.ccxt.fetch_all_balances.return_value = self.fetch_balance
 409
 410         balance_store = market.BalanceStore(self.m)
 411         balance_store.fetch_balances()
 412
 413         self.assertNotIn("XEM", balance_store.currencies())
 414
 415         repartition_hash = {
 416                 "XEM": (D("0.75"), "long"),
 417                 "BTC": (D("0.26"), "long"),
 418                 "DASH": (D("0.10"), "short"),
 419                 }
 420         repartition.return_value = repartition_hash
 421
 422         amounts = balance_store.dispatch_assets(portfolio.Amount("BTC", "11.1"))
 423         repartition.assert_called_with(liquidity="medium")
 424         self.assertIn("XEM", balance_store.currencies())
 425         self.assertEqual(D("2.6"), amounts["BTC"].value)
 426         self.assertEqual(D("7.5"), amounts["XEM"].value)
 427         self.assertEqual(D("-1.0"), amounts["DASH"].value)
 428         self.m.report.log_balances.assert_called_with(tag=None, checkpoint=None)
 429         self.m.report.log_dispatch.assert_called_once_with(portfolio.Amount("BTC",
 430             "11.1"), amounts, "medium", repartition_hash)
 431
 432     def test_currencies(self):
 433         balance_store = market.BalanceStore(self.m)
 434
 435         balance_store.all = {
 436                 "BTC": portfolio.Balance("BTC", {
 437                     "total": "0.65",
 438                     "exchange_total":"0.65",
 439                     "exchange_free": "0.35",
 440                     "exchange_used": "0.30"}),
 441                 "ETH": portfolio.Balance("ETH", {
 442                     "total": 3,
 443                     "exchange_total": 3,
 444                     "exchange_free": 3,
 445                     "exchange_used": 0}),
 446                 }
 447         self.assertListEqual(["BTC", "ETH"], list(balance_store.currencies()))
 448
 449     def test_as_json(self):
 450         balance_mock1 = mock.Mock()
 451         balance_mock1.as_json.return_value = 1
 452
 453         balance_mock2 = mock.Mock()
 454         balance_mock2.as_json.return_value = 2
 455
 456         balance_store = market.BalanceStore(self.m)
 457         balance_store.all = {
 458                 "BTC": balance_mock1,
 459                 "ETH": balance_mock2,
 460                 }
 461
 462         as_json = balance_store.as_json()
 463         self.assertEqual(1, as_json["BTC"])
 464         self.assertEqual(2, as_json["ETH"])
 465
 466 @unittest.skipUnless("unit" in limits, "Unit skipped")
 467 class ReportStoreTest(WebMockTestCase):
 468     def test_add_log(self):
 469         with self.subTest(market=self.m):
 470             self.m.user_id = 1
 471             self.m.market_id = 3
 472             report_store = market.ReportStore(self.m)
 473             result = report_store.add_log({"foo": "bar"})
 474
 475             self.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": 1, "market_id": 3}, result)
 476             self.assertEqual(result, report_store.logs[0])
 477
 478         with self.subTest(market=None):
 479             report_store = market.ReportStore(None)
 480             result = report_store.add_log({"foo": "bar"})
 481
 482             self.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": None, "market_id": None}, result)
 483
 484     def test_add_redis_status(self):
 485         report_store = market.ReportStore(self.m)
 486         result = report_store.add_redis_status({"foo": "bar"})
 487
 488         self.assertEqual({"foo": "bar"}, result)
 489         self.assertEqual(result, report_store.redis_status[0])
 490
 491     def test_set_verbose(self):
 492         report_store = market.ReportStore(self.m)
 493         with self.subTest(verbose=True):
 494             report_store.set_verbose(True)
 495             self.assertTrue(report_store.verbose_print)
 496
 497         with self.subTest(verbose=False):
 498             report_store.set_verbose(False)
 499             self.assertFalse(report_store.verbose_print)
 500
 501     def test_merge(self):
 502         self.m.user_id = 1
 503         self.m.market_id = 3
 504         report_store1 = market.ReportStore(self.m, verbose_print=False)
 505         report_store2 = market.ReportStore(None, verbose_print=False)
 506
 507         report_store2.log_stage("1")
 508         report_store1.log_stage("2")
 509         report_store2.log_stage("3")
 510
 511         report_store1.merge(report_store2)
 512
 513         self.assertEqual(3, len(report_store1.logs))
 514         self.assertEqual(["1", "2", "3"], list(map(lambda x: x["stage"], report_store1.logs)))
 515         self.assertEqual(6, len(report_store1.print_logs))
 516
 517     def test_print_log(self):
 518         report_store = market.ReportStore(self.m)
 519         with self.subTest(verbose=True),\
 520                 mock.patch.object(store, "datetime") as time_mock,\
 521                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
 522             time_mock.datetime.now.return_value = datetime.datetime(2018, 2, 25, 2, 20, 10)
 523             report_store.set_verbose(True)
 524             report_store.print_log("Coucou")
 525             report_store.print_log(portfolio.Amount("BTC", 1))
 526             self.assertEqual(stdout_mock.getvalue(), "2018-02-25 02:20:10: Coucou\n2018-02-25 02:20:10: 1.00000000 BTC\n")
 527
 528         with self.subTest(verbose=False),\
 529                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
 530             report_store.set_verbose(False)
 531             report_store.print_log("Coucou")
 532             report_store.print_log(portfolio.Amount("BTC", 1))
 533             self.assertEqual(stdout_mock.getvalue(), "")
 534
 535     def test_default_json_serial(self):
 536         report_store = market.ReportStore(self.m)
 537
 538         self.assertEqual("2018-02-24T00:00:00",
 539                 report_store.default_json_serial(portfolio.datetime.datetime(2018, 2, 24)))
 540         self.assertEqual("1.00000000 BTC",
 541                 report_store.default_json_serial(portfolio.Amount("BTC", 1)))
 542
 543     def test_to_json(self):
 544         report_store = market.ReportStore(self.m)
 545         report_store.logs.append({"foo": "bar"})
 546         self.assertEqual('[\n  {\n    "foo": "bar"\n  }\n]', report_store.to_json())
 547         report_store.logs.append({"date": portfolio.datetime.datetime(2018, 2, 24)})
 548         self.assertEqual('[\n  {\n    "foo": "bar"\n  },\n  {\n    "date": "2018-02-24T00:00:00"\n  }\n]', report_store.to_json())
 549         report_store.logs.append({"amount": portfolio.Amount("BTC", 1)})
 550         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())
 551
 552     def test_to_json_array(self):
 553         report_store = market.ReportStore(self.m)
 554         report_store.logs.append({
 555             "date": "date1", "type": "type1", "foo": "bar", "bla": "bla"
 556             })
 557         report_store.logs.append({
 558             "date": "date2", "type": "type2", "foo": "bar", "bla": "bla"
 559             })
 560         logs = list(report_store.to_json_array())
 561
 562         self.assertEqual(2, len(logs))
 563         self.assertEqual(("date1", "type1", '{\n  "foo": "bar",\n  "bla": "bla"\n}'), logs[0])
 564         self.assertEqual(("date2", "type2", '{\n  "foo": "bar",\n  "bla": "bla"\n}'), logs[1])
 565
 566     def test_to_json_redis(self):
 567         report_store = market.ReportStore(self.m)
 568         report_store.redis_status.append({
 569             "type": "type1", "foo": "bar", "bla": "bla"
 570             })
 571         report_store.redis_status.append({
 572             "type": "type2", "foo": "bar", "bla": "bla"
 573             })
 574         logs = list(report_store.to_json_redis())
 575
 576         self.assertEqual(2, len(logs))
 577         self.assertEqual(("type1", '{"foo": "bar", "bla": "bla"}'), logs[0])
 578         self.assertEqual(("type2", '{"foo": "bar", "bla": "bla"}'), logs[1])
 579
 580     @mock.patch.object(market.ReportStore, "print_log")
 581     @mock.patch.object(market.ReportStore, "add_log")
 582     def test_log_stage(self, add_log, print_log):
 583         report_store = market.ReportStore(self.m)
 584         c = lambda x: x
 585         report_store.log_stage("foo", bar="baz", c=c, d=portfolio.Amount("BTC", 1))
 586         print_log.assert_has_calls([
 587             mock.call("-----------"),
 588             mock.call("[Stage] foo bar=baz, c=c = lambda x: x, d={'currency': 'BTC', 'value': Decimal('1')}"),
 589             ])
 590         add_log.assert_called_once_with({
 591             'type': 'stage',
 592             'stage': 'foo',
 593             'args': {
 594                 'bar': 'baz',
 595                 'c': 'c = lambda x: x',
 596                 'd': {
 597                     'currency': 'BTC',
 598                     'value': D('1')
 599                     }
 600                 }
 601             })
 602
 603     @mock.patch.object(market.ReportStore, "print_log")
 604     @mock.patch.object(market.ReportStore, "add_log")
 605     @mock.patch.object(market.ReportStore, "add_redis_status")
 606     def test_log_balances(self, add_redis_status, add_log, print_log):
 607         report_store = market.ReportStore(self.m)
 608         self.m.balances.as_json.return_value = "json"
 609         self.m.balances.all = { "FOO": "bar", "BAR": "baz" }
 610
 611         with self.subTest(tickers=None):
 612             report_store.log_balances(tag="tag")
 613             print_log.assert_has_calls([
 614                 mock.call("[Balance]"),
 615                 mock.call("\tbar"),
 616                 mock.call("\tbaz"),
 617                 ])
 618             add_log.assert_called_once_with({
 619                 'type': 'balance',
 620                 'checkpoint': None,
 621                 'balances': 'json',
 622                 'tag': 'tag'
 623                 })
 624             add_redis_status.assert_called_once_with({
 625                 'type': 'balance',
 626                 'balances': 'json',
 627                 'checkpoint': None,
 628                 'tag': 'tag'
 629                 })
 630         add_log.reset_mock()
 631         add_redis_status.reset_mock()
 632         with self.subTest(tickers="present"):
 633             amounts = {
 634                     "BTC": portfolio.Amount("BTC", 10),
 635                     "ETH": portfolio.Amount("BTC", D("0.3"))
 636                     }
 637             amounts["ETH"].rate = D("0.1")
 638
 639             report_store.log_balances(tag="tag", tickers=amounts,
 640                     ticker_currency="BTC", compute_value="default",
 641                     type="total")
 642             add_log.assert_called_once_with({
 643                 'type': 'balance',
 644                 'checkpoint': None,
 645                 'balances': 'json',
 646                 'tag': 'tag',
 647                 'tickers': {
 648                     'compute_value': 'default',
 649                     'balance_type': 'total',
 650                     'currency': 'BTC',
 651                     'balances': {
 652                         'BTC': D('10'),
 653                         'ETH': D('0.3')
 654                         },
 655                     'rates': {
 656                         'BTC': None,
 657                         'ETH': D('0.1')
 658                         },
 659                     'total': D('10.3')
 660                     },
 661                 })
 662             add_redis_status.assert_called_once_with({
 663                 'type': 'balance',
 664                 'checkpoint': None,
 665                 'balances': 'json',
 666                 'tag': 'tag',
 667                 'tickers': {
 668                     'compute_value': 'default',
 669                     'balance_type': 'total',
 670                     'currency': 'BTC',
 671                     'balances': {
 672                         'BTC': D('10'),
 673                         'ETH': D('0.3')
 674                         },
 675                     'rates': {
 676                         'BTC': None,
 677                         'ETH': D('0.1')
 678                         },
 679                     'total': D('10.3')
 680                     },
 681                 })
 682
 683     @mock.patch.object(market.ReportStore, "print_log")
 684     @mock.patch.object(market.ReportStore, "add_log")
 685     def test_log_tickers(self, add_log, print_log):
 686         report_store = market.ReportStore(self.m)
 687         amounts = {
 688                 "BTC": portfolio.Amount("BTC", 10),
 689                 "ETH": portfolio.Amount("BTC", D("0.3"))
 690                 }
 691         amounts["ETH"].rate = D("0.1")
 692
 693         report_store.log_tickers(amounts, "BTC", "default", "total")
 694         print_log.assert_not_called()
 695         add_log.assert_called_once_with({
 696             'type': 'tickers',
 697             'compute_value': 'default',
 698             'balance_type': 'total',
 699             'currency': 'BTC',
 700             'balances': {
 701                 'BTC': D('10'),
 702                 'ETH': D('0.3')
 703                 },
 704             'rates': {
 705                 'BTC': None,
 706                 'ETH': D('0.1')
 707                 },
 708             'total': D('10.3')
 709             })
 710
 711         add_log.reset_mock()
 712         compute_value = lambda x: x["bid"]
 713         report_store.log_tickers(amounts, "BTC", compute_value, "total")
 714         add_log.assert_called_once_with({
 715             'type': 'tickers',
 716             'compute_value': 'compute_value = lambda x: x["bid"]',
 717             'balance_type': 'total',
 718             'currency': 'BTC',
 719             'balances': {
 720                 'BTC': D('10'),
 721                 'ETH': D('0.3')
 722                 },
 723             'rates': {
 724                 'BTC': None,
 725                 'ETH': D('0.1')
 726                 },
 727             'total': D('10.3')
 728             })
 729
 730     @mock.patch.object(market.ReportStore, "print_log")
 731     @mock.patch.object(market.ReportStore, "add_log")
 732     def test_log_dispatch(self, add_log, print_log):
 733         report_store = market.ReportStore(self.m)
 734         amount = portfolio.Amount("BTC", "10.3")
 735         amounts = {
 736                 "BTC": portfolio.Amount("BTC", 10),
 737                 "ETH": portfolio.Amount("BTC", D("0.3"))
 738                 }
 739         report_store.log_dispatch(amount, amounts, "medium", "repartition")
 740         print_log.assert_not_called()
 741         add_log.assert_called_once_with({
 742             'type': 'dispatch',
 743             'liquidity': 'medium',
 744             'repartition_ratio': 'repartition',
 745             'total_amount': {
 746                 'currency': 'BTC',
 747                 'value': D('10.3')
 748                 },
 749             'repartition': {
 750                 'BTC': D('10'),
 751                 'ETH': D('0.3')
 752                 }
 753             })
 754
 755     @mock.patch.object(market.ReportStore, "print_log")
 756     @mock.patch.object(market.ReportStore, "add_log")
 757     def test_log_trades(self, add_log, print_log):
 758         report_store = market.ReportStore(self.m)
 759         trade_mock1 = mock.Mock()
 760         trade_mock2 = mock.Mock()
 761         trade_mock1.as_json.return_value = { "trade": "1" }
 762         trade_mock2.as_json.return_value = { "trade": "2" }
 763
 764         matching_and_trades = [
 765                 (True, trade_mock1),
 766                 (False, trade_mock2),
 767                 ]
 768         report_store.log_trades(matching_and_trades, "only")
 769
 770         print_log.assert_not_called()
 771         add_log.assert_called_with({
 772             'type': 'trades',
 773             'only': 'only',
 774             'debug': False,
 775             'trades': [
 776                 {'trade': '1', 'skipped': False},
 777                 {'trade': '2', 'skipped': True}
 778                 ]
 779             })
 780
 781     @mock.patch.object(market.ReportStore, "print_log")
 782     @mock.patch.object(market.ReportStore, "add_log")
 783     def test_log_orders(self, add_log, print_log):
 784         report_store = market.ReportStore(self.m)
 785
 786         order_mock1 = mock.Mock()
 787         order_mock2 = mock.Mock()
 788
 789         order_mock1.as_json.return_value = "order1"
 790         order_mock2.as_json.return_value = "order2"
 791
 792         orders = [order_mock1, order_mock2]
 793
 794         report_store.log_orders(orders, tick="tick",
 795                 only="only", compute_value="compute_value")
 796
 797         print_log.assert_called_once_with("[Orders]")
 798         self.m.trades.print_all_with_order.assert_called_once_with(ind="\t")
 799
 800         add_log.assert_called_with({
 801             'type': 'orders',
 802             'only': 'only',
 803             'compute_value': 'compute_value',
 804             'tick': 'tick',
 805             'orders': ['order1', 'order2']
 806             })
 807
 808         add_log.reset_mock()
 809         def compute_value(x, y):
 810             return x[y]
 811         report_store.log_orders(orders, tick="tick",
 812                 only="only", compute_value=compute_value)
 813         add_log.assert_called_with({
 814             'type': 'orders',
 815             'only': 'only',
 816             'compute_value': 'def compute_value(x, y):\n            return x[y]',
 817             'tick': 'tick',
 818             'orders': ['order1', 'order2']
 819             })
 820
 821
 822     @mock.patch.object(market.ReportStore, "print_log")
 823     @mock.patch.object(market.ReportStore, "add_log")
 824     def test_log_order(self, add_log, print_log):
 825         report_store = market.ReportStore(self.m)
 826         order_mock = mock.Mock()
 827         order_mock.as_json.return_value = "order"
 828         new_order_mock = mock.Mock()
 829         new_order_mock.as_json.return_value = "new_order"
 830         order_mock.__repr__ = mock.Mock()
 831         order_mock.__repr__.return_value = "Order Mock"
 832         new_order_mock.__repr__ = mock.Mock()
 833         new_order_mock.__repr__.return_value = "New order Mock"
 834
 835         with self.subTest(finished=True):
 836             report_store.log_order(order_mock, 1, finished=True)
 837             print_log.assert_called_once_with("[Order] Finished Order Mock")
 838             add_log.assert_called_once_with({
 839                 'type': 'order',
 840                 'tick': 1,
 841                 'update': None,
 842                 'order': 'order',
 843                 'compute_value': None,
 844                 'new_order': None
 845                 })
 846
 847         add_log.reset_mock()
 848         print_log.reset_mock()
 849
 850         with self.subTest(update="waiting"):
 851             report_store.log_order(order_mock, 1, update="waiting")
 852             print_log.assert_called_once_with("[Order] Order Mock, tick 1, waiting")
 853             add_log.assert_called_once_with({
 854                 'type': 'order',
 855                 'tick': 1,
 856                 'update': 'waiting',
 857                 'order': 'order',
 858                 'compute_value': None,
 859                 'new_order': None
 860                 })
 861
 862         add_log.reset_mock()
 863         print_log.reset_mock()
 864         with self.subTest(update="adjusting"):
 865             compute_value = lambda x: (x["bid"] + x["ask"]*2)/3
 866             report_store.log_order(order_mock, 3,
 867                     update="adjusting", new_order=new_order_mock,
 868                     compute_value=compute_value)
 869             print_log.assert_called_once_with("[Order] Order Mock, tick 3, cancelling and adjusting to New order Mock")
 870             add_log.assert_called_once_with({
 871                 'type': 'order',
 872                 'tick': 3,
 873                 'update': 'adjusting',
 874                 'order': 'order',
 875                 'compute_value': 'compute_value = lambda x: (x["bid"] + x["ask"]*2)/3',
 876                 'new_order': 'new_order'
 877                 })
 878
 879         add_log.reset_mock()
 880         print_log.reset_mock()
 881         with self.subTest(update="market_fallback"):
 882             report_store.log_order(order_mock, 7,
 883                     update="market_fallback", new_order=new_order_mock)
 884             print_log.assert_called_once_with("[Order] Order Mock, tick 7, fallbacking to market value")
 885             add_log.assert_called_once_with({
 886                 'type': 'order',
 887                 'tick': 7,
 888                 'update': 'market_fallback',
 889                 'order': 'order',
 890                 'compute_value': None,
 891                 'new_order': 'new_order'
 892                 })
 893
 894         add_log.reset_mock()
 895         print_log.reset_mock()
 896         with self.subTest(update="market_adjusting"):
 897             report_store.log_order(order_mock, 17,
 898                     update="market_adjust", new_order=new_order_mock)
 899             print_log.assert_called_once_with("[Order] Order Mock, tick 17, market value, cancelling and adjusting to New order Mock")
 900             add_log.assert_called_once_with({
 901                 'type': 'order',
 902                 'tick': 17,
 903                 'update': 'market_adjust',
 904                 'order': 'order',
 905                 'compute_value': None,
 906                 'new_order': 'new_order'
 907                 })
 908
 909     @mock.patch.object(market.ReportStore, "print_log")
 910     @mock.patch.object(market.ReportStore, "add_log")
 911     def test_log_move_balances(self, add_log, print_log):
 912         report_store = market.ReportStore(self.m)
 913         needed = {
 914                 "BTC": portfolio.Amount("BTC", 10),
 915                 "USDT": 1
 916                 }
 917         moving = {
 918                 "BTC": portfolio.Amount("BTC", 3),
 919                 "USDT": -2
 920                 }
 921         report_store.log_move_balances(needed, moving)
 922         print_log.assert_not_called()
 923         add_log.assert_called_once_with({
 924             'type': 'move_balances',
 925             'debug': False,
 926             'needed': {
 927                 'BTC': D('10'),
 928                 'USDT': 1
 929                 },
 930             'moving': {
 931                 'BTC': D('3'),
 932                 'USDT': -2
 933                 }
 934             })
 935
 936     def test_log_http_request(self):
 937         with mock.patch.object(market.ReportStore, "add_log") as add_log:
 938             report_store = market.ReportStore(self.m)
 939             response = mock.Mock()
 940             response.status_code = 200
 941             response.text = "Hey"
 942             response.elapsed.total_seconds.return_value = 120
 943
 944             report_store.log_http_request("method", "url", "body",
 945                     "headers", response)
 946             add_log.assert_called_once_with({
 947                 'type': 'http_request',
 948                 'method': 'method',
 949                 'url': 'url',
 950                 'body': 'body',
 951                 'headers': 'headers',
 952                 'status': 200,
 953                 'duration': 120,
 954                 'response': 'Hey',
 955                 'response_same_as': None,
 956                 })
 957
 958             add_log.reset_mock()
 959             report_store.log_http_request("method", "url", "body",
 960                     "headers", ValueError("Foo"))
 961             add_log.assert_called_once_with({
 962                 'type': 'http_request',
 963                 'method': 'method',
 964                 'url': 'url',
 965                 'body': 'body',
 966                 'headers': 'headers',
 967                 'status': -1,
 968                 'response': None,
 969                 'error': 'ValueError',
 970                 'error_message': 'Foo',
 971                 })
 972
 973         with self.subTest(no_http_dup=True, duplicate=True):
 974             self.m.user_id = 1
 975             self.m.market_id = 3
 976             report_store = market.ReportStore(self.m, no_http_dup=True)
 977             original_add_log = report_store.add_log
 978             with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log:
 979                 report_store.log_http_request("method", "url", "body",
 980                         "headers", response)
 981                 report_store.log_http_request("method", "url", "body",
 982                         "headers", response)
 983                 self.assertEqual(2, add_log.call_count)
 984                 self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"])
 985                 self.assertIsNone(add_log.mock_calls[1][1][0]["response"])
 986                 self.assertEqual(add_log.mock_calls[0][1][0]["date"], add_log.mock_calls[1][1][0]["response_same_as"])
 987         with self.subTest(no_http_dup=True, duplicate=False, case="Different call"):
 988             self.m.user_id = 1
 989             self.m.market_id = 3
 990             report_store = market.ReportStore(self.m, no_http_dup=True)
 991             original_add_log = report_store.add_log
 992             with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log:
 993                 report_store.log_http_request("method", "url", "body",
 994                         "headers", response)
 995                 report_store.log_http_request("method2", "url", "body",
 996                         "headers", response)
 997                 self.assertEqual(2, add_log.call_count)
 998                 self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"])
 999                 self.assertIsNone(add_log.mock_calls[1][1][0]["response_same_as"])
1000         with self.subTest(no_http_dup=True, duplicate=False, case="Call inbetween"):
1001             self.m.user_id = 1
1002             self.m.market_id = 3
1003             report_store = market.ReportStore(self.m, no_http_dup=True)
1004             original_add_log = report_store.add_log
1005
1006             response2 = mock.Mock()
1007             response2.status_code = 200
1008             response2.text = "Hey there!"
1009
1010             with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log:
1011                 report_store.log_http_request("method", "url", "body",
1012                         "headers", response)
1013                 report_store.log_http_request("method", "url", "body",
1014                         "headers", response2)
1015                 report_store.log_http_request("method", "url", "body",
1016                         "headers", response)
1017                 self.assertEqual(3, add_log.call_count)
1018                 self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"])
1019                 self.assertIsNone(add_log.mock_calls[1][1][0]["response_same_as"])
1020                 self.assertIsNone(add_log.mock_calls[2][1][0]["response_same_as"])
1021
1022     @mock.patch.object(market.ReportStore, "add_log")
1023     def test_log_market(self, add_log):
1024         report_store = market.ReportStore(self.m)
1025
1026         report_store.log_market(self.market_args(debug=True, quiet=False))
1027         add_log.assert_called_once_with({
1028             "type": "market",
1029             "commit": "$Format:%H$",
1030             "args": { "report_path": None, "debug": True, "quiet": False },
1031             })
1032
1033     @mock.patch.object(market.ReportStore, "print_log")
1034     @mock.patch.object(market.ReportStore, "add_log")
1035     def test_log_error(self, add_log, print_log):
1036         report_store = market.ReportStore(self.m)
1037         with self.subTest(message=None, exception=None):
1038             report_store.log_error("action")
1039             print_log.assert_called_once_with("[Error] action")
1040             add_log.assert_called_once_with({
1041                 'type': 'error',
1042                 'action': 'action',
1043                 'exception_class': None,
1044                 'exception_message': None,
1045                 'message': None
1046                 })
1047
1048         print_log.reset_mock()
1049         add_log.reset_mock()
1050         with self.subTest(message="Hey", exception=None):
1051             report_store.log_error("action", message="Hey")
1052             print_log.assert_has_calls([
1053                     mock.call("[Error] action"),
1054                     mock.call("\tHey")
1055                     ])
1056             add_log.assert_called_once_with({
1057                 'type': 'error',
1058                 'action': 'action',
1059                 'exception_class': None,
1060                 'exception_message': None,
1061                 'message': "Hey"
1062                 })
1063
1064         print_log.reset_mock()
1065         add_log.reset_mock()
1066         with self.subTest(message=None, exception=Exception("bouh")):
1067             report_store.log_error("action", exception=Exception("bouh"))
1068             print_log.assert_has_calls([
1069                     mock.call("[Error] action"),
1070                     mock.call("\tException: bouh")
1071                     ])
1072             add_log.assert_called_once_with({
1073                 'type': 'error',
1074                 'action': 'action',
1075                 'exception_class': "Exception",
1076                 'exception_message': "bouh",
1077                 'message': None
1078                 })
1079
1080         print_log.reset_mock()
1081         add_log.reset_mock()
1082         with self.subTest(message="Hey", exception=Exception("bouh")):
1083             report_store.log_error("action", message="Hey", exception=Exception("bouh"))
1084             print_log.assert_has_calls([
1085                     mock.call("[Error] action"),
1086                     mock.call("\tException: bouh"),
1087                     mock.call("\tHey")
1088                     ])
1089             add_log.assert_called_once_with({
1090                 'type': 'error',
1091                 'action': 'action',
1092                 'exception_class': "Exception",
1093                 'exception_message': "bouh",
1094                 'message': "Hey"
1095                 })
1096
1097     @mock.patch.object(market.ReportStore, "print_log")
1098     @mock.patch.object(market.ReportStore, "add_log")
1099     def test_log_debug_action(self, add_log, print_log):
1100         report_store = market.ReportStore(self.m)
1101         report_store.log_debug_action("Hey")
1102
1103         print_log.assert_called_once_with("[Debug] Hey")
1104         add_log.assert_called_once_with({
1105             'type': 'debug_action',
1106             'action': 'Hey'
1107             })
1108
1109 @unittest.skipUnless("unit" in limits, "Unit skipped")
1110 class PortfolioTest(WebMockTestCase):
1111     def setUp(self):
1112         super().setUp()
1113
1114         with open("test_samples/test_portfolio.json") as example:
1115             self.json_response = example.read()
1116
1117         self.wm.get(market.Portfolio.URL, text=self.json_response)
1118
1119     @mock.patch.object(market.Portfolio, "parse_cryptoportfolio")
1120     @mock.patch.object(market.Portfolio, "store_cryptoportfolio")
1121     def test_get_cryptoportfolio(self, store_cryptoportfolio, parse_cryptoportfolio):
1122         with self.subTest(parallel=False):
1123             self.wm.get(market.Portfolio.URL, [
1124                 {"text":'{ "foo": "bar" }', "status_code": 200},
1125                 {"text": "System Error", "status_code": 500},
1126                 {"exc": requests.exceptions.ConnectTimeout},
1127                 ])
1128             market.Portfolio.get_cryptoportfolio()
1129             self.assertIn("foo", market.Portfolio.data.get())
1130             self.assertEqual("bar", market.Portfolio.data.get()["foo"])
1131             self.assertTrue(self.wm.called)
1132             self.assertEqual(1, self.wm.call_count)
1133             market.Portfolio.report.log_error.assert_not_called()
1134             market.Portfolio.report.log_http_request.assert_called_once()
1135             parse_cryptoportfolio.assert_called_once_with()
1136             store_cryptoportfolio.assert_called_once_with()
1137             market.Portfolio.report.log_http_request.reset_mock()
1138             parse_cryptoportfolio.reset_mock()
1139             store_cryptoportfolio.reset_mock()
1140             market.Portfolio.data = store.LockedVar(None)
1141
1142             market.Portfolio.get_cryptoportfolio()
1143             self.assertIsNone(market.Portfolio.data.get())
1144             self.assertEqual(2, self.wm.call_count)
1145             parse_cryptoportfolio.assert_not_called()
1146             store_cryptoportfolio.assert_not_called()
1147             market.Portfolio.report.log_error.assert_not_called()
1148             market.Portfolio.report.log_http_request.assert_called_once()
1149             market.Portfolio.report.log_http_request.reset_mock()
1150             parse_cryptoportfolio.reset_mock()
1151             store_cryptoportfolio.reset_mock()
1152
1153             market.Portfolio.data = store.LockedVar("Foo")
1154             market.Portfolio.get_cryptoportfolio()
1155             self.assertEqual(2, self.wm.call_count)
1156             parse_cryptoportfolio.assert_not_called()
1157             store_cryptoportfolio.assert_not_called()
1158
1159             market.Portfolio.get_cryptoportfolio(refetch=True)
1160             self.assertEqual("Foo", market.Portfolio.data.get())
1161             self.assertEqual(3, self.wm.call_count)
1162             market.Portfolio.report.log_error.assert_called_once_with("get_cryptoportfolio",
1163                     exception=mock.ANY)
1164             market.Portfolio.report.log_http_request.assert_not_called()
1165         with self.subTest(parallel=True):
1166             with mock.patch.object(market.Portfolio, "is_worker_thread") as is_worker,\
1167                     mock.patch.object(market.Portfolio, "notify_and_wait") as notify:
1168                 with self.subTest(worker=True):
1169                     market.Portfolio.data = store.LockedVar(None)
1170                     market.Portfolio.worker = mock.Mock()
1171                     is_worker.return_value = True
1172                     self.wm.get(market.Portfolio.URL, [
1173                         {"text":'{ "foo": "bar" }', "status_code": 200},
1174                         ])
1175                     market.Portfolio.get_cryptoportfolio()
1176                     self.assertIn("foo", market.Portfolio.data.get())
1177                 parse_cryptoportfolio.reset_mock()
1178                 store_cryptoportfolio.reset_mock()
1179                 with self.subTest(worker=False):
1180                     market.Portfolio.data = store.LockedVar(None)
1181                     market.Portfolio.worker = mock.Mock()
1182                     is_worker.return_value = False
1183                     market.Portfolio.get_cryptoportfolio()
1184                     notify.assert_called_once_with()
1185                     parse_cryptoportfolio.assert_not_called()
1186                     store_cryptoportfolio.assert_not_called()
1187
1188     def test_parse_cryptoportfolio(self):
1189         with self.subTest(description="Normal case"):
1190             market.Portfolio.data = store.LockedVar(store.json.loads(
1191                 self.json_response, parse_int=D, parse_float=D))
1192             market.Portfolio.parse_cryptoportfolio()
1193
1194             self.assertListEqual(
1195                     ["medium", "high"],
1196                     list(market.Portfolio.liquidities.get().keys()))
1197
1198             liquidities = market.Portfolio.liquidities.get()
1199             self.assertEqual(10, len(liquidities["medium"].keys()))
1200             self.assertEqual(10, len(liquidities["high"].keys()))
1201
1202             expected = {
1203                     'BTC':  (D("0.2857"), "long"),
1204                     'DGB':  (D("0.1015"), "long"),
1205                     'DOGE': (D("0.1805"), "long"),
1206                     'SC':   (D("0.0623"), "long"),
1207                     'ZEC':  (D("0.3701"), "long"),
1208                     }
1209             date = portfolio.datetime.datetime(2018, 1, 8)
1210             self.assertDictEqual(expected, liquidities["high"][date])
1211
1212             expected = {
1213                     'BTC':  (D("1.1102e-16"), "long"),
1214                     'ETC':  (D("0.1"), "long"),
1215                     'FCT':  (D("0.1"), "long"),
1216                     'GAS':  (D("0.1"), "long"),
1217                     'NAV':  (D("0.1"), "long"),
1218                     'OMG':  (D("0.1"), "long"),
1219                     'OMNI': (D("0.1"), "long"),
1220                     'PPC':  (D("0.1"), "long"),
1221                     'RIC':  (D("0.1"), "long"),
1222                     'VIA':  (D("0.1"), "long"),
1223                     'XCP':  (D("0.1"), "long"),
1224                     }
1225             self.assertDictEqual(expected, liquidities["medium"][date])
1226             self.assertEqual(portfolio.datetime.datetime(2018, 1, 15), market.Portfolio.last_date.get())
1227
1228         with self.subTest(description="Missing weight"):
1229             data = store.json.loads(self.json_response, parse_int=D, parse_float=D)
1230             del(data["portfolio_2"]["weights"])
1231             market.Portfolio.data = store.LockedVar(data)
1232
1233             market.Portfolio.parse_cryptoportfolio()
1234             self.assertListEqual(
1235                     ["medium", "high"],
1236                     list(market.Portfolio.liquidities.get().keys()))
1237             self.assertEqual({}, market.Portfolio.liquidities.get("medium"))
1238
1239         with self.subTest(description="All missing weights"):
1240             data = store.json.loads(self.json_response, parse_int=D, parse_float=D)
1241             del(data["portfolio_1"]["weights"])
1242             del(data["portfolio_2"]["weights"])
1243             market.Portfolio.data = store.LockedVar(data)
1244
1245             market.Portfolio.parse_cryptoportfolio()
1246             self.assertEqual({}, market.Portfolio.liquidities.get("medium"))
1247             self.assertEqual({}, market.Portfolio.liquidities.get("high"))
1248             self.assertEqual(datetime.datetime(1,1,1), market.Portfolio.last_date.get())
1249
1250     @mock.patch.object(store.dbs, "redis_connected")
1251     @mock.patch.object(store.dbs, "redis")
1252     def test_store_cryptoportfolio(self, redis, redis_connected):
1253         store.Portfolio.liquidities = store.LockedVar({
1254                 "medium": {
1255                     datetime.datetime(2018,3,1): "medium_2018-03-01",
1256                     datetime.datetime(2018,3,8): "medium_2018-03-08",
1257                     },
1258                 "high": {
1259                     datetime.datetime(2018,3,1): "high_2018-03-01",
1260                     datetime.datetime(2018,3,8): "high_2018-03-08",
1261                     }
1262                 })
1263         store.Portfolio.last_date = store.LockedVar(datetime.datetime(2018,3,8))
1264
1265         with self.subTest(redis_connected=False):
1266             redis_connected.return_value = False
1267             store.Portfolio.store_cryptoportfolio()
1268             redis.set.assert_not_called()
1269
1270         with self.subTest(redis_connected=True):
1271             redis_connected.return_value = True
1272             store.Portfolio.store_cryptoportfolio()
1273             redis.set.assert_has_calls([
1274                 mock.call("/cryptoportfolio/repartition/latest", '{"medium": "medium_2018-03-08", "high": "high_2018-03-08"}'),
1275                 mock.call("/cryptoportfolio/repartition/date", "2018-03-08"),
1276                 ])
1277
1278     @mock.patch.object(store.dbs, "redis_connected")
1279     @mock.patch.object(store.dbs, "redis")
1280     def test_retrieve_cryptoportfolio(self, redis, redis_connected):
1281         with self.subTest(redis_connected=False):
1282             redis_connected.return_value = False
1283             store.Portfolio.retrieve_cryptoportfolio()
1284             redis.get.assert_not_called()
1285             self.assertIsNone(store.Portfolio.data.get())
1286
1287         with self.subTest(redis_connected=True, value=None):
1288             redis_connected.return_value = True
1289             redis.get.return_value = None
1290             store.Portfolio.retrieve_cryptoportfolio()
1291             self.assertEqual(2, redis.get.call_count)
1292
1293         redis.reset_mock()
1294         with self.subTest(redis_connected=True, value="present"):
1295             redis_connected.return_value = True
1296             redis.get.side_effect = [
1297                     b'{ "medium": "medium_repartition", "high": "high_repartition" }',
1298                     b"2018-03-08"
1299                     ]
1300             store.Portfolio.retrieve_cryptoportfolio()
1301             self.assertEqual(2, redis.get.call_count)
1302             self.assertEqual(datetime.datetime(2018,3,8), store.Portfolio.last_date.get())
1303             self.assertEqual("", store.Portfolio.data.get())
1304             expected_liquidities = {
1305                     'high': { datetime.datetime(2018, 3, 8): 'high_repartition' },
1306                     'medium': { datetime.datetime(2018, 3, 8): 'medium_repartition' },
1307                     }
1308             self.assertEqual(expected_liquidities, store.Portfolio.liquidities.get())
1309
1310     @mock.patch.object(market.Portfolio, "get_cryptoportfolio")
1311     @mock.patch.object(market.Portfolio, "retrieve_cryptoportfolio")
1312     def test_repartition(self, retrieve_cryptoportfolio, get_cryptoportfolio):
1313         with self.subTest(from_cache=False):
1314             market.Portfolio.liquidities = store.LockedVar({
1315                     "medium": {
1316                         "2018-03-01": "medium_2018-03-01",
1317                         "2018-03-08": "medium_2018-03-08",
1318                         },
1319                     "high": {
1320                         "2018-03-01": "high_2018-03-01",
1321                         "2018-03-08": "high_2018-03-08",
1322                         }
1323                     })
1324             market.Portfolio.last_date = store.LockedVar("2018-03-08")
1325
1326             self.assertEqual("medium_2018-03-08", market.Portfolio.repartition())
1327             get_cryptoportfolio.assert_called_once_with()
1328             retrieve_cryptoportfolio.assert_not_called()
1329             self.assertEqual("medium_2018-03-08", market.Portfolio.repartition(liquidity="medium"))
1330             self.assertEqual("high_2018-03-08", market.Portfolio.repartition(liquidity="high"))
1331
1332         retrieve_cryptoportfolio.reset_mock()
1333         get_cryptoportfolio.reset_mock()
1334
1335         with self.subTest(from_cache=True):
1336             self.assertEqual("medium_2018-03-08", market.Portfolio.repartition(from_cache=True))
1337             get_cryptoportfolio.assert_called_once_with()
1338             retrieve_cryptoportfolio.assert_called_once_with()
1339
1340     @mock.patch.object(market.time, "sleep")
1341     @mock.patch.object(market.Portfolio, "get_cryptoportfolio")
1342     def test_wait_for_recent(self, get_cryptoportfolio, sleep):
1343         self.call_count = 0
1344         def _get(refetch=False):
1345             if self.call_count != 0:
1346                 self.assertTrue(refetch)
1347             else:
1348                 self.assertFalse(refetch)
1349             self.call_count += 1
1350             market.Portfolio.last_date = store.LockedVar(store.datetime.datetime.now()\
1351                 - store.datetime.timedelta(10)\
1352                 + store.datetime.timedelta(self.call_count))
1353         get_cryptoportfolio.side_effect = _get
1354
1355         market.Portfolio.wait_for_recent()
1356         sleep.assert_called_with(30)
1357         self.assertEqual(6, sleep.call_count)
1358         self.assertEqual(7, get_cryptoportfolio.call_count)
1359         market.Portfolio.report.print_log.assert_called_with("Attempt to fetch up-to-date cryptoportfolio")
1360
1361         sleep.reset_mock()
1362         get_cryptoportfolio.reset_mock()
1363         market.Portfolio.last_date = store.LockedVar(None)
1364         self.call_count = 0
1365         market.Portfolio.wait_for_recent(delta=15)
1366         sleep.assert_not_called()
1367         self.assertEqual(1, get_cryptoportfolio.call_count)
1368
1369         sleep.reset_mock()
1370         get_cryptoportfolio.reset_mock()
1371         market.Portfolio.last_date = store.LockedVar(None)
1372         self.call_count = 0
1373         market.Portfolio.wait_for_recent(delta=1)
1374         sleep.assert_called_with(30)
1375         self.assertEqual(9, sleep.call_count)
1376         self.assertEqual(10, get_cryptoportfolio.call_count)
1377
1378     def test_is_worker_thread(self):
1379         with self.subTest(worker=None):
1380             self.assertFalse(store.Portfolio.is_worker_thread())
1381
1382         with self.subTest(worker="not self"),\
1383                 mock.patch("threading.current_thread") as current_thread:
1384             current = mock.Mock()
1385             current_thread.return_value = current
1386             store.Portfolio.worker = mock.Mock()
1387             self.assertFalse(store.Portfolio.is_worker_thread())
1388
1389         with self.subTest(worker="self"),\
1390                 mock.patch("threading.current_thread") as current_thread:
1391             current = mock.Mock()
1392             current_thread.return_value = current
1393             store.Portfolio.worker = current
1394             self.assertTrue(store.Portfolio.is_worker_thread())
1395
1396     def test_start_worker(self):
1397         with mock.patch.object(store.Portfolio, "wait_for_notification") as notification:
1398             store.Portfolio.start_worker()
1399             notification.assert_called_once_with(poll=30)
1400
1401             self.assertEqual("lock", store.Portfolio.last_date.lock.__class__.__name__)
1402             self.assertEqual("lock", store.Portfolio.liquidities.lock.__class__.__name__)
1403             store.Portfolio.report.start_lock.assert_called_once_with()
1404
1405             self.assertIsNotNone(store.Portfolio.worker)
1406             self.assertIsNotNone(store.Portfolio.worker_notify)
1407             self.assertIsNotNone(store.Portfolio.callback)
1408             self.assertTrue(store.Portfolio.worker_started)
1409
1410             self.assertFalse(store.Portfolio.worker.is_alive())
1411             self.assertEqual(1, threading.active_count())
1412
1413     def test_stop_worker(self):
1414         with mock.patch.object(store.Portfolio, "get_cryptoportfolio") as get,\
1415                 mock.patch.object(store.Portfolio, "report") as report,\
1416                 mock.patch.object(store.time, "sleep") as sleep:
1417             store.Portfolio.start_worker(poll=3)
1418             store.Portfolio.stop_worker()
1419             store.Portfolio.worker.join()
1420             get.assert_not_called()
1421             report.assert_not_called()
1422             sleep.assert_not_called()
1423             self.assertFalse(store.Portfolio.worker.is_alive())
1424
1425     def test_wait_for_notification(self):
1426         with self.assertRaises(RuntimeError):
1427             store.Portfolio.wait_for_notification()
1428
1429         with mock.patch.object(store.Portfolio, "get_cryptoportfolio") as get,\
1430                 mock.patch.object(store.Portfolio, "report") as report,\
1431                 mock.patch.object(store.time, "sleep") as sleep:
1432             store.Portfolio.start_worker(poll=3)
1433
1434             store.Portfolio.worker_notify.set()
1435
1436             store.Portfolio.callback.wait()
1437
1438             report.print_log.assert_called_once_with("[Worker] Fetching cryptoportfolio")
1439             get.assert_called_once_with(refetch=True)
1440             sleep.assert_called_once_with(3)
1441             self.assertFalse(store.Portfolio.worker_notify.is_set())
1442             self.assertTrue(store.Portfolio.worker.is_alive())
1443
1444             store.Portfolio.callback.clear()
1445             store.Portfolio.worker_started = False
1446             store.Portfolio.worker_notify.set()
1447             store.Portfolio.worker.join()
1448             self.assertFalse(store.Portfolio.worker.is_alive())
1449
1450     def test_notify_and_wait(self):
1451         with mock.patch.object(store.Portfolio, "callback") as callback,\
1452                 mock.patch.object(store.Portfolio, "worker_notify") as worker_notify:
1453             store.Portfolio.notify_and_wait()
1454             callback.clear.assert_called_once_with()
1455             worker_notify.set.assert_called_once_with()
1456             callback.wait.assert_called_once_with()
1457
1458