feat: Implement test harness via libtest-mimic instead

bindings/haskell/Cargo.toml

@@ -31,5 +31,5 @@ crate-type = ["cdylib"]
 doc = false
 
 [dependencies]
+chrono = "0.4"
 opendal.workspace = true
-chrono = "0.4"

bindings/lua/Cargo.toml

@@ -27,7 +27,6 @@ license.workspace = true
 repository.workspace = true
 rust-version.workspace = true
 
-
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [lib]

core/Cargo.toml

@@ -111,14 +111,14 @@ services-cos = [
   "reqsign?/reqwest_request",
 ]
 services-dashmap = ["dep:dashmap"]
+services-dropbox = []
 services-fs = ["tokio/fs"]
 services-ftp = ["dep:suppaftp", "dep:lazy-regex", "dep:bb8", "dep:async-tls"]
 services-gcs = [
   "dep:reqsign",
   "reqsign?/services-google",
   "reqsign?/reqwest_request",
 ]
-services-dropbox = []
 services-gdrive = []
 services-ghac = []
 services-hdfs = ["dep:hdrs"]
@@ -165,6 +165,10 @@ bench = false
 harness = false
 name = "ops"
 
+[[test]]
+harness = false
+name = "behavior"
+
 [dependencies]
 anyhow = { version = "1.0.30", features = ["std"] }
 async-compat = "0.2"
@@ -228,6 +232,7 @@ uuid = { version = "1", features = ["serde", "v4"] }
 [dev-dependencies]
 criterion = { version = "0.4", features = ["async", "async_tokio"] }
 dotenvy = "0.15"
+libtest-mimic = "0.6"
 opentelemetry = { version = "0.19", default-features = false, features = [
   "trace",
 ] }

core/src/services/memory/backend.rs

@@ -17,6 +17,7 @@
 
 use std::collections::BTreeMap;
 use std::collections::HashMap;
+use std::fmt::Debug;
 use std::sync::Arc;
 
 use async_trait::async_trait;
