+@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.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()
+
+ process.reset_mock()
+ with self.subTest(before=True, after=False):
+ helper.main_process_market(m, None, before=True)
+
+ process.assert_called_once_with("sell_all", steps="before")
+
+ 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")
+
+ process.reset_mock()
+ with self.subTest(before=True, after=True):
+ helper.main_process_market(m, None, before=True, after=True)
+
+ process.assert_has_calls([
+ mock.call("sell_all", steps="before"),
+ mock.call("sell_all", steps="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))
+
+ 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")),
+ ])
+
+@unittest.skipUnless("unit" in limits, "Unit skipped")
+class ProcessorTest(WebMockTestCase):
+ def test_values(self):
+ processor = helper.Processor(self.m)
+
+ self.assertEqual(self.m, processor.market)
+
+ def test_run_action(self):
+ processor = helper.Processor(self.m)
+
+ with mock.patch.object(processor, "parse_args") as parse_args:
+ method_mock = mock.Mock()
+ parse_args.return_value = [method_mock, { "foo": "bar" }]
+
+ processor.run_action("foo", "bar", "baz")
+
+ parse_args.assert_called_with("foo", "bar", "baz")
+
+ method_mock.assert_called_with(foo="bar")
+
+ processor.run_action("wait_for_recent", "bar", "baz")
+
+ method_mock.assert_called_with(self.m, foo="bar")
+
+ def test_select_step(self):
+ processor = helper.Processor(self.m)
+
+ scenario = processor.scenarios["sell_all"]
+
+ self.assertEqual(scenario, processor.select_steps(scenario, "all"))
+ self.assertEqual(["all_sell"], list(map(lambda x: x["name"], processor.select_steps(scenario, "before"))))
+ self.assertEqual(["wait", "all_buy"], list(map(lambda x: x["name"], processor.select_steps(scenario, "after"))))
+ self.assertEqual(["wait"], list(map(lambda x: x["name"], processor.select_steps(scenario, 2))))
+ self.assertEqual(["wait"], list(map(lambda x: x["name"], processor.select_steps(scenario, "wait"))))
+
+ with self.assertRaises(TypeError):
+ processor.select_steps(scenario, ["wait"])
+
+ @mock.patch("helper.Processor.process_step")
+ def test_process(self, process_step):
+ processor = helper.Processor(self.m)
+
+ processor.process("sell_all", foo="bar")
+ self.assertEqual(3, process_step.call_count)
+
+ steps = list(map(lambda x: x[1][1]["name"], process_step.mock_calls))
+ scenario_names = list(map(lambda x: x[1][0], process_step.mock_calls))
+ kwargs = list(map(lambda x: x[1][2], process_step.mock_calls))
+ self.assertEqual(["all_sell", "wait", "all_buy"], steps)
+ self.assertEqual(["sell_all", "sell_all", "sell_all"], scenario_names)
+ self.assertEqual([{"foo":"bar"}, {"foo":"bar"}, {"foo":"bar"}], kwargs)
+
+ process_step.reset_mock()
+
+ processor.process("sell_needed", steps=["before", "after"])
+ self.assertEqual(3, process_step.call_count)
+
+ def test_method_arguments(self):
+ ccxt = mock.Mock(spec=market.ccxt.poloniexE)
+ m = market.Market(ccxt)
+
+ processor = helper.Processor(m)
+
+ method, arguments = processor.method_arguments("wait_for_recent")
+ self.assertEqual(portfolio.Portfolio.wait_for_recent, method)
+ self.assertEqual(["delta"], arguments)
+
+ method, arguments = processor.method_arguments("prepare_trades")
+ self.assertEqual(m.prepare_trades, method)
+ self.assertEqual(['base_currency', 'liquidity', 'compute_value', 'repartition', 'only'], arguments)
+
+ method, arguments = processor.method_arguments("prepare_orders")
+ self.assertEqual(m.trades.prepare_orders, method)
+
+ method, arguments = processor.method_arguments("move_balances")
+ self.assertEqual(m.move_balances, method)
+
+ method, arguments = processor.method_arguments("run_orders")
+ self.assertEqual(m.trades.run_orders, method)
+
+ method, arguments = processor.method_arguments("follow_orders")
+ self.assertEqual(m.follow_orders, method)
+
+ method, arguments = processor.method_arguments("close_trades")
+ self.assertEqual(m.trades.close_trades, method)
+
+ def test_process_step(self):
+ processor = helper.Processor(self.m)
+
+ with mock.patch.object(processor, "run_action") as run_action:
+ step = processor.scenarios["sell_needed"][1]
+
+ processor.process_step("foo", step, {"foo":"bar"})
+
+ self.m.report.log_stage.assert_has_calls([
+ mock.call("process_foo__1_sell_begin"),
+ mock.call("process_foo__1_sell_end"),
+ ])
+ self.m.balances.fetch_balances.assert_has_calls([
+ mock.call(tag="process_foo__1_sell_begin"),
+ mock.call(tag="process_foo__1_sell_end"),
+ ])
+
+ self.assertEqual(5, run_action.call_count)
+
+ run_action.assert_has_calls([
+ mock.call('prepare_trades', {}, {'foo': 'bar'}),
+ mock.call('prepare_orders', {'only': 'dispose', 'compute_value': 'average'}, {'foo': 'bar'}),
+ mock.call('run_orders', {}, {'foo': 'bar'}),
+ mock.call('follow_orders', {}, {'foo': 'bar'}),
+ mock.call('close_trades', {}, {'foo': 'bar'}),
+ ])
+
+ self.m.reset_mock()
+ with mock.patch.object(processor, "run_action") as run_action:
+ step = processor.scenarios["sell_needed"][0]
+
+ processor.process_step("foo", step, {"foo":"bar"})
+ self.m.balances.fetch_balances.assert_not_called()
+
+ def test_parse_args(self):
+ processor = helper.Processor(self.m)
+
+ with mock.patch.object(processor, "method_arguments") as method_arguments:
+ method_mock = mock.Mock()
+ method_arguments.return_value = [
+ method_mock,
+ ["foo2", "foo"]
+ ]
+ method, args = processor.parse_args("action", {"foo": "bar", "foo2": "bar"}, {"foo": "bar2", "bla": "bla"})
+
+ self.assertEqual(method_mock, method)
+ self.assertEqual({"foo": "bar2", "foo2": "bar"}, args)
+
+ with mock.patch.object(processor, "method_arguments") as method_arguments:
+ method_mock = mock.Mock()
+ method_arguments.return_value = [
+ method_mock,
+ ["repartition"]
+ ]
+ method, args = processor.parse_args("action", {"repartition": { "base_currency": 1 }}, {})
+
+ self.assertEqual(1, len(args["repartition"]))
+ self.assertIn("BTC", args["repartition"])
+
+ with mock.patch.object(processor, "method_arguments") as method_arguments:
+ method_mock = mock.Mock()
+ method_arguments.return_value = [
+ method_mock,
+ ["repartition", "base_currency"]
+ ]
+ method, args = processor.parse_args("action", {"repartition": { "base_currency": 1 }}, {"base_currency": "USDT"})
+
+ self.assertEqual(1, len(args["repartition"]))
+ self.assertIn("USDT", args["repartition"])
+
+ with mock.patch.object(processor, "method_arguments") as method_arguments:
+ method_mock = mock.Mock()
+ method_arguments.return_value = [
+ method_mock,
+ ["repartition", "base_currency"]
+ ]
+ method, args = processor.parse_args("action", {"repartition": { "ETH": 1 }}, {"base_currency": "USDT"})
+
+ self.assertEqual(1, len(args["repartition"]))
+ self.assertIn("ETH", args["repartition"])
+
+