projects / perso / Immae / Projets / Cryptomonnaies / Cryptoportfolio / Trader.git / blame
| Commit | Line | Data |
|---|---|---|
| c682bdf4 IB |
1 | from .helper import * |
| 2 | import requests | |
| 3 | import datetime | |
| 4 | import threading | |
| 5 | import market, portfolio, store | |
| 6 | ||
| 3080f31d | 7 | @unittest.skipUnless("unit" in limits, "Unit skipped") |
| c682bdf4 IB |
8 | class NoopLockTest(unittest.TestCase): |
| 9 | def test_with(self): | |
| 10 | noop_lock = store.NoopLock() | |
| 11 | with noop_lock: | |
| 12 | self.assertTrue(True) | |
| 13 | ||
| 3080f31d | 14 | @unittest.skipUnless("unit" in limits, "Unit skipped") |
| c682bdf4 IB |
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 | ||
| 3080f31d | 66 | @unittest.skipUnless("unit" in limits, "Unit skipped") |
| c682bdf4 IB |
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 | ||
| 3080f31d | 291 | @unittest.skipUnless("unit" in limits, "Unit skipped") |
| c682bdf4 IB |
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 | balance_store.fetch_balances() | |
| 373 | self.assertNotIn("ETC", balance_store.currencies()) | |
| 374 | self.assertListEqual(["USDT", "XVG", "XMR"], list(balance_store.currencies())) | |
| 375 | ||
| 376 | balance_store.all["ETC"] = portfolio.Balance("ETC", { | |
| 377 | "exchange_total": "1", "exchange_free": "0", | |
| 378 | "exchange_used": "1" }) | |
| 379 | balance_store.fetch_balances(tag="foo") | |
| 380 | self.assertEqual(0, balance_store.all["ETC"].total) | |
| 381 | self.assertListEqual(["USDT", "XVG", "XMR", "ETC"], list(balance_store.currencies())) | |
| 382 | self.m.report.log_balances.assert_called_with(tag="foo") | |
| 383 | ||
| 384 | @mock.patch.object(market.Portfolio, "repartition") | |
| 385 | def test_dispatch_assets(self, repartition): | |
| 386 | self.m.ccxt.fetch_all_balances.return_value = self.fetch_balance | |
| 387 | ||
| 388 | balance_store = market.BalanceStore(self.m) | |
| 389 | balance_store.fetch_balances() | |
| 390 | ||
| 391 | self.assertNotIn("XEM", balance_store.currencies()) | |
| 392 | ||
| 393 | repartition_hash = { | |
| 394 | "XEM": (D("0.75"), "long"), | |
| 395 | "BTC": (D("0.26"), "long"), | |
| 396 | "DASH": (D("0.10"), "short"), | |
| 397 | } | |
| 398 | repartition.return_value = repartition_hash | |
| 399 | ||
| 400 | amounts = balance_store.dispatch_assets(portfolio.Amount("BTC", "11.1")) | |
| 401 | repartition.assert_called_with(liquidity="medium") | |
| 402 | self.assertIn("XEM", balance_store.currencies()) | |
| 403 | self.assertEqual(D("2.6"), amounts["BTC"].value) | |
| 404 | self.assertEqual(D("7.5"), amounts["XEM"].value) | |
| 405 | self.assertEqual(D("-1.0"), amounts["DASH"].value) | |
| 406 | self.m.report.log_balances.assert_called_with(tag=None) | |
| 407 | self.m.report.log_dispatch.assert_called_once_with(portfolio.Amount("BTC", | |
| 408 | "11.1"), amounts, "medium", repartition_hash) | |
| 409 | ||
| 410 | def test_currencies(self): | |
| 411 | balance_store = market.BalanceStore(self.m) | |
| 412 | ||
| 413 | balance_store.all = { | |
| 414 | "BTC": portfolio.Balance("BTC", { | |
| 415 | "total": "0.65", | |
| 416 | "exchange_total":"0.65", | |
| 417 | "exchange_free": "0.35", | |
| 418 | "exchange_used": "0.30"}), | |
| 419 | "ETH": portfolio.Balance("ETH", { | |
| 420 | "total": 3, | |
| 421 | "exchange_total": 3, | |
| 422 | "exchange_free": 3, | |
| 423 | "exchange_used": 0}), | |
| 424 | } | |
| 425 | self.assertListEqual(["BTC", "ETH"], list(balance_store.currencies())) | |
| 426 | ||
| 427 | def test_as_json(self): | |
| 428 | balance_mock1 = mock.Mock() | |
| 429 | balance_mock1.as_json.return_value = 1 | |
| 430 | ||
| 431 | balance_mock2 = mock.Mock() | |
| 432 | balance_mock2.as_json.return_value = 2 | |
| 433 | ||
| 434 | balance_store = market.BalanceStore(self.m) | |
| 435 | balance_store.all = { | |
| 436 | "BTC": balance_mock1, | |
| 437 | "ETH": balance_mock2, | |
| 438 | } | |
| 439 | ||
| 440 | as_json = balance_store.as_json() | |
| 441 | self.assertEqual(1, as_json["BTC"]) | |
| 442 | self.assertEqual(2, as_json["ETH"]) | |
| 443 | ||
| 3080f31d | 444 | @unittest.skipUnless("unit" in limits, "Unit skipped") |
| c682bdf4 IB |
445 | class ReportStoreTest(WebMockTestCase): |
| 446 | def test_add_log(self): | |
| e7d7c0e5 IB |
447 | with self.subTest(market=self.m): |
| 448 | self.m.user_id = 1 | |
| 449 | self.m.market_id = 3 | |
| 450 | report_store = market.ReportStore(self.m) | |
| 451 | result = report_store.add_log({"foo": "bar"}) | |
| 452 | ||
| 453 | self.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": 1, "market_id": 3}, result) | |
| 454 | self.assertEqual(result, report_store.logs[0]) | |
| 455 | ||
| 456 | with self.subTest(market=None): | |
| 457 | report_store = market.ReportStore(None) | |
| 458 | result = report_store.add_log({"foo": "bar"}) | |
| c682bdf4 | 459 | |
| e7d7c0e5 | 460 | self.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": None, "market_id": None}, result) |
| c682bdf4 IB |
461 | |
| 462 | def test_set_verbose(self): | |
| 463 | report_store = market.ReportStore(self.m) | |
| 464 | with self.subTest(verbose=True): | |
| 465 | report_store.set_verbose(True) | |
| 466 | self.assertTrue(report_store.verbose_print) | |
| 467 | ||
| 468 | with self.subTest(verbose=False): | |
| 469 | report_store.set_verbose(False) | |
| 470 | self.assertFalse(report_store.verbose_print) | |
| 471 | ||
| 472 | def test_merge(self): | |
| e7d7c0e5 IB |
473 | self.m.user_id = 1 |
| 474 | self.m.market_id = 3 | |
| c682bdf4 IB |
475 | report_store1 = market.ReportStore(self.m, verbose_print=False) |
| 476 | report_store2 = market.ReportStore(None, verbose_print=False) | |
| 477 | ||
| 478 | report_store2.log_stage("1") | |
| 479 | report_store1.log_stage("2") | |
| 480 | report_store2.log_stage("3") | |
| 481 | ||
| 482 | report_store1.merge(report_store2) | |
| 483 | ||
| 484 | self.assertEqual(3, len(report_store1.logs)) | |
| 485 | self.assertEqual(["1", "2", "3"], list(map(lambda x: x["stage"], report_store1.logs))) | |
| 486 | self.assertEqual(6, len(report_store1.print_logs)) | |
| 487 | ||
| 488 | def test_print_log(self): | |
| 489 | report_store = market.ReportStore(self.m) | |
| 490 | with self.subTest(verbose=True),\ | |
| 491 | mock.patch.object(store, "datetime") as time_mock,\ | |
| 492 | mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock: | |
| e7d7c0e5 | 493 | time_mock.datetime.now.return_value = datetime.datetime(2018, 2, 25, 2, 20, 10) |
| c682bdf4 IB |
494 | report_store.set_verbose(True) |
| 495 | report_store.print_log("Coucou") | |
| 496 | report_store.print_log(portfolio.Amount("BTC", 1)) | |
| 497 | self.assertEqual(stdout_mock.getvalue(), "2018-02-25 02:20:10: Coucou\n2018-02-25 02:20:10: 1.00000000 BTC\n") | |
| 498 | ||
| 499 | with self.subTest(verbose=False),\ | |
| 500 | mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock: | |
| 501 | report_store.set_verbose(False) | |
| 502 | report_store.print_log("Coucou") | |
| 503 | report_store.print_log(portfolio.Amount("BTC", 1)) | |
| 504 | self.assertEqual(stdout_mock.getvalue(), "") | |
| 505 | ||
| 506 | def test_default_json_serial(self): | |
| 507 | report_store = market.ReportStore(self.m) | |
| 508 | ||
| 509 | self.assertEqual("2018-02-24T00:00:00", | |
| e7d7c0e5 | 510 | report_store.default_json_serial(portfolio.datetime.datetime(2018, 2, 24))) |
| c682bdf4 IB |
511 | self.assertEqual("1.00000000 BTC", |
| 512 | report_store.default_json_serial(portfolio.Amount("BTC", 1))) | |
| 513 | ||
| 514 | def test_to_json(self): | |
| 515 | report_store = market.ReportStore(self.m) | |
| 516 | report_store.logs.append({"foo": "bar"}) | |
| 517 | self.assertEqual('[\n {\n "foo": "bar"\n }\n]', report_store.to_json()) | |
| e7d7c0e5 | 518 | report_store.logs.append({"date": portfolio.datetime.datetime(2018, 2, 24)}) |
| c682bdf4 IB |
519 | self.assertEqual('[\n {\n "foo": "bar"\n },\n {\n "date": "2018-02-24T00:00:00"\n }\n]', report_store.to_json()) |
| 520 | report_store.logs.append({"amount": portfolio.Amount("BTC", 1)}) | |
| 521 | 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()) | |
| 522 | ||
| 523 | def test_to_json_array(self): | |
| 524 | report_store = market.ReportStore(self.m) | |
| 525 | report_store.logs.append({ | |
| 526 | "date": "date1", "type": "type1", "foo": "bar", "bla": "bla" | |
| 527 | }) | |
| 528 | report_store.logs.append({ | |
| 529 | "date": "date2", "type": "type2", "foo": "bar", "bla": "bla" | |
| 530 | }) | |
| 531 | logs = list(report_store.to_json_array()) | |
| 532 | ||
| 533 | self.assertEqual(2, len(logs)) | |
| 534 | self.assertEqual(("date1", "type1", '{\n "foo": "bar",\n "bla": "bla"\n}'), logs[0]) | |
| 535 | self.assertEqual(("date2", "type2", '{\n "foo": "bar",\n "bla": "bla"\n}'), logs[1]) | |
| 536 | ||
| 537 | @mock.patch.object(market.ReportStore, "print_log") | |
| 538 | @mock.patch.object(market.ReportStore, "add_log") | |
| 539 | def test_log_stage(self, add_log, print_log): | |
| 540 | report_store = market.ReportStore(self.m) | |
| 541 | c = lambda x: x | |
| 542 | report_store.log_stage("foo", bar="baz", c=c, d=portfolio.Amount("BTC", 1)) | |
| 543 | print_log.assert_has_calls([ | |
| 544 | mock.call("-----------"), | |
| 545 | mock.call("[Stage] foo bar=baz, c=c = lambda x: x, d={'currency': 'BTC', 'value': Decimal('1')}"), | |
| 546 | ]) | |
| 547 | add_log.assert_called_once_with({ | |
| 548 | 'type': 'stage', | |
| 549 | 'stage': 'foo', | |
| 550 | 'args': { | |
| 551 | 'bar': 'baz', | |
| 552 | 'c': 'c = lambda x: x', | |
| 553 | 'd': { | |
| 554 | 'currency': 'BTC', | |
| 555 | 'value': D('1') | |
| 556 | } | |
| 557 | } | |
| 558 | }) | |
| 559 | ||
| 560 | @mock.patch.object(market.ReportStore, "print_log") | |
| 561 | @mock.patch.object(market.ReportStore, "add_log") | |
| 562 | def test_log_balances(self, add_log, print_log): | |
| 563 | report_store = market.ReportStore(self.m) | |
| 564 | self.m.balances.as_json.return_value = "json" | |
| 565 | self.m.balances.all = { "FOO": "bar", "BAR": "baz" } | |
| 566 | ||
| 567 | report_store.log_balances(tag="tag") | |
| 568 | print_log.assert_has_calls([ | |
| 569 | mock.call("[Balance]"), | |
| 570 | mock.call("\tbar"), | |
| 571 | mock.call("\tbaz"), | |
| 572 | ]) | |
| 573 | add_log.assert_called_once_with({ | |
| 574 | 'type': 'balance', | |
| 575 | 'balances': 'json', | |
| 576 | 'tag': 'tag' | |
| 577 | }) | |
| 578 | ||
| 579 | @mock.patch.object(market.ReportStore, "print_log") | |
| 580 | @mock.patch.object(market.ReportStore, "add_log") | |
| 581 | def test_log_tickers(self, add_log, print_log): | |
| 582 | report_store = market.ReportStore(self.m) | |
| 583 | amounts = { | |
| 584 | "BTC": portfolio.Amount("BTC", 10), | |
| 585 | "ETH": portfolio.Amount("BTC", D("0.3")) | |
| 586 | } | |
| 587 | amounts["ETH"].rate = D("0.1") | |
| 588 | ||
| 589 | report_store.log_tickers(amounts, "BTC", "default", "total") | |
| 590 | print_log.assert_not_called() | |
| 591 | add_log.assert_called_once_with({ | |
| 592 | 'type': 'tickers', | |
| 593 | 'compute_value': 'default', | |
| 594 | 'balance_type': 'total', | |
| 595 | 'currency': 'BTC', | |
| 596 | 'balances': { | |
| 597 | 'BTC': D('10'), | |
| 598 | 'ETH': D('0.3') | |
| 599 | }, | |
| 600 | 'rates': { | |
| 601 | 'BTC': None, | |
| 602 | 'ETH': D('0.1') | |
| 603 | }, | |
| 604 | 'total': D('10.3') | |
| 605 | }) | |
| 606 | ||
| 607 | add_log.reset_mock() | |
| 608 | compute_value = lambda x: x["bid"] | |
| 609 | report_store.log_tickers(amounts, "BTC", compute_value, "total") | |
| 610 | add_log.assert_called_once_with({ | |
| 611 | 'type': 'tickers', | |
| 612 | 'compute_value': 'compute_value = lambda x: x["bid"]', | |
| 613 | 'balance_type': 'total', | |
| 614 | 'currency': 'BTC', | |
| 615 | 'balances': { | |
| 616 | 'BTC': D('10'), | |
| 617 | 'ETH': D('0.3') | |
| 618 | }, | |
| 619 | 'rates': { | |
| 620 | 'BTC': None, | |
| 621 | 'ETH': D('0.1') | |
| 622 | }, | |
| 623 | 'total': D('10.3') | |
| 624 | }) | |
| 625 | ||
| 626 | @mock.patch.object(market.ReportStore, "print_log") | |
| 627 | @mock.patch.object(market.ReportStore, "add_log") | |
| 628 | def test_log_dispatch(self, add_log, print_log): | |
| 629 | report_store = market.ReportStore(self.m) | |
| 630 | amount = portfolio.Amount("BTC", "10.3") | |
| 631 | amounts = { | |
| 632 | "BTC": portfolio.Amount("BTC", 10), | |
| 633 | "ETH": portfolio.Amount("BTC", D("0.3")) | |
| 634 | } | |
| 635 | report_store.log_dispatch(amount, amounts, "medium", "repartition") | |
| 636 | print_log.assert_not_called() | |
| 637 | add_log.assert_called_once_with({ | |
| 638 | 'type': 'dispatch', | |
| 639 | 'liquidity': 'medium', | |
| 640 | 'repartition_ratio': 'repartition', | |
| 641 | 'total_amount': { | |
| 642 | 'currency': 'BTC', | |
| 643 | 'value': D('10.3') | |
| 644 | }, | |
| 645 | 'repartition': { | |
| 646 | 'BTC': D('10'), | |
| 647 | 'ETH': D('0.3') | |
| 648 | } | |
| 649 | }) | |
| 650 | ||
| 651 | @mock.patch.object(market.ReportStore, "print_log") | |
| 652 | @mock.patch.object(market.ReportStore, "add_log") | |
| 653 | def test_log_trades(self, add_log, print_log): | |
| 654 | report_store = market.ReportStore(self.m) | |
| 655 | trade_mock1 = mock.Mock() | |
| 656 | trade_mock2 = mock.Mock() | |
| 657 | trade_mock1.as_json.return_value = { "trade": "1" } | |
| 658 | trade_mock2.as_json.return_value = { "trade": "2" } | |
| 659 | ||
| 660 | matching_and_trades = [ | |
| 661 | (True, trade_mock1), | |
| 662 | (False, trade_mock2), | |
| 663 | ] | |
| 664 | report_store.log_trades(matching_and_trades, "only") | |
| 665 | ||
| 666 | print_log.assert_not_called() | |
| 667 | add_log.assert_called_with({ | |
| 668 | 'type': 'trades', | |
| 669 | 'only': 'only', | |
| 670 | 'debug': False, | |
| 671 | 'trades': [ | |
| 672 | {'trade': '1', 'skipped': False}, | |
| 673 | {'trade': '2', 'skipped': True} | |
| 674 | ] | |
| 675 | }) | |
| 676 | ||
| 677 | @mock.patch.object(market.ReportStore, "print_log") | |
| 678 | @mock.patch.object(market.ReportStore, "add_log") | |
| 679 | def test_log_orders(self, add_log, print_log): | |
| 680 | report_store = market.ReportStore(self.m) | |
| 681 | ||
| 682 | order_mock1 = mock.Mock() | |
| 683 | order_mock2 = mock.Mock() | |
| 684 | ||
| 685 | order_mock1.as_json.return_value = "order1" | |
| 686 | order_mock2.as_json.return_value = "order2" | |
| 687 | ||
| 688 | orders = [order_mock1, order_mock2] | |
| 689 | ||
| 690 | report_store.log_orders(orders, tick="tick", | |
| 691 | only="only", compute_value="compute_value") | |
| 692 | ||
| 693 | print_log.assert_called_once_with("[Orders]") | |
| 694 | self.m.trades.print_all_with_order.assert_called_once_with(ind="\t") | |
| 695 | ||
| 696 | add_log.assert_called_with({ | |
| 697 | 'type': 'orders', | |
| 698 | 'only': 'only', | |
| 699 | 'compute_value': 'compute_value', | |
| 700 | 'tick': 'tick', | |
| 701 | 'orders': ['order1', 'order2'] | |
| 702 | }) | |
| 703 | ||
| 704 | add_log.reset_mock() | |
| 705 | def compute_value(x, y): | |
| 706 | return x[y] | |
| 707 | report_store.log_orders(orders, tick="tick", | |
| 708 | only="only", compute_value=compute_value) | |
| 709 | add_log.assert_called_with({ | |
| 710 | 'type': 'orders', | |
| 711 | 'only': 'only', | |
| 712 | 'compute_value': 'def compute_value(x, y):\n return x[y]', | |
| 713 | 'tick': 'tick', | |
| 714 | 'orders': ['order1', 'order2'] | |
| 715 | }) | |
| 716 | ||
| 717 | ||
| 718 | @mock.patch.object(market.ReportStore, "print_log") | |
| 719 | @mock.patch.object(market.ReportStore, "add_log") | |
| 720 | def test_log_order(self, add_log, print_log): | |
| 721 | report_store = market.ReportStore(self.m) | |
| 722 | order_mock = mock.Mock() | |
| 723 | order_mock.as_json.return_value = "order" | |
| 724 | new_order_mock = mock.Mock() | |
| 725 | new_order_mock.as_json.return_value = "new_order" | |
| 726 | order_mock.__repr__ = mock.Mock() | |
| 727 | order_mock.__repr__.return_value = "Order Mock" | |
| 728 | new_order_mock.__repr__ = mock.Mock() | |
| 729 | new_order_mock.__repr__.return_value = "New order Mock" | |
| 730 | ||
| 731 | with self.subTest(finished=True): | |
| 732 | report_store.log_order(order_mock, 1, finished=True) | |
| 733 | print_log.assert_called_once_with("[Order] Finished Order Mock") | |
| 734 | add_log.assert_called_once_with({ | |
| 735 | 'type': 'order', | |
| 736 | 'tick': 1, | |
| 737 | 'update': None, | |
| 738 | 'order': 'order', | |
| 739 | 'compute_value': None, | |
| 740 | 'new_order': None | |
| 741 | }) | |
| 742 | ||
| 743 | add_log.reset_mock() | |
| 744 | print_log.reset_mock() | |
| 745 | ||
| 746 | with self.subTest(update="waiting"): | |
| 747 | report_store.log_order(order_mock, 1, update="waiting") | |
| 748 | print_log.assert_called_once_with("[Order] Order Mock, tick 1, waiting") | |
| 749 | add_log.assert_called_once_with({ | |
| 750 | 'type': 'order', | |
| 751 | 'tick': 1, | |
| 752 | 'update': 'waiting', | |
| 753 | 'order': 'order', | |
| 754 | 'compute_value': None, | |
| 755 | 'new_order': None | |
| 756 | }) | |
| 757 | ||
| 758 | add_log.reset_mock() | |
| 759 | print_log.reset_mock() | |
| 760 | with self.subTest(update="adjusting"): | |
| 761 | compute_value = lambda x: (x["bid"] + x["ask"]*2)/3 | |
| 762 | report_store.log_order(order_mock, 3, | |
| 763 | update="adjusting", new_order=new_order_mock, | |
| 764 | compute_value=compute_value) | |
| 765 | print_log.assert_called_once_with("[Order] Order Mock, tick 3, cancelling and adjusting to New order Mock") | |
| 766 | add_log.assert_called_once_with({ | |
| 767 | 'type': 'order', | |
| 768 | 'tick': 3, | |
| 769 | 'update': 'adjusting', | |
| 770 | 'order': 'order', | |
| 771 | 'compute_value': 'compute_value = lambda x: (x["bid"] + x["ask"]*2)/3', | |
| 772 | 'new_order': 'new_order' | |
| 773 | }) | |
| 774 | ||
| 775 | add_log.reset_mock() | |
| 776 | print_log.reset_mock() | |
| 777 | with self.subTest(update="market_fallback"): | |
| 778 | report_store.log_order(order_mock, 7, | |
| 779 | update="market_fallback", new_order=new_order_mock) | |
| 780 | print_log.assert_called_once_with("[Order] Order Mock, tick 7, fallbacking to market value") | |
| 781 | add_log.assert_called_once_with({ | |
| 782 | 'type': 'order', | |
| 783 | 'tick': 7, | |
| 784 | 'update': 'market_fallback', | |
| 785 | 'order': 'order', | |
| 786 | 'compute_value': None, | |
| 787 | 'new_order': 'new_order' | |
| 788 | }) | |
| 789 | ||
| 790 | add_log.reset_mock() | |
| 791 | print_log.reset_mock() | |
| 792 | with self.subTest(update="market_adjusting"): | |
| 793 | report_store.log_order(order_mock, 17, | |
| 794 | update="market_adjust", new_order=new_order_mock) | |
| 795 | print_log.assert_called_once_with("[Order] Order Mock, tick 17, market value, cancelling and adjusting to New order Mock") | |
| 796 | add_log.assert_called_once_with({ | |
| 797 | 'type': 'order', | |
| 798 | 'tick': 17, | |
| 799 | 'update': 'market_adjust', | |
| 800 | 'order': 'order', | |
| 801 | 'compute_value': None, | |
| 802 | 'new_order': 'new_order' | |
| 803 | }) | |
| 804 | ||
| 805 | @mock.patch.object(market.ReportStore, "print_log") | |
| 806 | @mock.patch.object(market.ReportStore, "add_log") | |
| 807 | def test_log_move_balances(self, add_log, print_log): | |
| 808 | report_store = market.ReportStore(self.m) | |
| 809 | needed = { | |
| 810 | "BTC": portfolio.Amount("BTC", 10), | |
| 811 | "USDT": 1 | |
| 812 | } | |
| 813 | moving = { | |
| 814 | "BTC": portfolio.Amount("BTC", 3), | |
| 815 | "USDT": -2 | |
| 816 | } | |
| 817 | report_store.log_move_balances(needed, moving) | |
| 818 | print_log.assert_not_called() | |
| 819 | add_log.assert_called_once_with({ | |
| 820 | 'type': 'move_balances', | |
| 821 | 'debug': False, | |
| 822 | 'needed': { | |
| 823 | 'BTC': D('10'), | |
| 824 | 'USDT': 1 | |
| 825 | }, | |
| 826 | 'moving': { | |
| 827 | 'BTC': D('3'), | |
| 828 | 'USDT': -2 | |
| 829 | } | |
| 830 | }) | |
| 831 | ||
| e7d7c0e5 IB |
832 | def test_log_http_request(self): |
| 833 | with mock.patch.object(market.ReportStore, "add_log") as add_log: | |
| 834 | report_store = market.ReportStore(self.m) | |
| 835 | response = mock.Mock() | |
| 836 | response.status_code = 200 | |
| 837 | response.text = "Hey" | |
| 9fe90554 | 838 | response.elapsed.total_seconds.return_value = 120 |
| c682bdf4 | 839 | |
| e7d7c0e5 IB |
840 | report_store.log_http_request("method", "url", "body", |
| 841 | "headers", response) | |
| 842 | add_log.assert_called_once_with({ | |
| 843 | 'type': 'http_request', | |
| 844 | 'method': 'method', | |
| 845 | 'url': 'url', | |
| 846 | 'body': 'body', | |
| 847 | 'headers': 'headers', | |
| 848 | 'status': 200, | |
| 9fe90554 | 849 | 'duration': 120, |
| e7d7c0e5 IB |
850 | 'response': 'Hey', |
| 851 | 'response_same_as': None, | |
| 852 | }) | |
| c682bdf4 | 853 | |
| e7d7c0e5 IB |
854 | add_log.reset_mock() |
| 855 | report_store.log_http_request("method", "url", "body", | |
| 856 | "headers", ValueError("Foo")) | |
| 857 | add_log.assert_called_once_with({ | |
| 858 | 'type': 'http_request', | |
| 859 | 'method': 'method', | |
| 860 | 'url': 'url', | |
| 861 | 'body': 'body', | |
| 862 | 'headers': 'headers', | |
| 863 | 'status': -1, | |
| 864 | 'response': None, | |
| 865 | 'error': 'ValueError', | |
| 866 | 'error_message': 'Foo', | |
| 867 | }) | |
| 868 | ||
| 869 | with self.subTest(no_http_dup=True, duplicate=True): | |
| 870 | self.m.user_id = 1 | |
| 871 | self.m.market_id = 3 | |
| 872 | report_store = market.ReportStore(self.m, no_http_dup=True) | |
| 873 | original_add_log = report_store.add_log | |
| 874 | with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log: | |
| 875 | report_store.log_http_request("method", "url", "body", | |
| 876 | "headers", response) | |
| 877 | report_store.log_http_request("method", "url", "body", | |
| 878 | "headers", response) | |
| 879 | self.assertEqual(2, add_log.call_count) | |
| 880 | self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"]) | |
| 881 | self.assertIsNone(add_log.mock_calls[1][1][0]["response"]) | |
| 882 | self.assertEqual(add_log.mock_calls[0][1][0]["date"], add_log.mock_calls[1][1][0]["response_same_as"]) | |
| 883 | with self.subTest(no_http_dup=True, duplicate=False, case="Different call"): | |
| 884 | self.m.user_id = 1 | |
| 885 | self.m.market_id = 3 | |
| 886 | report_store = market.ReportStore(self.m, no_http_dup=True) | |
| 887 | original_add_log = report_store.add_log | |
| 888 | with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log: | |
| 889 | report_store.log_http_request("method", "url", "body", | |
| 890 | "headers", response) | |
| 891 | report_store.log_http_request("method2", "url", "body", | |
| 892 | "headers", response) | |
| 893 | self.assertEqual(2, add_log.call_count) | |
| 894 | self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"]) | |
| 895 | self.assertIsNone(add_log.mock_calls[1][1][0]["response_same_as"]) | |
| 896 | with self.subTest(no_http_dup=True, duplicate=False, case="Call inbetween"): | |
| 897 | self.m.user_id = 1 | |
| 898 | self.m.market_id = 3 | |
| 899 | report_store = market.ReportStore(self.m, no_http_dup=True) | |
| 900 | original_add_log = report_store.add_log | |
| 901 | ||
| 902 | response2 = mock.Mock() | |
| 903 | response2.status_code = 200 | |
| 904 | response2.text = "Hey there!" | |
| 905 | ||
| 906 | with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log: | |
| 907 | report_store.log_http_request("method", "url", "body", | |
| 908 | "headers", response) | |
| 909 | report_store.log_http_request("method", "url", "body", | |
| 910 | "headers", response2) | |
| 911 | report_store.log_http_request("method", "url", "body", | |
| 912 | "headers", response) | |
| 913 | self.assertEqual(3, add_log.call_count) | |
| 914 | self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"]) | |
| 915 | self.assertIsNone(add_log.mock_calls[1][1][0]["response_same_as"]) | |
| 916 | self.assertIsNone(add_log.mock_calls[2][1][0]["response_same_as"]) | |
| c682bdf4 IB |
917 | |
| 918 | @mock.patch.object(market.ReportStore, "add_log") | |
| 919 | def test_log_market(self, add_log): | |
| 920 | report_store = market.ReportStore(self.m) | |
| 921 | ||
| e7d7c0e5 | 922 | report_store.log_market(self.market_args(debug=True, quiet=False)) |
| c682bdf4 IB |
923 | add_log.assert_called_once_with({ |
| 924 | "type": "market", | |
| 925 | "commit": "$Format:%H$", | |
| 926 | "args": { "report_path": None, "debug": True, "quiet": False }, | |
| c682bdf4 IB |
927 | }) |
| 928 | ||
| 929 | @mock.patch.object(market.ReportStore, "print_log") | |
| 930 | @mock.patch.object(market.ReportStore, "add_log") | |
| 931 | def test_log_error(self, add_log, print_log): | |
| 932 | report_store = market.ReportStore(self.m) | |
| 933 | with self.subTest(message=None, exception=None): | |
| 934 | report_store.log_error("action") | |
| 935 | print_log.assert_called_once_with("[Error] action") | |
| 936 | add_log.assert_called_once_with({ | |
| 937 | 'type': 'error', | |
| 938 | 'action': 'action', | |
| 939 | 'exception_class': None, | |
| 940 | 'exception_message': None, | |
| 941 | 'message': None | |
| 942 | }) | |
| 943 | ||
| 944 | print_log.reset_mock() | |
| 945 | add_log.reset_mock() | |
| 946 | with self.subTest(message="Hey", exception=None): | |
| 947 | report_store.log_error("action", message="Hey") | |
| 948 | print_log.assert_has_calls([ | |
| 949 | mock.call("[Error] action"), | |
| 950 | mock.call("\tHey") | |
| 951 | ]) | |
| 952 | add_log.assert_called_once_with({ | |
| 953 | 'type': 'error', | |
| 954 | 'action': 'action', | |
| 955 | 'exception_class': None, | |
| 956 | 'exception_message': None, | |
| 957 | 'message': "Hey" | |
| 958 | }) | |
| 959 | ||
| 960 | print_log.reset_mock() | |
| 961 | add_log.reset_mock() | |
| 962 | with self.subTest(message=None, exception=Exception("bouh")): | |
| 963 | report_store.log_error("action", exception=Exception("bouh")) | |
| 964 | print_log.assert_has_calls([ | |
| 965 | mock.call("[Error] action"), | |
| 966 | mock.call("\tException: bouh") | |
| 967 | ]) | |
| 968 | add_log.assert_called_once_with({ | |
| 969 | 'type': 'error', | |
| 970 | 'action': 'action', | |
| 971 | 'exception_class': "Exception", | |
| 972 | 'exception_message': "bouh", | |
| 973 | 'message': None | |
| 974 | }) | |
| 975 | ||
| 976 | print_log.reset_mock() | |
| 977 | add_log.reset_mock() | |
| 978 | with self.subTest(message="Hey", exception=Exception("bouh")): | |
| 979 | report_store.log_error("action", message="Hey", exception=Exception("bouh")) | |
| 980 | print_log.assert_has_calls([ | |
| 981 | mock.call("[Error] action"), | |
| 982 | mock.call("\tException: bouh"), | |
| 983 | mock.call("\tHey") | |
| 984 | ]) | |
| 985 | add_log.assert_called_once_with({ | |
| 986 | 'type': 'error', | |
| 987 | 'action': 'action', | |
| 988 | 'exception_class': "Exception", | |
| 989 | 'exception_message': "bouh", | |
| 990 | 'message': "Hey" | |
| 991 | }) | |
| 992 | ||
| 993 | @mock.patch.object(market.ReportStore, "print_log") | |
| 994 | @mock.patch.object(market.ReportStore, "add_log") | |
| 995 | def test_log_debug_action(self, add_log, print_log): | |
| 996 | report_store = market.ReportStore(self.m) | |
| 997 | report_store.log_debug_action("Hey") | |
| 998 | ||
| 999 | print_log.assert_called_once_with("[Debug] Hey") | |
| 1000 | add_log.assert_called_once_with({ | |
| 1001 | 'type': 'debug_action', | |
| 1002 | 'action': 'Hey' | |
| 1003 | }) | |
| 1004 | ||
| 3080f31d | 1005 | @unittest.skipUnless("unit" in limits, "Unit skipped") |
| c682bdf4 IB |
1006 | class PortfolioTest(WebMockTestCase): |
| 1007 | def setUp(self): | |
| 1008 | super().setUp() | |
| 1009 | ||
| 1010 | with open("test_samples/test_portfolio.json") as example: | |
| 1011 | self.json_response = example.read() | |
| 1012 | ||
| 1013 | self.wm.get(market.Portfolio.URL, text=self.json_response) | |
| 1014 | ||
| 1015 | @mock.patch.object(market.Portfolio, "parse_cryptoportfolio") | |
| 1016 | def test_get_cryptoportfolio(self, parse_cryptoportfolio): | |
| 1017 | with self.subTest(parallel=False): | |
| 1018 | self.wm.get(market.Portfolio.URL, [ | |
| 1019 | {"text":'{ "foo": "bar" }', "status_code": 200}, | |
| 1020 | {"text": "System Error", "status_code": 500}, | |
| 1021 | {"exc": requests.exceptions.ConnectTimeout}, | |
| 1022 | ]) | |
| 1023 | market.Portfolio.get_cryptoportfolio() | |
| 1024 | self.assertIn("foo", market.Portfolio.data.get()) | |
| 1025 | self.assertEqual("bar", market.Portfolio.data.get()["foo"]) | |
| 1026 | self.assertTrue(self.wm.called) | |
| 1027 | self.assertEqual(1, self.wm.call_count) | |
| 1028 | market.Portfolio.report.log_error.assert_not_called() | |
| 1029 | market.Portfolio.report.log_http_request.assert_called_once() | |
| 1030 | parse_cryptoportfolio.assert_called_once_with() | |
| 1031 | market.Portfolio.report.log_http_request.reset_mock() | |
| 1032 | parse_cryptoportfolio.reset_mock() | |
| 1033 | market.Portfolio.data = store.LockedVar(None) | |
| 1034 | ||
| 1035 | market.Portfolio.get_cryptoportfolio() | |
| 1036 | self.assertIsNone(market.Portfolio.data.get()) | |
| 1037 | self.assertEqual(2, self.wm.call_count) | |
| 1038 | parse_cryptoportfolio.assert_not_called() | |
| 1039 | market.Portfolio.report.log_error.assert_not_called() | |
| 1040 | market.Portfolio.report.log_http_request.assert_called_once() | |
| 1041 | market.Portfolio.report.log_http_request.reset_mock() | |
| 1042 | parse_cryptoportfolio.reset_mock() | |
| 1043 | ||
| 1044 | market.Portfolio.data = store.LockedVar("Foo") | |
| 1045 | market.Portfolio.get_cryptoportfolio() | |
| 1046 | self.assertEqual(2, self.wm.call_count) | |
| 1047 | parse_cryptoportfolio.assert_not_called() | |
| 1048 | ||
| 1049 | market.Portfolio.get_cryptoportfolio(refetch=True) | |
| 1050 | self.assertEqual("Foo", market.Portfolio.data.get()) | |
| 1051 | self.assertEqual(3, self.wm.call_count) | |
| 1052 | market.Portfolio.report.log_error.assert_called_once_with("get_cryptoportfolio", | |
| 1053 | exception=mock.ANY) | |
| 1054 | market.Portfolio.report.log_http_request.assert_not_called() | |
| 1055 | with self.subTest(parallel=True): | |
| 1056 | with mock.patch.object(market.Portfolio, "is_worker_thread") as is_worker,\ | |
| 1057 | mock.patch.object(market.Portfolio, "notify_and_wait") as notify: | |
| 1058 | with self.subTest(worker=True): | |
| 1059 | market.Portfolio.data = store.LockedVar(None) | |
| 1060 | market.Portfolio.worker = mock.Mock() | |
| 1061 | is_worker.return_value = True | |
| 1062 | self.wm.get(market.Portfolio.URL, [ | |
| 1063 | {"text":'{ "foo": "bar" }', "status_code": 200}, | |
| 1064 | ]) | |
| 1065 | market.Portfolio.get_cryptoportfolio() | |
| 1066 | self.assertIn("foo", market.Portfolio.data.get()) | |
| 1067 | parse_cryptoportfolio.reset_mock() | |
| 1068 | with self.subTest(worker=False): | |
| 1069 | market.Portfolio.data = store.LockedVar(None) | |
| 1070 | market.Portfolio.worker = mock.Mock() | |
| 1071 | is_worker.return_value = False | |
| 1072 | market.Portfolio.get_cryptoportfolio() | |
| 1073 | notify.assert_called_once_with() | |
| 1074 | parse_cryptoportfolio.assert_not_called() | |
| 1075 | ||
| 1076 | def test_parse_cryptoportfolio(self): | |
| 1077 | with self.subTest(description="Normal case"): | |
| 1078 | market.Portfolio.data = store.LockedVar(store.json.loads( | |
| 1079 | self.json_response, parse_int=D, parse_float=D)) | |
| 1080 | market.Portfolio.parse_cryptoportfolio() | |
| 1081 | ||
| 1082 | self.assertListEqual( | |
| 1083 | ["medium", "high"], | |
| 1084 | list(market.Portfolio.liquidities.get().keys())) | |
| 1085 | ||
| 1086 | liquidities = market.Portfolio.liquidities.get() | |
| 1087 | self.assertEqual(10, len(liquidities["medium"].keys())) | |
| 1088 | self.assertEqual(10, len(liquidities["high"].keys())) | |
| 1089 | ||
| 1090 | expected = { | |
| 1091 | 'BTC': (D("0.2857"), "long"), | |
| 1092 | 'DGB': (D("0.1015"), "long"), | |
| 1093 | 'DOGE': (D("0.1805"), "long"), | |
| 1094 | 'SC': (D("0.0623"), "long"), | |
| 1095 | 'ZEC': (D("0.3701"), "long"), | |
| 1096 | } | |
| e7d7c0e5 | 1097 | date = portfolio.datetime.datetime(2018, 1, 8) |
| c682bdf4 IB |
1098 | self.assertDictEqual(expected, liquidities["high"][date]) |
| 1099 | ||
| 1100 | expected = { | |
| 1101 | 'BTC': (D("1.1102e-16"), "long"), | |
| 1102 | 'ETC': (D("0.1"), "long"), | |
| 1103 | 'FCT': (D("0.1"), "long"), | |
| 1104 | 'GAS': (D("0.1"), "long"), | |
| 1105 | 'NAV': (D("0.1"), "long"), | |
| 1106 | 'OMG': (D("0.1"), "long"), | |
| 1107 | 'OMNI': (D("0.1"), "long"), | |
| 1108 | 'PPC': (D("0.1"), "long"), | |
| 1109 | 'RIC': (D("0.1"), "long"), | |
| 1110 | 'VIA': (D("0.1"), "long"), | |
| 1111 | 'XCP': (D("0.1"), "long"), | |
| 1112 | } | |
| 1113 | self.assertDictEqual(expected, liquidities["medium"][date]) | |
| e7d7c0e5 | 1114 | self.assertEqual(portfolio.datetime.datetime(2018, 1, 15), market.Portfolio.last_date.get()) |
| c682bdf4 IB |
1115 | |
| 1116 | with self.subTest(description="Missing weight"): | |
| 1117 | data = store.json.loads(self.json_response, parse_int=D, parse_float=D) | |
| 1118 | del(data["portfolio_2"]["weights"]) | |
| 1119 | market.Portfolio.data = store.LockedVar(data) | |
| 1120 | ||
| 1121 | market.Portfolio.parse_cryptoportfolio() | |
| 1122 | self.assertListEqual( | |
| 1123 | ["medium", "high"], | |
| 1124 | list(market.Portfolio.liquidities.get().keys())) | |
| 1125 | self.assertEqual({}, market.Portfolio.liquidities.get("medium")) | |
| 1126 | ||
| 1127 | with self.subTest(description="All missing weights"): | |
| 1128 | data = store.json.loads(self.json_response, parse_int=D, parse_float=D) | |
| 1129 | del(data["portfolio_1"]["weights"]) | |
| 1130 | del(data["portfolio_2"]["weights"]) | |
| 1131 | market.Portfolio.data = store.LockedVar(data) | |
| 1132 | ||
| 1133 | market.Portfolio.parse_cryptoportfolio() | |
| 1134 | self.assertEqual({}, market.Portfolio.liquidities.get("medium")) | |
| 1135 | self.assertEqual({}, market.Portfolio.liquidities.get("high")) | |
| 1136 | self.assertEqual(datetime.datetime(1,1,1), market.Portfolio.last_date.get()) | |
| 1137 | ||
| 1138 | ||
| 1139 | @mock.patch.object(market.Portfolio, "get_cryptoportfolio") | |
| 1140 | def test_repartition(self, get_cryptoportfolio): | |
| 1141 | market.Portfolio.liquidities = store.LockedVar({ | |
| 1142 | "medium": { | |
| 1143 | "2018-03-01": "medium_2018-03-01", | |
| 1144 | "2018-03-08": "medium_2018-03-08", | |
| 1145 | }, | |
| 1146 | "high": { | |
| 1147 | "2018-03-01": "high_2018-03-01", | |
| 1148 | "2018-03-08": "high_2018-03-08", | |
| 1149 | } | |
| 1150 | }) | |
| 1151 | market.Portfolio.last_date = store.LockedVar("2018-03-08") | |
| 1152 | ||
| 1153 | self.assertEqual("medium_2018-03-08", market.Portfolio.repartition()) | |
| 1154 | get_cryptoportfolio.assert_called_once_with() | |
| 1155 | self.assertEqual("medium_2018-03-08", market.Portfolio.repartition(liquidity="medium")) | |
| 1156 | self.assertEqual("high_2018-03-08", market.Portfolio.repartition(liquidity="high")) | |
| 1157 | ||
| 1158 | @mock.patch.object(market.time, "sleep") | |
| 1159 | @mock.patch.object(market.Portfolio, "get_cryptoportfolio") | |
| 1160 | def test_wait_for_recent(self, get_cryptoportfolio, sleep): | |
| 1161 | self.call_count = 0 | |
| 1162 | def _get(refetch=False): | |
| 1163 | if self.call_count != 0: | |
| 1164 | self.assertTrue(refetch) | |
| 1165 | else: | |
| 1166 | self.assertFalse(refetch) | |
| 1167 | self.call_count += 1 | |
| e7d7c0e5 IB |
1168 | market.Portfolio.last_date = store.LockedVar(store.datetime.datetime.now()\ |
| 1169 | - store.datetime.timedelta(10)\ | |
| 1170 | + store.datetime.timedelta(self.call_count)) | |
| c682bdf4 IB |
1171 | get_cryptoportfolio.side_effect = _get |
| 1172 | ||
| 1173 | market.Portfolio.wait_for_recent() | |
| 1174 | sleep.assert_called_with(30) | |
| 1175 | self.assertEqual(6, sleep.call_count) | |
| 1176 | self.assertEqual(7, get_cryptoportfolio.call_count) | |
| 1177 | market.Portfolio.report.print_log.assert_called_with("Attempt to fetch up-to-date cryptoportfolio") | |
| 1178 | ||
| 1179 | sleep.reset_mock() | |
| 1180 | get_cryptoportfolio.reset_mock() | |
| 1181 | market.Portfolio.last_date = store.LockedVar(None) | |
| 1182 | self.call_count = 0 | |
| 1183 | market.Portfolio.wait_for_recent(delta=15) | |
| 1184 | sleep.assert_not_called() | |
| 1185 | self.assertEqual(1, get_cryptoportfolio.call_count) | |
| 1186 | ||
| 1187 | sleep.reset_mock() | |
| 1188 | get_cryptoportfolio.reset_mock() | |
| 1189 | market.Portfolio.last_date = store.LockedVar(None) | |
| 1190 | self.call_count = 0 | |
| 1191 | market.Portfolio.wait_for_recent(delta=1) | |
| 1192 | sleep.assert_called_with(30) | |
| 1193 | self.assertEqual(9, sleep.call_count) | |
| 1194 | self.assertEqual(10, get_cryptoportfolio.call_count) | |
| 1195 | ||
| 1196 | def test_is_worker_thread(self): | |
| 1197 | with self.subTest(worker=None): | |
| 1198 | self.assertFalse(store.Portfolio.is_worker_thread()) | |
| 1199 | ||
| 1200 | with self.subTest(worker="not self"),\ | |
| 1201 | mock.patch("threading.current_thread") as current_thread: | |
| 1202 | current = mock.Mock() | |
| 1203 | current_thread.return_value = current | |
| 1204 | store.Portfolio.worker = mock.Mock() | |
| 1205 | self.assertFalse(store.Portfolio.is_worker_thread()) | |
| 1206 | ||
| 1207 | with self.subTest(worker="self"),\ | |
| 1208 | mock.patch("threading.current_thread") as current_thread: | |
| 1209 | current = mock.Mock() | |
| 1210 | current_thread.return_value = current | |
| 1211 | store.Portfolio.worker = current | |
| 1212 | self.assertTrue(store.Portfolio.is_worker_thread()) | |
| 1213 | ||
| 1214 | def test_start_worker(self): | |
| 1215 | with mock.patch.object(store.Portfolio, "wait_for_notification") as notification: | |
| 1216 | store.Portfolio.start_worker() | |
| 1217 | notification.assert_called_once_with(poll=30) | |
| 1218 | ||
| 1219 | self.assertEqual("lock", store.Portfolio.last_date.lock.__class__.__name__) | |
| 1220 | self.assertEqual("lock", store.Portfolio.liquidities.lock.__class__.__name__) | |
| 1221 | store.Portfolio.report.start_lock.assert_called_once_with() | |
| 1222 | ||
| 1223 | self.assertIsNotNone(store.Portfolio.worker) | |
| 1224 | self.assertIsNotNone(store.Portfolio.worker_notify) | |
| 1225 | self.assertIsNotNone(store.Portfolio.callback) | |
| 1226 | self.assertTrue(store.Portfolio.worker_started) | |
| 1227 | ||
| 1228 | self.assertFalse(store.Portfolio.worker.is_alive()) | |
| e7d7c0e5 IB |
1229 | self.assertEqual(1, threading.active_count()) |
| 1230 | ||
| 1231 | def test_stop_worker(self): | |
| 1232 | with mock.patch.object(store.Portfolio, "get_cryptoportfolio") as get,\ | |
| 1233 | mock.patch.object(store.Portfolio, "report") as report,\ | |
| 1234 | mock.patch.object(store.time, "sleep") as sleep: | |
| 1235 | store.Portfolio.start_worker(poll=3) | |
| 1236 | store.Portfolio.stop_worker() | |
| 1237 | store.Portfolio.worker.join() | |
| 1238 | get.assert_not_called() | |
| 1239 | report.assert_not_called() | |
| 1240 | sleep.assert_not_called() | |
| 1241 | self.assertFalse(store.Portfolio.worker.is_alive()) | |
| c682bdf4 IB |
1242 | |
| 1243 | def test_wait_for_notification(self): | |
| 1244 | with self.assertRaises(RuntimeError): | |
| 1245 | store.Portfolio.wait_for_notification() | |
| 1246 | ||
| 1247 | with mock.patch.object(store.Portfolio, "get_cryptoportfolio") as get,\ | |
| 1248 | mock.patch.object(store.Portfolio, "report") as report,\ | |
| 1249 | mock.patch.object(store.time, "sleep") as sleep: | |
| 1250 | store.Portfolio.start_worker(poll=3) | |
| 1251 | ||
| 1252 | store.Portfolio.worker_notify.set() | |
| 1253 | ||
| 1254 | store.Portfolio.callback.wait() | |
| 1255 | ||
| a0dcf4e0 | 1256 | report.print_log.assert_called_once_with("[Worker] Fetching cryptoportfolio") |
| c682bdf4 IB |
1257 | get.assert_called_once_with(refetch=True) |
| 1258 | sleep.assert_called_once_with(3) | |
| 1259 | self.assertFalse(store.Portfolio.worker_notify.is_set()) | |
| 1260 | self.assertTrue(store.Portfolio.worker.is_alive()) | |
| 1261 | ||
| 1262 | store.Portfolio.callback.clear() | |
| 1263 | store.Portfolio.worker_started = False | |
| 1264 | store.Portfolio.worker_notify.set() | |
| e7d7c0e5 | 1265 | store.Portfolio.worker.join() |
| c682bdf4 IB |
1266 | self.assertFalse(store.Portfolio.worker.is_alive()) |
| 1267 | ||
| 1268 | def test_notify_and_wait(self): | |
| 1269 | with mock.patch.object(store.Portfolio, "callback") as callback,\ | |
| 1270 | mock.patch.object(store.Portfolio, "worker_notify") as worker_notify: | |
| 1271 | store.Portfolio.notify_and_wait() | |
| 1272 | callback.clear.assert_called_once_with() | |
| 1273 | worker_notify.set.assert_called_once_with() | |
| 1274 | callback.wait.assert_called_once_with() | |
| 1275 | ||
| 1276 |