From: Ismaël Bouya Date: Fri, 20 Apr 2018 22:42:47 +0000 (+0200) Subject: Merge branch 'redis' into dev X-Git-Tag: v1.3^2 X-Git-Url: https://git.immae.eu/?a=commitdiff_plain;h=c5ca26b83ca9f120fb39f1e61265216342f8a4db;hp=ad64ff17e3aa7d7af40a3724a8cd9f19ca045422;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FCryptoportfolio%2FTrader.git Merge branch 'redis' into dev --- diff --git a/main.py b/main.py index 2c7b570..13c2240 100644 --- a/main.py +++ b/main.py @@ -95,13 +95,25 @@ def parse_config(args): del(args.db_password) del(args.db_database) + redis_config = { + "host": args.redis_host, + "port": args.redis_port, + "db": args.redis_database, + } + if redis_config["host"].startswith("/"): + redis_config["unix_socket_path"] = redis_config.pop("host") + del(redis_config["port"]) + del(args.redis_host) + del(args.redis_port) + del(args.redis_database) + report_path = args.report_path if report_path is not None and not \ os.path.exists(report_path): os.makedirs(report_path) - return pg_config + return pg_config, redis_config def parse_args(argv): parser = configargparse.ArgumentParser( @@ -134,6 +146,10 @@ def parse_args(argv): help="Store report to database (default)") parser.add_argument("--no-report-db", action='store_false', dest="report_db", help="Don't store report to database") + parser.add_argument("--report-redis", action='store_true', default=False, dest="report_redis", + help="Store report to redis") + parser.add_argument("--no-report-redis", action='store_false', dest="report_redis", + help="Don't store report to redis (default)") parser.add_argument("--report-path", required=False, help="Where to store the reports (default: absent, don't store)") parser.add_argument("--no-report-path", action='store_const', dest='report_path', const=None, @@ -148,14 +164,24 @@ def parse_args(argv): help="Password access to database (default: cryptoportfolio)") parser.add_argument("--db-database", default="cryptoportfolio", help="Database access to database (default: cryptoportfolio)") - - return parser.parse_args(argv) - -def process(market_config, market_id, user_id, args, pg_config): + parser.add_argument("--redis-host", default="localhost", + help="Host access to database (default: localhost). Use path for socket") + parser.add_argument("--redis-port", default=6379, + help="Port access to redis (default: 6379)") + parser.add_argument("--redis-database", default=0, + help="Redis database to use (default: 0)") + + parsed = parser.parse_args(argv) + if parsed.action is None: + parsed.action = ["sell_all"] + return parsed + +def process(market_config, market_id, user_id, args, pg_config, redis_config): try: market.Market\ .from_config(market_config, args, market_id=market_id, - pg_config=pg_config, user_id=user_id)\ + pg_config=pg_config, redis_config=redis_config, + user_id=user_id)\ .process(args.action, before=args.before, after=args.after) except Exception as e: print("{}: {}".format(e.__class__.__name__, e)) @@ -163,7 +189,7 @@ def process(market_config, market_id, user_id, args, pg_config): def main(argv): args = parse_args(argv) - pg_config = parse_config(args) + pg_config, redis_config = parse_config(args) market.Portfolio.report.set_verbose(not args.quiet) @@ -180,7 +206,7 @@ def main(argv): process_ = process for market_id, market_config, user_id in fetch_markets(pg_config, args.user): - process_(market_config, market_id, user_id, args, pg_config) + process_(market_config, market_id, user_id, args, pg_config, redis_config) if args.parallel: for thread in threads: diff --git a/market.py b/market.py index 7a37cf6..ce0c48c 100644 --- a/market.py +++ b/market.py @@ -2,6 +2,7 @@ from ccxt import ExchangeError, NotSupported, RequestTimeout, InvalidNonce import ccxt_wrapper as ccxt import time import psycopg2 +import redis from store import * from cachetools.func import ttl_cache from datetime import datetime @@ -26,7 +27,7 @@ class Market: self.balances = BalanceStore(self) self.processor = Processor(self) - for key in ["user_id", "market_id", "pg_config"]: + for key in ["user_id", "market_id", "pg_config", "redis_config"]: setattr(self, key, kwargs.get(key, None)) self.report.log_market(self.args) @@ -46,6 +47,8 @@ class Market: self.store_file_report(date) if self.pg_config is not None and self.args.report_db: self.store_database_report(date) + if self.redis_config is not None and self.args.report_redis: + self.store_redis_report(date) def store_file_report(self, date): try: @@ -74,19 +77,26 @@ class Market: except Exception as e: print("impossible to store report to database: {}; {}".format(e.__class__.__name__, e)) + def store_redis_report(self, date): + try: + conn = redis.Redis(**self.redis_config) + for type_, log in self.report.to_json_redis(): + key = "/cryptoportfolio/{}/{}/{}".format(self.market_id, date.isoformat(), type_) + conn.set(key, log, ex=31*24*60*60) + key = "/cryptoportfolio/{}/latest/{}".format(self.market_id, type_) + conn.set(key, log) + except Exception as e: + print("impossible to store report to redis: {}; {}".format(e.__class__.__name__, e)) + def process(self, actions, before=False, after=False): try: - if len(actions or []) == 0: - if before: - self.processor.process("sell_all", steps="before") - if after: - self.processor.process("sell_all", steps="after") - else: - for action in actions: - if hasattr(self, action): - getattr(self, action)() - else: - self.report.log_error("market_process", message="Unknown action {}".format(action)) + for action in actions: + if bool(before) is bool(after): + self.processor.process(action, steps="all") + elif before: + self.processor.process(action, steps="before") + elif after: + self.processor.process(action, steps="after") except Exception as e: self.report.log_error("market_process", exception=e) finally: @@ -212,16 +222,7 @@ class Market: liquidity=liquidity, repartition=repartition) self.trades.compute_trades(values_in_base, new_repartition, only=only) - # Helpers - def print_orders(self, base_currency="BTC"): - self.report.log_stage("print_orders") - self.balances.fetch_balances(tag="print_orders") - self.prepare_trades(base_currency=base_currency, compute_value="average") - self.trades.prepare_orders(compute_value="average") - - def print_balances(self, base_currency="BTC"): - self.report.log_stage("print_balances") - self.balances.fetch_balances() + def print_tickers(self, base_currency="BTC"): if base_currency is not None: self.report.print_log("total:") self.report.print_log(sum(self.balances.in_currency(base_currency).values())) @@ -237,12 +238,20 @@ class Processor: "wait_for_recent": {}, }, ], + "print_balances": [ + { + "name": "print_balances", + "number": 1, + "fetch_balances": ["begin"], + "print_tickers": { "base_currency": "BTC" }, + } + ], "print_orders": [ { "name": "wait", "number": 1, - "before": False, - "after": True, + "before": True, + "after": False, "wait_for_recent": {}, }, { @@ -328,7 +337,7 @@ class Processor: ordered_actions = [ "wait_for_recent", "prepare_trades", "prepare_orders", "move_balances", "run_orders", "follow_orders", - "close_trades"] + "close_trades", "print_tickers"] def __init__(self, market): self.market = market @@ -337,7 +346,7 @@ class Processor: if step == "all": return scenario elif step == "before" or step == "after": - return list(filter(lambda x: step in x and x[step], scenario)) + return list(filter(lambda x: x.get(step, False), scenario)) elif type(step) == int: return [scenario[step-1]] elif type(step) == str: @@ -345,7 +354,12 @@ class Processor: else: raise TypeError("Unknown step {}".format(step)) + def can_process(self, scenario_name): + return scenario_name in self.scenarios + def process(self, scenario_name, steps="all", **kwargs): + if not self.can_process(scenario_name): + raise TypeError("Unknown scenario {}".format(scenario_name)) scenario = self.scenarios[scenario_name] selected_steps = [] @@ -388,6 +402,8 @@ class Processor: method = self.market.follow_orders elif action == "close_trades": method = self.market.trades.close_trades + elif action == "print_tickers": + method = self.market.print_tickers signature = inspect.getfullargspec(method) defaults = signature.defaults or [] diff --git a/requirements.txt b/requirements.txt index 2451c80..3a4db2d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,3 +6,4 @@ psycopg2==2.7.4 retry==0.9.2 cachetools==2.0.1 configargparse==0.12.0 +redis==2.10.6 diff --git a/store.py b/store.py index 0c018e0..072d3a2 100644 --- a/store.py +++ b/store.py @@ -17,6 +17,7 @@ class ReportStore: self.print_logs = [] self.logs = [] + self.redis_status = [] self.no_http_dup = no_http_dup self.last_http = None @@ -46,6 +47,10 @@ class ReportStore: self.logs.append(hash_) return hash_ + def add_redis_status(self, hash_): + self.redis_status.append(hash_) + return hash_ + @staticmethod def default_json_serial(obj): if isinstance(obj, (datetime.datetime, datetime.date)): @@ -63,6 +68,13 @@ class ReportStore: json.dumps(log, default=self.default_json_serial, indent=" ") ) + def to_json_redis(self): + for log in (x.copy() for x in self.redis_status): + yield ( + log.pop("type"), + json.dumps(log, default=self.default_json_serial) + ) + def set_verbose(self, verbose_print): self.verbose_print = verbose_print @@ -91,11 +103,14 @@ class ReportStore: for currency, balance in self.market.balances.all.items(): self.print_log("\t{}".format(balance)) - self.add_log({ - "type": "balance", - "tag": tag, - "balances": self.market.balances.as_json() - }) + log = { + "type": "balance", + "tag": tag, + "balances": self.market.balances.as_json() + } + + self.add_log(log.copy()) + self.add_redis_status(log) def log_tickers(self, amounts, other_currency, compute_value, type): @@ -107,15 +122,18 @@ class ReportStore: for currency, amount in amounts.items(): values[currency] = amount.as_json()["value"] rates[currency] = amount.rate - self.add_log({ - "type": "tickers", - "compute_value": compute_value, - "balance_type": type, - "currency": other_currency, - "balances": values, - "rates": rates, - "total": sum(amounts.values()).as_json()["value"] - }) + log = { + "type": "tickers", + "compute_value": compute_value, + "balance_type": type, + "currency": other_currency, + "balances": values, + "rates": rates, + "total": sum(amounts.values()).as_json()["value"] + } + + self.add_log(log.copy()) + self.add_redis_status(log) def log_dispatch(self, amount, amounts, liquidity, repartition): self.add_log({ diff --git a/tests/test_main.py b/tests/test_main.py index d2f8029..b650870 100644 --- a/tests/test_main.py +++ b/tests/test_main.py @@ -135,16 +135,16 @@ class MainTest(WebMockTestCase): args_mock.after = "after" self.assertEqual("", stdout_mock.getvalue()) - main.process("config", 3, 1, args_mock, "pg_config") + main.process("config", 3, 1, args_mock, "pg_config", "redis_config") market_mock.from_config.assert_has_calls([ - mock.call("config", args_mock, pg_config="pg_config", market_id=3, user_id=1), + mock.call("config", args_mock, pg_config="pg_config", redis_config="redis_config", market_id=3, user_id=1), mock.call().process("action", before="before", after="after"), ]) with self.subTest(exception=True): market_mock.from_config.side_effect = Exception("boo") - main.process(3, "config", 1, args_mock, "pg_config") + main.process(3, "config", 1, args_mock, "pg_config", "redis_config") self.assertEqual("Exception: boo\n", stdout_mock.getvalue()) def test_main(self): @@ -159,7 +159,7 @@ class MainTest(WebMockTestCase): args_mock.user = "user" parse_args.return_value = args_mock - parse_config.return_value = "pg_config" + parse_config.return_value = ["pg_config", "redis_config"] fetch_markets.return_value = [[3, "config1", 1], [1, "config2", 2]] @@ -171,8 +171,8 @@ class MainTest(WebMockTestCase): self.assertEqual(2, process.call_count) process.assert_has_calls([ - mock.call("config1", 3, 1, args_mock, "pg_config"), - mock.call("config2", 1, 2, args_mock, "pg_config"), + mock.call("config1", 3, 1, args_mock, "pg_config", "redis_config"), + mock.call("config2", 1, 2, args_mock, "pg_config", "redis_config"), ]) with self.subTest(parallel=True): with mock.patch("main.parse_args") as parse_args,\ @@ -187,7 +187,7 @@ class MainTest(WebMockTestCase): args_mock.user = "user" parse_args.return_value = args_mock - parse_config.return_value = "pg_config" + parse_config.return_value = ["pg_config", "redis_config"] fetch_markets.return_value = [[3, "config1", 1], [1, "config2", 2]] @@ -202,9 +202,9 @@ class MainTest(WebMockTestCase): self.assertEqual(2, process.call_count) process.assert_has_calls([ mock.call.__bool__(), - mock.call("config1", 3, 1, args_mock, "pg_config"), + mock.call("config1", 3, 1, args_mock, "pg_config", "redis_config"), mock.call.__bool__(), - mock.call("config2", 1, 2, args_mock, "pg_config"), + mock.call("config2", 1, 2, args_mock, "pg_config", "redis_config"), ]) with self.subTest(quiet=True): with mock.patch("main.parse_args") as parse_args,\ @@ -219,7 +219,7 @@ class MainTest(WebMockTestCase): args_mock.user = "user" parse_args.return_value = args_mock - parse_config.return_value = "pg_config" + parse_config.return_value = ["pg_config", "redis_config"] fetch_markets.return_value = [[3, "config1", 1], [1, "config2", 2]] @@ -240,7 +240,7 @@ class MainTest(WebMockTestCase): args_mock.user = "user" parse_args.return_value = args_mock - parse_config.return_value = "pg_config" + parse_config.return_value = ["pg_config", "redis_config"] fetch_markets.return_value = [[3, "config1", 1], [1, "config2", 2]] @@ -259,15 +259,39 @@ class MainTest(WebMockTestCase): "db_user": "user", "db_password": "password", "db_database": "database", + "redis_host": "rhost", + "redis_port": "rport", + "redis_database": "rdb", "report_path": None, }) - result = main.parse_config(args) + db_config, redis_config = main.parse_config(args) self.assertEqual({ "host": "host", "port": "port", "user": "user", "password": "password", "database": "database" - }, result) + }, db_config) + self.assertEqual({ "host": "rhost", "port": "rport", "db": + "rdb"}, redis_config) + with self.assertRaises(AttributeError): args.db_password + with self.assertRaises(AttributeError): + args.redis_host + + with self.subTest(redis_host="socket"): + args = main.configargparse.Namespace(**{ + "db_host": "host", + "db_port": "port", + "db_user": "user", + "db_password": "password", + "db_database": "database", + "redis_host": "/run/foo", + "redis_port": "rport", + "redis_database": "rdb", + "report_path": None, + }) + + db_config, redis_config = main.parse_config(args) + self.assertEqual({ "unix_socket_path": "/run/foo", "db": "rdb"}, redis_config) with self.subTest(report_path="present"): args = main.configargparse.Namespace(**{ @@ -276,6 +300,9 @@ class MainTest(WebMockTestCase): "db_user": "user", "db_password": "password", "db_database": "database", + "redis_host": "rhost", + "redis_port": "rport", + "redis_database": "rdb", "report_path": "report_path", }) diff --git a/tests/test_market.py b/tests/test_market.py index 14b23b5..e3482b8 100644 --- a/tests/test_market.py +++ b/tests/test_market.py @@ -530,23 +530,55 @@ class MarketTest(WebMockTestCase): 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: @@ -557,12 +589,14 @@ class MarketTest(WebMockTestCase): 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: @@ -573,12 +607,14 @@ class MarketTest(WebMockTestCase): 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: @@ -589,6 +625,7 @@ class MarketTest(WebMockTestCase): 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"), @@ -596,6 +633,7 @@ class MarketTest(WebMockTestCase): 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: @@ -606,22 +644,54 @@ class MarketTest(WebMockTestCase): 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,\ @@ -634,10 +704,8 @@ class MarketTest(WebMockTestCase): "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")), @@ -648,8 +716,8 @@ class MarketTest(WebMockTestCase): @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() @@ -659,9 +727,9 @@ class MarketTest(WebMockTestCase): 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() @@ -669,7 +737,7 @@ class MarketTest(WebMockTestCase): 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() @@ -678,54 +746,30 @@ class MarketTest(WebMockTestCase): 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() @@ -768,24 +812,39 @@ class ProcessorTest(WebMockTestCase): 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) @@ -816,6 +875,9 @@ class ProcessorTest(WebMockTestCase): 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) diff --git a/tests/test_store.py b/tests/test_store.py index ffd2645..df113b7 100644 --- a/tests/test_store.py +++ b/tests/test_store.py @@ -459,6 +459,13 @@ class ReportStoreTest(WebMockTestCase): self.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": None, "market_id": None}, result) + def test_add_redis_status(self): + report_store = market.ReportStore(self.m) + result = report_store.add_redis_status({"foo": "bar"}) + + self.assertEqual({"foo": "bar"}, result) + self.assertEqual(result, report_store.redis_status[0]) + def test_set_verbose(self): report_store = market.ReportStore(self.m) with self.subTest(verbose=True): @@ -534,6 +541,20 @@ class ReportStoreTest(WebMockTestCase): self.assertEqual(("date1", "type1", '{\n "foo": "bar",\n "bla": "bla"\n}'), logs[0]) self.assertEqual(("date2", "type2", '{\n "foo": "bar",\n "bla": "bla"\n}'), logs[1]) + def test_to_json_redis(self): + report_store = market.ReportStore(self.m) + report_store.redis_status.append({ + "type": "type1", "foo": "bar", "bla": "bla" + }) + report_store.redis_status.append({ + "type": "type2", "foo": "bar", "bla": "bla" + }) + logs = list(report_store.to_json_redis()) + + self.assertEqual(2, len(logs)) + self.assertEqual(("type1", '{"foo": "bar", "bla": "bla"}'), logs[0]) + self.assertEqual(("type2", '{"foo": "bar", "bla": "bla"}'), logs[1]) + @mock.patch.object(market.ReportStore, "print_log") @mock.patch.object(market.ReportStore, "add_log") def test_log_stage(self, add_log, print_log): @@ -559,7 +580,8 @@ class ReportStoreTest(WebMockTestCase): @mock.patch.object(market.ReportStore, "print_log") @mock.patch.object(market.ReportStore, "add_log") - def test_log_balances(self, add_log, print_log): + @mock.patch.object(market.ReportStore, "add_redis_status") + def test_log_balances(self, add_redis_status, add_log, print_log): report_store = market.ReportStore(self.m) self.m.balances.as_json.return_value = "json" self.m.balances.all = { "FOO": "bar", "BAR": "baz" } @@ -575,10 +597,16 @@ class ReportStoreTest(WebMockTestCase): 'balances': 'json', 'tag': 'tag' }) + add_redis_status.assert_called_once_with({ + 'type': 'balance', + 'balances': 'json', + 'tag': 'tag' + }) @mock.patch.object(market.ReportStore, "print_log") @mock.patch.object(market.ReportStore, "add_log") - def test_log_tickers(self, add_log, print_log): + @mock.patch.object(market.ReportStore, "add_redis_status") + def test_log_tickers(self, add_redis_status, add_log, print_log): report_store = market.ReportStore(self.m) amounts = { "BTC": portfolio.Amount("BTC", 10), @@ -603,6 +631,21 @@ class ReportStoreTest(WebMockTestCase): }, 'total': D('10.3') }) + add_redis_status.assert_called_once_with({ + 'type': 'tickers', + 'compute_value': 'default', + 'balance_type': 'total', + 'currency': 'BTC', + 'balances': { + 'BTC': D('10'), + 'ETH': D('0.3') + }, + 'rates': { + 'BTC': None, + 'ETH': D('0.1') + }, + 'total': D('10.3') + }) add_log.reset_mock() compute_value = lambda x: x["bid"]