+@unittest.skipUnless("unit" in limits, "Unit skipped")
+class OrderTest(WebMockTestCase):
+ def test_values(self):
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ self.assertEqual("buy", order.action)
+ self.assertEqual(10, order.amount.value)
+ self.assertEqual("ETH", order.amount.currency)
+ self.assertEqual(D("0.1"), order.rate)
+ self.assertEqual("BTC", order.base_currency)
+ self.assertEqual("market", order.market)
+ self.assertEqual("long", order.trade_type)
+ self.assertEqual("pending", order.status)
+ self.assertEqual("trade", order.trade)
+ self.assertIsNone(order.id)
+ self.assertFalse(order.close_if_possible)
+
+ def test__repr(self):
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ self.assertEqual("Order(buy long 10.00000000 ETH at 0.1 BTC [pending])", repr(order))
+
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade",
+ close_if_possible=True)
+ self.assertEqual("Order(buy long 10.00000000 ETH at 0.1 BTC [pending] ✂)", repr(order))
+
+ def test_account(self):
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ self.assertEqual("exchange", order.account)
+
+ order = portfolio.Order("sell", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "short", "market", "trade")
+ self.assertEqual("margin", order.account)
+
+ def test_pending(self):
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ self.assertTrue(order.pending)
+ order.status = "open"
+ self.assertFalse(order.pending)
+
+ def test_open(self):
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ self.assertFalse(order.open)
+ order.status = "open"
+ self.assertTrue(order.open)
+
+ def test_finished(self):
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ self.assertFalse(order.finished)
+ order.status = "closed"
+ self.assertTrue(order.finished)
+ order.status = "canceled"
+ self.assertTrue(order.finished)
+ order.status = "error"
+ self.assertTrue(order.finished)
+
+ @mock.patch.object(portfolio.Order, "fetch")
+ def test_cancel(self, fetch):
+ market = mock.Mock()
+ portfolio.TradeStore.debug = True
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", market, "trade")
+ order.status = "open"
+
+ order.cancel()
+ market.cancel_order.assert_not_called()
+ self.assertEqual("canceled", order.status)
+
+ portfolio.TradeStore.debug = False
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", market, "trade")
+ order.status = "open"
+ order.id = 42
+
+ order.cancel()
+ market.cancel_order.assert_called_with(42)
+ fetch.assert_called_once()
+
+ def test_dust_amount_remaining(self):
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ order.remaining_amount = mock.Mock(return_value=portfolio.Amount("ETH", 1))
+ self.assertFalse(order.dust_amount_remaining())
+
+ order.remaining_amount = mock.Mock(return_value=portfolio.Amount("ETH", D("0.0001")))
+ self.assertTrue(order.dust_amount_remaining())
+
+ @mock.patch.object(portfolio.Order, "fetch")
+ @mock.patch.object(portfolio.Order, "filled_amount", return_value=portfolio.Amount("ETH", 1))
+ def test_remaining_amount(self, filled_amount, fetch):
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "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):
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ order.mouvements.append(portfolio.Mouvement("ETH", "BTC", {
+ "tradeID": 42, "type": "buy", "fee": "0.0015",
+ "date": "2017-12-30 12:00:12", "rate": "0.1",
+ "amount": "3", "total": "0.3"
+ }))
+ order.mouvements.append(portfolio.Mouvement("ETH", "BTC", {
+ "tradeID": 43, "type": "buy", "fee": "0.0015",
+ "date": "2017-12-30 13:00:12", "rate": "0.2",
+ "amount": "2", "total": "0.4"
+ }))
+ self.assertEqual(portfolio.Amount("ETH", 5), order.filled_amount())
+ fetch.assert_not_called()
+ order.status = "open"
+ self.assertEqual(portfolio.Amount("ETH", 5), order.filled_amount(in_base_currency=False))
+ fetch.assert_called_once()
+ self.assertEqual(portfolio.Amount("BTC", "0.7"), order.filled_amount(in_base_currency=True))
+
+ def test_fetch_mouvements(self):
+ market = mock.Mock()
+ market.privatePostReturnOrderTrades.return_value = [
+ {
+ "tradeID": 42, "type": "buy", "fee": "0.0015",
+ "date": "2017-12-30 12:00:12", "rate": "0.1",
+ "amount": "3", "total": "0.3"
+ },
+ {
+ "tradeID": 43, "type": "buy", "fee": "0.0015",
+ "date": "2017-12-30 13:00:12", "rate": "0.2",
+ "amount": "2", "total": "0.4"
+ }
+ ]
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", market, "trade")
+ order.id = 12
+ order.mouvements = ["Foo", "Bar", "Baz"]
+
+ order.fetch_mouvements()
+
+ market.privatePostReturnOrderTrades.assert_called_with({"orderNumber": 12})
+ self.assertEqual(2, len(order.mouvements))
+ self.assertEqual(42, order.mouvements[0].id)
+ self.assertEqual(43, order.mouvements[1].id)
+
+ market.privatePostReturnOrderTrades.side_effect = portfolio.ExchangeError
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", market, "trade")
+ order.fetch_mouvements()
+ self.assertEqual(0, len(order.mouvements))
+
+ def test_mark_finished_order(self):
+ market = mock.Mock()
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "short", market, "trade",
+ close_if_possible=True)
+ order.status = "closed"
+ portfolio.TradeStore.debug = False
+
+ order.mark_finished_order()
+ market.close_margin_position.assert_called_with("ETH", "BTC")
+ market.close_margin_position.reset_mock()
+
+ order.status = "open"
+ order.mark_finished_order()
+ market.close_margin_position.assert_not_called()
+
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "short", market, "trade",
+ close_if_possible=False)
+ order.status = "closed"
+ order.mark_finished_order()
+ market.close_margin_position.assert_not_called()
+
+ order = portfolio.Order("sell", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "short", market, "trade",
+ close_if_possible=True)
+ order.status = "closed"
+ order.mark_finished_order()
+ market.close_margin_position.assert_not_called()
+
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", market, "trade",
+ close_if_possible=True)
+ order.status = "closed"
+ order.mark_finished_order()
+ market.close_margin_position.assert_not_called()
+
+ portfolio.TradeStore.debug = True
+
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "short", market, "trade",
+ close_if_possible=True)
+ order.status = "closed"
+
+ order.mark_finished_order()
+ market.close_margin_position.assert_not_called()
+
+ @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:
+ market = mock.Mock()
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", market, "trade")
+ order.id = 45
+ with self.subTest(debug=True):
+ portfolio.TradeStore.debug = True
+ order.fetch()
+ time_mock.assert_not_called()
+ order.fetch(force=True)
+ time_mock.assert_not_called()
+ market.fetch_order.assert_not_called()
+ fetch_mouvements.assert_not_called()
+ self.assertIsNone(order.fetch_cache_timestamp)
+
+ with self.subTest(debug=False):
+ portfolio.TradeStore.debug = False
+ time_mock.return_value = time
+ market.fetch_order.return_value = {
+ "status": "foo",
+ "datetime": "timestamp"
+ }
+ order.fetch()
+
+ market.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))
+
+ market.fetch_order.reset_mock()
+ fetch_mouvements.reset_mock()
+
+ time_mock.return_value = time + 8
+ order.fetch()
+ market.fetch_order.assert_not_called()
+ fetch_mouvements.assert_not_called()
+
+ order.fetch(force=True)
+ market.fetch_order.assert_called_once()
+ fetch_mouvements.assert_called_once()
+
+ market.fetch_order.reset_mock()
+ fetch_mouvements.reset_mock()
+
+ time_mock.return_value = time + 19
+ order.fetch()
+ market.fetch_order.assert_called_once()
+ fetch_mouvements.assert_called_once()
+
+ @mock.patch.object(portfolio.Order, "fetch")
+ @mock.patch.object(portfolio.Order, "mark_finished_order")
+ def test_get_status(self, mark_finished_order, fetch):
+ with self.subTest(debug=True):
+ portfolio.TradeStore.debug = True
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ self.assertEqual("pending", order.get_status())
+ fetch.assert_not_called()
+
+ with self.subTest(debug=False, finished=False):
+ portfolio.TradeStore.debug = False
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ def _fetch(order):
+ def update_status():
+ order.status = "open"
+ return update_status
+ fetch.side_effect = _fetch(order)
+ self.assertEqual("open", order.get_status())
+ mark_finished_order.assert_not_called()
+ fetch.assert_called_once()
+
+ mark_finished_order.reset_mock()
+ fetch.reset_mock()
+ with self.subTest(debug=False, finished=True):
+ portfolio.TradeStore.debug = False
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", "market", "trade")
+ def _fetch(order):
+ def update_status():
+ order.status = "closed"
+ return update_status
+ fetch.side_effect = _fetch(order)
+ self.assertEqual("closed", order.get_status())
+ mark_finished_order.assert_called_once()
+ fetch.assert_called_once()
+
+ def test_run(self):
+ market = mock.Mock()
+
+ market.order_precision.return_value = 4
+ with self.subTest(debug=True),\
+ mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
+ portfolio.TradeStore.debug = True
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", market, "trade")
+ order.run()
+ market.create_order.assert_not_called()
+ self.assertEqual("market.create_order('ETH/BTC', 'limit', 'buy', 10.0000, price=0.1, account=exchange)\n", stdout_mock.getvalue())
+ self.assertEqual("open", order.status)
+ self.assertEqual(1, len(order.results))
+ self.assertEqual(-1, order.id)
+
+ market.create_order.reset_mock()
+ with self.subTest(debug=False):
+ portfolio.TradeStore.debug = False
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", market, "trade")
+ market.create_order.return_value = { "id": 123 }
+ order.run()
+ market.create_order.assert_called_once()
+ self.assertEqual(1, len(order.results))
+ self.assertEqual("open", order.status)
+
+ market.create_order.reset_mock()
+ with self.subTest(exception=True),\
+ mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
+ order = portfolio.Order("buy", portfolio.Amount("ETH", 10),
+ D("0.1"), "BTC", "long", market, "trade")
+ market.create_order.side_effect = Exception("bouh")
+ order.run()
+ market.create_order.assert_called_once()
+ self.assertEqual(0, len(order.results))
+ self.assertEqual("error", order.status)
+ self.assertRegex(stdout_mock.getvalue(), "error when running market.create_order")
+ self.assertRegex(stdout_mock.getvalue(), "Exception: bouh")
+
+ market.create_order.reset_mock()
+ with self.subTest(dust_amount_exception=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", market, "trade")
+ market.create_order.side_effect = portfolio.ExchangeNotAvailable
+ order.run()
+ market.create_order.assert_called_once()
+ self.assertEqual(0, len(order.results))
+ self.assertEqual("closed", order.status)
+ mark_finished_order.assert_called_once()
+
+
+@unittest.skipUnless("unit" in limits, "Unit skipped")
+class MouvementTest(WebMockTestCase):
+ def test_values(self):
+ mouvement = portfolio.Mouvement("ETH", "BTC", {
+ "tradeID": 42, "type": "buy", "fee": "0.0015",
+ "date": "2017-12-30 12:00:12", "rate": "0.1",
+ "amount": "10", "total": "1"
+ })
+ self.assertEqual("ETH", mouvement.currency)
+ self.assertEqual("BTC", mouvement.base_currency)
+ self.assertEqual(42, mouvement.id)
+ self.assertEqual("buy", mouvement.action)
+ self.assertEqual(D("0.0015"), mouvement.fee_rate)
+ self.assertEqual(portfolio.datetime(2017, 12, 30, 12, 0, 12), mouvement.date)
+ self.assertEqual(D("0.1"), mouvement.rate)
+ self.assertEqual(portfolio.Amount("ETH", "10"), mouvement.total)
+ self.assertEqual(portfolio.Amount("BTC", "1"), mouvement.total_in_base)
+
+ mouvement = portfolio.Mouvement("ETH", "BTC", { "foo": "bar" })
+ self.assertIsNone(mouvement.date)
+ self.assertIsNone(mouvement.id)
+ self.assertIsNone(mouvement.action)
+ self.assertEqual(-1, mouvement.fee_rate)
+ self.assertEqual(0, mouvement.rate)
+ self.assertEqual(portfolio.Amount("ETH", 0), mouvement.total)
+ self.assertEqual(portfolio.Amount("BTC", 0), mouvement.total_in_base)
+
+@unittest.skipUnless("acceptance" in limits, "Acceptance skipped")