code: def test_proxy_state_reconcile_draining_success():
      """Test that the proxy will remain DRAINING even if health check succeeds."""
      timer = MockTimer(start_time=0)
      # Start with HEALTHY state
      proxy_state = _create_proxy_state(
          status=ProxyStatus.HEALTHY, timer=timer
      )
      # Simulate health-checks passing
      proxy_state._actor_proxy_wrapper.healthy = (
          ProxyWrapperCallStatus.FINISHED_SUCCEED
      )
      # Simulate is_drained check returning false
      proxy_state._actor_proxy_wrapper.drained = (
          ProxyWrapperCallStatus.FINISHED_FAILED
      )
  
      for _ in range(10):
          proxy_state.update(draining=True)
          assert proxy_state.status == ProxyStatus.DRAINING
          # Advance timer by 5 (to trigger new health-check, drain-check)
          timer.advance(5)
  
      # assert proxy_state._actor_proxy_wrapper.get_num_health_checks() == 10
      # assert proxy_state._actor_proxy_wrapper.get_num_drain_checks() == 9
  
      # Make sure the status is still DRAINING
      assert proxy_state.status == ProxyStatus.DRAINING
  
      # Simulate is_drained request to ProxyActor pending (for 5 iterations)
      proxy_state._actor_proxy_wrapper.drained = (
          ProxyWrapperCallStatus.PENDING
      )
  
      for _ in range(5):
          proxy_state.update(draining=True)
          assert proxy_state.status == ProxyStatus.DRAINING
          # Advance timer by 5 (to trigger new health-check, drain-check)
          timer.advance(5)
  
      # assert proxy_state._actor_proxy_wrapper.get_num_health_checks() == 15
      # No new drain checks will occur, since there's a pending one (not completed yet)
      # assert proxy_state._actor_proxy_wrapper.get_num_drain_checks() == 14
  
      # Simulate draining completed
      proxy_state._actor_proxy_wrapper.drained = (
          ProxyWrapperCallStatus.FINISHED_SUCCEED
      )
      # Advance timer by 5 (to trigger new health-check, drain-check on next iteration)
      timer.advance(5)
  
      proxy_state.update(draining=True)
      # State should transition to DRAINED
      assert proxy_state.status == ProxyStatus.DRAINED
  
imports: import json
  import time
  from typing import List, Tuple
  from unittest.mock import patch
  import pytest
  from ray._private.test_utils import wait_for_condition
  from ray.serve._private.cluster_node_info_cache import ClusterNodeInfoCache
  from ray.serve._private.common import ProxyStatus
  from ray.serve._private.constants import PROXY_HEALTH_CHECK_UNHEALTHY_THRESHOLD
  from ray.serve._private.proxy_state import ProxyState, ProxyStateManager, ProxyWrapper, ProxyWrapperCallStatus
  from ray.serve._private.test_utils import MockTimer
  from ray.serve._private.utils import Timer
  from ray.serve.config import DeploymentMode, HTTPOptions
  from ray.serve.schema import LoggingConfig
label_desc: Use image node_id 24 for calling a global function with example usage: test_proxy_state_reconcile_draining_success() without return types