Merge pull request #6789 from yancong001/fix/Unexpected_error_while_p…

…rocessing_event_201

fix unexpected_error_while_processing_event_201

hummingbot/connector/derivative/hyperliquid_perpetual/hyperliquid_perpetual_derivative.py

@@ -24,7 +24,7 @@
 from hummingbot.connector.utils import combine_to_hb_trading_pair, get_new_client_order_id
 from hummingbot.core.api_throttler.data_types import RateLimit
 from hummingbot.core.data_type.common import OrderType, PositionAction, PositionMode, PositionSide, TradeType
-from hummingbot.core.data_type.in_flight_order import InFlightOrder, OrderState, OrderUpdate, TradeUpdate
+from hummingbot.core.data_type.in_flight_order import InFlightOrder, OrderUpdate, TradeUpdate
 from hummingbot.core.data_type.order_book_tracker_data_source import OrderBookTrackerDataSource
 from hummingbot.core.data_type.trade_fee import TokenAmount, TradeFeeBase
 from hummingbot.core.data_type.user_stream_tracker_data_source import UserStreamTrackerDataSource
@@ -215,6 +215,9 @@ async def _status_polling_loop_fetch_updates(self):
     async def _update_order_status(self):
         await self._update_orders()
 
+    async def _update_lost_orders_status(self):
+        await self._update_lost_orders()
+
     def _get_fee(self,
                  base_currency: str,
                  quote_currency: str,
@@ -449,16 +452,7 @@ async def _all_trade_updates_for_order(self, order: InFlightOrder) -> List[Trade
     async def _handle_update_error_for_active_order(self, order: InFlightOrder, error: Exception):
         try:
             raise error
-        except KeyError:
-            _order_update: OrderUpdate = OrderUpdate(
-                trading_pair=order.trading_pair,
-                update_timestamp=int(time.time()),
-                new_state=OrderState.PENDING_CREATE,
-                client_order_id=order.client_order_id,
-                exchange_order_id=str(order.exchange_order_id),
-            )
-            self._order_tracker.process_order_update(_order_update)
-        except asyncio.TimeoutError:
+        except (asyncio.TimeoutError, KeyError):
             self.logger().debug(
                 f"Tracked order {order.client_order_id} does not have an exchange id. "
                 f"Attempting fetch in next polling interval."

test/hummingbot/connector/derivative/hyperliquid_perpetual/test_hyperliquid_perpetual_derivative.py

@@ -467,10 +467,16 @@ def configure_order_not_found_error_cancelation_response(
     def configure_order_not_found_error_order_status_response(
             self, order: InFlightOrder, mock_api: aioresponses,
             callback: Optional[Callable] = lambda *args, **kwargs: None
-    ) -> List[str]:
-        # Implement the expected not found response when enabling
-        # test_lost_order_removed_if_not_found_during_order_status_update
-        raise NotImplementedError
+    ):
+        url_order_status = web_utils.public_rest_url(
+            CONSTANTS.ORDER_URL
+        )
+
+        regex_url = re.compile(f"^{url_order_status}".replace(".", r"\.").replace("?", r"\?") + ".*")
+
+        response = {"code": -2013, "msg": "order"}
+        mock_api.post(regex_url, body=json.dumps(response), callback=callback)
+        return url_order_status
 
     def configure_completely_filled_order_status_response(
             self,
@@ -984,9 +990,48 @@ def test_cancel_order_not_found_in_the_exchange(self, mock_api):
 
     @aioresponses()
     def test_lost_order_removed_if_not_found_during_order_status_update(self, mock_api):
-        # Disabling this test because the connector has not been updated yet to validate
-        # order not found during status update (check _is_order_not_found_during_status_update_error)
-        pass
+        self.exchange._set_current_timestamp(1640780000)
+        request_sent_event = asyncio.Event()
+
+        self.exchange.start_tracking_order(
+            order_id=self.client_order_id_prefix + "1",
+            exchange_order_id=self.expected_exchange_order_id,
+            trading_pair=self.trading_pair,
+            order_type=OrderType.LIMIT,
+            trade_type=TradeType.BUY,
+            price=Decimal("10000"),
+            amount=Decimal("1"),
+        )
+        order: InFlightOrder = self.exchange.in_flight_orders[self.client_order_id_prefix + "1"]
+
+        for _ in range(self.exchange._order_tracker._lost_order_count_limit + 1):
+            self.async_run_with_timeout(
+                self.exchange._order_tracker.process_order_not_found(client_order_id=order.client_order_id)
+            )
+
+        self.assertNotIn(order.client_order_id, self.exchange.in_flight_orders)
+
+        if self.is_order_fill_http_update_included_in_status_update:
+            # This is done for completeness reasons (to have a response available for the trades request)
+            self.configure_erroneous_http_fill_trade_response(order=order, mock_api=mock_api)
+
+        self.configure_order_not_found_error_order_status_response(
+            order=order, mock_api=mock_api, callback=lambda *args, **kwargs: request_sent_event.set()
+        )
+
+        self.async_run_with_timeout(self.exchange._update_lost_orders_status())
+        # Execute one more synchronization to ensure the async task that processes the update is finished
+        self.async_run_with_timeout(request_sent_event.wait())
+
+        self.assertTrue(order.is_done)
+        self.assertTrue(order.is_failure)
+
+        self.assertEqual(0, len(self.buy_order_completed_logger.event_log))
+        self.assertNotIn(order.client_order_id, self.exchange._order_tracker.all_fillable_orders)
+
+        self.assertFalse(
+            self.is_logged("INFO", f"BUY order {order.client_order_id} completely filled.")
+        )
 
     def _order_cancelation_request_successful_mock_response(self, order: InFlightOrder) -> Any:
         return {'status': 'ok', 'response': {'type': 'cancel', 'data': {'statuses': ['success']}}}