Add #test_with::lock

Cargo.toml

@@ -1,13 +1,14 @@
 [package]
 name = "test-with"
-version = "0.12.6"
+version = "0.13.0"
 authors = ["Antonio Yang <[email protected]>"]
 edition = "2021"
 license = "MIT"
 description = "A lib help you run test with condition"
 repository = "https://github.com/yanganto/test-with"
 keywords = [ "testing", "condition", "toggle", "integration", "ignore" ]
 categories = [ "development-tools", "testing" ]
+rust-version = "1.77.0" # Due to std::fs::create_new
 
 [lib]
 proc-macro = true
@@ -43,7 +44,7 @@ user = ["uzers"]
 executable = ["which"]
 
 [dev-dependencies]
-tokio = { version = "1.15.0", features = ["rt", "macros"] }
-serial_test = "2.0.0"
+tokio = { version = "1.38.0", features = ["rt", "rt-multi-thread", "macros"] }
+serial_test = "3.1.1"
 libtest-with = { version = "0.7.0-0", features = ["net", "resource", "user", "executable"] }
 rstest = "0.21.0"

README.md

@@ -359,6 +359,38 @@ mod test_with_mock {
 
 Please check out examples uder the [example/runner](https://github.com/yanganto/test-with/tree/main/examples/runner) project.
 
+## Lock
+`#[test_with::lock(LOCK_NAME)]` is way to make sure your test casess can run one by one by using file locks.
+The first parameter is the name of the file lock, the second parameter to specific the waiting seconds,
+default will be 60 seconds.
+
+```rust
+  // `LOCK` is file based lock to prevent test1 an test2 run at the same time
+  #[test_with::lock(LOCK)]
+  fn test_1() {
+      assert!(true);
+  }
+
+  // `LOCK` is file based lock to prevent test1 an test2 run at the same time
+  #[test_with::lock(LOCK)]
+  fn test_2() {
+      assert!(true);
+  }
+
+  // `ANOTHER_LOCK` is file based lock to prevent test3 an test4 run at the same time with 3 sec
+  // waiting time.
+  #[test_with::lock(ANOTHER_LOCK, 3)]
+  fn test_3() {
+      assert!(true);
+  }
+
+  // `ANOTHER_LOCK` is file based lock to prevent test3 an test4 run at the same time with 3 sec
+  // waiting time.
+  #[test_with::lock(ANOTHER_LOCK, 3)]
+  fn test_4() {
+      assert!(true);
+  }
+```
 
 ## Relating issues
 * [Solve this in runtime][original-issue]

examples/lock.rs

@@ -0,0 +1,30 @@
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    // `LOCK` is file based lock to prevent test1 an test2 run at the same time
+    #[test_with::lock(LOCK)]
+    fn test_1() {
+        assert!(true);
+    }
+
+    // `LOCK` is file based lock to prevent test1 an test2 run at the same time
+    #[test_with::lock(LOCK)]
+    fn test_2() {
+        assert!(true);
+    }
+
+    // `ANOTHER_LOCK` is file based lock to prevent test3 an test4 run at the same time with 3 sec
+    // waiting time.
+    #[test_with::lock(ANOTHER_LOCK, 3)]
+    fn test_3() {
+        assert!(true);
+    }
+
+    // `ANOTHER_LOCK` is file based lock to prevent test3 an test4 run at the same time with 3 sec
+    // waiting time.
+    #[test_with::lock(ANOTHER_LOCK, 3)]
+    fn test_4() {
+        assert!(true);
+    }
+}

flake.nix

@@ -14,7 +14,7 @@
         pkgs = import nixpkgs {
           inherit system overlays;
         };
-        rust = pkgs.rust-bin.stable."1.74.1".default;
+        rust = pkgs.rust-bin.stable."1.77.0".default;
         dr = dependency-refresh.defaultPackage.${system};
 
         publishScript = pkgs.writeShellScriptBin "crate-publish" ''

src/lib.rs

@@ -57,7 +57,6 @@ use std::net::IpAddr;
 use std::net::TcpStream;
 
 use proc_macro::TokenStream;
-#[cfg(any(feature = "resource", feature = "icmp"))]
 use proc_macro_error::abort_call_site;
 use proc_macro_error::proc_macro_error;
 use syn::{parse_macro_input, ItemFn, ItemMod};
@@ -68,7 +67,7 @@ use syn::{Item, ItemStruct, ItemType};
 #[cfg(feature = "executable")]
 use which::which;
 
-use crate::utils::{fn_macro, is_module, mod_macro, sanitize_env_vars_attr};
+use crate::utils::{fn_macro, is_module, lock_macro, mod_macro, sanitize_env_vars_attr};
 
 mod utils;
 
@@ -2821,3 +2820,50 @@ mod tests {
         }
     }
 }
+
+/// Run test case one by one when the lock is acquired
+/// It will automatically implement a file lock for the test case to prevent it run in the same
+/// time. Also, you can pass the second parameter to specific the waiting seconds, default will be
+/// 60 seconds.
+/// ```
+/// #[cfg(test)]
+/// mod tests {
+///
+///     // `LOCK` is file based lock to prevent test1 an test2 run at the same time
+///     #[test_with::lock(LOCK)]
+///     #[test]
+///     fn test_1() {
+///         assert!(true);
+///     }
+///
+///     // `LOCK` is file based lock to prevent test1 an test2 run at the same time
+///     #[test_with::lock(LOCK)]
+///     #[test]
+///     fn test_2() {
+///         assert!(true);
+///     }
+///
+///     // `ANOTHER_LOCK` is file based lock to prevent test3 an test4 run at the same time with 3 sec
+///     // waiting time.
+///     #[test_with::lock(ANOTHER_LOCK, 3)]
+///     fn test_3() {
+///         assert!(true);
+///     }
+///
+///     // `ANOTHER_LOCK` is file based lock to prevent test3 an test4 run at the same time with 3 sec
+///     // waiting time.
+///     #[test_with::lock(ANOTHER_LOCK, 3)]
+///     fn test_4() {
+///         assert!(true);
+///     }
+///
+/// }
+#[proc_macro_attribute]
+#[proc_macro_error]
+pub fn lock(attr: TokenStream, stream: TokenStream) -> TokenStream {
+    if is_module(&stream) {
+        abort_call_site!("#[test_with::lock] only works with fn")
+    } else {
+        lock_macro(attr, parse_macro_input!(stream as ItemFn))
+    }
+}