trade_mock2.prepare_order.return_value = 2
trade_mock3.prepare_order.return_value = 3
- trade_mock1.is_fullfiled = False
- trade_mock2.is_fullfiled = False
- trade_mock3.is_fullfiled = True
+ trade_mock1.pending = True
+ trade_mock2.pending = True
+ trade_mock3.pending = False
trade_store.all.append(trade_mock1)
trade_store.all.append(trade_mock2)
order_mock2.get_status.assert_called()
order_mock3.get_status.assert_called()
+ def test_close_trades(self):
+ trade_mock1 = mock.Mock()
+ trade_mock2 = mock.Mock()
+ trade_mock3 = mock.Mock()
+
+ trade_store = market.TradeStore(self.m)
+
+ trade_store.all.append(trade_mock1)
+ trade_store.all.append(trade_mock2)
+ trade_store.all.append(trade_mock3)
+
+ trade_store.close_trades()
+
+ trade_mock1.close.assert_called_once_with()
+ trade_mock2.close.assert_called_once_with()
+ trade_mock3.close.assert_called_once_with()
+
def test_pending(self):
trade_mock1 = mock.Mock()
- trade_mock1.is_fullfiled = False
+ trade_mock1.pending = True
trade_mock2 = mock.Mock()
- trade_mock2.is_fullfiled = False
+ trade_mock2.pending = True
trade_mock3 = mock.Mock()
- trade_mock3.is_fullfiled = True
+ trade_mock3.pending = False
trade_store = market.TradeStore(self.m)
value_to = portfolio.Amount("BTC", "1.0")
trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
- self.assertEqual("buy", trade.order_action(False))
- self.assertEqual("sell", trade.order_action(True))
+ trade.inverted = False
+ self.assertEqual("buy", trade.order_action())
+ trade.inverted = True
+ self.assertEqual("sell", trade.order_action())
value_from = portfolio.Amount("BTC", "0")
value_from.linked_to = portfolio.Amount("ETH", "0")
value_to = portfolio.Amount("BTC", "-1.0")
trade = portfolio.Trade(value_from, value_to, "ETH", self.m)
- self.assertEqual("sell", trade.order_action(False))
- self.assertEqual("buy", trade.order_action(True))
+ trade.inverted = False
+ self.assertEqual("sell", trade.order_action())
+ trade.inverted = True
+ self.assertEqual("buy", trade.order_action())
def test_trade_type(self):
value_from = portfolio.Amount("BTC", "0.5")
self.assertEqual("short", trade.trade_type)
def test_is_fullfiled(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)
+ with self.subTest(inverted=False):
+ 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()
- order1.filled_amount.return_value = portfolio.Amount("BTC", "0.3")
+ order1 = mock.Mock()
+ order1.filled_amount.return_value = portfolio.Amount("BTC", "0.3")
- order2 = mock.Mock()
- order2.filled_amount.return_value = portfolio.Amount("BTC", "0.01")
- trade.orders.append(order1)
- trade.orders.append(order2)
+ order2 = mock.Mock()
+ order2.filled_amount.return_value = portfolio.Amount("BTC", "0.01")
+ trade.orders.append(order1)
+ trade.orders.append(order2)
+
+ self.assertFalse(trade.is_fullfiled)
+
+ order3 = mock.Mock()
+ order3.filled_amount.return_value = portfolio.Amount("BTC", "0.19")
+ trade.orders.append(order3)
+
+ self.assertTrue(trade.is_fullfiled)
+
+ order1.filled_amount.assert_called_with(in_base_currency=True)
+ order2.filled_amount.assert_called_with(in_base_currency=True)
+ order3.filled_amount.assert_called_with(in_base_currency=True)
+
+ with self.subTest(inverted=True):
+ value_from = portfolio.Amount("BTC", "0.5")
+ value_from.linked_to = portfolio.Amount("USDT", "1000.0")
+ value_to = portfolio.Amount("BTC", "1.0")
+ trade = portfolio.Trade(value_from, value_to, "USDT", self.m)
+ trade.inverted = True
+
+ order1 = mock.Mock()
+ order1.filled_amount.return_value = portfolio.Amount("BTC", "0.3")
+
+ order2 = mock.Mock()
+ order2.filled_amount.return_value = portfolio.Amount("BTC", "0.01")
+ trade.orders.append(order1)
+ trade.orders.append(order2)
+
+ self.assertFalse(trade.is_fullfiled)
- self.assertFalse(trade.is_fullfiled)
+ order3 = mock.Mock()
+ order3.filled_amount.return_value = portfolio.Amount("BTC", "0.19")
+ trade.orders.append(order3)
- order3 = mock.Mock()
- order3.filled_amount.return_value = portfolio.Amount("BTC", "0.19")
- trade.orders.append(order3)
+ self.assertTrue(trade.is_fullfiled)
+
+ order1.filled_amount.assert_called_with(in_base_currency=False)
+ order2.filled_amount.assert_called_with(in_base_currency=False)
+ order3.filled_amount.assert_called_with(in_base_currency=False)
- self.assertTrue(trade.is_fullfiled)
def test_filled_amount(self):
value_from = portfolio.Amount("BTC", "0.5")
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()
+
+ 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.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.assertEqual(True, trade.closed)
+ order1.cancel.assert_called_once_with()
+
+ def test_pending(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)
+
+ trade.closed = True
+ self.assertEqual(False, trade.pending)
+
+ trade.closed = False
+ self.assertEqual(True, trade.pending)
+
+ order1 = mock.Mock()
+ order1.filled_amount.return_value = portfolio.Amount("BTC", "0.5")
+ trade.orders.append(order1)
+ self.assertEqual(False, trade.pending)
def test__repr(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()
- 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()
+
+ 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")
mock.call(portfolio.Amount("BTC", "0.95")),
])
- def test_process_sell_needed__1_sell(self):
- helper.process_sell_needed__1_sell(self.m)
+@unittest.skipUnless("unit" in limits, "Unit skipped")
+class ProcessorTest(WebMockTestCase):
+ def test_values(self):
+ processor = helper.Processor(self.m)
- self.m.balances.fetch_balances.assert_has_calls([
- mock.call(tag="process_sell_needed__1_sell_begin"),
- mock.call(tag="process_sell_needed__1_sell_end"),
- ])
- self.m.prepare_trades.assert_called_with(base_currency="BTC",
- liquidity="medium")
- self.m.trades.prepare_orders.assert_called_with(compute_value="average",
- only="dispose")
- self.m.trades.run_orders.assert_called()
- self.m.follow_orders.assert_called()
- self.m.report.log_stage.assert_has_calls([
- mock.call("process_sell_needed__1_sell_begin"),
- mock.call("process_sell_needed__1_sell_end")
- ])
+ self.assertEqual(self.m, processor.market)
- def test_process_sell_needed__2_buy(self):
- helper.process_sell_needed__2_buy(self.m)
+ def test_run_action(self):
+ processor = helper.Processor(self.m)
- self.m.balances.fetch_balances.assert_has_calls([
- mock.call(tag="process_sell_needed__2_buy_begin"),
- mock.call(tag="process_sell_needed__2_buy_end"),
- ])
- self.m.prepare_trades.assert_called_with(base_currency="BTC",
- liquidity="medium", only="acquire")
- self.m.trades.prepare_orders.assert_called_with(compute_value="average",
- only="acquire")
- self.m.move_balances.assert_called_with()
- self.m.trades.run_orders.assert_called()
- self.m.follow_orders.assert_called()
- self.m.report.log_stage.assert_has_calls([
- mock.call("process_sell_needed__2_buy_begin"),
- mock.call("process_sell_needed__2_buy_end")
- ])
+ with mock.patch.object(processor, "parse_args") as parse_args:
+ method_mock = mock.Mock()
+ parse_args.return_value = [method_mock, { "foo": "bar" }]
- def test_process_sell_all__1_sell(self):
- helper.process_sell_all__1_all_sell(self.m)
+ processor.run_action("foo", "bar", "baz")
- self.m.balances.fetch_balances.assert_has_calls([
- mock.call(tag="process_sell_all__1_all_sell_begin"),
- mock.call(tag="process_sell_all__1_all_sell_end"),
- ])
- self.m.prepare_trades.assert_called_with(base_currency="BTC",
- liquidity="medium", repartition={'BTC': (1, 'long')})
- self.m.trades.prepare_orders.assert_called_with(compute_value="average")
- self.m.trades.run_orders.assert_called()
- self.m.follow_orders.assert_called()
- self.m.report.log_stage.assert_has_calls([
- mock.call("process_sell_all__1_all_sell_begin"),
- mock.call("process_sell_all__1_all_sell_end")
- ])
+ parse_args.assert_called_with("foo", "bar", "baz")
- @mock.patch("portfolio.Portfolio.wait_for_recent")
- def test_process_sell_all__2_wait(self, wait):
- helper.process_sell_all__2_wait(self.m)
+ method_mock.assert_called_with(foo="bar")
- wait.assert_called_once_with(self.m)
- self.m.report.log_stage.assert_has_calls([
- mock.call("process_sell_all__2_wait_begin"),
- mock.call("process_sell_all__2_wait_end")
- ])
+ processor.run_action("wait_for_recent", "bar", "baz")
- def test_process_sell_all__3_all_buy(self):
- helper.process_sell_all__3_all_buy(self.m)
+ 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"])
- self.m.balances.fetch_balances.assert_has_calls([
- mock.call(tag="process_sell_all__3_all_buy_begin"),
- mock.call(tag="process_sell_all__3_all_buy_end"),
- ])
- self.m.prepare_trades.assert_called_with(base_currency="BTC",
- liquidity="medium")
- self.m.trades.prepare_orders.assert_called_with(compute_value="average")
- self.m.move_balances.assert_called_with()
- self.m.trades.run_orders.assert_called()
- self.m.follow_orders.assert_called()
- self.m.report.log_stage.assert_has_calls([
- mock.call("process_sell_all__3_all_buy_begin"),
- mock.call("process_sell_all__3_all_buy_end")
- ])
@unittest.skipUnless("acceptance" in limits, "Acceptance skipped")
class AcceptanceTest(WebMockTestCase):
projects / perso / Immae / Projets / Cryptomonnaies / Cryptoportfolio / Trader.git / blobdiff