]> git.immae.eu Git - perso/Immae/Projets/Cryptomonnaies/Cryptoportfolio/Trader.git/blame - tests/test_store.py
projects / perso / Immae / Projets / Cryptomonnaies / Cryptoportfolio / Trader.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'refactor_db' into dev
[perso/Immae/Projets/Cryptomonnaies/Cryptoportfolio/Trader.git] / tests / test_store.py
CommitLineData
c682bdf4
IB		 1from .helper import *
2import requests
3import datetime
4import threading
5import market, portfolio, store
6
3080f31d 7@unittest.skipUnless("unit" in limits, "Unit skipped")
c682bdf4
IB		 8class 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		 15class 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		 67class 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		 292class 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
2b1ee8f4
IB		 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")
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, ticker_currency='FOO', tickers='tickers',
392 type='type')
c682bdf4 393
9b697863
IB		 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
c682bdf4
IB		 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)
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
3080f31d 466@unittest.skipUnless("unit" in limits, "Unit skipped")
c682bdf4
IB		 467class ReportStoreTest(WebMockTestCase):
468 def test_add_log(self):
e7d7c0e5
IB		 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"})
c682bdf4 481
e7d7c0e5 482 self.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": None, "market_id": None}, result)
c682bdf4 483
1593c7a9
IB		 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
c682bdf4
IB		 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):
e7d7c0e5
IB		 502 self.m.user_id = 1
503 self.m.market_id = 3
c682bdf4
IB		 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:
e7d7c0e5 522 time_mock.datetime.now.return_value = datetime.datetime(2018, 2, 25, 2, 20, 10)
c682bdf4
IB		 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",
e7d7c0e5 539 report_store.default_json_serial(portfolio.datetime.datetime(2018, 2, 24)))
c682bdf4
IB		 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())
e7d7c0e5 547 report_store.logs.append({"date": portfolio.datetime.datetime(2018, 2, 24)})
c682bdf4
IB		 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
1593c7a9
IB		 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
c682bdf4
IB		 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")
1593c7a9
IB		 605 @mock.patch.object(market.ReportStore, "add_redis_status")
606 def test_log_balances(self, add_redis_status, add_log, print_log):
c682bdf4
IB		 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
2b1ee8f4
IB		 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 'balances': 'json',
621 'tag': 'tag'
622 })
623 add_redis_status.assert_called_once_with({
624 'type': 'balance',
625 'balances': 'json',
626 'tag': 'tag'
627 })
628 add_log.reset_mock()
629 add_redis_status.reset_mock()
630 with self.subTest(tickers="present"):
631 amounts = {
632 "BTC": portfolio.Amount("BTC", 10),
633 "ETH": portfolio.Amount("BTC", D("0.3"))
634 }
635 amounts["ETH"].rate = D("0.1")
636
637 report_store.log_balances(tag="tag", tickers=amounts,
638 ticker_currency="BTC", compute_value="default",
639 type="total")
640 add_log.assert_called_once_with({
641 'type': 'balance',
642 'balances': 'json',
643 'tag': 'tag',
644 'tickers': {
645 'compute_value': 'default',
646 'balance_type': 'total',
647 'currency': 'BTC',
648 'balances': {
649 'BTC': D('10'),
650 'ETH': D('0.3')
651 },
652 'rates': {
653 'BTC': None,
654 'ETH': D('0.1')
655 },
656 'total': D('10.3')
657 },
658 })
659 add_redis_status.assert_called_once_with({
660 'type': 'balance',
661 'balances': 'json',
662 'tag': 'tag',
663 'tickers': {
664 'compute_value': 'default',
665 'balance_type': 'total',
666 'currency': 'BTC',
667 'balances': {
668 'BTC': D('10'),
669 'ETH': D('0.3')
670 },
671 'rates': {
672 'BTC': None,
673 'ETH': D('0.1')
674 },
675 'total': D('10.3')
676 },
677 })
c682bdf4
IB		 678
679 @mock.patch.object(market.ReportStore, "print_log")
680 @mock.patch.object(market.ReportStore, "add_log")
2b1ee8f4 681 def test_log_tickers(self, add_log, print_log):
c682bdf4
IB		 682 report_store = market.ReportStore(self.m)
683 amounts = {
684 "BTC": portfolio.Amount("BTC", 10),
685 "ETH": portfolio.Amount("BTC", D("0.3"))
686 }
687 amounts["ETH"].rate = D("0.1")
688
689 report_store.log_tickers(amounts, "BTC", "default", "total")
690 print_log.assert_not_called()
691 add_log.assert_called_once_with({
692 'type': 'tickers',
693 'compute_value': 'default',
694 'balance_type': 'total',
695 'currency': 'BTC',
696 'balances': {
697 'BTC': D('10'),
698 'ETH': D('0.3')
699 },
700 'rates': {
701 'BTC': None,
702 'ETH': D('0.1')
703 },
704 'total': D('10.3')
705 })
706
707 add_log.reset_mock()
708 compute_value = lambda x: x["bid"]
709 report_store.log_tickers(amounts, "BTC", compute_value, "total")
710 add_log.assert_called_once_with({
711 'type': 'tickers',
712 'compute_value': 'compute_value = lambda x: x["bid"]',
713 'balance_type': 'total',
714 'currency': 'BTC',
715 'balances': {
716 'BTC': D('10'),
717 'ETH': D('0.3')
718 },
719 'rates': {
720 'BTC': None,
721 'ETH': D('0.1')
722 },
723 'total': D('10.3')
724 })
725
726 @mock.patch.object(market.ReportStore, "print_log")
727 @mock.patch.object(market.ReportStore, "add_log")
728 def test_log_dispatch(self, add_log, print_log):
729 report_store = market.ReportStore(self.m)
730 amount = portfolio.Amount("BTC", "10.3")
731 amounts = {
732 "BTC": portfolio.Amount("BTC", 10),
733 "ETH": portfolio.Amount("BTC", D("0.3"))
734 }
735 report_store.log_dispatch(amount, amounts, "medium", "repartition")
736 print_log.assert_not_called()
737 add_log.assert_called_once_with({
738 'type': 'dispatch',
739 'liquidity': 'medium',
740 'repartition_ratio': 'repartition',
741 'total_amount': {
742 'currency': 'BTC',
743 'value': D('10.3')
744 },
745 'repartition': {
746 'BTC': D('10'),
747 'ETH': D('0.3')
748 }
749 })
750
751 @mock.patch.object(market.ReportStore, "print_log")
752 @mock.patch.object(market.ReportStore, "add_log")
753 def test_log_trades(self, add_log, print_log):
754 report_store = market.ReportStore(self.m)
755 trade_mock1 = mock.Mock()
756 trade_mock2 = mock.Mock()
757 trade_mock1.as_json.return_value = { "trade": "1" }
758 trade_mock2.as_json.return_value = { "trade": "2" }
759
760 matching_and_trades = [
761 (True, trade_mock1),
762 (False, trade_mock2),
763 ]
764 report_store.log_trades(matching_and_trades, "only")
765
766 print_log.assert_not_called()
767 add_log.assert_called_with({
768 'type': 'trades',
769 'only': 'only',
770 'debug': False,
771 'trades': [
772 {'trade': '1', 'skipped': False},
773 {'trade': '2', 'skipped': True}
774 ]
775 })
776
777 @mock.patch.object(market.ReportStore, "print_log")
778 @mock.patch.object(market.ReportStore, "add_log")
779 def test_log_orders(self, add_log, print_log):
780 report_store = market.ReportStore(self.m)
781
782 order_mock1 = mock.Mock()
783 order_mock2 = mock.Mock()
784
785 order_mock1.as_json.return_value = "order1"
786 order_mock2.as_json.return_value = "order2"
787
788 orders = [order_mock1, order_mock2]
789
790 report_store.log_orders(orders, tick="tick",
791 only="only", compute_value="compute_value")
792
793 print_log.assert_called_once_with("[Orders]")
794 self.m.trades.print_all_with_order.assert_called_once_with(ind="\t")
795
796 add_log.assert_called_with({
797 'type': 'orders',
798 'only': 'only',
799 'compute_value': 'compute_value',
800 'tick': 'tick',
801 'orders': ['order1', 'order2']
802 })
803
804 add_log.reset_mock()
805 def compute_value(x, y):
806 return x[y]
807 report_store.log_orders(orders, tick="tick",
808 only="only", compute_value=compute_value)
809 add_log.assert_called_with({
810 'type': 'orders',
811 'only': 'only',
812 'compute_value': 'def compute_value(x, y):\n return x[y]',
813 'tick': 'tick',
814 'orders': ['order1', 'order2']
815 })
816
817
818 @mock.patch.object(market.ReportStore, "print_log")
819 @mock.patch.object(market.ReportStore, "add_log")
820 def test_log_order(self, add_log, print_log):
821 report_store = market.ReportStore(self.m)
822 order_mock = mock.Mock()
823 order_mock.as_json.return_value = "order"
824 new_order_mock = mock.Mock()
825 new_order_mock.as_json.return_value = "new_order"
826 order_mock.__repr__ = mock.Mock()
827 order_mock.__repr__.return_value = "Order Mock"
828 new_order_mock.__repr__ = mock.Mock()
829 new_order_mock.__repr__.return_value = "New order Mock"
830
831 with self.subTest(finished=True):
832 report_store.log_order(order_mock, 1, finished=True)
833 print_log.assert_called_once_with("[Order] Finished Order Mock")
834 add_log.assert_called_once_with({
835 'type': 'order',
836 'tick': 1,
837 'update': None,
838 'order': 'order',
839 'compute_value': None,
840 'new_order': None
841 })
842
843 add_log.reset_mock()
844 print_log.reset_mock()
845
846 with self.subTest(update="waiting"):
847 report_store.log_order(order_mock, 1, update="waiting")
848 print_log.assert_called_once_with("[Order] Order Mock, tick 1, waiting")
849 add_log.assert_called_once_with({
850 'type': 'order',
851 'tick': 1,
852 'update': 'waiting',
853 'order': 'order',
854 'compute_value': None,
855 'new_order': None
856 })
857
858 add_log.reset_mock()
859 print_log.reset_mock()
860 with self.subTest(update="adjusting"):
861 compute_value = lambda x: (x["bid"] + x["ask"]*2)/3
862 report_store.log_order(order_mock, 3,
863 update="adjusting", new_order=new_order_mock,
864 compute_value=compute_value)
865 print_log.assert_called_once_with("[Order] Order Mock, tick 3, cancelling and adjusting to New order Mock")
866 add_log.assert_called_once_with({
867 'type': 'order',
868 'tick': 3,
869 'update': 'adjusting',
870 'order': 'order',
871 'compute_value': 'compute_value = lambda x: (x["bid"] + x["ask"]*2)/3',
872 'new_order': 'new_order'
873 })
874
875 add_log.reset_mock()
876 print_log.reset_mock()
877 with self.subTest(update="market_fallback"):
878 report_store.log_order(order_mock, 7,
879 update="market_fallback", new_order=new_order_mock)
880 print_log.assert_called_once_with("[Order] Order Mock, tick 7, fallbacking to market value")
881 add_log.assert_called_once_with({
882 'type': 'order',
883 'tick': 7,
884 'update': 'market_fallback',
885 'order': 'order',
886 'compute_value': None,
887 'new_order': 'new_order'
888 })
889
890 add_log.reset_mock()
891 print_log.reset_mock()
892 with self.subTest(update="market_adjusting"):
893 report_store.log_order(order_mock, 17,
894 update="market_adjust", new_order=new_order_mock)
895 print_log.assert_called_once_with("[Order] Order Mock, tick 17, market value, cancelling and adjusting to New order Mock")
896 add_log.assert_called_once_with({
897 'type': 'order',
898 'tick': 17,
899 'update': 'market_adjust',
900 'order': 'order',
901 'compute_value': None,
902 'new_order': 'new_order'
903 })
904
905 @mock.patch.object(market.ReportStore, "print_log")
906 @mock.patch.object(market.ReportStore, "add_log")
907 def test_log_move_balances(self, add_log, print_log):
908 report_store = market.ReportStore(self.m)
909 needed = {
910 "BTC": portfolio.Amount("BTC", 10),
911 "USDT": 1
912 }
913 moving = {
914 "BTC": portfolio.Amount("BTC", 3),
915 "USDT": -2
916 }
917 report_store.log_move_balances(needed, moving)
918 print_log.assert_not_called()
919 add_log.assert_called_once_with({
920 'type': 'move_balances',
921 'debug': False,
922 'needed': {
923 'BTC': D('10'),
924 'USDT': 1
925 },
926 'moving': {
927 'BTC': D('3'),
928 'USDT': -2
929 }
930 })
931
e7d7c0e5
IB		 932 def test_log_http_request(self):
933 with mock.patch.object(market.ReportStore, "add_log") as add_log:
934 report_store = market.ReportStore(self.m)
935 response = mock.Mock()
936 response.status_code = 200
937 response.text = "Hey"
9fe90554 938 response.elapsed.total_seconds.return_value = 120
c682bdf4 939
e7d7c0e5
IB		 940 report_store.log_http_request("method", "url", "body",
941 "headers", response)
942 add_log.assert_called_once_with({
943 'type': 'http_request',
944 'method': 'method',
945 'url': 'url',
946 'body': 'body',
947 'headers': 'headers',
948 'status': 200,
9fe90554 949 'duration': 120,
e7d7c0e5
IB		 950 'response': 'Hey',
951 'response_same_as': None,
952 })
c682bdf4 953
e7d7c0e5
IB		 954 add_log.reset_mock()
955 report_store.log_http_request("method", "url", "body",
956 "headers", ValueError("Foo"))
957 add_log.assert_called_once_with({
958 'type': 'http_request',
959 'method': 'method',
960 'url': 'url',
961 'body': 'body',
962 'headers': 'headers',
963 'status': -1,
964 'response': None,
965 'error': 'ValueError',
966 'error_message': 'Foo',
967 })
968
969 with self.subTest(no_http_dup=True, duplicate=True):
970 self.m.user_id = 1
971 self.m.market_id = 3
972 report_store = market.ReportStore(self.m, no_http_dup=True)
973 original_add_log = report_store.add_log
974 with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log:
975 report_store.log_http_request("method", "url", "body",
976 "headers", response)
977 report_store.log_http_request("method", "url", "body",
978 "headers", response)
979 self.assertEqual(2, add_log.call_count)
980 self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"])
981 self.assertIsNone(add_log.mock_calls[1][1][0]["response"])
982 self.assertEqual(add_log.mock_calls[0][1][0]["date"], add_log.mock_calls[1][1][0]["response_same_as"])
983 with self.subTest(no_http_dup=True, duplicate=False, case="Different call"):
984 self.m.user_id = 1
985 self.m.market_id = 3
986 report_store = market.ReportStore(self.m, no_http_dup=True)
987 original_add_log = report_store.add_log
988 with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log:
989 report_store.log_http_request("method", "url", "body",
990 "headers", response)
991 report_store.log_http_request("method2", "url", "body",
992 "headers", response)
993 self.assertEqual(2, add_log.call_count)
994 self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"])
995 self.assertIsNone(add_log.mock_calls[1][1][0]["response_same_as"])
996 with self.subTest(no_http_dup=True, duplicate=False, case="Call inbetween"):
997 self.m.user_id = 1
998 self.m.market_id = 3
999 report_store = market.ReportStore(self.m, no_http_dup=True)
1000 original_add_log = report_store.add_log
1001
1002 response2 = mock.Mock()
1003 response2.status_code = 200
1004 response2.text = "Hey there!"
1005
1006 with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log:
1007 report_store.log_http_request("method", "url", "body",
1008 "headers", response)
1009 report_store.log_http_request("method", "url", "body",
1010 "headers", response2)
1011 report_store.log_http_request("method", "url", "body",
1012 "headers", response)
1013 self.assertEqual(3, add_log.call_count)
1014 self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"])
1015 self.assertIsNone(add_log.mock_calls[1][1][0]["response_same_as"])
1016 self.assertIsNone(add_log.mock_calls[2][1][0]["response_same_as"])
c682bdf4
IB		 1017
1018 @mock.patch.object(market.ReportStore, "add_log")
1019 def test_log_market(self, add_log):
1020 report_store = market.ReportStore(self.m)
1021
e7d7c0e5 1022 report_store.log_market(self.market_args(debug=True, quiet=False))
c682bdf4
IB		 1023 add_log.assert_called_once_with({
1024 "type": "market",
1025 "commit": "$Format:%H$",
1026 "args": { "report_path": None, "debug": True, "quiet": False },
c682bdf4
IB		 1027 })
1028
1029 @mock.patch.object(market.ReportStore, "print_log")
1030 @mock.patch.object(market.ReportStore, "add_log")
1031 def test_log_error(self, add_log, print_log):
1032 report_store = market.ReportStore(self.m)
1033 with self.subTest(message=None, exception=None):
1034 report_store.log_error("action")
1035 print_log.assert_called_once_with("[Error] action")
1036 add_log.assert_called_once_with({
1037 'type': 'error',
1038 'action': 'action',
1039 'exception_class': None,
1040 'exception_message': None,
1041 'message': None
1042 })
1043
1044 print_log.reset_mock()
1045 add_log.reset_mock()
1046 with self.subTest(message="Hey", exception=None):
1047 report_store.log_error("action", message="Hey")
1048 print_log.assert_has_calls([
1049 mock.call("[Error] action"),
1050 mock.call("\tHey")
1051 ])
1052 add_log.assert_called_once_with({
1053 'type': 'error',
1054 'action': 'action',
1055 'exception_class': None,
1056 'exception_message': None,
1057 'message': "Hey"
1058 })
1059
1060 print_log.reset_mock()
1061 add_log.reset_mock()
1062 with self.subTest(message=None, exception=Exception("bouh")):
1063 report_store.log_error("action", exception=Exception("bouh"))
1064 print_log.assert_has_calls([
1065 mock.call("[Error] action"),
1066 mock.call("\tException: bouh")
1067 ])
1068 add_log.assert_called_once_with({
1069 'type': 'error',
1070 'action': 'action',
1071 'exception_class': "Exception",
1072 'exception_message': "bouh",
1073 'message': None
1074 })
1075
1076 print_log.reset_mock()
1077 add_log.reset_mock()
1078 with self.subTest(message="Hey", exception=Exception("bouh")):
1079 report_store.log_error("action", message="Hey", exception=Exception("bouh"))
1080 print_log.assert_has_calls([
1081 mock.call("[Error] action"),
1082 mock.call("\tException: bouh"),
1083 mock.call("\tHey")
1084 ])
1085 add_log.assert_called_once_with({
1086 'type': 'error',
1087 'action': 'action',
1088 'exception_class': "Exception",
1089 'exception_message': "bouh",
1090 'message': "Hey"
1091 })
1092
1093 @mock.patch.object(market.ReportStore, "print_log")
1094 @mock.patch.object(market.ReportStore, "add_log")
1095 def test_log_debug_action(self, add_log, print_log):
1096 report_store = market.ReportStore(self.m)
1097 report_store.log_debug_action("Hey")
1098
1099 print_log.assert_called_once_with("[Debug] Hey")
1100 add_log.assert_called_once_with({
1101 'type': 'debug_action',
1102 'action': 'Hey'
1103 })
1104
3080f31d 1105@unittest.skipUnless("unit" in limits, "Unit skipped")
c682bdf4
IB		 1106class PortfolioTest(WebMockTestCase):
1107 def setUp(self):
1108 super().setUp()
1109
1110 with open("test_samples/test_portfolio.json") as example:
1111 self.json_response = example.read()
1112
1113 self.wm.get(market.Portfolio.URL, text=self.json_response)
1114
1115 @mock.patch.object(market.Portfolio, "parse_cryptoportfolio")
40d0fa27
IB		 1116 @mock.patch.object(market.Portfolio, "store_cryptoportfolio")
1117 def test_get_cryptoportfolio(self, store_cryptoportfolio, parse_cryptoportfolio):
c682bdf4
IB		 1118 with self.subTest(parallel=False):
1119 self.wm.get(market.Portfolio.URL, [
1120 {"text":'{ "foo": "bar" }', "status_code": 200},
1121 {"text": "System Error", "status_code": 500},
1122 {"exc": requests.exceptions.ConnectTimeout},
1123 ])
1124 market.Portfolio.get_cryptoportfolio()
1125 self.assertIn("foo", market.Portfolio.data.get())
1126 self.assertEqual("bar", market.Portfolio.data.get()["foo"])
1127 self.assertTrue(self.wm.called)
1128 self.assertEqual(1, self.wm.call_count)
1129 market.Portfolio.report.log_error.assert_not_called()
1130 market.Portfolio.report.log_http_request.assert_called_once()
1131 parse_cryptoportfolio.assert_called_once_with()
40d0fa27 1132 store_cryptoportfolio.assert_called_once_with()
c682bdf4
IB		 1133 market.Portfolio.report.log_http_request.reset_mock()
1134 parse_cryptoportfolio.reset_mock()
40d0fa27 1135 store_cryptoportfolio.reset_mock()
c682bdf4
IB		 1136 market.Portfolio.data = store.LockedVar(None)
1137
1138 market.Portfolio.get_cryptoportfolio()
1139 self.assertIsNone(market.Portfolio.data.get())
1140 self.assertEqual(2, self.wm.call_count)
1141 parse_cryptoportfolio.assert_not_called()
40d0fa27 1142 store_cryptoportfolio.assert_not_called()
c682bdf4
IB		 1143 market.Portfolio.report.log_error.assert_not_called()
1144 market.Portfolio.report.log_http_request.assert_called_once()
1145 market.Portfolio.report.log_http_request.reset_mock()
1146 parse_cryptoportfolio.reset_mock()
40d0fa27 1147 store_cryptoportfolio.reset_mock()
c682bdf4
IB		 1148
1149 market.Portfolio.data = store.LockedVar("Foo")
1150 market.Portfolio.get_cryptoportfolio()
1151 self.assertEqual(2, self.wm.call_count)
1152 parse_cryptoportfolio.assert_not_called()
40d0fa27 1153 store_cryptoportfolio.assert_not_called()
c682bdf4
IB		 1154
1155 market.Portfolio.get_cryptoportfolio(refetch=True)
1156 self.assertEqual("Foo", market.Portfolio.data.get())
1157 self.assertEqual(3, self.wm.call_count)
1158 market.Portfolio.report.log_error.assert_called_once_with("get_cryptoportfolio",
1159 exception=mock.ANY)
1160 market.Portfolio.report.log_http_request.assert_not_called()
1161 with self.subTest(parallel=True):
1162 with mock.patch.object(market.Portfolio, "is_worker_thread") as is_worker,\
1163 mock.patch.object(market.Portfolio, "notify_and_wait") as notify:
1164 with self.subTest(worker=True):
1165 market.Portfolio.data = store.LockedVar(None)
1166 market.Portfolio.worker = mock.Mock()
1167 is_worker.return_value = True
1168 self.wm.get(market.Portfolio.URL, [
1169 {"text":'{ "foo": "bar" }', "status_code": 200},
1170 ])
1171 market.Portfolio.get_cryptoportfolio()
1172 self.assertIn("foo", market.Portfolio.data.get())
1173 parse_cryptoportfolio.reset_mock()
40d0fa27 1174 store_cryptoportfolio.reset_mock()
c682bdf4
IB		 1175 with self.subTest(worker=False):
1176 market.Portfolio.data = store.LockedVar(None)
1177 market.Portfolio.worker = mock.Mock()
1178 is_worker.return_value = False
1179 market.Portfolio.get_cryptoportfolio()
1180 notify.assert_called_once_with()
1181 parse_cryptoportfolio.assert_not_called()
40d0fa27 1182 store_cryptoportfolio.assert_not_called()
c682bdf4
IB		 1183
1184 def test_parse_cryptoportfolio(self):
1185 with self.subTest(description="Normal case"):
1186 market.Portfolio.data = store.LockedVar(store.json.loads(
1187 self.json_response, parse_int=D, parse_float=D))
1188 market.Portfolio.parse_cryptoportfolio()
1189
1190 self.assertListEqual(
1191 ["medium", "high"],
1192 list(market.Portfolio.liquidities.get().keys()))
1193
1194 liquidities = market.Portfolio.liquidities.get()
1195 self.assertEqual(10, len(liquidities["medium"].keys()))
1196 self.assertEqual(10, len(liquidities["high"].keys()))
1197
1198 expected = {
1199 'BTC': (D("0.2857"), "long"),
1200 'DGB': (D("0.1015"), "long"),
1201 'DOGE': (D("0.1805"), "long"),
1202 'SC': (D("0.0623"), "long"),
1203 'ZEC': (D("0.3701"), "long"),
1204 }
e7d7c0e5 1205 date = portfolio.datetime.datetime(2018, 1, 8)
c682bdf4
IB		 1206 self.assertDictEqual(expected, liquidities["high"][date])
1207
1208 expected = {
1209 'BTC': (D("1.1102e-16"), "long"),
1210 'ETC': (D("0.1"), "long"),
1211 'FCT': (D("0.1"), "long"),
1212 'GAS': (D("0.1"), "long"),
1213 'NAV': (D("0.1"), "long"),
1214 'OMG': (D("0.1"), "long"),
1215 'OMNI': (D("0.1"), "long"),
1216 'PPC': (D("0.1"), "long"),
1217 'RIC': (D("0.1"), "long"),
1218 'VIA': (D("0.1"), "long"),
1219 'XCP': (D("0.1"), "long"),
1220 }
1221 self.assertDictEqual(expected, liquidities["medium"][date])
e7d7c0e5 1222 self.assertEqual(portfolio.datetime.datetime(2018, 1, 15), market.Portfolio.last_date.get())
c682bdf4
IB		 1223
1224 with self.subTest(description="Missing weight"):
1225 data = store.json.loads(self.json_response, parse_int=D, parse_float=D)
1226 del(data["portfolio_2"]["weights"])
1227 market.Portfolio.data = store.LockedVar(data)
1228
1229 market.Portfolio.parse_cryptoportfolio()
1230 self.assertListEqual(
1231 ["medium", "high"],
1232 list(market.Portfolio.liquidities.get().keys()))
1233 self.assertEqual({}, market.Portfolio.liquidities.get("medium"))
1234
1235 with self.subTest(description="All missing weights"):
1236 data = store.json.loads(self.json_response, parse_int=D, parse_float=D)
1237 del(data["portfolio_1"]["weights"])
1238 del(data["portfolio_2"]["weights"])
1239 market.Portfolio.data = store.LockedVar(data)
1240
1241 market.Portfolio.parse_cryptoportfolio()
1242 self.assertEqual({}, market.Portfolio.liquidities.get("medium"))
1243 self.assertEqual({}, market.Portfolio.liquidities.get("high"))
1244 self.assertEqual(datetime.datetime(1,1,1), market.Portfolio.last_date.get())
1245
40d0fa27
IB		 1246 @mock.patch.object(store.dbs, "redis_connected")
1247 @mock.patch.object(store.dbs, "redis")
1248 def test_store_cryptoportfolio(self, redis, redis_connected):
1249 store.Portfolio.liquidities = store.LockedVar({
1250 "medium": {
1251 datetime.datetime(2018,3,1): "medium_2018-03-01",
1252 datetime.datetime(2018,3,8): "medium_2018-03-08",
1253 },
1254 "high": {
1255 datetime.datetime(2018,3,1): "high_2018-03-01",
1256 datetime.datetime(2018,3,8): "high_2018-03-08",
1257 }
1258 })
1259 store.Portfolio.last_date = store.LockedVar(datetime.datetime(2018,3,8))
1260
1261 with self.subTest(redis_connected=False):
1262 redis_connected.return_value = False
1263 store.Portfolio.store_cryptoportfolio()
1264 redis.set.assert_not_called()
1265
1266 with self.subTest(redis_connected=True):
1267 redis_connected.return_value = True
1268 store.Portfolio.store_cryptoportfolio()
1269 redis.set.assert_has_calls([
1270 mock.call("/cryptoportfolio/repartition/latest", '{"medium": "medium_2018-03-08", "high": "high_2018-03-08"}'),
1271 mock.call("/cryptoportfolio/repartition/date", "2018-03-08"),
1272 ])
c682bdf4 1273
9b697863
IB		 1274 @mock.patch.object(store.dbs, "redis_connected")
1275 @mock.patch.object(store.dbs, "redis")
1276 def test_retrieve_cryptoportfolio(self, redis, redis_connected):
1277 with self.subTest(redis_connected=False):
1278 redis_connected.return_value = False
1279 store.Portfolio.retrieve_cryptoportfolio()
1280 redis.get.assert_not_called()
1281 self.assertIsNone(store.Portfolio.data.get())
1282
1283 with self.subTest(redis_connected=True, value=None):
1284 redis_connected.return_value = True
1285 redis.get.return_value = None
1286 store.Portfolio.retrieve_cryptoportfolio()
1287 self.assertEqual(2, redis.get.call_count)
1288
1289 redis.reset_mock()
1290 with self.subTest(redis_connected=True, value="present"):
1291 redis_connected.return_value = True
1292 redis.get.side_effect = [
1293 b'{ "medium": "medium_repartition", "high": "high_repartition" }',
1294 b"2018-03-08"
1295 ]
1296 store.Portfolio.retrieve_cryptoportfolio()
1297 self.assertEqual(2, redis.get.call_count)
1298 self.assertEqual(datetime.datetime(2018,3,8), store.Portfolio.last_date.get())
1299 self.assertEqual("", store.Portfolio.data.get())
1300 expected_liquidities = {
1301 'high': { datetime.datetime(2018, 3, 8): 'high_repartition' },
1302 'medium': { datetime.datetime(2018, 3, 8): 'medium_repartition' },
c682bdf4 1303 }
9b697863 1304 self.assertEqual(expected_liquidities, store.Portfolio.liquidities.get())
c682bdf4 1305
9b697863
IB		 1306 @mock.patch.object(market.Portfolio, "get_cryptoportfolio")
1307 @mock.patch.object(market.Portfolio, "retrieve_cryptoportfolio")
1308 def test_repartition(self, retrieve_cryptoportfolio, get_cryptoportfolio):
1309 with self.subTest(from_cache=False):
1310 market.Portfolio.liquidities = store.LockedVar({
1311 "medium": {
1312 "2018-03-01": "medium_2018-03-01",
1313 "2018-03-08": "medium_2018-03-08",
1314 },
1315 "high": {
1316 "2018-03-01": "high_2018-03-01",
1317 "2018-03-08": "high_2018-03-08",
1318 }
1319 })
1320 market.Portfolio.last_date = store.LockedVar("2018-03-08")
1321
1322 self.assertEqual("medium_2018-03-08", market.Portfolio.repartition())
1323 get_cryptoportfolio.assert_called_once_with()
1324 retrieve_cryptoportfolio.assert_not_called()
1325 self.assertEqual("medium_2018-03-08", market.Portfolio.repartition(liquidity="medium"))
1326 self.assertEqual("high_2018-03-08", market.Portfolio.repartition(liquidity="high"))
1327
1328 retrieve_cryptoportfolio.reset_mock()
1329 get_cryptoportfolio.reset_mock()
1330
1331 with self.subTest(from_cache=True):
1332 self.assertEqual("medium_2018-03-08", market.Portfolio.repartition(from_cache=True))
1333 get_cryptoportfolio.assert_called_once_with()
1334 retrieve_cryptoportfolio.assert_called_once_with()
c682bdf4
IB		 1335
1336 @mock.patch.object(market.time, "sleep")
1337 @mock.patch.object(market.Portfolio, "get_cryptoportfolio")
1338 def test_wait_for_recent(self, get_cryptoportfolio, sleep):
1339 self.call_count = 0
1340 def _get(refetch=False):
1341 if self.call_count != 0:
1342 self.assertTrue(refetch)
1343 else:
1344 self.assertFalse(refetch)
1345 self.call_count += 1
e7d7c0e5
IB		 1346 market.Portfolio.last_date = store.LockedVar(store.datetime.datetime.now()\
1347 - store.datetime.timedelta(10)\
1348 + store.datetime.timedelta(self.call_count))
c682bdf4
IB		 1349 get_cryptoportfolio.side_effect = _get
1350
1351 market.Portfolio.wait_for_recent()
1352 sleep.assert_called_with(30)
1353 self.assertEqual(6, sleep.call_count)
1354 self.assertEqual(7, get_cryptoportfolio.call_count)
1355 market.Portfolio.report.print_log.assert_called_with("Attempt to fetch up-to-date cryptoportfolio")
1356
1357 sleep.reset_mock()
1358 get_cryptoportfolio.reset_mock()
1359 market.Portfolio.last_date = store.LockedVar(None)
1360 self.call_count = 0
1361 market.Portfolio.wait_for_recent(delta=15)
1362 sleep.assert_not_called()
1363 self.assertEqual(1, get_cryptoportfolio.call_count)
1364
1365 sleep.reset_mock()
1366 get_cryptoportfolio.reset_mock()
1367 market.Portfolio.last_date = store.LockedVar(None)
1368 self.call_count = 0
1369 market.Portfolio.wait_for_recent(delta=1)
1370 sleep.assert_called_with(30)
1371 self.assertEqual(9, sleep.call_count)
1372 self.assertEqual(10, get_cryptoportfolio.call_count)
1373
1374 def test_is_worker_thread(self):
1375 with self.subTest(worker=None):
1376 self.assertFalse(store.Portfolio.is_worker_thread())
1377
1378 with self.subTest(worker="not self"),\
1379 mock.patch("threading.current_thread") as current_thread:
1380 current = mock.Mock()
1381 current_thread.return_value = current
1382 store.Portfolio.worker = mock.Mock()
1383 self.assertFalse(store.Portfolio.is_worker_thread())
1384
1385 with self.subTest(worker="self"),\
1386 mock.patch("threading.current_thread") as current_thread:
1387 current = mock.Mock()
1388 current_thread.return_value = current
1389 store.Portfolio.worker = current
1390 self.assertTrue(store.Portfolio.is_worker_thread())
1391
1392 def test_start_worker(self):
1393 with mock.patch.object(store.Portfolio, "wait_for_notification") as notification:
1394 store.Portfolio.start_worker()
1395 notification.assert_called_once_with(poll=30)
1396
1397 self.assertEqual("lock", store.Portfolio.last_date.lock.__class__.__name__)
1398 self.assertEqual("lock", store.Portfolio.liquidities.lock.__class__.__name__)
1399 store.Portfolio.report.start_lock.assert_called_once_with()
1400
1401 self.assertIsNotNone(store.Portfolio.worker)
1402 self.assertIsNotNone(store.Portfolio.worker_notify)
1403 self.assertIsNotNone(store.Portfolio.callback)
1404 self.assertTrue(store.Portfolio.worker_started)
1405
1406 self.assertFalse(store.Portfolio.worker.is_alive())
e7d7c0e5
IB		 1407 self.assertEqual(1, threading.active_count())
1408
1409 def test_stop_worker(self):
1410 with mock.patch.object(store.Portfolio, "get_cryptoportfolio") as get,\
1411 mock.patch.object(store.Portfolio, "report") as report,\
1412 mock.patch.object(store.time, "sleep") as sleep:
1413 store.Portfolio.start_worker(poll=3)
1414 store.Portfolio.stop_worker()
1415 store.Portfolio.worker.join()
1416 get.assert_not_called()
1417 report.assert_not_called()
1418 sleep.assert_not_called()
1419 self.assertFalse(store.Portfolio.worker.is_alive())
c682bdf4
IB		 1420
1421 def test_wait_for_notification(self):
1422 with self.assertRaises(RuntimeError):
1423 store.Portfolio.wait_for_notification()
1424
1425 with mock.patch.object(store.Portfolio, "get_cryptoportfolio") as get,\
1426 mock.patch.object(store.Portfolio, "report") as report,\
1427 mock.patch.object(store.time, "sleep") as sleep:
1428 store.Portfolio.start_worker(poll=3)
1429
1430 store.Portfolio.worker_notify.set()
1431
1432 store.Portfolio.callback.wait()
1433
a0dcf4e0 1434 report.print_log.assert_called_once_with("[Worker] Fetching cryptoportfolio")
c682bdf4
IB		 1435 get.assert_called_once_with(refetch=True)
1436 sleep.assert_called_once_with(3)
1437 self.assertFalse(store.Portfolio.worker_notify.is_set())
1438 self.assertTrue(store.Portfolio.worker.is_alive())
1439
1440 store.Portfolio.callback.clear()
1441 store.Portfolio.worker_started = False
1442 store.Portfolio.worker_notify.set()
e7d7c0e5 1443 store.Portfolio.worker.join()
c682bdf4
IB		 1444 self.assertFalse(store.Portfolio.worker.is_alive())
1445
1446 def test_notify_and_wait(self):
1447 with mock.patch.object(store.Portfolio, "callback") as callback,\
1448 mock.patch.object(store.Portfolio, "worker_notify") as worker_notify:
1449 store.Portfolio.notify_and_wait()
1450 callback.clear.assert_called_once_with()
1451 worker_notify.set.assert_called_once_with()
1452 callback.wait.assert_called_once_with()
1453
1454
The trade bot responsible to follow the cryptoportfolio every week