X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=test.py;h=235f6189008ae7bf67cbf5c17600c153d14db618;hb=065ee3422a6ee9d40136cfa6b272e951e15c2e50;hp=a9cae94e58265bcf9d1dcde67b53598d0547b35d;hpb=f86ee14037646bedc3a3dee4a48f085308981757;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FCryptoportfolio%2FTrader.git diff --git a/test.py b/test.py index a9cae94..235f618 100644 --- a/test.py +++ b/test.py @@ -35,10 +35,6 @@ class WebMockTestCase(unittest.TestCase): mock.patch.multiple(portfolio.Portfolio, last_date=None, data=None, liquidities={}), mock.patch.multiple(portfolio.Computation, computations=portfolio.Computation.computations), - mock.patch.multiple(market.Market, - fees_cache={}, - ticker_cache={}, - ticker_cache_timestamp=self.time.time()), ] for patcher in self.patchers: patcher.start() @@ -49,6 +45,87 @@ class WebMockTestCase(unittest.TestCase): self.wm.stop() super(WebMockTestCase, self).tearDown() +@unittest.skipUnless("unit" in limits, "Unit skipped") +class poloniexETest(unittest.TestCase): + def setUp(self): + super(poloniexETest, self).setUp() + self.wm = requests_mock.Mocker() + self.wm.start() + + self.s = market.ccxt.poloniexE() + + def tearDown(self): + self.wm.stop() + super(poloniexETest, self).tearDown() + + def test_nanoseconds(self): + with mock.patch.object(market.ccxt.time, "time") as time: + time.return_value = 123456.7890123456 + self.assertEqual(123456789012345, self.s.nanoseconds()) + + def test_nonce(self): + with mock.patch.object(market.ccxt.time, "time") as time: + time.return_value = 123456.7890123456 + self.assertEqual(123456789012345, self.s.nonce()) + + def test_order_precision(self): + self.assertEqual(8, self.s.order_precision("FOO")) + + def test_transfer_balance(self): + with self.subTest(success=True),\ + mock.patch.object(self.s, "privatePostTransferBalance") as t: + t.return_value = { "success": 1 } + result = self.s.transfer_balance("FOO", 12, "exchange", "margin") + t.assert_called_once_with({ + "currency": "FOO", + "amount": 12, + "fromAccount": "exchange", + "toAccount": "margin", + "confirmed": 1 + }) + self.assertTrue(result) + + with self.subTest(success=False),\ + mock.patch.object(self.s, "privatePostTransferBalance") as t: + t.return_value = { "success": 0 } + self.assertFalse(self.s.transfer_balance("FOO", 12, "exchange", "margin")) + + def test_close_margin_position(self): + with mock.patch.object(self.s, "privatePostCloseMarginPosition") as c: + self.s.close_margin_position("FOO", "BAR") + c.assert_called_with({"currencyPair": "BAR_FOO"}) + + def test_tradable_balances(self): + with mock.patch.object(self.s, "privatePostReturnTradableBalances") as r: + r.return_value = { + "FOO": { "exchange": "12.1234", "margin": "0.0123" }, + "BAR": { "exchange": "1", "margin": "0" }, + } + balances = self.s.tradable_balances() + self.assertEqual(["FOO", "BAR"], list(balances.keys())) + self.assertEqual(["exchange", "margin"], list(balances["FOO"].keys())) + self.assertEqual(D("12.1234"), balances["FOO"]["exchange"]) + self.assertEqual(["exchange", "margin"], list(balances["BAR"].keys())) + + def test_margin_summary(self): + with mock.patch.object(self.s, "privatePostReturnMarginAccountSummary") as r: + r.return_value = { + "currentMargin": "1.49680968", + "lendingFees": "0.0000001", + "pl": "0.00008254", + "totalBorrowedValue": "0.00673602", + "totalValue": "0.01000000", + "netValue": "0.01008254", + } + expected = { + 'current_margin': D('1.49680968'), + 'gains': D('0.00008254'), + 'lending_fees': D('0.0000001'), + 'total': D('0.01000000'), + 'total_borrowed': D('0.00673602') + } + self.assertEqual(expected, self.s.margin_summary()) + @unittest.skipUnless("unit" in limits, "Unit skipped") class PortfolioTest(WebMockTestCase): def fill_data(self): @@ -472,8 +549,9 @@ class BalanceTest(WebMockTestCase): "exchange_free": "0.35", "exchange_used": "0.30", "margin_total": "-10", - "margin_borrowed": "-10", - "margin_free": "0", + "margin_borrowed": "10", + "margin_available": "0", + "margin_in_position": "0", "margin_position_type": "short", "margin_borrowed_base_currency": "USDT", "margin_liquidation_price": "1.20", @@ -489,11 +567,11 @@ class BalanceTest(WebMockTestCase): self.assertEqual("BTC", balance.exchange_total.currency) self.assertEqual(portfolio.D("-10"), balance.margin_total.value) - self.assertEqual(portfolio.D("-10"), balance.margin_borrowed.value) - self.assertEqual(portfolio.D("0"), balance.margin_free.value) + self.assertEqual(portfolio.D("10"), balance.margin_borrowed.value) + self.assertEqual(portfolio.D("0"), balance.margin_available.value) self.assertEqual("BTC", balance.margin_total.currency) self.assertEqual("BTC", balance.margin_borrowed.currency) - self.assertEqual("BTC", balance.margin_free.currency) + self.assertEqual("BTC", balance.margin_available.currency) self.assertEqual("BTC", balance.currency) @@ -511,10 +589,10 @@ class BalanceTest(WebMockTestCase): self.assertEqual("Balance(BTX Exch: [❌1.00000000 BTX])", repr(balance)) balance = portfolio.Balance("BTX", { "margin_total": 3, - "margin_borrowed": 1, "margin_free": 2 }) - self.assertEqual("Balance(BTX Margin: [✔2.00000000 BTX + borrowed 1.00000000 BTX = 3.00000000 BTX])", repr(balance)) + "margin_in_position": 1, "margin_available": 2 }) + self.assertEqual("Balance(BTX Margin: [✔2.00000000 BTX + ❌1.00000000 BTX = 3.00000000 BTX])", repr(balance)) - balance = portfolio.Balance("BTX", { "margin_total": 2, "margin_free": 2 }) + balance = portfolio.Balance("BTX", { "margin_total": 2, "margin_available": 2 }) self.assertEqual("Balance(BTX Margin: [✔2.00000000 BTX])", repr(balance)) balance = portfolio.Balance("BTX", { "margin_total": -3, @@ -524,8 +602,8 @@ class BalanceTest(WebMockTestCase): self.assertEqual("Balance(BTX Margin: [-3.00000000 BTX @@ 0.10000000 BTC/0.00200000 BTC])", repr(balance)) balance = portfolio.Balance("BTX", { "margin_total": 1, - "margin_borrowed": 1, "exchange_free": 2, "exchange_total": 2}) - self.assertEqual("Balance(BTX Exch: [✔2.00000000 BTX] Margin: [borrowed 1.00000000 BTX] Total: [0.00000000 BTX])", repr(balance)) + "margin_in_position": 1, "exchange_free": 2, "exchange_total": 2}) + self.assertEqual("Balance(BTX Exch: [✔2.00000000 BTX] Margin: [❌1.00000000 BTX] Total: [0.00000000 BTX])", repr(balance)) def test_as_json(self): balance = portfolio.Balance("BTX", { "exchange_free": 2, "exchange_total": 2 }) @@ -536,7 +614,7 @@ class BalanceTest(WebMockTestCase): self.assertEqual(D(2), as_json["exchange_free"]) self.assertEqual(D(0), as_json["exchange_used"]) self.assertEqual(D(0), as_json["margin_total"]) - self.assertEqual(D(0), as_json["margin_free"]) + self.assertEqual(D(0), as_json["margin_available"]) self.assertEqual(D(0), as_json["margin_borrowed"]) @unittest.skipUnless("unit" in limits, "Unit skipped") @@ -571,7 +649,7 @@ class MarketTest(WebMockTestCase): ccxt.poloniexE.return_value = self.ccxt self.ccxt.session.request.return_value = "response" - m = market.Market.from_config("config") + m = market.Market.from_config({"key": "key", "secred": "secret"}) self.assertEqual(self.ccxt, m.ccxt) @@ -580,80 +658,74 @@ class MarketTest(WebMockTestCase): m.report.log_http_request.assert_called_with('GET', 'URL', 'data', 'headers', 'response') - m = market.Market.from_config("config", debug=True) + m = market.Market.from_config({"key": "key", "secred": "secret"}, debug=True) self.assertEqual(True, m.debug) - def test_get_ticker(self): - m = market.Market(self.ccxt) - self.ccxt.fetch_ticker.side_effect = [ - { "bid": 1, "ask": 3 }, - market.ExchangeError("foo"), - { "bid": 10, "ask": 40 }, - market.ExchangeError("foo"), - market.ExchangeError("foo"), + def test_get_tickers(self): + self.ccxt.fetch_tickers.side_effect = [ + "tickers", + market.NotSupported ] - ticker = m.get_ticker("ETH", "ETC") - self.ccxt.fetch_ticker.assert_called_with("ETH/ETC") - self.assertEqual(1, ticker["bid"]) - self.assertEqual(3, ticker["ask"]) - self.assertEqual(2, ticker["average"]) - self.assertFalse(ticker["inverted"]) - - ticker = m.get_ticker("ETH", "XVG") - self.assertEqual(0.0625, ticker["average"]) - self.assertTrue(ticker["inverted"]) - self.assertIn("original", ticker) - self.assertEqual(10, ticker["original"]["bid"]) - - ticker = m.get_ticker("XVG", "XMR") - self.assertIsNone(ticker) - - self.ccxt.fetch_ticker.assert_has_calls([ - mock.call("ETH/ETC"), - mock.call("ETH/XVG"), - mock.call("XVG/ETH"), - mock.call("XVG/XMR"), - mock.call("XMR/XVG"), - ]) + m = market.Market(self.ccxt) + self.assertEqual("tickers", m.get_tickers()) + self.assertEqual("tickers", m.get_tickers()) + self.ccxt.fetch_tickers.assert_called_once() - self.ccxt = mock.Mock(spec=market.ccxt.poloniexE) - m1b = market.Market(self.ccxt) - m1b.get_ticker("ETH", "ETC") - self.ccxt.fetch_ticker.assert_not_called() - - self.ccxt = mock.Mock(spec=market.ccxt.poloniex) - m2 = market.Market(self.ccxt) - self.ccxt.fetch_ticker.side_effect = [ - { "bid": 1, "ask": 3 }, - { "bid": 1.2, "ask": 3.5 }, - ] - ticker1 = m2.get_ticker("ETH", "ETC") - ticker2 = m2.get_ticker("ETH", "ETC") - ticker3 = m2.get_ticker("ETC", "ETH") - self.ccxt.fetch_ticker.assert_called_once_with("ETH/ETC") - self.assertEqual(1, ticker1["bid"]) - self.assertDictEqual(ticker1, ticker2) - self.assertDictEqual(ticker1, ticker3["original"]) - - ticker4 = m2.get_ticker("ETH", "ETC", refresh=True) - ticker5 = m2.get_ticker("ETH", "ETC") - self.assertEqual(1.2, ticker4["bid"]) - self.assertDictEqual(ticker4, ticker5) - - self.ccxt = mock.Mock(spec=market.ccxt.binance) - m3 = market.Market(self.ccxt) - self.ccxt.fetch_ticker.side_effect = [ - { "bid": 1, "ask": 3 }, - { "bid": 1.2, "ask": 3.5 }, - ] - ticker6 = m3.get_ticker("ETH", "ETC") - m3.ticker_cache_timestamp -= 4 - ticker7 = m3.get_ticker("ETH", "ETC") - m3.ticker_cache_timestamp -= 2 - ticker8 = m3.get_ticker("ETH", "ETC") - self.assertDictEqual(ticker6, ticker7) - self.assertEqual(1.2, ticker8["bid"]) + self.assertIsNone(m.get_tickers(refresh=self.time.time())) + + def test_get_ticker(self): + with self.subTest(get_tickers=True): + self.ccxt.fetch_tickers.return_value = { + "ETH/ETC": { "bid": 1, "ask": 3 }, + "XVG/ETH": { "bid": 10, "ask": 40 }, + } + m = market.Market(self.ccxt) + + ticker = m.get_ticker("ETH", "ETC") + self.assertEqual(1, ticker["bid"]) + self.assertEqual(3, ticker["ask"]) + self.assertEqual(2, ticker["average"]) + self.assertFalse(ticker["inverted"]) + + ticker = m.get_ticker("ETH", "XVG") + self.assertEqual(0.0625, ticker["average"]) + self.assertTrue(ticker["inverted"]) + self.assertIn("original", ticker) + self.assertEqual(10, ticker["original"]["bid"]) + self.assertEqual(25, ticker["original"]["average"]) + + ticker = m.get_ticker("XVG", "XMR") + self.assertIsNone(ticker) + + with self.subTest(get_tickers=False): + self.ccxt.fetch_tickers.return_value = None + self.ccxt.fetch_ticker.side_effect = [ + { "bid": 1, "ask": 3 }, + market.ExchangeError("foo"), + { "bid": 10, "ask": 40 }, + market.ExchangeError("foo"), + market.ExchangeError("foo"), + ] + + m = market.Market(self.ccxt) + + ticker = m.get_ticker("ETH", "ETC") + self.ccxt.fetch_ticker.assert_called_with("ETH/ETC") + self.assertEqual(1, ticker["bid"]) + self.assertEqual(3, ticker["ask"]) + self.assertEqual(2, ticker["average"]) + self.assertFalse(ticker["inverted"]) + + ticker = m.get_ticker("ETH", "XVG") + self.assertEqual(0.0625, ticker["average"]) + self.assertTrue(ticker["inverted"]) + self.assertIn("original", ticker) + self.assertEqual(10, ticker["original"]["bid"]) + self.assertEqual(25, ticker["original"]["average"]) + + ticker = m.get_ticker("XVG", "XMR") + self.assertIsNone(ticker) def test_fetch_fees(self): m = market.Market(self.ccxt) @@ -906,9 +978,9 @@ class MarketTest(WebMockTestCase): trade3 = portfolio.Trade(value_from, value_to, "XVG", m) m.trades.all = [trade1, trade2, trade3] - balance1 = portfolio.Balance("BTC", { "margin_free": "0" }) - balance2 = portfolio.Balance("USDT", { "margin_free": "100" }) - balance3 = portfolio.Balance("ETC", { "margin_free": "10" }) + balance1 = portfolio.Balance("BTC", { "margin_in_position": "0", "margin_available": "0" }) + balance2 = portfolio.Balance("USDT", { "margin_in_position": "100", "margin_available": "50" }) + balance3 = portfolio.Balance("ETC", { "margin_in_position": "10", "margin_available": "15" }) m.balances.all = {"BTC": balance1, "USDT": balance2, "ETC": balance3} m.move_balances() @@ -921,8 +993,8 @@ class MarketTest(WebMockTestCase): self.assertEqual(3, m.report.log_debug_action.call_count) else: self.ccxt.transfer_balance.assert_any_call("BTC", 3, "exchange", "margin") - self.ccxt.transfer_balance.assert_any_call("USDT", 50, "margin", "exchange") - self.ccxt.transfer_balance.assert_any_call("ETC", 10, "margin", "exchange") + self.ccxt.transfer_balance.assert_any_call("USDT", 100, "exchange", "margin") + self.ccxt.transfer_balance.assert_any_call("ETC", 5, "margin", "exchange") @unittest.skipUnless("unit" in limits, "Unit skipped") class TradeStoreTest(WebMockTestCase): @@ -1001,16 +1073,24 @@ class TradeStoreTest(WebMockTestCase): trade_mock1 = mock.Mock() trade_mock2 = mock.Mock() + trade_mock3 = mock.Mock() trade_mock1.prepare_order.return_value = 1 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_store.all.append(trade_mock1) trade_store.all.append(trade_mock2) + trade_store.all.append(trade_mock3) trade_store.prepare_orders() trade_mock1.prepare_order.assert_called_with(compute_value="default") trade_mock2.prepare_order.assert_called_with(compute_value="default") + trade_mock3.prepare_order.assert_not_called() self.m.report.log_orders.assert_called_once_with([1, 2], None, "default") self.m.report.log_orders.reset_mock() @@ -1108,6 +1188,21 @@ class TradeStoreTest(WebMockTestCase): order_mock2.get_status.assert_called() order_mock3.get_status.assert_called() + def test_pending(self): + trade_mock1 = mock.Mock() + trade_mock1.is_fullfiled = False + trade_mock2 = mock.Mock() + trade_mock2.is_fullfiled = False + trade_mock3 = mock.Mock() + trade_mock3.is_fullfiled = True + + trade_store = market.TradeStore(self.m) + + trade_store.all.append(trade_mock1) + trade_store.all.append(trade_mock2) + trade_store.all.append(trade_mock3) + + self.assertEqual([trade_mock1, trade_mock2], trade_store.pending) @unittest.skipUnless("unit" in limits, "Unit skipped") class BalanceStoreTest(WebMockTestCase): @@ -1301,13 +1396,16 @@ class TradeTest(WebMockTestCase): self.assertEqual(self.m, trade.market) with self.assertRaises(AssertionError): - portfolio.Trade(value_from, value_to, "ETC", self.m) + portfolio.Trade(value_from, -value_to, "ETH", self.m) with self.assertRaises(AssertionError): - value_from.linked_to = None - portfolio.Trade(value_from, value_to, "ETH", self.m) + portfolio.Trade(value_from, value_to, "ETC", self.m) with self.assertRaises(AssertionError): value_from.currency = "ETH" portfolio.Trade(value_from, value_to, "ETH", self.m) + value_from.currency = "BTC" + with self.assertRaises(AssertionError): + value_from2 = portfolio.Amount("BTC", "1.0") + portfolio.Trade(value_from2, value_to, "ETH", self.m) value_from = portfolio.Amount("BTC", 0) trade = portfolio.Trade(value_from, value_to, "ETH", self.m) @@ -1374,6 +1472,28 @@ class TradeTest(WebMockTestCase): 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) + + 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) + + order3 = mock.Mock() + order3.filled_amount.return_value = portfolio.Amount("BTC", "0.19") + trade.orders.append(order3) + + self.assertTrue(trade.is_fullfiled) + def test_filled_amount(self): value_from = portfolio.Amount("BTC", "0.5") value_from.linked_to = portfolio.Amount("ETH", "10.0") @@ -1458,6 +1578,25 @@ class TradeTest(WebMockTestCase): D("0.125"), "BTC", "long", self.m, trade, close_if_possible=False) + with self.subTest(action="dispose", inverted=False, close_if_possible=True): + filled_amount.return_value = portfolio.Amount("FOO", "60") + compute_value.return_value = D("0.125") + + value_from = portfolio.Amount("BTC", "10") + value_from.rate = D("0.1") + value_from.linked_to = portfolio.Amount("FOO", "100") + value_to = portfolio.Amount("BTC", "1") + trade = portfolio.Trade(value_from, value_to, "FOO", self.m) + + trade.prepare_order(close_if_possible=True) + + filled_amount.assert_called_with(in_base_currency=False) + compute_value.assert_called_with(self.m.get_ticker.return_value, "sell", compute_value="default") + self.assertEqual(1, len(trade.orders)) + Order.assert_called_with("sell", portfolio.Amount("FOO", 30), + D("0.125"), "BTC", "long", self.m, + trade, close_if_possible=True) + with self.subTest(action="acquire", inverted=False): filled_amount.return_value = portfolio.Amount("BTC", "3") compute_value.return_value = D("0.125") @@ -1569,7 +1708,7 @@ class TradeTest(WebMockTestCase): self.assertEqual(2, self.m.report.log_order.call_count) calls = [ mock.call(order_mock, 2, update="adjusting", - compute_value='lambda x, y: (x[y] + x["average"]) / 2', + compute_value=mock.ANY, new_order=new_order_mock), mock.call(order_mock, 2, new_order=new_order_mock), ] @@ -1588,7 +1727,7 @@ class TradeTest(WebMockTestCase): self.m.report.log_order.assert_called() calls = [ mock.call(order_mock, 5, update="adjusting", - compute_value='lambda x, y: (x[y]*2 + x["average"]) / 3', + compute_value=mock.ANY, new_order=new_order_mock), mock.call(order_mock, 5, new_order=new_order_mock), ] @@ -1812,7 +1951,7 @@ class OrderTest(WebMockTestCase): order.cancel() self.m.ccxt.cancel_order.assert_called_with(42) - fetch.assert_called_once() + fetch.assert_called_once_with() self.m.report.log_debug_action.assert_not_called() def test_dust_amount_remaining(self): @@ -1831,11 +1970,9 @@ class OrderTest(WebMockTestCase): D("0.1"), "BTC", "long", self.m, "trade") self.assertEqual(9, order.remaining_amount().value) - order.fetch.assert_not_called() order.status = "open" self.assertEqual(9, order.remaining_amount().value) - fetch.assert_called_once() @mock.patch.object(portfolio.Order, "fetch") def test_filled_amount(self, fetch): @@ -1938,61 +2075,38 @@ class OrderTest(WebMockTestCase): @mock.patch.object(portfolio.Order, "fetch_mouvements") def test_fetch(self, fetch_mouvements): - time = self.time.time() - with mock.patch.object(portfolio.time, "time") as time_mock: - order = portfolio.Order("buy", portfolio.Amount("ETH", 10), - D("0.1"), "BTC", "long", self.m, "trade") - order.id = 45 - with self.subTest(debug=True): - self.m.debug = True - order.fetch() - time_mock.assert_not_called() - self.m.report.log_debug_action.assert_called_once() - self.m.report.log_debug_action.reset_mock() - order.fetch(force=True) - time_mock.assert_not_called() - self.m.ccxt.fetch_order.assert_not_called() - fetch_mouvements.assert_not_called() - self.m.report.log_debug_action.assert_called_once() - self.m.report.log_debug_action.reset_mock() - self.assertIsNone(order.fetch_cache_timestamp) - - with self.subTest(debug=False): - self.m.debug = False - time_mock.return_value = time - self.m.ccxt.fetch_order.return_value = { - "status": "foo", - "datetime": "timestamp" - } - order.fetch() - - self.m.ccxt.fetch_order.assert_called_once() - fetch_mouvements.assert_called_once() - self.assertEqual("foo", order.status) - self.assertEqual("timestamp", order.timestamp) - self.assertEqual(time, order.fetch_cache_timestamp) - self.assertEqual(1, len(order.results)) - - self.m.ccxt.fetch_order.reset_mock() - fetch_mouvements.reset_mock() - - time_mock.return_value = time + 8 - order.fetch() - self.m.ccxt.fetch_order.assert_not_called() - fetch_mouvements.assert_not_called() + order = portfolio.Order("buy", portfolio.Amount("ETH", 10), + D("0.1"), "BTC", "long", self.m, "trade") + order.id = 45 + with self.subTest(debug=True): + self.m.debug = True + order.fetch() + self.m.report.log_debug_action.assert_called_once() + self.m.report.log_debug_action.reset_mock() + self.m.ccxt.fetch_order.assert_not_called() + fetch_mouvements.assert_not_called() - order.fetch(force=True) - self.m.ccxt.fetch_order.assert_called_once() - fetch_mouvements.assert_called_once() + with self.subTest(debug=False): + self.m.debug = False + self.m.ccxt.fetch_order.return_value = { + "status": "foo", + "datetime": "timestamp" + } + order.fetch() - self.m.ccxt.fetch_order.reset_mock() - fetch_mouvements.reset_mock() + self.m.ccxt.fetch_order.assert_called_once_with(45, symbol="ETH") + fetch_mouvements.assert_called_once() + self.assertEqual("foo", order.status) + self.assertEqual("timestamp", order.timestamp) + self.assertEqual(1, len(order.results)) + self.m.report.log_debug_action.assert_not_called() - time_mock.return_value = time + 19 + with self.subTest(missing_order=True): + self.m.ccxt.fetch_order.side_effect = [ + portfolio.OrderNotCached, + ] order.fetch() - self.m.ccxt.fetch_order.assert_called_once() - fetch_mouvements.assert_called_once() - self.m.report.log_debug_action.assert_not_called() + self.assertEqual("closed_unknown", order.status) @mock.patch.object(portfolio.Order, "fetch") @mock.patch.object(portfolio.Order, "mark_finished_order") @@ -2073,13 +2187,69 @@ class OrderTest(WebMockTestCase): mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order: order = portfolio.Order("buy", portfolio.Amount("ETH", 0.001), D("0.1"), "BTC", "long", self.m, "trade") - self.m.ccxt.create_order.side_effect = portfolio.ExchangeNotAvailable + self.m.ccxt.create_order.side_effect = portfolio.InvalidOrder order.run() self.m.ccxt.create_order.assert_called_once() self.assertEqual(0, len(order.results)) self.assertEqual("closed", order.status) mark_finished_order.assert_called_once() + self.m.ccxt.order_precision.return_value = 8 + self.m.ccxt.create_order.reset_mock() + with self.subTest(insufficient_funds=True),\ + mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order: + order = portfolio.Order("buy", portfolio.Amount("ETH", "0.001"), + D("0.1"), "BTC", "long", self.m, "trade") + self.m.ccxt.create_order.side_effect = [ + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + { "id": 123 }, + ] + order.run() + self.m.ccxt.create_order.assert_has_calls([ + mock.call('ETH/BTC', 'limit', 'buy', D('0.0010'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.00099'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.0009801'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.00097029'), account='exchange', price=D('0.1')), + ]) + self.assertEqual(4, self.m.ccxt.create_order.call_count) + self.assertEqual(1, len(order.results)) + self.assertEqual("open", order.status) + self.assertEqual(4, order.tries) + self.m.report.log_error.assert_called() + self.assertEqual(4, self.m.report.log_error.call_count) + + self.m.ccxt.order_precision.return_value = 8 + self.m.ccxt.create_order.reset_mock() + self.m.report.log_error.reset_mock() + with self.subTest(insufficient_funds=True),\ + mock.patch.object(portfolio.Order, "mark_finished_order") as mark_finished_order: + order = portfolio.Order("buy", portfolio.Amount("ETH", "0.001"), + D("0.1"), "BTC", "long", self.m, "trade") + self.m.ccxt.create_order.side_effect = [ + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + portfolio.InsufficientFunds, + ] + order.run() + self.m.ccxt.create_order.assert_has_calls([ + mock.call('ETH/BTC', 'limit', 'buy', D('0.0010'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.00099'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.0009801'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.00097029'), account='exchange', price=D('0.1')), + mock.call('ETH/BTC', 'limit', 'buy', D('0.00096059'), account='exchange', price=D('0.1')), + ]) + self.assertEqual(5, self.m.ccxt.create_order.call_count) + self.assertEqual(0, len(order.results)) + self.assertEqual("error", order.status) + self.assertEqual(5, order.tries) + self.m.report.log_error.assert_called() + self.assertEqual(5, self.m.report.log_error.call_count) + self.m.report.log_error.assert_called_with(mock.ANY, message="Giving up Order(buy long 0.00096060 ETH at 0.1 BTC [pending])", exception=mock.ANY) + @unittest.skipUnless("unit" in limits, "Unit skipped") class MouvementTest(WebMockTestCase): @@ -2180,8 +2350,7 @@ class ReportStoreTest(WebMockTestCase): report_store.logs.append({"date": portfolio.datetime(2018, 2, 24)}) self.assertEqual('[{"foo": "bar"}, {"date": "2018-02-24T00:00:00"}]', report_store.to_json()) report_store.logs.append({"amount": portfolio.Amount("BTC", 1)}) - with self.assertRaises(TypeError): - report_store.to_json() + self.assertEqual('[{"foo": "bar"}, {"date": "2018-02-24T00:00:00"}, {"amount": "1.00000000 BTC"}]', report_store.to_json()) @mock.patch.object(market.ReportStore, "print_log") @mock.patch.object(market.ReportStore, "add_log") @@ -2241,6 +2410,25 @@ class ReportStoreTest(WebMockTestCase): 'total': D('10.3') }) + add_log.reset_mock() + compute_value = lambda x: x["bid"] + report_store.log_tickers(amounts, "BTC", compute_value, "total") + add_log.assert_called_once_with({ + 'type': 'tickers', + 'compute_value': 'compute_value = lambda x: x["bid"]', + 'balance_type': 'total', + 'currency': 'BTC', + 'balances': { + 'BTC': D('10'), + 'ETH': D('0.3') + }, + 'rates': { + 'BTC': None, + 'ETH': D('0.1') + }, + 'total': D('10.3') + }) + @mock.patch.object(market.ReportStore, "print_log") @mock.patch.object(market.ReportStore, "add_log") def test_log_dispatch(self, add_log, print_log): @@ -2319,6 +2507,20 @@ class ReportStoreTest(WebMockTestCase): 'orders': ['order1', 'order2'] }) + add_log.reset_mock() + def compute_value(x, y): + return x[y] + report_store.log_orders(orders, tick="tick", + only="only", compute_value=compute_value) + add_log.assert_called_with({ + 'type': 'orders', + 'only': 'only', + 'compute_value': 'def compute_value(x, y):\n return x[y]', + 'tick': 'tick', + 'orders': ['order1', 'order2'] + }) + + @mock.patch.object(market.ReportStore, "print_log") @mock.patch.object(market.ReportStore, "add_log") def test_log_order(self, add_log, print_log): @@ -2362,16 +2564,17 @@ class ReportStoreTest(WebMockTestCase): add_log.reset_mock() print_log.reset_mock() with self.subTest(update="adjusting"): + compute_value = lambda x: (x["bid"] + x["ask"]*2)/3 report_store.log_order(order_mock, 3, update="adjusting", new_order=new_order_mock, - compute_value="default") + compute_value=compute_value) print_log.assert_called_once_with("[Order] Order Mock, tick 3, cancelling and adjusting to New order Mock") add_log.assert_called_once_with({ 'type': 'order', 'tick': 3, 'update': 'adjusting', 'order': 'order', - 'compute_value': "default", + 'compute_value': 'compute_value = lambda x: (x["bid"] + x["ask"]*2)/3', 'new_order': 'new_order' }) @@ -2531,6 +2734,119 @@ class ReportStoreTest(WebMockTestCase): @unittest.skipUnless("unit" in limits, "Unit skipped") class HelperTest(WebMockTestCase): + def test_make_order(self): + self.m.get_ticker.return_value = { + "inverted": False, + "average": D("0.1"), + "bid": D("0.09"), + "ask": D("0.11"), + } + + with self.subTest(description="nominal case"): + helper.make_order(self.m, 10, "ETH") + + self.m.report.log_stage.assert_has_calls([ + mock.call("make_order_begin"), + mock.call("make_order_end"), + ]) + self.m.balances.fetch_balances.assert_has_calls([ + mock.call(tag="make_order_begin"), + mock.call(tag="make_order_end"), + ]) + self.m.trades.all.append.assert_called_once() + trade = self.m.trades.all.append.mock_calls[0][1][0] + self.assertEqual(False, trade.orders[0].close_if_possible) + self.assertEqual(0, trade.value_from) + self.assertEqual("ETH", trade.currency) + self.assertEqual("BTC", trade.base_currency) + self.m.report.log_orders.assert_called_once_with([trade.orders[0]], None, "average") + self.m.trades.run_orders.assert_called_once_with() + self.m.follow_orders.assert_called_once_with() + + order = trade.orders[0] + self.assertEqual(D("0.10"), order.rate) + + self.m.reset_mock() + with self.subTest(compute_value="default"): + helper.make_order(self.m, 10, "ETH", action="dispose", + compute_value="ask") + + trade = self.m.trades.all.append.mock_calls[0][1][0] + order = trade.orders[0] + self.assertEqual(D("0.11"), order.rate) + + self.m.reset_mock() + with self.subTest(follow=False): + result = helper.make_order(self.m, 10, "ETH", follow=False) + + self.m.report.log_stage.assert_has_calls([ + mock.call("make_order_begin"), + mock.call("make_order_end_not_followed"), + ]) + self.m.balances.fetch_balances.assert_called_once_with(tag="make_order_begin") + + self.m.trades.all.append.assert_called_once() + trade = self.m.trades.all.append.mock_calls[0][1][0] + self.assertEqual(0, trade.value_from) + self.assertEqual("ETH", trade.currency) + self.assertEqual("BTC", trade.base_currency) + self.m.report.log_orders.assert_called_once_with([trade.orders[0]], None, "average") + self.m.trades.run_orders.assert_called_once_with() + self.m.follow_orders.assert_not_called() + self.assertEqual(trade.orders[0], result) + + self.m.reset_mock() + with self.subTest(base_currency="USDT"): + helper.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.assertEqual("USDT", trade.base_currency) + + self.m.reset_mock() + with self.subTest(close_if_possible=True): + helper.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") + + trade = self.m.trades.all.append.mock_calls[0][1][0] + self.assertEqual(0, trade.value_to) + self.assertEqual(1, trade.value_from.value) + self.assertEqual("ETH", trade.currency) + self.assertEqual("BTC", trade.base_currency) + + self.m.reset_mock() + with self.subTest(compute_value="default"): + helper.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: + 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) + + 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) + + 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): @@ -2559,11 +2875,11 @@ class HelperTest(WebMockTestCase): self.assertRegex(stdout_mock.getvalue(), "impossible to store report file: FileNotFoundError;") @mock.patch("helper.process_sell_all__1_all_sell") - @mock.patch("helper.process_sell_all__2_all_buy") - @mock.patch("portfolio.Portfolio.wait_for_recent") - def test_main_process_market(self, wait, buy, sell): + @mock.patch("helper.process_sell_all__2_wait") + @mock.patch("helper.process_sell_all__3_all_buy") + def test_main_process_market(self, buy, wait, sell): with self.subTest(before=False, after=False): - helper.main_process_market("user") + helper.main_process_market("user", None) wait.assert_not_called() buy.assert_not_called() @@ -2573,7 +2889,7 @@ class HelperTest(WebMockTestCase): wait.reset_mock() sell.reset_mock() with self.subTest(before=True, after=False): - helper.main_process_market("user", before=True) + helper.main_process_market("user", None, before=True) wait.assert_not_called() buy.assert_not_called() @@ -2583,7 +2899,7 @@ class HelperTest(WebMockTestCase): wait.reset_mock() sell.reset_mock() with self.subTest(before=False, after=True): - helper.main_process_market("user", after=True) + helper.main_process_market("user", None, after=True) wait.assert_called_once_with("user") buy.assert_called_once_with("user") @@ -2593,12 +2909,39 @@ class HelperTest(WebMockTestCase): wait.reset_mock() sell.reset_mock() with self.subTest(before=True, after=True): - helper.main_process_market("user", before=True, after=True) + helper.main_process_market("user", None, before=True, after=True) wait.assert_called_once_with("user") buy.assert_called_once_with("user") sell.assert_called_once_with("user") + buy.reset_mock() + wait.reset_mock() + sell.reset_mock() + with self.subTest(action="print_balances"),\ + mock.patch("helper.print_balances") as print_balances: + helper.main_process_market("user", ["print_balances"]) + + buy.assert_not_called() + wait.assert_not_called() + sell.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"]) + + buy.assert_not_called() + wait.assert_not_called() + sell.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() @@ -2608,12 +2951,23 @@ class HelperTest(WebMockTestCase): connect_mock.cursor.return_value = cursor_mock psycopg2.connect.return_value = connect_mock - rows = list(helper.main_fetch_markets({"foo": "bar"})) + 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)) - psycopg2.connect.assert_called_once_with(foo="bar") - cursor_mock.execute.assert_called_once_with("SELECT config,user_id FROM market_configs") + 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) + self.assertEqual(["row_1", "row_2"], rows) @mock.patch.object(helper.sys, "exit") def test_main_parse_args(self, exit): @@ -2703,6 +3057,7 @@ class HelperTest(WebMockTestCase): 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:"), @@ -2762,12 +3117,22 @@ class HelperTest(WebMockTestCase): mock.call("process_sell_all__1_all_sell_end") ]) - def test_process_sell_all__2_all_buy(self): - helper.process_sell_all__2_all_buy(self.m) + @mock.patch("portfolio.Portfolio.wait_for_recent") + def test_process_sell_all__2_wait(self, wait): + helper.process_sell_all__2_wait(self.m) + + 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") + ]) + + def test_process_sell_all__3_all_buy(self): + helper.process_sell_all__3_all_buy(self.m) self.m.balances.fetch_balances.assert_has_calls([ - mock.call(tag="process_sell_all__2_all_buy_begin"), - mock.call(tag="process_sell_all__2_all_buy_end"), + 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") @@ -2776,8 +3141,8 @@ class HelperTest(WebMockTestCase): 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__2_all_buy_begin"), - mock.call("process_sell_all__2_all_buy_end") + 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")