+@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):
+ 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,\
+ 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.process_sell_all__1_all_sell")
+ @mock.patch("helper.process_sell_all__2_wait")
+ @mock.patch("helper.process_sell_all__3_all_buy")
+ def test_main_process_market(self, buy, wait, sell):
+ with self.subTest(before=False, after=False):
+ helper.main_process_market("user", None)
+
+ wait.assert_not_called()
+ buy.assert_not_called()
+ sell.assert_not_called()
+
+ buy.reset_mock()
+ wait.reset_mock()
+ sell.reset_mock()
+ with self.subTest(before=True, after=False):
+ helper.main_process_market("user", None, before=True)
+
+ wait.assert_not_called()
+ buy.assert_not_called()
+ sell.assert_called_once_with("user")
+
+ buy.reset_mock()
+ wait.reset_mock()
+ sell.reset_mock()
+ with self.subTest(before=False, after=True):
+ helper.main_process_market("user", None, after=True)
+
+ wait.assert_called_once_with("user")
+ buy.assert_called_once_with("user")
+ sell.assert_not_called()
+
+ buy.reset_mock()
+ wait.reset_mock()
+ sell.reset_mock()
+ with self.subTest(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,\
+ mock.patch("helper.print_balances") as print_balances:
+ helper.main_process_market("user", ["print_orders", "print_balances"])
+
+ buy.assert_not_called()
+ wait.assert_not_called()
+ sell.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))
+
+ 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)
+
+ @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):
+ with self.subTest(pg_config=True, report_path=None):
+ config_mock = mock.MagicMock()
+ configparser.ConfigParser.return_value = config_mock
+ def config(element):
+ return element == "postgresql"
+
+ config_mock.__contains__.side_effect = config
+ config_mock.__getitem__.return_value = "pg_config"
+
+ result = helper.main_parse_config("configfile")
+
+ config_mock.read.assert_called_with("configfile")
+
+ self.assertEqual(["pg_config", None], result)
+
+ with self.subTest(pg_config=True, report_path="present"):
+ config_mock = mock.MagicMock()
+ configparser.ConfigParser.return_value = config_mock
+
+ config_mock.__contains__.return_value = True
+ config_mock.__getitem__.side_effect = [
+ {"report_path": "report_path"},
+ {"report_path": "report_path"},
+ "pg_config",
+ ]
+
+ os.path.exists.return_value = False
+ result = helper.main_parse_config("configfile")
+
+ config_mock.read.assert_called_with("configfile")
+ self.assertEqual(["pg_config", "report_path"], result)
+ os.path.exists.assert_called_once_with("report_path")
+ os.makedirs.assert_called_once_with("report_path")
+
+ with self.subTest(pg_config=False),\
+ 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")
+
+ 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())
+
+
+ def test_print_orders(self):
+ helper.print_orders(self.m)
+
+ 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")
+
+ 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")),
+ ])
+
+ def test_process_sell_needed__1_sell(self):
+ helper.process_sell_needed__1_sell(self.m)
+
+ self.m.balances.fetch_balances.assert_has_calls([
+ mock.call(tag="process_sell_needed__1_sell_begin"),
+ mock.call(tag="process_sell_needed__1_sell_end"),
+ ])
+ self.m.prepare_trades.assert_called_with(base_currency="BTC",
+ liquidity="medium")
+ self.m.trades.prepare_orders.assert_called_with(compute_value="average",
+ only="dispose")
+ self.m.trades.run_orders.assert_called()
+ self.m.follow_orders.assert_called()
+ self.m.report.log_stage.assert_has_calls([
+ mock.call("process_sell_needed__1_sell_begin"),
+ mock.call("process_sell_needed__1_sell_end")
+ ])
+
+ def test_process_sell_needed__2_buy(self):
+ helper.process_sell_needed__2_buy(self.m)
+
+ self.m.balances.fetch_balances.assert_has_calls([
+ mock.call(tag="process_sell_needed__2_buy_begin"),
+ mock.call(tag="process_sell_needed__2_buy_end"),
+ ])
+ self.m.prepare_trades.assert_called_with(base_currency="BTC",
+ liquidity="medium", only="acquire")
+ self.m.trades.prepare_orders.assert_called_with(compute_value="average",
+ only="acquire")
+ self.m.move_balances.assert_called_with()
+ self.m.trades.run_orders.assert_called()
+ self.m.follow_orders.assert_called()
+ self.m.report.log_stage.assert_has_calls([
+ mock.call("process_sell_needed__2_buy_begin"),
+ mock.call("process_sell_needed__2_buy_end")
+ ])
+
+ def test_process_sell_all__1_sell(self):
+ helper.process_sell_all__1_all_sell(self.m)
+
+ self.m.balances.fetch_balances.assert_has_calls([
+ mock.call(tag="process_sell_all__1_all_sell_begin"),
+ mock.call(tag="process_sell_all__1_all_sell_end"),
+ ])
+ self.m.prepare_trades_to_sell_all.assert_called_with(base_currency="BTC")
+ self.m.trades.prepare_orders.assert_called_with(compute_value="average")
+ self.m.trades.run_orders.assert_called()
+ self.m.follow_orders.assert_called()
+ self.m.report.log_stage.assert_has_calls([
+ mock.call("process_sell_all__1_all_sell_begin"),
+ mock.call("process_sell_all__1_all_sell_end")
+ ])
+
+ @mock.patch("portfolio.Portfolio.wait_for_recent")
+ def test_process_sell_all__2_wait(self, wait):
+ helper.process_sell_all__2_wait(self.m)
+
+ wait.assert_called_once_with(self.m)
+ self.m.report.log_stage.assert_has_calls([
+ mock.call("process_sell_all__2_wait_begin"),
+ mock.call("process_sell_all__2_wait_end")
+ ])
+
+ def test_process_sell_all__3_all_buy(self):
+ helper.process_sell_all__3_all_buy(self.m)
+
+ self.m.balances.fetch_balances.assert_has_calls([
+ mock.call(tag="process_sell_all__3_all_buy_begin"),
+ mock.call(tag="process_sell_all__3_all_buy_end"),
+ ])
+ self.m.prepare_trades.assert_called_with(base_currency="BTC",
+ liquidity="medium")
+ self.m.trades.prepare_orders.assert_called_with(compute_value="average")
+ self.m.move_balances.assert_called_with()
+ self.m.trades.run_orders.assert_called()
+ self.m.follow_orders.assert_called()
+ self.m.report.log_stage.assert_has_calls([
+ mock.call("process_sell_all__3_all_buy_begin"),
+ mock.call("process_sell_all__3_all_buy_end")
+ ])
+