X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=test.py;h=feac62f7be7755cebac97c4ccdd4774285a3f457;hb=1f117ac79e10c3c9728d3b267d134dec2a165603;hp=0bfa2b7b6140d1c3f7e9320441347afce7cf95af;hpb=c5a7f2863f5c041ff906b2407a74971e2178a729;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FCryptoportfolio%2FTrader.git diff --git a/test.py b/test.py index 0bfa2b7..feac62f 100644 --- a/test.py +++ b/test.py @@ -7,7 +7,7 @@ from unittest import mock import requests import requests_mock from io import StringIO -import portfolio, helper, market +import portfolio, market, main limits = ["acceptance", "unit"] for test_type in limits: @@ -907,7 +907,163 @@ class MarketTest(WebMockTestCase): self.ccxt.transfer_balance.assert_any_call("BTC", 3, "exchange", "margin") self.ccxt.transfer_balance.assert_any_call("USDT", 100, "exchange", "margin") self.ccxt.transfer_balance.assert_any_call("ETC", 5, "margin", "exchange") - + + def test_store_report(self): + + file_open = mock.mock_open() + with self.subTest(file=None), mock.patch("market.open", file_open): + m = market.Market(self.ccxt, user_id=1) + m.store_report() + file_open.assert_not_called() + + file_open = mock.mock_open() + m = market.Market(self.ccxt, report_path="present", user_id=1) + with self.subTest(file="present"),\ + mock.patch("market.open", file_open),\ + mock.patch.object(m, "report") as report,\ + mock.patch.object(market, "datetime") as time_mock: + + time_mock.now.return_value = datetime.datetime(2018, 2, 25) + report.to_json.return_value = "json_content" + + m.store_report() + + file_open.assert_any_call("present/2018-02-25T00:00:00_1.json", "w") + file_open().write.assert_called_once_with("json_content") + m.report.to_json.assert_called_once_with() + + m = market.Market(self.ccxt, report_path="error", user_id=1) + with self.subTest(file="error"),\ + mock.patch("market.open") as file_open,\ + mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock: + file_open.side_effect = FileNotFoundError + + m.store_report() + + self.assertRegex(stdout_mock.getvalue(), "impossible to store report file: FileNotFoundError;") + + def test_print_orders(self): + m = market.Market(self.ccxt) + with mock.patch.object(m.report, "log_stage") as log_stage,\ + mock.patch.object(m.balances, "fetch_balances") as fetch_balances,\ + mock.patch.object(m, "prepare_trades") as prepare_trades,\ + mock.patch.object(m.trades, "prepare_orders") as prepare_orders: + m.print_orders() + + log_stage.assert_called_with("print_orders") + fetch_balances.assert_called_with(tag="print_orders") + prepare_trades.assert_called_with(base_currency="BTC", + compute_value="average") + prepare_orders.assert_called_with(compute_value="average") + + def test_print_balances(self): + m = market.Market(self.ccxt) + + with mock.patch.object(m.balances, "in_currency") as in_currency,\ + mock.patch.object(m.report, "log_stage") as log_stage,\ + mock.patch.object(m.balances, "fetch_balances") as fetch_balances,\ + mock.patch.object(m.report, "print_log") as print_log: + + in_currency.return_value = { + "BTC": portfolio.Amount("BTC", "0.65"), + "ETH": portfolio.Amount("BTC", "0.3"), + } + + m.print_balances() + + log_stage.assert_called_once_with("print_balances") + fetch_balances.assert_called_with() + print_log.assert_has_calls([ + mock.call("total:"), + mock.call(portfolio.Amount("BTC", "0.95")), + ]) + + @mock.patch("market.Processor.process") + @mock.patch("market.ReportStore.log_error") + @mock.patch("market.Market.store_report") + def test_process(self, store_report, log_error, process): + m = market.Market(self.ccxt) + with self.subTest(before=False, after=False): + m.process(None) + + process.assert_not_called() + store_report.assert_called_once() + log_error.assert_not_called() + + process.reset_mock() + log_error.reset_mock() + store_report.reset_mock() + with self.subTest(before=True, after=False): + m.process(None, before=True) + + process.assert_called_once_with("sell_all", steps="before") + store_report.assert_called_once() + log_error.assert_not_called() + + process.reset_mock() + log_error.reset_mock() + store_report.reset_mock() + with self.subTest(before=False, after=True): + m.process(None, after=True) + + process.assert_called_once_with("sell_all", steps="after") + store_report.assert_called_once() + log_error.assert_not_called() + + process.reset_mock() + log_error.reset_mock() + store_report.reset_mock() + with self.subTest(before=True, after=True): + m.process(None, before=True, after=True) + + process.assert_has_calls([ + mock.call("sell_all", steps="before"), + mock.call("sell_all", steps="after"), + ]) + store_report.assert_called_once() + log_error.assert_not_called() + + process.reset_mock() + log_error.reset_mock() + store_report.reset_mock() + with self.subTest(action="print_balances"),\ + mock.patch.object(m, "print_balances") as print_balances: + m.process(["print_balances"]) + + process.assert_not_called() + log_error.assert_not_called() + store_report.assert_called_once() + print_balances.assert_called_once_with() + + log_error.reset_mock() + store_report.reset_mock() + with self.subTest(action="print_orders"),\ + mock.patch.object(m, "print_orders") as print_orders,\ + mock.patch.object(m, "print_balances") as print_balances: + m.process(["print_orders", "print_balances"]) + + process.assert_not_called() + log_error.assert_not_called() + store_report.assert_called_once() + print_orders.assert_called_once_with() + print_balances.assert_called_once_with() + + log_error.reset_mock() + store_report.reset_mock() + with self.subTest(action="unknown"): + m.process(["unknown"]) + log_error.assert_called_once_with("market_process", message="Unknown action unknown") + store_report.assert_called_once() + + log_error.reset_mock() + store_report.reset_mock() + with self.subTest(unhandled_exception=True): + process.side_effect = Exception("bouh") + + m.process(None, before=True) + log_error.assert_called_with("market_process", exception=mock.ANY) + store_report.assert_called_once() + @unittest.skipUnless("unit" in limits, "Unit skipped") class TradeStoreTest(WebMockTestCase): def test_compute_trades(self): @@ -1746,25 +1902,46 @@ class TradeTest(WebMockTestCase): trade.orders.append(order_mock1) trade.orders.append(order_mock2) - trade.print_with_order() + with mock.patch.object(trade, "filled_amount") as filled: + filled.return_value = portfolio.Amount("BTC", "0.1") + + trade.print_with_order() + + self.m.report.print_log.assert_called() + calls = self.m.report.print_log.mock_calls + self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire)", str(calls[0][1][0])) + self.assertEqual("\tMock 1", str(calls[1][1][0])) + self.assertEqual("\tMock 2", str(calls[2][1][0])) + self.assertEqual("\t\tMouvement 1", str(calls[3][1][0])) + self.assertEqual("\t\tMouvement 2", str(calls[4][1][0])) + + self.m.report.print_log.reset_mock() - self.m.report.print_log.assert_called() - calls = self.m.report.print_log.mock_calls - self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire)", str(calls[0][1][0])) - self.assertEqual("\tMock 1", str(calls[1][1][0])) - self.assertEqual("\tMock 2", str(calls[2][1][0])) - self.assertEqual("\t\tMouvement 1", str(calls[3][1][0])) - self.assertEqual("\t\tMouvement 2", str(calls[4][1][0])) + filled.return_value = portfolio.Amount("BTC", "0.5") + trade.print_with_order() + calls = self.m.report.print_log.mock_calls + self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire ✔)", str(calls[0][1][0])) + + self.m.report.print_log.reset_mock() + + filled.return_value = portfolio.Amount("BTC", "0.1") + trade.closed = True + trade.print_with_order() + calls = self.m.report.print_log.mock_calls + self.assertEqual("Trade(0.50000000 BTC [10.00000000 ETH] -> 1.00000000 BTC in ETH, acquire ❌)", str(calls[0][1][0])) def test_close(self): value_from = portfolio.Amount("BTC", "0.5") value_from.linked_to = portfolio.Amount("ETH", "10.0") value_to = portfolio.Amount("BTC", "1.0") trade = portfolio.Trade(value_from, value_to, "ETH", self.m) + order1 = mock.Mock() + trade.orders.append(order1) trade.close() self.assertEqual(True, trade.closed) + order1.cancel.assert_called_once_with() def test_pending(self): value_from = portfolio.Amount("BTC", "0.5") @@ -1888,27 +2065,57 @@ class OrderTest(WebMockTestCase): @mock.patch.object(portfolio.Order, "fetch") def test_cancel(self, fetch): - self.m.debug = True - order = portfolio.Order("buy", portfolio.Amount("ETH", 10), - D("0.1"), "BTC", "long", self.m, "trade") - order.status = "open" + with self.subTest(debug=True): + self.m.debug = True + order = portfolio.Order("buy", portfolio.Amount("ETH", 10), + D("0.1"), "BTC", "long", self.m, "trade") + order.status = "open" - order.cancel() - self.m.ccxt.cancel_order.assert_not_called() - self.m.report.log_debug_action.assert_called_once() - self.m.report.log_debug_action.reset_mock() - self.assertEqual("canceled", order.status) + order.cancel() + self.m.ccxt.cancel_order.assert_not_called() + self.m.report.log_debug_action.assert_called_once() + self.m.report.log_debug_action.reset_mock() + self.assertEqual("canceled", order.status) - self.m.debug = False - order = portfolio.Order("buy", portfolio.Amount("ETH", 10), - D("0.1"), "BTC", "long", self.m, "trade") - order.status = "open" - order.id = 42 + with self.subTest(desc="Nominal case"): + self.m.debug = False + order = portfolio.Order("buy", portfolio.Amount("ETH", 10), + D("0.1"), "BTC", "long", self.m, "trade") + order.status = "open" + order.id = 42 + + order.cancel() + self.m.ccxt.cancel_order.assert_called_with(42) + fetch.assert_called_once_with() + self.m.report.log_debug_action.assert_not_called() + + with self.subTest(exception=True): + self.m.ccxt.cancel_order.side_effect = portfolio.OrderNotFound + order = portfolio.Order("buy", portfolio.Amount("ETH", 10), + D("0.1"), "BTC", "long", self.m, "trade") + order.status = "open" + order.id = 42 + order.cancel() + self.m.ccxt.cancel_order.assert_called_with(42) + self.m.report.log_error.assert_called_once() + + self.m.reset_mock() + with self.subTest(id=None): + self.m.ccxt.cancel_order.side_effect = portfolio.OrderNotFound + order = portfolio.Order("buy", portfolio.Amount("ETH", 10), + D("0.1"), "BTC", "long", self.m, "trade") + order.status = "open" + order.cancel() + self.m.ccxt.cancel_order.assert_not_called() - order.cancel() - self.m.ccxt.cancel_order.assert_called_with(42) - fetch.assert_called_once_with() - self.m.report.log_debug_action.assert_not_called() + self.m.reset_mock() + with self.subTest(open=False): + self.m.ccxt.cancel_order.side_effect = portfolio.OrderNotFound + order = portfolio.Order("buy", portfolio.Amount("ETH", 10), + D("0.1"), "BTC", "long", self.m, "trade") + order.status = "closed" + order.cancel() + self.m.ccxt.cancel_order.assert_not_called() def test_dust_amount_remaining(self): order = portfolio.Order("buy", portfolio.Amount("ETH", 10), @@ -2050,7 +2257,7 @@ class OrderTest(WebMockTestCase): } order.fetch() - self.m.ccxt.fetch_order.assert_called_once_with(45, symbol="ETH") + self.m.ccxt.fetch_order.assert_called_once_with(45) fetch_mouvements.assert_called_once() self.assertEqual("foo", order.status) self.assertEqual("timestamp", order.timestamp) @@ -2701,7 +2908,7 @@ class ReportStoreTest(WebMockTestCase): }) @unittest.skipUnless("unit" in limits, "Unit skipped") -class HelperTest(WebMockTestCase): +class MainTest(WebMockTestCase): def test_make_order(self): self.m.get_ticker.return_value = { "inverted": False, @@ -2711,7 +2918,7 @@ class HelperTest(WebMockTestCase): } with self.subTest(description="nominal case"): - helper.make_order(self.m, 10, "ETH") + main.make_order(self.m, 10, "ETH") self.m.report.log_stage.assert_has_calls([ mock.call("make_order_begin"), @@ -2736,7 +2943,7 @@ class HelperTest(WebMockTestCase): self.m.reset_mock() with self.subTest(compute_value="default"): - helper.make_order(self.m, 10, "ETH", action="dispose", + main.make_order(self.m, 10, "ETH", action="dispose", compute_value="ask") trade = self.m.trades.all.append.mock_calls[0][1][0] @@ -2745,7 +2952,7 @@ class HelperTest(WebMockTestCase): self.m.reset_mock() with self.subTest(follow=False): - result = helper.make_order(self.m, 10, "ETH", follow=False) + result = main.make_order(self.m, 10, "ETH", follow=False) self.m.report.log_stage.assert_has_calls([ mock.call("make_order_begin"), @@ -2765,7 +2972,7 @@ class HelperTest(WebMockTestCase): self.m.reset_mock() with self.subTest(base_currency="USDT"): - helper.make_order(self.m, 1, "BTC", base_currency="USDT") + main.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) @@ -2773,14 +2980,14 @@ class HelperTest(WebMockTestCase): self.m.reset_mock() with self.subTest(close_if_possible=True): - helper.make_order(self.m, 10, "ETH", close_if_possible=True) + main.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") + main.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) @@ -2790,19 +2997,19 @@ class HelperTest(WebMockTestCase): self.m.reset_mock() with self.subTest(compute_value="default"): - helper.make_order(self.m, 10, "ETH", action="dispose", + main.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: + def test_get_user_market(self): + with mock.patch("main.fetch_markets") as main_fetch_markets,\ + mock.patch("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) + m = main.get_user_market("config_path.ini", 1) self.assertIsInstance(m, market.Market) self.assertFalse(m.debug) @@ -2810,141 +3017,56 @@ class HelperTest(WebMockTestCase): 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) + m = main.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): - helper.main_store_report(None, 1, self.m) - file_open.assert_not_called() - - file_open = mock.mock_open() - with self.subTest(file="present"), mock.patch("helper.open", file_open),\ - mock.patch.object(helper, "datetime") as time_mock: - time_mock.now.return_value = datetime.datetime(2018, 2, 25) - self.m.report.to_json.return_value = "json_content" - - helper.main_store_report("present", 1, self.m) - - file_open.assert_any_call("present/2018-02-25T00:00:00_1.json", "w") - file_open().write.assert_called_once_with("json_content") - self.m.report.to_json.assert_called_once_with() - - with self.subTest(file="error"),\ - mock.patch("helper.open") as file_open,\ + def test_main(self): + with mock.patch("main.parse_args") as parse_args,\ + mock.patch("main.parse_config") as parse_config,\ + mock.patch("main.fetch_markets") as fetch_markets,\ + mock.patch("market.Market") as market_mock,\ mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock: - file_open.side_effect = FileNotFoundError - - helper.main_store_report("error", 1, self.m) - - self.assertRegex(stdout_mock.getvalue(), "impossible to store report file: FileNotFoundError;") - - @mock.patch("helper.Processor.process") - def test_main_process_market(self, process): - with self.subTest(before=False, after=False): - m = mock.Mock() - helper.main_process_market(m, None) - process.assert_not_called() + args_mock = mock.Mock() + args_mock.action = "action" + args_mock.config = "config" + args_mock.user = "user" + args_mock.debug = "debug" + args_mock.before = "before" + args_mock.after = "after" + parse_args.return_value = args_mock - process.reset_mock() - with self.subTest(before=True, after=False): - helper.main_process_market(m, None, before=True) + parse_config.return_value = ["pg_config", "report_path"] - process.assert_called_once_with("sell_all", steps="before") + fetch_markets.return_value = [["config1", 1], ["config2", 2]] - process.reset_mock() - with self.subTest(before=False, after=True): - helper.main_process_market(m, None, after=True) - - process.assert_called_once_with("sell_all", steps="after") + main.main(["Foo", "Bar"]) - process.reset_mock() - with self.subTest(before=True, after=True): - helper.main_process_market(m, None, before=True, after=True) + parse_args.assert_called_with(["Foo", "Bar"]) + parse_config.assert_called_with("config") + fetch_markets.assert_called_with("pg_config", "user") - process.assert_has_calls([ - mock.call("sell_all", steps="before"), - mock.call("sell_all", steps="after"), + self.assertEqual(2, market_mock.from_config.call_count) + market_mock.from_config.assert_has_calls([ + mock.call("config1", debug="debug", user_id=1, report_path="report_path"), + mock.call().process("action", before="before", after="after"), + mock.call("config2", debug="debug", user_id=2, report_path="report_path"), + mock.call().process("action", before="before", after="after") ]) - process.reset_mock() - with self.subTest(action="print_balances"),\ - mock.patch("helper.print_balances") as print_balances: - helper.main_process_market("user", ["print_balances"]) - - process.assert_not_called() - print_balances.assert_called_once_with("user") - - with self.subTest(action="print_orders"),\ - mock.patch("helper.print_orders") as print_orders,\ - mock.patch("helper.print_balances") as print_balances: - helper.main_process_market("user", ["print_orders", "print_balances"]) - - process.assert_not_called() - print_orders.assert_called_once_with("user") - print_balances.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() - cursor_mock = mock.MagicMock() - cursor_mock.__iter__.return_value = ["row_1", "row_2"] - - connect_mock.cursor.return_value = cursor_mock - psycopg2.connect.return_value = connect_mock - - 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)) + self.assertEqual("", stdout_mock.getvalue()) - 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) + with self.subTest(exception=True): + market_mock.from_config.side_effect = Exception("boo") + main.main(["Foo", "Bar"]) + self.assertEqual("Exception: boo\nException: boo\n", stdout_mock.getvalue()) - @mock.patch.object(helper.sys, "exit") - def test_main_parse_args(self, exit): - with self.subTest(config="config.ini"): - args = helper.main_parse_args([]) - self.assertEqual("config.ini", args.config) - self.assertFalse(args.before) - self.assertFalse(args.after) - self.assertFalse(args.debug) - - args = helper.main_parse_args(["--before", "--after", "--debug"]) - self.assertTrue(args.before) - self.assertTrue(args.after) - self.assertTrue(args.debug) - - exit.assert_not_called() - - with self.subTest(config="inexistant"),\ - mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock: - args = helper.main_parse_args(["--config", "foo.bar"]) - exit.assert_called_once_with(1) - self.assertEqual("no config file found, exiting\n", stdout_mock.getvalue()) - - @mock.patch.object(helper.sys, "exit") - @mock.patch("helper.configparser") - @mock.patch("helper.os") - def test_main_parse_config(self, os, configparser, exit): + @mock.patch.object(main.sys, "exit") + @mock.patch("main.configparser") + @mock.patch("main.os") + def test_parse_config(self, os, configparser, exit): with self.subTest(pg_config=True, report_path=None): config_mock = mock.MagicMock() configparser.ConfigParser.return_value = config_mock @@ -2954,7 +3076,7 @@ class HelperTest(WebMockTestCase): config_mock.__contains__.side_effect = config config_mock.__getitem__.return_value = "pg_config" - result = helper.main_parse_config("configfile") + result = main.parse_config("configfile") config_mock.read.assert_called_with("configfile") @@ -2972,7 +3094,7 @@ class HelperTest(WebMockTestCase): ] os.path.exists.return_value = False - result = helper.main_parse_config("configfile") + result = main.parse_config("configfile") config_mock.read.assert_called_with("configfile") self.assertEqual(["pg_config", "report_path"], result) @@ -2983,46 +3105,71 @@ class HelperTest(WebMockTestCase): mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock: config_mock = mock.MagicMock() configparser.ConfigParser.return_value = config_mock - result = helper.main_parse_config("configfile") + result = main.parse_config("configfile") config_mock.read.assert_called_with("configfile") exit.assert_called_once_with(1) self.assertEqual("no configuration for postgresql in config file\n", stdout_mock.getvalue()) + @mock.patch.object(main.sys, "exit") + def test_parse_args(self, exit): + with self.subTest(config="config.ini"): + args = main.parse_args([]) + self.assertEqual("config.ini", args.config) + self.assertFalse(args.before) + self.assertFalse(args.after) + self.assertFalse(args.debug) - def test_print_orders(self): - helper.print_orders(self.m) + args = main.parse_args(["--before", "--after", "--debug"]) + self.assertTrue(args.before) + self.assertTrue(args.after) + self.assertTrue(args.debug) - self.m.report.log_stage.assert_called_with("print_orders") - self.m.balances.fetch_balances.assert_called_with(tag="print_orders") - self.m.prepare_trades.assert_called_with(base_currency="BTC", - compute_value="average") - self.m.trades.prepare_orders.assert_called_with(compute_value="average") + exit.assert_not_called() + + with self.subTest(config="inexistant"),\ + mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock: + args = main.parse_args(["--config", "foo.bar"]) + exit.assert_called_once_with(1) + self.assertEqual("no config file found, exiting\n", stdout_mock.getvalue()) + + @mock.patch.object(main, "psycopg2") + def test_fetch_markets(self, psycopg2): + connect_mock = mock.Mock() + cursor_mock = mock.MagicMock() + cursor_mock.__iter__.return_value = ["row_1", "row_2"] + + connect_mock.cursor.return_value = cursor_mock + psycopg2.connect.return_value = connect_mock + + with self.subTest(user=None): + rows = list(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(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 WHERE user_id = %s", 1) + + self.assertEqual(["row_1", "row_2"], rows) - def test_print_balances(self): - self.m.balances.in_currency.return_value = { - "BTC": portfolio.Amount("BTC", "0.65"), - "ETH": portfolio.Amount("BTC", "0.3"), - } - - 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:"), - mock.call(portfolio.Amount("BTC", "0.95")), - ]) @unittest.skipUnless("unit" in limits, "Unit skipped") class ProcessorTest(WebMockTestCase): def test_values(self): - processor = helper.Processor(self.m) + processor = market.Processor(self.m) self.assertEqual(self.m, processor.market) def test_run_action(self): - processor = helper.Processor(self.m) + processor = market.Processor(self.m) with mock.patch.object(processor, "parse_args") as parse_args: method_mock = mock.Mock() @@ -3039,7 +3186,7 @@ class ProcessorTest(WebMockTestCase): method_mock.assert_called_with(self.m, foo="bar") def test_select_step(self): - processor = helper.Processor(self.m) + processor = market.Processor(self.m) scenario = processor.scenarios["sell_all"] @@ -3052,9 +3199,9 @@ class ProcessorTest(WebMockTestCase): with self.assertRaises(TypeError): processor.select_steps(scenario, ["wait"]) - @mock.patch("helper.Processor.process_step") + @mock.patch("market.Processor.process_step") def test_process(self, process_step): - processor = helper.Processor(self.m) + processor = market.Processor(self.m) processor.process("sell_all", foo="bar") self.assertEqual(3, process_step.call_count) @@ -3075,7 +3222,7 @@ class ProcessorTest(WebMockTestCase): ccxt = mock.Mock(spec=market.ccxt.poloniexE) m = market.Market(ccxt) - processor = helper.Processor(m) + processor = market.Processor(m) method, arguments = processor.method_arguments("wait_for_recent") self.assertEqual(portfolio.Portfolio.wait_for_recent, method) @@ -3101,7 +3248,7 @@ class ProcessorTest(WebMockTestCase): self.assertEqual(m.trades.close_trades, method) def test_process_step(self): - processor = helper.Processor(self.m) + processor = market.Processor(self.m) with mock.patch.object(processor, "run_action") as run_action: step = processor.scenarios["sell_needed"][1] @@ -3135,7 +3282,7 @@ class ProcessorTest(WebMockTestCase): self.m.balances.fetch_balances.assert_not_called() def test_parse_args(self): - processor = helper.Processor(self.m) + processor = market.Processor(self.m) with mock.patch.object(processor, "method_arguments") as method_arguments: method_mock = mock.Mock()