diff --git a/openraft/tests/benchmark/bench_cluster.rs b/openraft/tests/benchmark/bench_cluster.rs
index 674eb5b6b..f6cbdcf0c 100644
--- a/openraft/tests/benchmark/bench_cluster.rs
+++ b/openraft/tests/benchmark/bench_cluster.rs
@@ -94,7 +94,7 @@ async fn do_bench(bench_config: &BenchConfig) -> anyhow::Result<()> {
     let now = Instant::now();
 
     for i in 0..n {
-        router.client_request(0, "foo", i as u64).await
+        router.client_request(0, "foo", i as u64).await?;
     }
 
     let elapsed = now.elapsed();
diff --git a/openraft/tests/fixtures/mod.rs b/openraft/tests/fixtures/mod.rs
index 80409376d..42137abea 100644
--- a/openraft/tests/fixtures/mod.rs
+++ b/openraft/tests/fixtures/mod.rs
@@ -539,7 +539,12 @@ where
     }
 
     /// Send a client request to the target node, causing test failure on error.
-    pub async fn client_request(&self, mut target: C::NodeId, client_id: &str, serial: u64) {
+    pub async fn client_request(
+        &self,
+        mut target: C::NodeId,
+        client_id: &str,
+        serial: u64,
+    ) -> Result<(), ClientWriteError<C::NodeId>> {
         for ith in 0..3 {
             let req = <C::D as IntoMemClientRequest<C::D>>::make_request(client_id, serial);
             if let Err(err) = self.send_client_request(target, req).await {
@@ -560,11 +565,16 @@ where
                     }
                     _ => {}
                 }
-                panic!("{:?}", err)
+                return Err(err);
             } else {
-                return;
+                return Ok(());
             }
         }
+
+        unreachable!(
+            "Max retry times exceeded. Can not finish client_request, target={}, client_id={} serial={}",
+            target, client_id, serial
+        )
     }
 
     /// Send external request to the particular node.
@@ -596,7 +606,7 @@ where
         count: usize,
     ) -> Result<(), ClientWriteError<C::NodeId>> {
         for idx in 0..count {
-            self.client_request(target, client_id, idx as u64).await
+            self.client_request(target, client_id, idx as u64).await?;
         }
 
         Ok(())
diff --git a/openraft/tests/membership/t00_learner_restart.rs b/openraft/tests/membership/t00_learner_restart.rs
index 3b8c3fe24..b6046a0c4 100644
--- a/openraft/tests/membership/t00_learner_restart.rs
+++ b/openraft/tests/membership/t00_learner_restart.rs
@@ -53,7 +53,7 @@ async fn learner_restart() -> Result<()> {
     }
 
     router.add_learner(0, 1).await?;
-    router.client_request(0, "foo", 1).await;
+    router.client_request(0, "foo", 1).await?;
     log_index += 2;
 
     router.wait_for_log(&btreeset![0, 1], Some(log_index), None, "write one log").await?;
diff --git a/openraft/tests/metrics/t20_metrics_state_machine_consistency.rs b/openraft/tests/metrics/t20_metrics_state_machine_consistency.rs
index a8de55ede..3a9830b9a 100644
--- a/openraft/tests/metrics/t20_metrics_state_machine_consistency.rs
+++ b/openraft/tests/metrics/t20_metrics_state_machine_consistency.rs
@@ -42,7 +42,7 @@ async fn metrics_state_machine_consistency() -> Result<()> {
     log_index += 1;
 
     tracing::info!("--- write one log");
-    router.client_request(0, "foo", 1).await;
+    router.client_request(0, "foo", 1).await?;
 
     // Wait for metrics to be up to date.
     // Once last_applied updated, the key should be visible in state machine.
diff --git a/openraft/tests/state_machine/t40_clean_applied_logs.rs b/openraft/tests/state_machine/t40_clean_applied_logs.rs
index 2972ddffe..ef0ce9a94 100644
--- a/openraft/tests/state_machine/t40_clean_applied_logs.rs
+++ b/openraft/tests/state_machine/t40_clean_applied_logs.rs
@@ -30,7 +30,7 @@ async fn clean_applied_logs() -> Result<()> {
 
     let count = (10 - log_index) as usize;
     for idx in 0..count {
-        router.client_request(0, "0", idx as u64).await;
+        router.client_request(0, "0", idx as u64).await?;
         // raft commit at once with a single leader cluster.
         // If we send too fast, logs are removed before forwarding to learner.
         // Then it triggers snapshot replication, which is not expected.