m.store_database_report(datetime.datetime(2018, 3, 24))
self.assertEqual(stdout_mock.getvalue(), "impossible to store report to database: Exception; Bouh\n")
+ @mock.patch.object(market, "redis")
+ def test_store_redis_report(self, redis):
+ connect_mock = mock.Mock()
+ redis.Redis.return_value = connect_mock
+
+ m = market.Market(self.ccxt, self.market_args(),
+ redis_config={"config": "redis_config"}, market_id=1)
+
+ with self.subTest(error=False),\
+ mock.patch.object(m, "report") as report:
+ report.to_json_redis.return_value = [
+ ("type1", "payload1"),
+ ("type2", "payload2"),
+ ]
+ m.store_redis_report(datetime.datetime(2018, 3, 24))
+ connect_mock.assert_has_calls([
+ mock.call.set("/cryptoportfolio/1/2018-03-24T00:00:00/type1", "payload1", ex=31*24*60*60),
+ mock.call.set("/cryptoportfolio/1/latest/type1", "payload1"),
+ mock.call.set("/cryptoportfolio/1/2018-03-24T00:00:00/type2", "payload2", ex=31*24*60*60),
+ mock.call.set("/cryptoportfolio/1/latest/type2", "payload2"),
+ ])
+
+ connect_mock.reset_mock()
+ with self.subTest(error=True),\
+ mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
+ redis.Redis.side_effect = Exception("Bouh")
+ m.store_redis_report(datetime.datetime(2018, 3, 24))
+ self.assertEqual(stdout_mock.getvalue(), "impossible to store report to redis: Exception; Bouh\n")
+
def test_store_report(self):
m = market.Market(self.ccxt, self.market_args(report_db=False), user_id=1)
with self.subTest(file=None, pg_config=None),\
mock.patch.object(m, "report") as report,\
mock.patch.object(m, "store_database_report") as db_report,\
+ mock.patch.object(m, "store_redis_report") as redis_report,\
mock.patch.object(m, "store_file_report") as file_report:
m.store_report()
report.merge.assert_called_with(store.Portfolio.report)
file_report.assert_not_called()
db_report.assert_not_called()
+ redis_report.assert_not_called()
report.reset_mock()
m = market.Market(self.ccxt, self.market_args(report_db=False, report_path="present"), user_id=1)
with self.subTest(file="present", pg_config=None),\
mock.patch.object(m, "report") as report,\
mock.patch.object(m, "store_file_report") as file_report,\
+ mock.patch.object(m, "store_redis_report") as redis_report,\
mock.patch.object(m, "store_database_report") as db_report,\
mock.patch.object(market.datetime, "datetime") as time_mock:
report.merge.assert_called_with(store.Portfolio.report)
file_report.assert_called_once_with(datetime.datetime(2018, 2, 25))
db_report.assert_not_called()
+ redis_report.assert_not_called()
report.reset_mock()
m = market.Market(self.ccxt, self.market_args(report_db=True, report_path="present"), user_id=1)
with self.subTest(file="present", pg_config=None, report_db=True),\
mock.patch.object(m, "report") as report,\
mock.patch.object(m, "store_file_report") as file_report,\
+ mock.patch.object(m, "store_redis_report") as redis_report,\
mock.patch.object(m, "store_database_report") as db_report,\
mock.patch.object(market.datetime, "datetime") as time_mock:
report.merge.assert_called_with(store.Portfolio.report)
file_report.assert_called_once_with(datetime.datetime(2018, 2, 25))
db_report.assert_not_called()
+ redis_report.assert_not_called()
report.reset_mock()
m = market.Market(self.ccxt, self.market_args(report_db=True), pg_config="present", user_id=1)
with self.subTest(file=None, pg_config="present"),\
mock.patch.object(m, "report") as report,\
mock.patch.object(m, "store_file_report") as file_report,\
+ mock.patch.object(m, "store_redis_report") as redis_report,\
mock.patch.object(m, "store_database_report") as db_report,\
mock.patch.object(market.datetime, "datetime") as time_mock:
report.merge.assert_called_with(store.Portfolio.report)
file_report.assert_not_called()
db_report.assert_called_once_with(datetime.datetime(2018, 2, 25))
+ redis_report.assert_not_called()
report.reset_mock()
m = market.Market(self.ccxt, self.market_args(report_db=True, report_path="present"),
with self.subTest(file="present", pg_config="present"),\
mock.patch.object(m, "report") as report,\
mock.patch.object(m, "store_file_report") as file_report,\
+ mock.patch.object(m, "store_redis_report") as redis_report,\
mock.patch.object(m, "store_database_report") as db_report,\
mock.patch.object(market.datetime, "datetime") as time_mock:
report.merge.assert_called_with(store.Portfolio.report)
file_report.assert_called_once_with(datetime.datetime(2018, 2, 25))
db_report.assert_called_once_with(datetime.datetime(2018, 2, 25))
+ redis_report.assert_not_called()
- def test_print_orders(self):
- m = market.Market(self.ccxt, self.market_args())
- 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()
+ report.reset_mock()
+ m = market.Market(self.ccxt, self.market_args(report_redis=False),
+ redis_config="redis_config", user_id=1)
+ with self.subTest(redis_config="present", report_redis=False),\
+ mock.patch.object(m, "report") as report,\
+ mock.patch.object(m, "store_file_report") as file_report,\
+ mock.patch.object(m, "store_redis_report") as redis_report,\
+ mock.patch.object(m, "store_database_report") as db_report,\
+ mock.patch.object(market.datetime, "datetime") as time_mock:
- 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")
+ time_mock.now.return_value = datetime.datetime(2018, 2, 25)
- def test_print_balances(self):
+ m.store_report()
+ redis_report.assert_not_called()
+
+ report.reset_mock()
+ m = market.Market(self.ccxt, self.market_args(report_redis=True),
+ user_id=1)
+ with self.subTest(redis_config="absent", report_redis=True),\
+ mock.patch.object(m, "report") as report,\
+ mock.patch.object(m, "store_file_report") as file_report,\
+ mock.patch.object(m, "store_redis_report") as redis_report,\
+ mock.patch.object(m, "store_database_report") as db_report,\
+ mock.patch.object(market.datetime, "datetime") as time_mock:
+
+ time_mock.now.return_value = datetime.datetime(2018, 2, 25)
+
+ m.store_report()
+ redis_report.assert_not_called()
+
+ report.reset_mock()
+ m = market.Market(self.ccxt, self.market_args(report_redis=True),
+ redis_config="redis_config", user_id=1)
+ with self.subTest(redis_config="present", report_redis=True),\
+ mock.patch.object(m, "report") as report,\
+ mock.patch.object(m, "store_file_report") as file_report,\
+ mock.patch.object(m, "store_redis_report") as redis_report,\
+ mock.patch.object(m, "store_database_report") as db_report,\
+ mock.patch.object(market.datetime, "datetime") as time_mock:
+
+ time_mock.now.return_value = datetime.datetime(2018, 2, 25)
+
+ m.store_report()
+ redis_report.assert_called_once_with(datetime.datetime(2018, 2, 25))
+
+ def test_print_tickers(self):
m = market.Market(self.ccxt, self.market_args())
with mock.patch.object(m.balances, "in_currency") as in_currency,\
"ETH": portfolio.Amount("BTC", "0.3"),
}
- m.print_balances()
+ m.print_tickers()
- 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.Market.store_report")
def test_process(self, store_report, log_error, process):
m = market.Market(self.ccxt, self.market_args())
- with self.subTest(before=False, after=False):
- m.process(None)
+ with self.subTest(actions=[], before=False, after=False):
+ m.process([])
process.assert_not_called()
store_report.assert_called_once()
log_error.reset_mock()
store_report.reset_mock()
with self.subTest(before=True, after=False):
- m.process(None, before=True)
+ m.process(["foo"], before=True)
- process.assert_called_once_with("sell_all", steps="before")
+ process.assert_called_once_with("foo", steps="before")
store_report.assert_called_once()
log_error.assert_not_called()
log_error.reset_mock()
store_report.reset_mock()
with self.subTest(before=False, after=True):
- m.process(None, after=True)
+ m.process(["sell_all"], after=True)
process.assert_called_once_with("sell_all", steps="after")
store_report.assert_called_once()
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)
+ with self.subTest(before=False, after=False):
+ m.process(["foo"])
- process.assert_has_calls([
- mock.call("sell_all", steps="before"),
- mock.call("sell_all", steps="after"),
- ])
+ process.assert_called_once_with("foo", steps="all")
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"])
+ with self.subTest(before=True, after=True):
+ m.process(["sell_all"], before=True, after=True)
- process.assert_not_called()
- log_error.assert_not_called()
+ process.assert_called_once_with("sell_all", steps="all")
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()
+ process.reset_mock()
log_error.reset_mock()
store_report.reset_mock()
with self.subTest(unhandled_exception=True):
process.side_effect = Exception("bouh")
- m.process(None, before=True)
+ m.process(["some_action"], before=True)
log_error.assert_called_with("market_process", exception=mock.ANY)
store_report.assert_called_once()
with self.assertRaises(TypeError):
processor.select_steps(scenario, ["wait"])
+ def test_can_process(self):
+ processor = market.Processor(self.m)
+
+ with self.subTest(True):
+ self.assertTrue(processor.can_process("sell_all"))
+
+ with self.subTest(False):
+ self.assertFalse(processor.can_process("unknown_action"))
+
@mock.patch("market.Processor.process_step")
def test_process(self, process_step):
- processor = market.Processor(self.m)
+ with self.subTest("unknown action"):
+ processor = market.Processor(self.m)
+ with self.assertRaises(TypeError):
+ processor.process("unknown_action")
- processor.process("sell_all", foo="bar")
- self.assertEqual(3, process_step.call_count)
+ with self.subTest("nominal case"):
+ processor = market.Processor(self.m)
- 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)
+ processor.process("sell_all", foo="bar")
+ self.assertEqual(3, process_step.call_count)
- process_step.reset_mock()
+ 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)
- processor.process("sell_needed", steps=["before", "after"])
- self.assertEqual(3, process_step.call_count)
+ 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)
method, arguments = processor.method_arguments("close_trades")
self.assertEqual(m.trades.close_trades, method)
+ method, arguments = processor.method_arguments("print_tickers")
+ self.assertEqual(m.print_tickers, method)
+
def test_process_step(self):
processor = market.Processor(self.m)
projects / perso / Immae / Projets / Cryptomonnaies / Cryptoportfolio / Trader.git / blobdiff