@@ -64,11 +65,17 @@ impl Builder for MemoryBuilder {
 /// Backend is used to serve `Accessor` support in memory.
 pub type MemoryBackend = typed_kv::Backend<Adapter>;
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct Adapter {
     inner: Arc<Mutex<BTreeMap<String, typed_kv::Value>>>,
 }
 
+impl Debug for Adapter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MemoryBackend").finish_non_exhaustive()
+    }
+}
+
 #[async_trait]
 impl typed_kv::Adapter for Adapter {
     fn info(&self) -> typed_kv::Info {

core/tests/behavior/append.rs

@@ -15,68 +15,35 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::vec;
+
 use anyhow::Result;
 use futures::io::BufReader;
 use futures::io::Cursor;
 use log::warn;
-use opendal::EntryMode;
-use opendal::ErrorKind;
-use opendal::Operator;
 use sha2::Digest;
 use sha2::Sha256;
 
-use super::utils::*;
-
-/// Test services that meet the following capability:
-///
-/// - can_read
-/// - can_write
-/// - can_append
-macro_rules! behavior_append_test {
-    ($service:ident, $($(#[$meta:meta])* $test:ident),*,) => {
-        paste::item! {
-            $(
-                #[test]
-                $(
-                    #[$meta]
-                )*
-                fn [<append_ $test >]() -> anyhow::Result<()> {
-                    match OPERATOR.as_ref() {
-                        Some(op) if op.info().can_read()
-                            && op.info().can_write()
-                            && op.info().can_append() => RUNTIME.block_on($crate::append::$test(op.clone())),
-                        Some(_) => {
-                            log::warn!("service {} doesn't support append, ignored", opendal::Scheme::$service);
-                            Ok(())
-                        },
-                        None => {
-                            Ok(())
-                        }
-                    }
-                }
-            )*
-        }
-    };
-}
+use crate::*;
 
-#[macro_export]
-macro_rules! behavior_append_tests {
-     ($($service:ident),*) => {
-        $(
-            behavior_append_test!(
-                $service,
-
-                test_append_create_append,
-                test_append_with_dir_path,
-                test_append_with_cache_control,
-                test_append_with_content_type,
-                test_append_with_content_disposition,
-
-                test_appender_futures_copy,
-                test_fuzz_appender,
-            );
-        )*
-    };
+pub fn behavior_append_tests(runtime: &Runtime, op: &Operator) -> Vec<Trial> {
+    let cap = op.info().capability();
+
+    if !(cap.read && cap.write && cap.append) {
+        return vec![];
+    }
+
+    async_trials!(
+        runtime,
+        op,
+        test_append_create_append,
+        test_append_with_dir_path,
+        test_append_with_cache_control,
+        test_append_with_content_type,
+        test_append_with_content_disposition,
+        test_appender_futures_copy,
+        test_fuzz_appender
+    )
 }
 
 /// Test append to a file must success.

core/tests/behavior/blocking_copy.rs

@@ -16,66 +16,30 @@
 // under the License.
 
 use anyhow::Result;
-use opendal::BlockingOperator;
-use opendal::ErrorKind;
-
-use super::utils::*;
-
-/// Test services that meet the following capability:
-///
-/// - can_read
-/// - can_write
-/// - can_copy
-/// - can_blocking
-macro_rules! behavior_blocking_copy_test {
-    ($service:ident, $($(#[$meta:meta])* $test:ident),*,) => {
-        paste::item! {
-            $(
-                #[test]
-                $(
-                    #[$meta]
-                )*
-                fn [<blocking_copy_ $test >]() -> anyhow::Result<()> {
-                    match OPERATOR.as_ref() {
-                        Some(op) if op.info().can_read()
-                            && op.info().can_write()
-                            && op.info().can_copy()
-                            && op.info().can_blocking() => $crate::blocking_copy::$test(op.blocking()),
-                        Some(_) => {
-                            log::warn!("service {} doesn't support blocking_copy, ignored", opendal::Scheme::$service);
-                            Ok(())
-                        },
-                        None => {
-                            Ok(())
-                        }
-                    }
-                }
-            )*
-        }
-    };
-}
 
-#[macro_export]
-macro_rules! behavior_blocking_copy_tests {
-     ($($service:ident),*) => {
-        $(
-            behavior_blocking_copy_test!(
-                $service,
-
-                test_copy_file,
-                test_copy_non_existing_source,
-                test_copy_source_dir,
-                test_copy_target_dir,
-                test_copy_self,
-                test_copy_nested,
-                test_copy_overwrite,
-            );
-        )*
-    };
+use crate::*;
+
+pub fn behavior_blocking_copy_tests(op: &Operator) -> Vec<Trial> {
+    let cap = op.info().capability();
+
+    if !(cap.read && cap.write && cap.copy && cap.blocking) {
+        return vec![];
+    }
+
+    blocking_trials!(
+        op,
+        test_blocking_copy_file,
+        test_blocking_copy_non_existing_source,
+        test_blocking_copy_source_dir,
+        test_blocking_copy_target_dir,
+        test_blocking_copy_self,
+        test_blocking_copy_nested,
+        test_blocking_copy_overwrite
+    )
 }
 
 /// Copy a file and test with stat.
-pub fn test_copy_file(op: BlockingOperator) -> Result<()> {
+pub fn test_blocking_copy_file(op: BlockingOperator) -> Result<()> {
     let source_path = uuid::Uuid::new_v4().to_string();
     let (source_content, _) = gen_bytes();
 
@@ -94,7 +58,7 @@ pub fn test_copy_file(op: BlockingOperator) -> Result<()> {
 }
 
 /// Copy a nonexistent source should return an error.
-pub fn test_copy_non_existing_source(op: BlockingOperator) -> Result<()> {
+pub fn test_blocking_copy_non_existing_source(op: BlockingOperator) -> Result<()> {
     let source_path = uuid::Uuid::new_v4().to_string();
     let target_path = uuid::Uuid::new_v4().to_string();
 
@@ -106,7 +70,7 @@ pub fn test_copy_non_existing_source(op: BlockingOperator) -> Result<()> {
 }
 
 /// Copy a dir as source should return an error.
-pub fn test_copy_source_dir(op: BlockingOperator) -> Result<()> {
+pub fn test_blocking_copy_source_dir(op: BlockingOperator) -> Result<()> {
     let source_path = format!("{}/", uuid::Uuid::new_v4());
     let target_path = uuid::Uuid::new_v4().to_string();
 
@@ -120,7 +84,7 @@ pub fn test_copy_source_dir(op: BlockingOperator) -> Result<()> {
 }
 
 /// Copy to a dir should return an error.
-pub fn test_copy_target_dir(op: BlockingOperator) -> Result<()> {
+pub fn test_blocking_copy_target_dir(op: BlockingOperator) -> Result<()> {
     let source_path = uuid::Uuid::new_v4().to_string();
     let (source_content, _) = gen_bytes();
 
@@ -141,7 +105,7 @@ pub fn test_copy_target_dir(op: BlockingOperator) -> Result<()> {
 }
 
 /// Copy a file to self should return an error.
-pub fn test_copy_self(op: BlockingOperator) -> Result<()> {
+pub fn test_blocking_copy_self(op: BlockingOperator) -> Result<()> {
     let source_path = uuid::Uuid::new_v4().to_string();
     let (source_content, _size) = gen_bytes();
 
@@ -157,7 +121,7 @@ pub fn test_copy_self(op: BlockingOperator) -> Result<()> {
 }
 
 /// Copy to a nested path, parent path should be created successfully.
-pub fn test_copy_nested(op: BlockingOperator) -> Result<()> {
+pub fn test_blocking_copy_nested(op: BlockingOperator) -> Result<()> {
     let source_path = uuid::Uuid::new_v4().to_string();
     let (source_content, _) = gen_bytes();
 
@@ -181,7 +145,7 @@ pub fn test_copy_nested(op: BlockingOperator) -> Result<()> {
 }
 
 /// Copy to a exist path should overwrite successfully.
-pub fn test_copy_overwrite(op: BlockingOperator) -> Result<()> {
+pub fn test_blocking_copy_overwrite(op: BlockingOperator) -> Result<()> {
     let source_path = uuid::Uuid::new_v4().to_string();
     let (source_content, _) = gen_bytes();