Convert async_sleep into SleepBackend enum

Author: paolobarbolini

src/client.rs

@@ -12,7 +12,7 @@ use crate::{
     search::*,
     task_info::TaskInfo,
     tasks::{Task, TasksCancelQuery, TasksDeleteQuery, TasksResults, TasksSearchQuery},
-    utils::async_sleep,
+    utils::SleepBackend,
     DefaultHttpClient,
 };
 
@@ -933,7 +933,7 @@ impl<Http: HttpClient> Client<Http> {
                     }
                     Task::Enqueued { .. } | Task::Processing { .. } => {
                         elapsed_time += interval;
-                        async_sleep(interval).await;
+                        self.sleep_backend().sleep(interval).await;
                     }
                 },
                 Err(error) => return Err(error),
@@ -1144,6 +1144,10 @@ impl<Http: HttpClient> Client<Http> {
 
         crate::tenant_tokens::generate_tenant_token(api_key_uid, search_rules, api_key, expires_at)
     }
+
+    fn sleep_backend(&self) -> SleepBackend {
+        SleepBackend::infer()
+    }
 }
 
 #[derive(Debug, Clone, Deserialize)]

src/utils.rs

@@ -1,44 +1,77 @@
 use std::time::Duration;
 
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) async fn async_sleep(interval: Duration) {
-    let (sender, receiver) = futures_channel::oneshot::channel::<()>();
-    std::thread::spawn(move || {
-        std::thread::sleep(interval);
-        let _ = sender.send(());
-    });
-    let _ = receiver.await;
+#[derive(Debug, Copy, Clone)]
+pub(crate) enum SleepBackend {
+    #[cfg(not(target_arch = "wasm32"))]
+    Thread,
+    #[cfg(target_arch = "wasm32")]
+    Javascript,
 }
 
-#[cfg(target_arch = "wasm32")]
-pub(crate) async fn async_sleep(interval: Duration) {
-    use std::convert::TryInto;
-    use wasm_bindgen_futures::JsFuture;
-
-    JsFuture::from(web_sys::js_sys::Promise::new(&mut |yes, _| {
-        web_sys::window()
-            .unwrap()
-            .set_timeout_with_callback_and_timeout_and_arguments_0(
-                &yes,
-                interval.as_millis().try_into().unwrap(),
-            )
-            .unwrap();
-    }))
-    .await
-    .unwrap();
+impl SleepBackend {
+    pub(crate) fn infer() -> Self {
+        #[cfg(not(target_arch = "wasm32"))]
+        return Self::Thread;
+
+        #[cfg(target_arch = "wasm32")]
+        return Self::Javascript;
+    }
+
+    pub(crate) async fn sleep(self, interval: Duration) {
+        match self {
+            #[cfg(not(target_arch = "wasm32"))]
+            Self::Thread => {
+                let (sender, receiver) = futures_channel::oneshot::channel::<()>();
+                std::thread::spawn(move || {
+                    std::thread::sleep(interval);
+                    let _ = sender.send(());
+                });
+                let _ = receiver.await;
+            }
+            #[cfg(target_arch = "wasm32")]
+            Self::Javascript => {
+                use std::convert::TryInto;
+                use wasm_bindgen_futures::JsFuture;
+
+                JsFuture::from(web_sys::js_sys::Promise::new(&mut |yes, _| {
+                    web_sys::window()
+                        .unwrap()
+                        .set_timeout_with_callback_and_timeout_and_arguments_0(
+                            &yes,
+                            interval.as_millis().try_into().unwrap(),
+                        )
+                        .unwrap();
+                }))
+                .await
+                .unwrap();
+            }
+        }
+    }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
     use meilisearch_test_macro::meilisearch_test;
 
+    #[cfg(not(target_arch = "wasm32"))]
+    #[meilisearch_test]
+    async fn sleep_thread() {
+        let sleep_duration = Duration::from_millis(10);
+        let now = std::time::Instant::now();
+
+        SleepBackend::Thread.sleep(sleep_duration).await;
+
+        assert!(now.elapsed() >= sleep_duration);
+    }
+
+    #[cfg(target_arch = "wasm32")]
     #[meilisearch_test]
-    async fn test_async_sleep() {
+    async fn sleep_javascript() {
         let sleep_duration = Duration::from_millis(10);
         let now = std::time::Instant::now();
 
-        async_sleep(sleep_duration).await;
+        SleepBackend::Javascript.sleep(sleep_duration).await;
 
         assert!(now.elapsed() >= sleep_duration);
     }