X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=test.py;h=778fc14961cf27011a352624936dcbe0b7780a2f;hb=2033e7fef780298be2ec15455a0ec1d26515de55;hp=a9cae94e58265bcf9d1dcde67b53598d0547b35d;hpb=f86ee14037646bedc3a3dee4a48f085308981757;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FCryptoportfolio%2FTrader.git diff --git a/test.py b/test.py index a9cae94..778fc14 100644 --- a/test.py +++ b/test.py @@ -571,7 +571,7 @@ class MarketTest(WebMockTestCase): ccxt.poloniexE.return_value = self.ccxt self.ccxt.session.request.return_value = "response" - m = market.Market.from_config("config") + m = market.Market.from_config({"key": "key", "secred": "secret"}) self.assertEqual(self.ccxt, m.ccxt) @@ -580,7 +580,7 @@ class MarketTest(WebMockTestCase): m.report.log_http_request.assert_called_with('GET', 'URL', 'data', 'headers', 'response') - m = market.Market.from_config("config", debug=True) + m = market.Market.from_config({"key": "key", "secred": "secret"}, debug=True) self.assertEqual(True, m.debug) def test_get_ticker(self): @@ -1458,6 +1458,25 @@ class TradeTest(WebMockTestCase): D("0.125"), "BTC", "long", self.m, trade, close_if_possible=False) + with self.subTest(action="dispose", inverted=False, close_if_possible=True): + filled_amount.return_value = portfolio.Amount("FOO", "60") + compute_value.return_value = D("0.125") + + value_from = portfolio.Amount("BTC", "10") + value_from.rate = D("0.1") + value_from.linked_to = portfolio.Amount("FOO", "100") + value_to = portfolio.Amount("BTC", "1") + trade = portfolio.Trade(value_from, value_to, "FOO", self.m) + + trade.prepare_order(close_if_possible=True) + + filled_amount.assert_called_with(in_base_currency=False) + compute_value.assert_called_with(self.m.get_ticker.return_value, "sell", compute_value="default") + self.assertEqual(1, len(trade.orders)) + Order.assert_called_with("sell", portfolio.Amount("FOO", 30), + D("0.125"), "BTC", "long", self.m, + trade, close_if_possible=True) + with self.subTest(action="acquire", inverted=False): filled_amount.return_value = portfolio.Amount("BTC", "3") compute_value.return_value = D("0.125") @@ -1812,7 +1831,7 @@ class OrderTest(WebMockTestCase): order.cancel() self.m.ccxt.cancel_order.assert_called_with(42) - fetch.assert_called_once() + fetch.assert_called_once_with(force=True) self.m.report.log_debug_action.assert_not_called() def test_dust_amount_remaining(self): @@ -1966,7 +1985,7 @@ class OrderTest(WebMockTestCase): } order.fetch() - self.m.ccxt.fetch_order.assert_called_once() + self.m.ccxt.fetch_order.assert_called_once_with(45, symbol="ETH") fetch_mouvements.assert_called_once() self.assertEqual("foo", order.status) self.assertEqual("timestamp", order.timestamp) @@ -1982,7 +2001,7 @@ class OrderTest(WebMockTestCase): fetch_mouvements.assert_not_called() order.fetch(force=True) - self.m.ccxt.fetch_order.assert_called_once() + self.m.ccxt.fetch_order.assert_called_once_with(45, symbol="ETH") fetch_mouvements.assert_called_once() self.m.ccxt.fetch_order.reset_mock() @@ -1990,7 +2009,7 @@ class OrderTest(WebMockTestCase): time_mock.return_value = time + 19 order.fetch() - self.m.ccxt.fetch_order.assert_called_once() + self.m.ccxt.fetch_order.assert_called_once_with(45, symbol="ETH") fetch_mouvements.assert_called_once() self.m.report.log_debug_action.assert_not_called() @@ -2073,13 +2092,69 @@ class OrderTest(WebMockTestCase): mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order: order = portfolio.Order("buy", portfolio.Amount("ETH", 0.001), D("0.1"), "BTC", "long", self.m, "trade") - self.m.ccxt.create_order.side_effect = portfolio.ExchangeNotAvailable + self.m.ccxt.create_order.side_effect = portfolio.InvalidOrder order.run() self.m.ccxt.create_order.assert_called_once() self.assertEqual(0, len(order.results)) self.assertEqual("closed", order.status) mark_finished_order.assert_called_once() + self.m.ccxt.order_precision.return_value = 8 + self.m.ccxt.create_order.reset_mock() + with self.subTest(insufficient_funds=True),\ + mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order: + order = portfolio.Order("buy", portfolio.Amount("ETH", "0.001"), + D("0.1"), "BTC", "long", self.m, "trade") + self.m.ccxt.create_order.side_effect = [ + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + { "id": 123 }, + ] + order.run() + self.m.ccxt.create_order.assert_has_calls([ + mock.call('ETH/BTC', 'limit', 'buy', D('0.0010'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.00099'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.0009801'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.00097029'), account='exchange', price=D('0.1')), + ]) + self.assertEqual(4, self.m.ccxt.create_order.call_count) + self.assertEqual(1, len(order.results)) + self.assertEqual("open", order.status) + self.assertEqual(4, order.tries) + self.m.report.log_error.assert_called() + self.assertEqual(4, self.m.report.log_error.call_count) + + self.m.ccxt.order_precision.return_value = 8 + self.m.ccxt.create_order.reset_mock() + self.m.report.log_error.reset_mock() + with self.subTest(insufficient_funds=True),\ + mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order: + order = portfolio.Order("buy", portfolio.Amount("ETH", "0.001"), + D("0.1"), "BTC", "long", self.m, "trade") + self.m.ccxt.create_order.side_effect = [ + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + ] + order.run() + self.m.ccxt.create_order.assert_has_calls([ + mock.call('ETH/BTC', 'limit', 'buy', D('0.0010'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.00099'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.0009801'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.00097029'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.00096059'), account='exchange', price=D('0.1')), + ]) + self.assertEqual(5, self.m.ccxt.create_order.call_count) + self.assertEqual(0, len(order.results)) + self.assertEqual("error", order.status) + self.assertEqual(5, order.tries) + self.m.report.log_error.assert_called() + self.assertEqual(5, self.m.report.log_error.call_count) + self.m.report.log_error.assert_called_with(mock.ANY, message="Giving up Order(buy long 0.00096060 ETH at 0.1 BTC [pending])", exception=mock.ANY) + @unittest.skipUnless("unit" in limits, "Unit skipped") class MouvementTest(WebMockTestCase): @@ -2180,8 +2255,7 @@ class ReportStoreTest(WebMockTestCase): report_store.logs.append({"date": portfolio.datetime(2018, 2, 24)}) self.assertEqual('[{"foo": "bar"}, {"date": "2018-02-24T00:00:00"}]', report_store.to_json()) report_store.logs.append({"amount": portfolio.Amount("BTC", 1)}) - with self.assertRaises(TypeError): - report_store.to_json() + self.assertEqual('[{"foo": "bar"}, {"date": "2018-02-24T00:00:00"}, {"amount": "1.00000000 BTC"}]', report_store.to_json()) @mock.patch.object(market.ReportStore, "print_log") @mock.patch.object(market.ReportStore, "add_log") @@ -2531,6 +2605,119 @@ class ReportStoreTest(WebMockTestCase): @unittest.skipUnless("unit" in limits, "Unit skipped") class HelperTest(WebMockTestCase): + def test_make_order(self): + self.m.get_ticker.return_value = { + "inverted": False, + "average": D("0.1"), + "bid": D("0.09"), + "ask": D("0.11"), + } + + with self.subTest(description="nominal case"): + helper.make_order(self.m, 10, "ETH") + + self.m.report.log_stage.assert_has_calls([ + mock.call("make_order_begin"), + mock.call("make_order_end"), + ]) + self.m.balances.fetch_balances.assert_has_calls([ + mock.call(tag="make_order_begin"), + mock.call(tag="make_order_end"), + ]) + self.m.trades.all.append.assert_called_once() + trade = self.m.trades.all.append.mock_calls[0][1][0] + self.assertEqual(False, trade.orders[0].close_if_possible) + self.assertEqual(0, trade.value_from) + self.assertEqual("ETH", trade.currency) + self.assertEqual("BTC", trade.base_currency) + self.m.report.log_orders.assert_called_once_with([trade.orders[0]], None, "average") + self.m.trades.run_orders.assert_called_once_with() + self.m.follow_orders.assert_called_once_with() + + order = trade.orders[0] + self.assertEqual(D("0.10"), order.rate) + + self.m.reset_mock() + with self.subTest(compute_value="default"): + helper.make_order(self.m, 10, "ETH", action="dispose", + compute_value="ask") + + trade = self.m.trades.all.append.mock_calls[0][1][0] + order = trade.orders[0] + self.assertEqual(D("0.11"), order.rate) + + self.m.reset_mock() + with self.subTest(follow=False): + result = helper.make_order(self.m, 10, "ETH", follow=False) + + self.m.report.log_stage.assert_has_calls([ + mock.call("make_order_begin"), + mock.call("make_order_end_not_followed"), + ]) + self.m.balances.fetch_balances.assert_called_once_with(tag="make_order_begin") + + self.m.trades.all.append.assert_called_once() + trade = self.m.trades.all.append.mock_calls[0][1][0] + self.assertEqual(0, trade.value_from) + self.assertEqual("ETH", trade.currency) + self.assertEqual("BTC", trade.base_currency) + self.m.report.log_orders.assert_called_once_with([trade.orders[0]], None, "average") + self.m.trades.run_orders.assert_called_once_with() + self.m.follow_orders.assert_not_called() + self.assertEqual(trade.orders[0], result) + + self.m.reset_mock() + with self.subTest(base_currency="USDT"): + helper.make_order(self.m, 1, "BTC", base_currency="USDT") + + trade = self.m.trades.all.append.mock_calls[0][1][0] + self.assertEqual("BTC", trade.currency) + self.assertEqual("USDT", trade.base_currency) + + self.m.reset_mock() + with self.subTest(close_if_possible=True): + helper.make_order(self.m, 10, "ETH", close_if_possible=True) + + trade = self.m.trades.all.append.mock_calls[0][1][0] + self.assertEqual(True, trade.orders[0].close_if_possible) + + self.m.reset_mock() + with self.subTest(action="dispose"): + helper.make_order(self.m, 10, "ETH", action="dispose") + + trade = self.m.trades.all.append.mock_calls[0][1][0] + self.assertEqual(0, trade.value_to) + self.assertEqual(1, trade.value_from.value) + self.assertEqual("ETH", trade.currency) + self.assertEqual("BTC", trade.base_currency) + + self.m.reset_mock() + with self.subTest(compute_value="default"): + helper.make_order(self.m, 10, "ETH", action="dispose", + compute_value="bid") + + trade = self.m.trades.all.append.mock_calls[0][1][0] + self.assertEqual(D("0.9"), trade.value_from.value) + + def test_user_market(self): + with mock.patch("helper.main_fetch_markets") as main_fetch_markets,\ + mock.patch("helper.main_parse_config") as main_parse_config: + with self.subTest(debug=False): + main_parse_config.return_value = ["pg_config", "report_path"] + main_fetch_markets.return_value = [({"key": "market_config"},)] + m = helper.get_user_market("config_path.ini", 1) + + self.assertIsInstance(m, market.Market) + self.assertFalse(m.debug) + + with self.subTest(debug=True): + main_parse_config.return_value = ["pg_config", "report_path"] + main_fetch_markets.return_value = [({"key": "market_config"},)] + m = helper.get_user_market("config_path.ini", 1, debug=True) + + self.assertIsInstance(m, market.Market) + self.assertTrue(m.debug) + def test_main_store_report(self): file_open = mock.mock_open() with self.subTest(file=None), mock.patch("__main__.open", file_open): @@ -2563,7 +2750,7 @@ class HelperTest(WebMockTestCase): @mock.patch("portfolio.Portfolio.wait_for_recent") def test_main_process_market(self, wait, buy, sell): with self.subTest(before=False, after=False): - helper.main_process_market("user") + helper.main_process_market("user", None) wait.assert_not_called() buy.assert_not_called() @@ -2573,7 +2760,7 @@ class HelperTest(WebMockTestCase): wait.reset_mock() sell.reset_mock() with self.subTest(before=True, after=False): - helper.main_process_market("user", before=True) + helper.main_process_market("user", None, before=True) wait.assert_not_called() buy.assert_not_called() @@ -2583,7 +2770,7 @@ class HelperTest(WebMockTestCase): wait.reset_mock() sell.reset_mock() with self.subTest(before=False, after=True): - helper.main_process_market("user", after=True) + helper.main_process_market("user", None, after=True) wait.assert_called_once_with("user") buy.assert_called_once_with("user") @@ -2593,12 +2780,37 @@ class HelperTest(WebMockTestCase): wait.reset_mock() sell.reset_mock() with self.subTest(before=True, after=True): - helper.main_process_market("user", before=True, after=True) + helper.main_process_market("user", None, before=True, after=True) wait.assert_called_once_with("user") buy.assert_called_once_with("user") sell.assert_called_once_with("user") + buy.reset_mock() + wait.reset_mock() + sell.reset_mock() + with self.subTest(action="print_balances"),\ + mock.patch("helper.print_balances") as print_balances: + helper.main_process_market("user", "print_balances") + + buy.assert_not_called() + wait.assert_not_called() + sell.assert_not_called() + print_balances.assert_called_once_with("user") + + with self.subTest(action="print_orders"),\ + mock.patch("helper.print_orders") as print_orders: + helper.main_process_market("user", "print_orders") + + buy.assert_not_called() + wait.assert_not_called() + sell.assert_not_called() + print_orders.assert_called_once_with("user") + + with self.subTest(action="unknown"),\ + self.assertRaises(NotImplementedError): + helper.main_process_market("user", "unknown") + @mock.patch.object(helper, "psycopg2") def test_fetch_markets(self, psycopg2): connect_mock = mock.Mock() @@ -2608,12 +2820,23 @@ class HelperTest(WebMockTestCase): connect_mock.cursor.return_value = cursor_mock psycopg2.connect.return_value = connect_mock - rows = list(helper.main_fetch_markets({"foo": "bar"})) + with self.subTest(user=None): + rows = list(helper.main_fetch_markets({"foo": "bar"}, None)) + + psycopg2.connect.assert_called_once_with(foo="bar") + cursor_mock.execute.assert_called_once_with("SELECT config,user_id FROM market_configs") + + self.assertEqual(["row_1", "row_2"], rows) + + psycopg2.connect.reset_mock() + cursor_mock.execute.reset_mock() + with self.subTest(user=1): + rows = list(helper.main_fetch_markets({"foo": "bar"}, 1)) - psycopg2.connect.assert_called_once_with(foo="bar") - cursor_mock.execute.assert_called_once_with("SELECT config,user_id FROM market_configs") + psycopg2.connect.assert_called_once_with(foo="bar") + cursor_mock.execute.assert_called_once_with("SELECT config,user_id FROM market_configs WHERE user_id = %s", 1) - self.assertEqual(["row_1", "row_2"], rows) + self.assertEqual(["row_1", "row_2"], rows) @mock.patch.object(helper.sys, "exit") def test_main_parse_args(self, exit): @@ -2703,6 +2926,7 @@ class HelperTest(WebMockTestCase): helper.print_balances(self.m) + self.m.report.log_stage.assert_called_once_with("print_balances") self.m.balances.fetch_balances.assert_called_with() self.m.report.print_log.assert_has_calls([ mock.call("total:"),