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:
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):
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")
@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),
}
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)
def test_to_json(self):
report_store = market.ReportStore(self.m)
report_store.logs.append({"foo": "bar"})
- self.assertEqual('[{"foo": "bar"}]', report_store.to_json())
+ self.assertEqual('[\n {\n "foo": "bar"\n }\n]', report_store.to_json())
report_store.logs.append({"date": portfolio.datetime(2018, 2, 24)})
- self.assertEqual('[{"foo": "bar"}, {"date": "2018-02-24T00:00:00"}]', report_store.to_json())
+ self.assertEqual('[\n {\n "foo": "bar"\n },\n {\n "date": "2018-02-24T00:00:00"\n }\n]', report_store.to_json())
report_store.logs.append({"amount": portfolio.Amount("BTC", 1)})
- self.assertEqual('[{"foo": "bar"}, {"date": "2018-02-24T00:00:00"}, {"amount": "1.00000000 BTC"}]', report_store.to_json())
+ 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())
@mock.patch.object(market.ReportStore, "print_log")
@mock.patch.object(market.ReportStore, "add_log")
})
@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,
}
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"),
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]
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"),
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)
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)
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)
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
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")
]
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)
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()
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"]
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)
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)
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]
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()