from .helper import *
-import market, store, portfolio
+import market, store, portfolio, dbs
import datetime
@unittest.skipUnless("unit" in limits, "Unit skipped")
@mock.patch.object(market.Market, "get_ticker")
@mock.patch.object(market.TradeStore, "compute_trades")
def test_prepare_trades(self, compute_trades, get_ticker, repartition):
- repartition.return_value = {
- "XEM": (D("0.75"), "long"),
- "BTC": (D("0.25"), "long"),
- }
- def _get_ticker(c1, c2):
- if c1 == "USDT" and c2 == "BTC":
- return { "average": D("0.0001") }
- if c1 == "XVG" and c2 == "BTC":
- return { "average": D("0.000001") }
- self.fail("Should be called with {}, {}".format(c1, c2))
- get_ticker.side_effect = _get_ticker
-
- with mock.patch("market.ReportStore"):
+ with self.subTest(available_balance_only=False),\
+ mock.patch("market.ReportStore"):
+ def _get_ticker(c1, c2):
+ if c1 == "USDT" and c2 == "BTC":
+ return { "average": D("0.0001") }
+ if c1 == "XVG" and c2 == "BTC":
+ return { "average": D("0.000001") }
+ self.fail("Should not be called with {}, {}".format(c1, c2))
+ get_ticker.side_effect = _get_ticker
+
+ repartition.return_value = {
+ "XEM": (D("0.75"), "long"),
+ "BTC": (D("0.25"), "long"),
+ }
m = market.Market(self.ccxt, self.market_args())
self.ccxt.fetch_all_balances.return_value = {
"USDT": {
self.assertEqual(D("0.7575"), call[0][1]["XEM"].value)
m.report.log_stage.assert_called_once_with("prepare_trades",
base_currency='BTC', compute_value='average',
- liquidity='medium', only=None, repartition=None)
- m.report.log_balances.assert_called_once_with(tag="tag")
+ available_balance_only=False, liquidity='medium',
+ only=None, repartition=None)
+ m.report.log_balances.assert_called_once_with(tag="tag", checkpoint=None)
+ compute_trades.reset_mock()
+ with self.subTest(available_balance_only=True),\
+ mock.patch("market.ReportStore"):
+ def _get_ticker(c1, c2):
+ if c1 == "ZRC" and c2 == "BTC":
+ return { "average": D("0.0001") }
+ if c1 == "DOGE" and c2 == "BTC":
+ return { "average": D("0.000001") }
+ if c1 == "ETH" and c2 == "BTC":
+ return { "average": D("0.1") }
+ self.fail("Should not be called with {}, {}".format(c1, c2))
+ get_ticker.side_effect = _get_ticker
+
+ repartition.return_value = {
+ "DOGE": (D("0.25"), "short"),
+ "BTC": (D("0.25"), "long"),
+ "ETH": (D("0.25"), "long"),
+ "XMR": (D("0.25"), "long"),
+ }
+ m = market.Market(self.ccxt, self.market_args())
+ self.ccxt.fetch_all_balances.return_value = {
+ "ZRC": {
+ "exchange_free": D("2.0"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("2.0"),
+ "total": D("2.0")
+ },
+ "DOGE": {
+ "exchange_free": D("5.0"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("5.0"),
+ "total": D("5.0")
+ },
+ "BTC": {
+ "exchange_free": D("0.075"),
+ "exchange_used": D("0.02"),
+ "exchange_total": D("0.095"),
+ "margin_available": D("0.025"),
+ "margin_in_position": D("0.01"),
+ "margin_total": D("0.035"),
+ "total": D("0.13")
+ },
+ "ETH": {
+ "exchange_free": D("1.0"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("1.0"),
+ "total": D("1.0")
+ },
+ }
+
+ m.balances.fetch_balances(tag="tag")
+ m.prepare_trades(available_balance_only=True)
+ compute_trades.assert_called_once()
+
+ call = compute_trades.call_args[0]
+ values_in_base = call[0]
+ new_repartition = call[1]
+
+ self.assertEqual(portfolio.Amount("BTC", "-0.025"),
+ new_repartition["DOGE"] - values_in_base["DOGE"])
+ self.assertEqual(portfolio.Amount("BTC", "0.025"),
+ new_repartition["ETH"] - values_in_base["ETH"])
+ self.assertEqual(0,
+ new_repartition["ZRC"] - values_in_base["ZRC"])
+ self.assertEqual(portfolio.Amount("BTC", "0.025"),
+ new_repartition["XMR"])
+
+ compute_trades.reset_mock()
+ with self.subTest(available_balance_only=True, balance=0),\
+ mock.patch("market.ReportStore"):
+ def _get_ticker(c1, c2):
+ if c1 == "ETH" and c2 == "BTC":
+ return { "average": D("0.1") }
+ self.fail("Should not be called with {}, {}".format(c1, c2))
+ get_ticker.side_effect = _get_ticker
+
+ repartition.return_value = {
+ "BTC": (D("0.5"), "long"),
+ "ETH": (D("0.5"), "long"),
+ }
+ m = market.Market(self.ccxt, self.market_args())
+ self.ccxt.fetch_all_balances.return_value = {
+ "ETH": {
+ "exchange_free": D("1.0"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("1.0"),
+ "total": D("1.0")
+ },
+ }
+
+ m.balances.fetch_balances(tag="tag")
+ m.prepare_trades(available_balance_only=True)
+ compute_trades.assert_called_once()
+
+ call = compute_trades.call_args[0]
+ values_in_base = call[0]
+ new_repartition = call[1]
+
+ self.assertEqual(new_repartition["ETH"], values_in_base["ETH"])
@mock.patch.object(market.time, "sleep")
@mock.patch.object(market.TradeStore, "all_orders")
order_mock2.trade = trade_mock
trade_mock.tick_actions_recreate.return_value = "tick1"
+ new_order_mock = mock.Mock()
+ trade_mock.prepare_order.return_value = new_order_mock
m.follow_orders()
trade_mock.tick_actions_recreate.assert_called_once_with(2)
trade_mock.prepare_order.assert_called_once_with(compute_value="tick1")
m.report.log_error.assert_called_once_with("follow_orders", message=mock.ANY)
+ m.report.log_order.assert_called_with(order_mock2, 2, new_order=new_order_mock)
+ new_order_mock.run.assert_called_once_with()
@mock.patch.object(market.BalanceStore, "fetch_balances")
def test_move_balance(self, fetch_balances):
self.assertRegex(stdout_mock.getvalue(), "impossible to store report file: FileNotFoundError;")
- @mock.patch.object(market, "psycopg2")
- def test_store_database_report(self, psycopg2):
- connect_mock = mock.Mock()
+ @mock.patch.object(dbs, "psql")
+ def test_store_database_report(self, psql):
cursor_mock = mock.MagicMock()
- connect_mock.cursor.return_value = cursor_mock
- psycopg2.connect.return_value = connect_mock
+ psql.cursor.return_value = cursor_mock
m = market.Market(self.ccxt, self.market_args(),
pg_config={"config": "pg_config"}, user_id=1)
cursor_mock.fetchone.return_value = [42]
("date2", "type2", "payload2"),
]
m.store_database_report(datetime.datetime(2018, 3, 24))
- connect_mock.assert_has_calls([
+ psql.assert_has_calls([
mock.call.cursor(),
mock.call.cursor().execute('INSERT INTO reports("date", "market_config_id", "debug") VALUES (%s, %s, %s) RETURNING id;', (datetime.datetime(2018, 3, 24), None, False)),
mock.call.cursor().fetchone(),
mock.call.cursor().execute('INSERT INTO report_lines("date", "report_id", "type", "payload") VALUES (%s, %s, %s, %s);', ('date2', 42, 'type2', 'payload2')),
mock.call.commit(),
mock.call.cursor().close(),
- mock.call.close()
])
- connect_mock.reset_mock()
with self.subTest(error=True),\
mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
- psycopg2.connect.side_effect = Exception("Bouh")
+ psql.cursor.side_effect = Exception("Bouh")
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(dbs, "redis")
+ def test_store_redis_report(self, redis):
+ 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))
+ redis.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"),
+ mock.call.set("/cryptoportfolio/1/latest/date", "2018-03-24T00:00:00"),
+ ])
+
+ redis.reset_mock()
+ with self.subTest(error=True),\
+ mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
+ redis.set.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),\
+ with self.subTest(file=None, pg_connected=None),\
+ mock.patch.object(dbs, "psql_connected") as psql,\
+ mock.patch.object(dbs, "redis_connected") as redis,\
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:
+ psql.return_value = False
+ redis.return_value = False
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),\
+ with self.subTest(file="present", pg_connected=None),\
+ mock.patch.object(dbs, "psql_connected") as psql,\
+ mock.patch.object(dbs, "redis_connected") as redis,\
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:
-
+ psql.return_value = False
+ redis.return_value = False
time_mock.now.return_value = datetime.datetime(2018, 2, 25)
m.store_report()
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),\
+ with self.subTest(file="present", pg_connected=None, report_db=True),\
+ mock.patch.object(dbs, "psql_connected") as psql,\
+ mock.patch.object(dbs, "redis_connected") as redis,\
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:
-
+ psql.return_value = False
+ redis.return_value = False
time_mock.now.return_value = datetime.datetime(2018, 2, 25)
m.store_report()
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"),\
+ m = market.Market(self.ccxt, self.market_args(report_db=True), user_id=1)
+ with self.subTest(file=None, pg_connected=True),\
+ mock.patch.object(dbs, "psql_connected") as psql,\
+ mock.patch.object(dbs, "redis_connected") as redis,\
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:
-
+ psql.return_value = True
+ redis.return_value = False
time_mock.now.return_value = datetime.datetime(2018, 2, 25)
m.store_report()
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"),
- pg_config="pg_config", user_id=1)
- with self.subTest(file="present", pg_config="present"),\
+ user_id=1)
+ with self.subTest(file="present", pg_connected=True),\
+ mock.patch.object(dbs, "psql_connected") as psql,\
+ mock.patch.object(dbs, "redis_connected") as redis,\
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:
-
+ psql.return_value = True
+ redis.return_value = False
time_mock.now.return_value = datetime.datetime(2018, 2, 25)
m.store_report()
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()
+
+ report.reset_mock()
+ m = market.Market(self.ccxt, self.market_args(report_redis=False),
+ user_id=1)
+ with self.subTest(redis_connected=True, report_redis=False),\
+ mock.patch.object(dbs, "psql_connected") as psql,\
+ mock.patch.object(dbs, "redis_connected") as redis,\
+ 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:
+ psql.return_value = False
+ redis.return_value = True
+ 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),
+ user_id=1)
+ with self.subTest(redis_connected=False, report_redis=True),\
+ mock.patch.object(dbs, "psql_connected") as psql,\
+ mock.patch.object(dbs, "redis_connected") as redis,\
+ 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:
+ psql.return_value = False
+ redis.return_value = False
+ 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),
+ user_id=1)
+ with self.subTest(redis_connected=True, report_redis=True),\
+ mock.patch.object(dbs, "psql_connected") as psql,\
+ mock.patch.object(dbs, "redis_connected") as redis,\
+ 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:
+ psql.return_value = False
+ redis.return_value = True
+ 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())
process.side_effect = Exception("bouh")
m.process(["some_action"], before=True)
- log_error.assert_called_with("market_process", exception=mock.ANY)
+ log_error.assert_called_with("market_process", exception=mock.ANY, message=mock.ANY)
store_report.assert_called_once()
process_step.reset_mock()
processor.process("sell_needed", steps=["before", "after"])
- self.assertEqual(3, process_step.call_count)
+ self.assertEqual(4, process_step.call_count)
def test_method_arguments(self):
ccxt = mock.Mock(spec=market.ccxt.poloniexE)
method, arguments = processor.method_arguments("prepare_trades")
self.assertEqual(m.prepare_trades, method)
- self.assertEqual(['base_currency', 'liquidity', 'compute_value', 'repartition', 'only'], arguments)
+ self.assertEqual(['base_currency', 'liquidity', 'compute_value', 'repartition', 'only', 'available_balance_only'], arguments)
method, arguments = processor.method_arguments("prepare_orders")
self.assertEqual(m.trades.prepare_orders, method)
processor = market.Processor(self.m)
with mock.patch.object(processor, "run_action") as run_action:
- step = processor.scenarios["sell_needed"][1]
+ step = processor.scenarios["sell_needed"][2]
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"),
+ mock.call("process_foo__2_sell_begin"),
+ mock.call("process_foo__2_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"),
+ mock.call(tag="process_foo__2_sell_begin"),
+ mock.call(tag="process_foo__2_sell_end"),
])
self.assertEqual(5, run_action.call_count)
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.report.log_stage.assert_has_calls([
+ mock.call("process_foo__0_print_balances_begin"),
+ mock.call("process_foo__0_print_balances_end"),
+ ])
+ self.m.balances.fetch_balances.assert_has_calls([
+ mock.call(add_portfolio=True, checkpoint='end',
+ log_tickers=True,
+ add_usdt=True,
+ tag='process_foo__0_print_balances_begin')
+ ])
+
+ self.assertEqual(0, run_action.call_count)
+
+ self.m.reset_mock()
+ 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.balances.fetch_balances.assert_not_called()
+ self.m.reset_mock()
+ with mock.patch.object(processor, "run_action") as run_action:
+ step = processor.scenarios["print_balances"][0]
+
+ processor.process_step("foo", step, {"foo":"bar"})
+ self.m.balances.fetch_balances.assert_called_once_with(
+ add_portfolio=True, add_usdt=True, log_tickers=True,
+ tag='process_foo__1_print_balances_begin')
+
def test_parse_args(self):
processor = market.Processor(self.m)
projects / perso / Immae / Projets / Cryptomonnaies / Cryptoportfolio / Trader.git / blobdiff