5 import market
, portfolio
, store
7 class NoopLockTest(unittest
.TestCase
):
9 noop_lock
= store
.NoopLock()
13 class LockedVarTest(unittest
.TestCase
):
15 def test_values(self
):
16 locked_var
= store
.LockedVar("Foo")
17 self
.assertIsInstance(locked_var
.lock
, store
.NoopLock
)
18 self
.assertEqual("Foo", locked_var
.val
)
21 with self
.subTest(desc
="Normal case"):
22 locked_var
= store
.LockedVar("Foo")
23 self
.assertEqual("Foo", locked_var
.get())
24 with self
.subTest(desc
="Dict"):
25 locked_var
= store
.LockedVar({"foo": "bar"}
)
26 self
.assertEqual({"foo": "bar"}
, locked_var
.get())
27 self
.assertEqual("bar", locked_var
.get("foo"))
28 self
.assertIsNone(locked_var
.get("other"))
31 locked_var
= store
.LockedVar("Foo")
33 self
.assertEqual("Bar", locked_var
.get())
35 def test__getattr(self
):
36 dummy
= type('Dummy', (object,), {})()
37 dummy
.attribute
= "Hey"
39 locked_var
= store
.LockedVar(dummy
)
40 self
.assertEqual("Hey", locked_var
.attribute
)
41 with self
.assertRaises(AttributeError):
44 def test_start_lock(self
):
45 locked_var
= store
.LockedVar("Foo")
46 locked_var
.start_lock()
47 self
.assertEqual("lock", locked_var
.lock
.__class
__.__name
__)
49 thread1
= threading
.Thread(target
=locked_var
.set, args
=["Bar1"])
50 thread2
= threading
.Thread(target
=locked_var
.set, args
=["Bar2"])
51 thread3
= threading
.Thread(target
=locked_var
.set, args
=["Bar3"])
58 self
.assertEqual("Foo", locked_var
.val
)
62 self
.assertEqual("Bar", locked_var
.get()[0:3])
64 class TradeStoreTest(WebMockTestCase
):
65 def test_compute_trades(self
):
66 self
.m
.balances
.currencies
.return_value
= ["XMR", "DASH", "XVG", "BTC", "ETH"]
69 "XMR": portfolio
.Amount("BTC", D("0.9")),
70 "DASH": portfolio
.Amount("BTC", D("0.4")),
71 "XVG": portfolio
.Amount("BTC", D("-0.5")),
72 "BTC": portfolio
.Amount("BTC", D("0.5")),
75 "DASH": portfolio
.Amount("BTC", D("0.5")),
76 "XVG": portfolio
.Amount("BTC", D("0.1")),
77 "BTC": portfolio
.Amount("BTC", D("0.4")),
78 "ETH": portfolio
.Amount("BTC", D("0.3")),
88 with mock
.patch
.object(market
.TradeStore
, "trade_if_matching") as trade_if_matching
:
89 trade_store
= market
.TradeStore(self
.m
)
90 trade_if_matching
.side_effect
= side_effect
92 trade_store
.compute_trades(values_in_base
,
93 new_repartition
, only
="only")
95 self
.assertEqual(5, trade_if_matching
.call_count
)
96 self
.assertEqual(3, len(trade_store
.all
))
97 self
.assertEqual([1, 4, 5], trade_store
.all
)
98 self
.m
.report
.log_trades
.assert_called_with(side_effect
, "only")
100 def test_trade_if_matching(self
):
102 with self
.subTest(only
="nope"):
103 trade_store
= market
.TradeStore(self
.m
)
104 result
= trade_store
.trade_if_matching(
105 portfolio
.Amount("BTC", D("0")),
106 portfolio
.Amount("BTC", D("0.3")),
108 self
.assertEqual(False, result
[0])
109 self
.assertIsInstance(result
[1], portfolio
.Trade
)
111 with self
.subTest(only
=None):
112 trade_store
= market
.TradeStore(self
.m
)
113 result
= trade_store
.trade_if_matching(
114 portfolio
.Amount("BTC", D("0")),
115 portfolio
.Amount("BTC", D("0.3")),
117 self
.assertEqual(True, result
[0])
119 with self
.subTest(only
="acquire"):
120 trade_store
= market
.TradeStore(self
.m
)
121 result
= trade_store
.trade_if_matching(
122 portfolio
.Amount("BTC", D("0")),
123 portfolio
.Amount("BTC", D("0.3")),
124 "ETH", only
="acquire")
125 self
.assertEqual(True, result
[0])
127 with self
.subTest(only
="dispose"):
128 trade_store
= market
.TradeStore(self
.m
)
129 result
= trade_store
.trade_if_matching(
130 portfolio
.Amount("BTC", D("0")),
131 portfolio
.Amount("BTC", D("0.3")),
132 "ETH", only
="dispose")
133 self
.assertEqual(False, result
[0])
135 def test_prepare_orders(self
):
136 trade_store
= market
.TradeStore(self
.m
)
138 trade_mock1
= mock
.Mock()
139 trade_mock2
= mock
.Mock()
140 trade_mock3
= mock
.Mock()
142 trade_mock1
.prepare_order
.return_value
= 1
143 trade_mock2
.prepare_order
.return_value
= 2
144 trade_mock3
.prepare_order
.return_value
= 3
146 trade_mock1
.pending
= True
147 trade_mock2
.pending
= True
148 trade_mock3
.pending
= False
150 trade_store
.all
.append(trade_mock1
)
151 trade_store
.all
.append(trade_mock2
)
152 trade_store
.all
.append(trade_mock3
)
154 trade_store
.prepare_orders()
155 trade_mock1
.prepare_order
.assert_called_with(compute_value
="default")
156 trade_mock2
.prepare_order
.assert_called_with(compute_value
="default")
157 trade_mock3
.prepare_order
.assert_not_called()
158 self
.m
.report
.log_orders
.assert_called_once_with([1, 2], None, "default")
160 self
.m
.report
.log_orders
.reset_mock()
162 trade_store
.prepare_orders(compute_value
="bla")
163 trade_mock1
.prepare_order
.assert_called_with(compute_value
="bla")
164 trade_mock2
.prepare_order
.assert_called_with(compute_value
="bla")
165 self
.m
.report
.log_orders
.assert_called_once_with([1, 2], None, "bla")
167 trade_mock1
.prepare_order
.reset_mock()
168 trade_mock2
.prepare_order
.reset_mock()
169 self
.m
.report
.log_orders
.reset_mock()
171 trade_mock1
.action
= "foo"
172 trade_mock2
.action
= "bar"
173 trade_store
.prepare_orders(only
="bar")
174 trade_mock1
.prepare_order
.assert_not_called()
175 trade_mock2
.prepare_order
.assert_called_with(compute_value
="default")
176 self
.m
.report
.log_orders
.assert_called_once_with([2], "bar", "default")
178 def test_print_all_with_order(self
):
179 trade_mock1
= mock
.Mock()
180 trade_mock2
= mock
.Mock()
181 trade_mock3
= mock
.Mock()
182 trade_store
= market
.TradeStore(self
.m
)
183 trade_store
.all
= [trade_mock1
, trade_mock2
, trade_mock3
]
185 trade_store
.print_all_with_order()
187 trade_mock1
.print_with_order
.assert_called()
188 trade_mock2
.print_with_order
.assert_called()
189 trade_mock3
.print_with_order
.assert_called()
191 def test_run_orders(self
):
192 with mock
.patch
.object(market
.TradeStore
, "all_orders") as all_orders
:
193 order_mock1
= mock
.Mock()
194 order_mock2
= mock
.Mock()
195 order_mock3
= mock
.Mock()
196 trade_store
= market
.TradeStore(self
.m
)
198 all_orders
.return_value
= [order_mock1
, order_mock2
, order_mock3
]
200 trade_store
.run_orders()
202 all_orders
.assert_called_with(state
="pending")
204 order_mock1
.run
.assert_called()
205 order_mock2
.run
.assert_called()
206 order_mock3
.run
.assert_called()
208 self
.m
.report
.log_stage
.assert_called_with("run_orders")
209 self
.m
.report
.log_orders
.assert_called_with([order_mock1
, order_mock2
,
212 def test_all_orders(self
):
213 trade_mock1
= mock
.Mock()
214 trade_mock2
= mock
.Mock()
216 order_mock1
= mock
.Mock()
217 order_mock2
= mock
.Mock()
218 order_mock3
= mock
.Mock()
220 trade_mock1
.orders
= [order_mock1
, order_mock2
]
221 trade_mock2
.orders
= [order_mock3
]
223 order_mock1
.status
= "pending"
224 order_mock2
.status
= "open"
225 order_mock3
.status
= "open"
227 trade_store
= market
.TradeStore(self
.m
)
228 trade_store
.all
.append(trade_mock1
)
229 trade_store
.all
.append(trade_mock2
)
231 orders
= trade_store
.all_orders()
232 self
.assertEqual(3, len(orders
))
234 open_orders
= trade_store
.all_orders(state
="open")
235 self
.assertEqual(2, len(open_orders
))
236 self
.assertEqual([order_mock2
, order_mock3
], open_orders
)
238 def test_update_all_orders_status(self
):
239 with mock
.patch
.object(market
.TradeStore
, "all_orders") as all_orders
:
240 order_mock1
= mock
.Mock()
241 order_mock2
= mock
.Mock()
242 order_mock3
= mock
.Mock()
244 all_orders
.return_value
= [order_mock1
, order_mock2
, order_mock3
]
246 trade_store
= market
.TradeStore(self
.m
)
248 trade_store
.update_all_orders_status()
249 all_orders
.assert_called_with(state
="open")
251 order_mock1
.get_status
.assert_called()
252 order_mock2
.get_status
.assert_called()
253 order_mock3
.get_status
.assert_called()
255 def test_close_trades(self
):
256 trade_mock1
= mock
.Mock()
257 trade_mock2
= mock
.Mock()
258 trade_mock3
= mock
.Mock()
260 trade_store
= market
.TradeStore(self
.m
)
262 trade_store
.all
.append(trade_mock1
)
263 trade_store
.all
.append(trade_mock2
)
264 trade_store
.all
.append(trade_mock3
)
266 trade_store
.close_trades()
268 trade_mock1
.close
.assert_called_once_with()
269 trade_mock2
.close
.assert_called_once_with()
270 trade_mock3
.close
.assert_called_once_with()
272 def test_pending(self
):
273 trade_mock1
= mock
.Mock()
274 trade_mock1
.pending
= True
275 trade_mock2
= mock
.Mock()
276 trade_mock2
.pending
= True
277 trade_mock3
= mock
.Mock()
278 trade_mock3
.pending
= False
280 trade_store
= market
.TradeStore(self
.m
)
282 trade_store
.all
.append(trade_mock1
)
283 trade_store
.all
.append(trade_mock2
)
284 trade_store
.all
.append(trade_mock3
)
286 self
.assertEqual([trade_mock1
, trade_mock2
], trade_store
.pending
)
288 class BalanceStoreTest(WebMockTestCase
):
292 self
.fetch_balance
= {
300 "exchange_free": D("6.0"),
301 "exchange_used": D("1.2"),
302 "exchange_total": D("7.2"),
308 "exchange_total": 16,
315 "margin_total": D("-1.0"),
320 def test_in_currency(self
):
321 self
.m
.get_ticker
.return_value
= {
327 balance_store
= market
.BalanceStore(self
.m
)
328 balance_store
.all
= {
329 "BTC": portfolio
.Balance("BTC", {
331 "exchange_total":"0.65",
332 "exchange_free": "0.35",
333 "exchange_used": "0.30"}),
334 "ETH": portfolio
.Balance("ETH", {
338 "exchange_used": 0}),
341 amounts
= balance_store
.in_currency("BTC")
342 self
.assertEqual("BTC", amounts
["ETH"].currency
)
343 self
.assertEqual(D("0.65"), amounts
["BTC"].value
)
344 self
.assertEqual(D("0.30"), amounts
["ETH"].value
)
345 self
.m
.report
.log_tickers
.assert_called_once_with(amounts
, "BTC",
347 self
.m
.report
.log_tickers
.reset_mock()
349 amounts
= balance_store
.in_currency("BTC", compute_value
="bid")
350 self
.assertEqual(D("0.65"), amounts
["BTC"].value
)
351 self
.assertEqual(D("0.27"), amounts
["ETH"].value
)
352 self
.m
.report
.log_tickers
.assert_called_once_with(amounts
, "BTC",
354 self
.m
.report
.log_tickers
.reset_mock()
356 amounts
= balance_store
.in_currency("BTC", compute_value
="bid", type="exchange_used")
357 self
.assertEqual(D("0.30"), amounts
["BTC"].value
)
358 self
.assertEqual(0, amounts
["ETH"].value
)
359 self
.m
.report
.log_tickers
.assert_called_once_with(amounts
, "BTC",
360 "bid", "exchange_used")
361 self
.m
.report
.log_tickers
.reset_mock()
363 def test_fetch_balances(self
):
364 self
.m
.ccxt
.fetch_all_balances
.return_value
= self
.fetch_balance
366 balance_store
= market
.BalanceStore(self
.m
)
368 balance_store
.fetch_balances()
369 self
.assertNotIn("ETC", balance_store
.currencies())
370 self
.assertListEqual(["USDT", "XVG", "XMR"], list(balance_store
.currencies()))
372 balance_store
.all
["ETC"] = portfolio
.Balance("ETC", {
373 "exchange_total": "1", "exchange_free": "0",
374 "exchange_used": "1" })
375 balance_store
.fetch_balances(tag
="foo")
376 self
.assertEqual(0, balance_store
.all
["ETC"].total
)
377 self
.assertListEqual(["USDT", "XVG", "XMR", "ETC"], list(balance_store
.currencies()))
378 self
.m
.report
.log_balances
.assert_called_with(tag
="foo")
380 @mock.patch.object(market
.Portfolio
, "repartition")
381 def test_dispatch_assets(self
, repartition
):
382 self
.m
.ccxt
.fetch_all_balances
.return_value
= self
.fetch_balance
384 balance_store
= market
.BalanceStore(self
.m
)
385 balance_store
.fetch_balances()
387 self
.assertNotIn("XEM", balance_store
.currencies())
390 "XEM": (D("0.75"), "long"),
391 "BTC": (D("0.26"), "long"),
392 "DASH": (D("0.10"), "short"),
394 repartition
.return_value
= repartition_hash
396 amounts
= balance_store
.dispatch_assets(portfolio
.Amount("BTC", "11.1"))
397 repartition
.assert_called_with(liquidity
="medium")
398 self
.assertIn("XEM", balance_store
.currencies())
399 self
.assertEqual(D("2.6"), amounts
["BTC"].value
)
400 self
.assertEqual(D("7.5"), amounts
["XEM"].value
)
401 self
.assertEqual(D("-1.0"), amounts
["DASH"].value
)
402 self
.m
.report
.log_balances
.assert_called_with(tag
=None)
403 self
.m
.report
.log_dispatch
.assert_called_once_with(portfolio
.Amount("BTC",
404 "11.1"), amounts
, "medium", repartition_hash
)
406 def test_currencies(self
):
407 balance_store
= market
.BalanceStore(self
.m
)
409 balance_store
.all
= {
410 "BTC": portfolio
.Balance("BTC", {
412 "exchange_total":"0.65",
413 "exchange_free": "0.35",
414 "exchange_used": "0.30"}),
415 "ETH": portfolio
.Balance("ETH", {
419 "exchange_used": 0}),
421 self
.assertListEqual(["BTC", "ETH"], list(balance_store
.currencies()))
423 def test_as_json(self
):
424 balance_mock1
= mock
.Mock()
425 balance_mock1
.as_json
.return_value
= 1
427 balance_mock2
= mock
.Mock()
428 balance_mock2
.as_json
.return_value
= 2
430 balance_store
= market
.BalanceStore(self
.m
)
431 balance_store
.all
= {
432 "BTC": balance_mock1
,
433 "ETH": balance_mock2
,
436 as_json
= balance_store
.as_json()
437 self
.assertEqual(1, as_json
["BTC"])
438 self
.assertEqual(2, as_json
["ETH"])
440 class ReportStoreTest(WebMockTestCase
):
441 def test_add_log(self
):
442 with self
.subTest(market
=self
.m
):
445 report_store
= market
.ReportStore(self
.m
)
446 result
= report_store
.add_log({"foo": "bar"}
)
448 self
.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": 1, "market_id": 3}
, result
)
449 self
.assertEqual(result
, report_store
.logs
[0])
451 with self
.subTest(market
=None):
452 report_store
= market
.ReportStore(None)
453 result
= report_store
.add_log({"foo": "bar"}
)
455 self
.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": None, "market_id": None}
, result
)
457 def test_set_verbose(self
):
458 report_store
= market
.ReportStore(self
.m
)
459 with self
.subTest(verbose
=True):
460 report_store
.set_verbose(True)
461 self
.assertTrue(report_store
.verbose_print
)
463 with self
.subTest(verbose
=False):
464 report_store
.set_verbose(False)
465 self
.assertFalse(report_store
.verbose_print
)
467 def test_merge(self
):
470 report_store1
= market
.ReportStore(self
.m
, verbose_print
=False)
471 report_store2
= market
.ReportStore(None, verbose_print
=False)
473 report_store2
.log_stage("1")
474 report_store1
.log_stage("2")
475 report_store2
.log_stage("3")
477 report_store1
.merge(report_store2
)
479 self
.assertEqual(3, len(report_store1
.logs
))
480 self
.assertEqual(["1", "2", "3"], list(map(lambda x
: x
["stage"], report_store1
.logs
)))
481 self
.assertEqual(6, len(report_store1
.print_logs
))
483 def test_print_log(self
):
484 report_store
= market
.ReportStore(self
.m
)
485 with self
.subTest(verbose
=True),\
486 mock
.patch
.object(store
, "datetime") as time_mock
,\
487 mock
.patch('sys.stdout', new_callable
=StringIO
) as stdout_mock
:
488 time_mock
.datetime
.now
.return_value
= datetime
.datetime(2018, 2, 25, 2, 20, 10)
489 report_store
.set_verbose(True)
490 report_store
.print_log("Coucou")
491 report_store
.print_log(portfolio
.Amount("BTC", 1))
492 self
.assertEqual(stdout_mock
.getvalue(), "2018-02-25 02:20:10: Coucou\n2018-02-25 02:20:10: 1.00000000 BTC\n")
494 with self
.subTest(verbose
=False),\
495 mock
.patch('sys.stdout', new_callable
=StringIO
) as stdout_mock
:
496 report_store
.set_verbose(False)
497 report_store
.print_log("Coucou")
498 report_store
.print_log(portfolio
.Amount("BTC", 1))
499 self
.assertEqual(stdout_mock
.getvalue(), "")
501 def test_default_json_serial(self
):
502 report_store
= market
.ReportStore(self
.m
)
504 self
.assertEqual("2018-02-24T00:00:00",
505 report_store
.default_json_serial(portfolio
.datetime
.datetime(2018, 2, 24)))
506 self
.assertEqual("1.00000000 BTC",
507 report_store
.default_json_serial(portfolio
.Amount("BTC", 1)))
509 def test_to_json(self
):
510 report_store
= market
.ReportStore(self
.m
)
511 report_store
.logs
.append({"foo": "bar"}
)
512 self
.assertEqual('[\n {\n "foo": "bar"\n }\n]', report_store
.to_json())
513 report_store
.logs
.append({"date": portfolio.datetime.datetime(2018, 2, 24)}
)
514 self
.assertEqual('[\n {\n "foo": "bar"\n },\n {\n "date": "2018-02-24T00:00:00"\n }\n]', report_store
.to_json())
515 report_store
.logs
.append({"amount": portfolio.Amount("BTC", 1)}
)
516 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())
518 def test_to_json_array(self
):
519 report_store
= market
.ReportStore(self
.m
)
520 report_store
.logs
.append({
521 "date": "date1", "type": "type1", "foo": "bar", "bla": "bla"
523 report_store
.logs
.append({
524 "date": "date2", "type": "type2", "foo": "bar", "bla": "bla"
526 logs
= list(report_store
.to_json_array())
528 self
.assertEqual(2, len(logs
))
529 self
.assertEqual(("date1", "type1", '{\n "foo": "bar",\n "bla": "bla"\n}'), logs
[0])
530 self
.assertEqual(("date2", "type2", '{\n "foo": "bar",\n "bla": "bla"\n}'), logs
[1])
532 @mock.patch.object(market
.ReportStore
, "print_log")
533 @mock.patch.object(market
.ReportStore
, "add_log")
534 def test_log_stage(self
, add_log
, print_log
):
535 report_store
= market
.ReportStore(self
.m
)
537 report_store
.log_stage("foo", bar
="baz", c
=c
, d
=portfolio
.Amount("BTC", 1))
538 print_log
.assert_has_calls([
539 mock
.call("-----------"),
540 mock
.call("[Stage] foo bar=baz, c=c = lambda x: x, d={'currency': 'BTC', 'value': Decimal('1')}"),
542 add_log
.assert_called_once_with({
547 'c': 'c = lambda x: x',
555 @mock.patch.object(market
.ReportStore
, "print_log")
556 @mock.patch.object(market
.ReportStore
, "add_log")
557 def test_log_balances(self
, add_log
, print_log
):
558 report_store
= market
.ReportStore(self
.m
)
559 self
.m
.balances
.as_json
.return_value
= "json"
560 self
.m
.balances
.all
= { "FOO": "bar", "BAR": "baz" }
562 report_store
.log_balances(tag
="tag")
563 print_log
.assert_has_calls([
564 mock
.call("[Balance]"),
568 add_log
.assert_called_once_with({
574 @mock.patch.object(market
.ReportStore
, "print_log")
575 @mock.patch.object(market
.ReportStore
, "add_log")
576 def test_log_tickers(self
, add_log
, print_log
):
577 report_store
= market
.ReportStore(self
.m
)
579 "BTC": portfolio
.Amount("BTC", 10),
580 "ETH": portfolio
.Amount("BTC", D("0.3"))
582 amounts
["ETH"].rate
= D("0.1")
584 report_store
.log_tickers(amounts
, "BTC", "default", "total")
585 print_log
.assert_not_called()
586 add_log
.assert_called_once_with({
588 'compute_value': 'default',
589 'balance_type': 'total',
603 compute_value
= lambda x
: x
["bid"]
604 report_store
.log_tickers(amounts
, "BTC", compute_value
, "total")
605 add_log
.assert_called_once_with({
607 'compute_value': 'compute_value = lambda x: x["bid"]',
608 'balance_type': 'total',
621 @mock.patch.object(market
.ReportStore
, "print_log")
622 @mock.patch.object(market
.ReportStore
, "add_log")
623 def test_log_dispatch(self
, add_log
, print_log
):
624 report_store
= market
.ReportStore(self
.m
)
625 amount
= portfolio
.Amount("BTC", "10.3")
627 "BTC": portfolio
.Amount("BTC", 10),
628 "ETH": portfolio
.Amount("BTC", D("0.3"))
630 report_store
.log_dispatch(amount
, amounts
, "medium", "repartition")
631 print_log
.assert_not_called()
632 add_log
.assert_called_once_with({
634 'liquidity': 'medium',
635 'repartition_ratio': 'repartition',
646 @mock.patch.object(market
.ReportStore
, "print_log")
647 @mock.patch.object(market
.ReportStore
, "add_log")
648 def test_log_trades(self
, add_log
, print_log
):
649 report_store
= market
.ReportStore(self
.m
)
650 trade_mock1
= mock
.Mock()
651 trade_mock2
= mock
.Mock()
652 trade_mock1
.as_json
.return_value
= { "trade": "1" }
653 trade_mock2
.as_json
.return_value
= { "trade": "2" }
655 matching_and_trades
= [
657 (False, trade_mock2
),
659 report_store
.log_trades(matching_and_trades
, "only")
661 print_log
.assert_not_called()
662 add_log
.assert_called_with({
667 {'trade': '1', 'skipped': False}
,
668 {'trade': '2', 'skipped': True}
672 @mock.patch.object(market
.ReportStore
, "print_log")
673 @mock.patch.object(market
.ReportStore
, "add_log")
674 def test_log_orders(self
, add_log
, print_log
):
675 report_store
= market
.ReportStore(self
.m
)
677 order_mock1
= mock
.Mock()
678 order_mock2
= mock
.Mock()
680 order_mock1
.as_json
.return_value
= "order1"
681 order_mock2
.as_json
.return_value
= "order2"
683 orders
= [order_mock1
, order_mock2
]
685 report_store
.log_orders(orders
, tick
="tick",
686 only
="only", compute_value
="compute_value")
688 print_log
.assert_called_once_with("[Orders]")
689 self
.m
.trades
.print_all_with_order
.assert_called_once_with(ind
="\t")
691 add_log
.assert_called_with({
694 'compute_value': 'compute_value',
696 'orders': ['order1', 'order2']
700 def compute_value(x
, y
):
702 report_store
.log_orders(orders
, tick
="tick",
703 only
="only", compute_value
=compute_value
)
704 add_log
.assert_called_with({
707 'compute_value': 'def compute_value(x, y):\n return x[y]',
709 'orders': ['order1', 'order2']
713 @mock.patch.object(market
.ReportStore
, "print_log")
714 @mock.patch.object(market
.ReportStore
, "add_log")
715 def test_log_order(self
, add_log
, print_log
):
716 report_store
= market
.ReportStore(self
.m
)
717 order_mock
= mock
.Mock()
718 order_mock
.as_json
.return_value
= "order"
719 new_order_mock
= mock
.Mock()
720 new_order_mock
.as_json
.return_value
= "new_order"
721 order_mock
.__repr
__ = mock
.Mock()
722 order_mock
.__repr
__.return_value
= "Order Mock"
723 new_order_mock
.__repr
__ = mock
.Mock()
724 new_order_mock
.__repr
__.return_value
= "New order Mock"
726 with self
.subTest(finished
=True):
727 report_store
.log_order(order_mock
, 1, finished
=True)
728 print_log
.assert_called_once_with("[Order] Finished Order Mock")
729 add_log
.assert_called_once_with({
734 'compute_value': None,
739 print_log
.reset_mock()
741 with self
.subTest(update
="waiting"):
742 report_store
.log_order(order_mock
, 1, update
="waiting")
743 print_log
.assert_called_once_with("[Order] Order Mock, tick 1, waiting")
744 add_log
.assert_called_once_with({
749 'compute_value': None,
754 print_log
.reset_mock()
755 with self
.subTest(update
="adjusting"):
756 compute_value
= lambda x
: (x
["bid"] + x
["ask"]*2)/3
757 report_store
.log_order(order_mock
, 3,
758 update
="adjusting", new_order
=new_order_mock
,
759 compute_value
=compute_value
)
760 print_log
.assert_called_once_with("[Order] Order Mock, tick 3, cancelling and adjusting to New order Mock")
761 add_log
.assert_called_once_with({
764 'update': 'adjusting',
766 'compute_value': 'compute_value = lambda x: (x["bid"] + x["ask"]*2)/3',
767 'new_order': 'new_order'
771 print_log
.reset_mock()
772 with self
.subTest(update
="market_fallback"):
773 report_store
.log_order(order_mock
, 7,
774 update
="market_fallback", new_order
=new_order_mock
)
775 print_log
.assert_called_once_with("[Order] Order Mock, tick 7, fallbacking to market value")
776 add_log
.assert_called_once_with({
779 'update': 'market_fallback',
781 'compute_value': None,
782 'new_order': 'new_order'
786 print_log
.reset_mock()
787 with self
.subTest(update
="market_adjusting"):
788 report_store
.log_order(order_mock
, 17,
789 update
="market_adjust", new_order
=new_order_mock
)
790 print_log
.assert_called_once_with("[Order] Order Mock, tick 17, market value, cancelling and adjusting to New order Mock")
791 add_log
.assert_called_once_with({
794 'update': 'market_adjust',
796 'compute_value': None,
797 'new_order': 'new_order'
800 @mock.patch.object(market
.ReportStore
, "print_log")
801 @mock.patch.object(market
.ReportStore
, "add_log")
802 def test_log_move_balances(self
, add_log
, print_log
):
803 report_store
= market
.ReportStore(self
.m
)
805 "BTC": portfolio
.Amount("BTC", 10),
809 "BTC": portfolio
.Amount("BTC", 3),
812 report_store
.log_move_balances(needed
, moving
)
813 print_log
.assert_not_called()
814 add_log
.assert_called_once_with({
815 'type': 'move_balances',
827 def test_log_http_request(self
):
828 with mock
.patch
.object(market
.ReportStore
, "add_log") as add_log
:
829 report_store
= market
.ReportStore(self
.m
)
830 response
= mock
.Mock()
831 response
.status_code
= 200
832 response
.text
= "Hey"
834 report_store
.log_http_request("method", "url", "body",
836 add_log
.assert_called_once_with({
837 'type': 'http_request',
841 'headers': 'headers',
844 'response_same_as': None,
848 report_store
.log_http_request("method", "url", "body",
849 "headers", ValueError("Foo"))
850 add_log
.assert_called_once_with({
851 'type': 'http_request',
855 'headers': 'headers',
858 'error': 'ValueError',
859 'error_message': 'Foo',
862 with self
.subTest(no_http_dup
=True, duplicate
=True):
865 report_store
= market
.ReportStore(self
.m
, no_http_dup
=True)
866 original_add_log
= report_store
.add_log
867 with mock
.patch
.object(report_store
, "add_log", side_effect
=original_add_log
) as add_log
:
868 report_store
.log_http_request("method", "url", "body",
870 report_store
.log_http_request("method", "url", "body",
872 self
.assertEqual(2, add_log
.call_count
)
873 self
.assertIsNone(add_log
.mock_calls
[0][1][0]["response_same_as"])
874 self
.assertIsNone(add_log
.mock_calls
[1][1][0]["response"])
875 self
.assertEqual(add_log
.mock_calls
[0][1][0]["date"], add_log
.mock_calls
[1][1][0]["response_same_as"])
876 with self
.subTest(no_http_dup
=True, duplicate
=False, case
="Different call"):
879 report_store
= market
.ReportStore(self
.m
, no_http_dup
=True)
880 original_add_log
= report_store
.add_log
881 with mock
.patch
.object(report_store
, "add_log", side_effect
=original_add_log
) as add_log
:
882 report_store
.log_http_request("method", "url", "body",
884 report_store
.log_http_request("method2", "url", "body",
886 self
.assertEqual(2, add_log
.call_count
)
887 self
.assertIsNone(add_log
.mock_calls
[0][1][0]["response_same_as"])
888 self
.assertIsNone(add_log
.mock_calls
[1][1][0]["response_same_as"])
889 with self
.subTest(no_http_dup
=True, duplicate
=False, case
="Call inbetween"):
892 report_store
= market
.ReportStore(self
.m
, no_http_dup
=True)
893 original_add_log
= report_store
.add_log
895 response2
= mock
.Mock()
896 response2
.status_code
= 200
897 response2
.text
= "Hey there!"
899 with mock
.patch
.object(report_store
, "add_log", side_effect
=original_add_log
) as add_log
:
900 report_store
.log_http_request("method", "url", "body",
902 report_store
.log_http_request("method", "url", "body",
903 "headers", response2
)
904 report_store
.log_http_request("method", "url", "body",
906 self
.assertEqual(3, add_log
.call_count
)
907 self
.assertIsNone(add_log
.mock_calls
[0][1][0]["response_same_as"])
908 self
.assertIsNone(add_log
.mock_calls
[1][1][0]["response_same_as"])
909 self
.assertIsNone(add_log
.mock_calls
[2][1][0]["response_same_as"])
911 @mock.patch.object(market
.ReportStore
, "add_log")
912 def test_log_market(self
, add_log
):
913 report_store
= market
.ReportStore(self
.m
)
915 report_store
.log_market(self
.market_args(debug
=True, quiet
=False))
916 add_log
.assert_called_once_with({
918 "commit": "$Format:%H$",
919 "args": { "report_path": None, "debug": True, "quiet": False }
,
922 @mock.patch.object(market
.ReportStore
, "print_log")
923 @mock.patch.object(market
.ReportStore
, "add_log")
924 def test_log_error(self
, add_log
, print_log
):
925 report_store
= market
.ReportStore(self
.m
)
926 with self
.subTest(message
=None, exception
=None):
927 report_store
.log_error("action")
928 print_log
.assert_called_once_with("[Error] action")
929 add_log
.assert_called_once_with({
932 'exception_class': None,
933 'exception_message': None,
937 print_log
.reset_mock()
939 with self
.subTest(message
="Hey", exception
=None):
940 report_store
.log_error("action", message
="Hey")
941 print_log
.assert_has_calls([
942 mock
.call("[Error] action"),
945 add_log
.assert_called_once_with({
948 'exception_class': None,
949 'exception_message': None,
953 print_log
.reset_mock()
955 with self
.subTest(message
=None, exception
=Exception("bouh")):
956 report_store
.log_error("action", exception
=Exception("bouh"))
957 print_log
.assert_has_calls([
958 mock
.call("[Error] action"),
959 mock
.call("\tException: bouh")
961 add_log
.assert_called_once_with({
964 'exception_class': "Exception",
965 'exception_message': "bouh",
969 print_log
.reset_mock()
971 with self
.subTest(message
="Hey", exception
=Exception("bouh")):
972 report_store
.log_error("action", message
="Hey", exception
=Exception("bouh"))
973 print_log
.assert_has_calls([
974 mock
.call("[Error] action"),
975 mock
.call("\tException: bouh"),
978 add_log
.assert_called_once_with({
981 'exception_class': "Exception",
982 'exception_message': "bouh",
986 @mock.patch.object(market
.ReportStore
, "print_log")
987 @mock.patch.object(market
.ReportStore
, "add_log")
988 def test_log_debug_action(self
, add_log
, print_log
):
989 report_store
= market
.ReportStore(self
.m
)
990 report_store
.log_debug_action("Hey")
992 print_log
.assert_called_once_with("[Debug] Hey")
993 add_log
.assert_called_once_with({
994 'type': 'debug_action',
998 class PortfolioTest(WebMockTestCase
):
1002 with open("test_samples/test_portfolio.json") as example
:
1003 self
.json_response
= example
.read()
1005 self
.wm
.get(market
.Portfolio
.URL
, text
=self
.json_response
)
1007 @mock.patch.object(market
.Portfolio
, "parse_cryptoportfolio")
1008 def test_get_cryptoportfolio(self
, parse_cryptoportfolio
):
1009 with self
.subTest(parallel
=False):
1010 self
.wm
.get(market
.Portfolio
.URL
, [
1011 {"text":'{ "foo": "bar" }
', "status_code": 200},
1012 {"text": "System Error", "status_code": 500},
1013 {"exc": requests.exceptions.ConnectTimeout},
1015 market.Portfolio.get_cryptoportfolio()
1016 self.assertIn("foo", market.Portfolio.data.get())
1017 self.assertEqual("bar", market.Portfolio.data.get()["foo"])
1018 self.assertTrue(self.wm.called)
1019 self.assertEqual(1, self.wm.call_count)
1020 market.Portfolio.report.log_error.assert_not_called()
1021 market.Portfolio.report.log_http_request.assert_called_once()
1022 parse_cryptoportfolio.assert_called_once_with()
1023 market.Portfolio.report.log_http_request.reset_mock()
1024 parse_cryptoportfolio.reset_mock()
1025 market.Portfolio.data = store.LockedVar(None)
1027 market.Portfolio.get_cryptoportfolio()
1028 self.assertIsNone(market.Portfolio.data.get())
1029 self.assertEqual(2, self.wm.call_count)
1030 parse_cryptoportfolio.assert_not_called()
1031 market.Portfolio.report.log_error.assert_not_called()
1032 market.Portfolio.report.log_http_request.assert_called_once()
1033 market.Portfolio.report.log_http_request.reset_mock()
1034 parse_cryptoportfolio.reset_mock()
1036 market.Portfolio.data = store.LockedVar("Foo")
1037 market.Portfolio.get_cryptoportfolio()
1038 self.assertEqual(2, self.wm.call_count)
1039 parse_cryptoportfolio.assert_not_called()
1041 market.Portfolio.get_cryptoportfolio(refetch=True)
1042 self.assertEqual("Foo", market.Portfolio.data.get())
1043 self.assertEqual(3, self.wm.call_count)
1044 market.Portfolio.report.log_error.assert_called_once_with("get_cryptoportfolio",
1046 market.Portfolio.report.log_http_request.assert_not_called()
1047 with self.subTest(parallel=True):
1048 with mock.patch.object(market.Portfolio, "is_worker_thread") as is_worker,\
1049 mock.patch.object(market.Portfolio, "notify_and_wait") as notify:
1050 with self.subTest(worker=True):
1051 market.Portfolio.data = store.LockedVar(None)
1052 market.Portfolio.worker = mock.Mock()
1053 is_worker.return_value = True
1054 self.wm.get(market.Portfolio.URL, [
1055 {"text":'{ "foo": "bar" }', "status_code": 200},
1057 market
.Portfolio
.get_cryptoportfolio()
1058 self
.assertIn("foo", market
.Portfolio
.data
.get())
1059 parse_cryptoportfolio
.reset_mock()
1060 with self
.subTest(worker
=False):
1061 market
.Portfolio
.data
= store
.LockedVar(None)
1062 market
.Portfolio
.worker
= mock
.Mock()
1063 is_worker
.return_value
= False
1064 market
.Portfolio
.get_cryptoportfolio()
1065 notify
.assert_called_once_with()
1066 parse_cryptoportfolio
.assert_not_called()
1068 def test_parse_cryptoportfolio(self
):
1069 with self
.subTest(description
="Normal case"):
1070 market
.Portfolio
.data
= store
.LockedVar(store
.json
.loads(
1071 self
.json_response
, parse_int
=D
, parse_float
=D
))
1072 market
.Portfolio
.parse_cryptoportfolio()
1074 self
.assertListEqual(
1076 list(market
.Portfolio
.liquidities
.get().keys()))
1078 liquidities
= market
.Portfolio
.liquidities
.get()
1079 self
.assertEqual(10, len(liquidities
["medium"].keys()))
1080 self
.assertEqual(10, len(liquidities
["high"].keys()))
1083 'BTC': (D("0.2857"), "long"),
1084 'DGB': (D("0.1015"), "long"),
1085 'DOGE': (D("0.1805"), "long"),
1086 'SC': (D("0.0623"), "long"),
1087 'ZEC': (D("0.3701"), "long"),
1089 date
= portfolio
.datetime
.datetime(2018, 1, 8)
1090 self
.assertDictEqual(expected
, liquidities
["high"][date
])
1093 'BTC': (D("1.1102e-16"), "long"),
1094 'ETC': (D("0.1"), "long"),
1095 'FCT': (D("0.1"), "long"),
1096 'GAS': (D("0.1"), "long"),
1097 'NAV': (D("0.1"), "long"),
1098 'OMG': (D("0.1"), "long"),
1099 'OMNI': (D("0.1"), "long"),
1100 'PPC': (D("0.1"), "long"),
1101 'RIC': (D("0.1"), "long"),
1102 'VIA': (D("0.1"), "long"),
1103 'XCP': (D("0.1"), "long"),
1105 self
.assertDictEqual(expected
, liquidities
["medium"][date
])
1106 self
.assertEqual(portfolio
.datetime
.datetime(2018, 1, 15), market
.Portfolio
.last_date
.get())
1108 with self
.subTest(description
="Missing weight"):
1109 data
= store
.json
.loads(self
.json_response
, parse_int
=D
, parse_float
=D
)
1110 del(data
["portfolio_2"]["weights"])
1111 market
.Portfolio
.data
= store
.LockedVar(data
)
1113 market
.Portfolio
.parse_cryptoportfolio()
1114 self
.assertListEqual(
1116 list(market
.Portfolio
.liquidities
.get().keys()))
1117 self
.assertEqual({}, market
.Portfolio
.liquidities
.get("medium"))
1119 with self
.subTest(description
="All missing weights"):
1120 data
= store
.json
.loads(self
.json_response
, parse_int
=D
, parse_float
=D
)
1121 del(data
["portfolio_1"]["weights"])
1122 del(data
["portfolio_2"]["weights"])
1123 market
.Portfolio
.data
= store
.LockedVar(data
)
1125 market
.Portfolio
.parse_cryptoportfolio()
1126 self
.assertEqual({}, market
.Portfolio
.liquidities
.get("medium"))
1127 self
.assertEqual({}, market
.Portfolio
.liquidities
.get("high"))
1128 self
.assertEqual(datetime
.datetime(1,1,1), market
.Portfolio
.last_date
.get())
1131 @mock.patch.object(market
.Portfolio
, "get_cryptoportfolio")
1132 def test_repartition(self
, get_cryptoportfolio
):
1133 market
.Portfolio
.liquidities
= store
.LockedVar({
1135 "2018-03-01": "medium_2018-03-01",
1136 "2018-03-08": "medium_2018-03-08",
1139 "2018-03-01": "high_2018-03-01",
1140 "2018-03-08": "high_2018-03-08",
1143 market
.Portfolio
.last_date
= store
.LockedVar("2018-03-08")
1145 self
.assertEqual("medium_2018-03-08", market
.Portfolio
.repartition())
1146 get_cryptoportfolio
.assert_called_once_with()
1147 self
.assertEqual("medium_2018-03-08", market
.Portfolio
.repartition(liquidity
="medium"))
1148 self
.assertEqual("high_2018-03-08", market
.Portfolio
.repartition(liquidity
="high"))
1150 @mock.patch.object(market
.time
, "sleep")
1151 @mock.patch.object(market
.Portfolio
, "get_cryptoportfolio")
1152 def test_wait_for_recent(self
, get_cryptoportfolio
, sleep
):
1154 def _get(refetch
=False):
1155 if self
.call_count
!= 0:
1156 self
.assertTrue(refetch
)
1158 self
.assertFalse(refetch
)
1159 self
.call_count
+= 1
1160 market
.Portfolio
.last_date
= store
.LockedVar(store
.datetime
.datetime
.now()\
1161 - store
.datetime
.timedelta(10)\
1162 + store
.datetime
.timedelta(self
.call_count
))
1163 get_cryptoportfolio
.side_effect
= _get
1165 market
.Portfolio
.wait_for_recent()
1166 sleep
.assert_called_with(30)
1167 self
.assertEqual(6, sleep
.call_count
)
1168 self
.assertEqual(7, get_cryptoportfolio
.call_count
)
1169 market
.Portfolio
.report
.print_log
.assert_called_with("Attempt to fetch up-to-date cryptoportfolio")
1172 get_cryptoportfolio
.reset_mock()
1173 market
.Portfolio
.last_date
= store
.LockedVar(None)
1175 market
.Portfolio
.wait_for_recent(delta
=15)
1176 sleep
.assert_not_called()
1177 self
.assertEqual(1, get_cryptoportfolio
.call_count
)
1180 get_cryptoportfolio
.reset_mock()
1181 market
.Portfolio
.last_date
= store
.LockedVar(None)
1183 market
.Portfolio
.wait_for_recent(delta
=1)
1184 sleep
.assert_called_with(30)
1185 self
.assertEqual(9, sleep
.call_count
)
1186 self
.assertEqual(10, get_cryptoportfolio
.call_count
)
1188 def test_is_worker_thread(self
):
1189 with self
.subTest(worker
=None):
1190 self
.assertFalse(store
.Portfolio
.is_worker_thread())
1192 with self
.subTest(worker
="not self"),\
1193 mock
.patch("threading.current_thread") as current_thread
:
1194 current
= mock
.Mock()
1195 current_thread
.return_value
= current
1196 store
.Portfolio
.worker
= mock
.Mock()
1197 self
.assertFalse(store
.Portfolio
.is_worker_thread())
1199 with self
.subTest(worker
="self"),\
1200 mock
.patch("threading.current_thread") as current_thread
:
1201 current
= mock
.Mock()
1202 current_thread
.return_value
= current
1203 store
.Portfolio
.worker
= current
1204 self
.assertTrue(store
.Portfolio
.is_worker_thread())
1206 def test_start_worker(self
):
1207 with mock
.patch
.object(store
.Portfolio
, "wait_for_notification") as notification
:
1208 store
.Portfolio
.start_worker()
1209 notification
.assert_called_once_with(poll
=30)
1211 self
.assertEqual("lock", store
.Portfolio
.last_date
.lock
.__class
__.__name
__)
1212 self
.assertEqual("lock", store
.Portfolio
.liquidities
.lock
.__class
__.__name
__)
1213 store
.Portfolio
.report
.start_lock
.assert_called_once_with()
1215 self
.assertIsNotNone(store
.Portfolio
.worker
)
1216 self
.assertIsNotNone(store
.Portfolio
.worker_notify
)
1217 self
.assertIsNotNone(store
.Portfolio
.callback
)
1218 self
.assertTrue(store
.Portfolio
.worker_started
)
1220 self
.assertFalse(store
.Portfolio
.worker
.is_alive())
1221 self
.assertEqual(1, threading
.active_count())
1223 def test_stop_worker(self
):
1224 with mock
.patch
.object(store
.Portfolio
, "get_cryptoportfolio") as get
,\
1225 mock
.patch
.object(store
.Portfolio
, "report") as report
,\
1226 mock
.patch
.object(store
.time
, "sleep") as sleep
:
1227 store
.Portfolio
.start_worker(poll
=3)
1228 store
.Portfolio
.stop_worker()
1229 store
.Portfolio
.worker
.join()
1230 get
.assert_not_called()
1231 report
.assert_not_called()
1232 sleep
.assert_not_called()
1233 self
.assertFalse(store
.Portfolio
.worker
.is_alive())
1235 def test_wait_for_notification(self
):
1236 with self
.assertRaises(RuntimeError):
1237 store
.Portfolio
.wait_for_notification()
1239 with mock
.patch
.object(store
.Portfolio
, "get_cryptoportfolio") as get
,\
1240 mock
.patch
.object(store
.Portfolio
, "report") as report
,\
1241 mock
.patch
.object(store
.time
, "sleep") as sleep
:
1242 store
.Portfolio
.start_worker(poll
=3)
1244 store
.Portfolio
.worker_notify
.set()
1246 store
.Portfolio
.callback
.wait()
1248 report
.print_log
.assert_called_once_with("[Worker] Fetching cryptoportfolio")
1249 get
.assert_called_once_with(refetch
=True)
1250 sleep
.assert_called_once_with(3)
1251 self
.assertFalse(store
.Portfolio
.worker_notify
.is_set())
1252 self
.assertTrue(store
.Portfolio
.worker
.is_alive())
1254 store
.Portfolio
.callback
.clear()
1255 store
.Portfolio
.worker_started
= False
1256 store
.Portfolio
.worker_notify
.set()
1257 store
.Portfolio
.worker
.join()
1258 self
.assertFalse(store
.Portfolio
.worker
.is_alive())
1260 def test_notify_and_wait(self
):
1261 with mock
.patch
.object(store
.Portfolio
, "callback") as callback
,\
1262 mock
.patch
.object(store
.Portfolio
, "worker_notify") as worker_notify
:
1263 store
.Portfolio
.notify_and_wait()
1264 callback
.clear
.assert_called_once_with()
1265 worker_notify
.set.assert_called_once_with()
1266 callback
.wait
.assert_called_once_with()