use command_executing in track_child

Author: branchseer

Cargo.lock

@@ -12,6 +12,7 @@ bumpalo = { workspace = true }
 const_format = { workspace = true, features = ["fmt"] }
 derive_more = { workspace = true, features = ["debug"] }
 fspy_shared = { workspace = true }
+fspy_test_utils = { workspace = true }
 futures-util = { workspace = true }
 libc = { workspace = true }
 ouroboros = { workspace = true }
@@ -44,7 +45,6 @@ tempfile = { workspace = true }
 [dev-dependencies]
 anyhow = { workspace = true }
 csv-async = { workspace = true }
-ctor = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros", "fs", "io-std"] }
 
 [target.'cfg(all(target_os = "linux", target_arch = "aarch64"))'.dev-dependencies]

crates/fspy/Cargo.toml

@@ -13,7 +13,7 @@ use test_utils::assert_contains;
 #[tokio::test]
 async fn open_read() -> anyhow::Result<()> {
     let accesses = track_child!({
-        File::open("hello");
+        let _ = File::open("hello");
     })
     .await?;
     assert_contains(&accesses, current_dir().unwrap().join("hello").as_path(), AccessMode::Read);
@@ -25,7 +25,7 @@ async fn open_read() -> anyhow::Result<()> {
 async fn open_write() -> anyhow::Result<()> {
     let accesses = track_child!({
         let path = format!("{}/hello", env!("CARGO_TARGET_TMPDIR"));
-        OpenOptions::new().write(true).open(path);
+        let _ = OpenOptions::new().write(true).open(path);
     })
     .await?;
     assert_contains(
@@ -41,7 +41,7 @@ async fn open_write() -> anyhow::Result<()> {
 async fn readdir() -> anyhow::Result<()> {
     let accesses = track_child!({
         let path = format!("{}/hello", env!("CARGO_TARGET_TMPDIR"));
-        std::fs::read_dir(path);
+        let _ = std::fs::read_dir(path);
     })
     .await?;
     assert_contains(

crates/fspy/tests/rust_std.rs

@@ -11,7 +11,7 @@ async fn open_read() -> anyhow::Result<()> {
     let accesses = track_child!({
         tokio::runtime::Builder::new_current_thread().enable_io().build().unwrap().block_on(
             async {
-                tokio::fs::File::open("hello").await;
+                let _ = tokio::fs::File::open("hello").await;
             },
         );
     })
@@ -28,7 +28,7 @@ async fn open_write() -> anyhow::Result<()> {
 
         tokio::runtime::Builder::new_current_thread().enable_io().build().unwrap().block_on(
             async {
-                OpenOptions::new().write(true).open(path).await;
+                let _ = OpenOptions::new().write(true).open(path).await;
             },
         );
     })
@@ -49,7 +49,7 @@ async fn readdir() -> anyhow::Result<()> {
 
         tokio::runtime::Builder::new_current_thread().enable_io().build().unwrap().block_on(
             async {
-                tokio::fs::read_dir(path).await;
+                let _ = tokio::fs::read_dir(path).await;
             },
         );
     })

crates/fspy/tests/rust_tokio.rs

@@ -1,6 +1,9 @@
 use std::path::{Path, PathBuf, StripPrefixError};
 
 use fspy::{AccessMode, PathAccessIterable};
+#[doc(hidden)]
+#[allow(unused)]
+pub use fspy_test_utils::command_executing;
 
 #[track_caller]
 pub fn assert_contains(
@@ -32,29 +35,19 @@ pub fn assert_contains(
 #[macro_export]
 macro_rules! track_child {
     ($body: block) => {{
-        const ID: &str =
-            ::core::concat!(::core::file!(), ":", ::core::line!(), ":", ::core::column!());
-        #[ctor::ctor]
-        unsafe fn init() {
-            let mut args = ::std::env::args();
-            let Some(_) = args.next() else {
-                return;
-            };
-            let Some(current_id) = args.next() else {
-                return;
-            };
-            if current_id == ID {
-                $body;
-                ::std::process::exit(0);
-            }
-        }
-        $crate::test_utils::_spawn_with_id(ID)
+        let std_cmd = $crate::test_utils::command_executing!((), |(): ()| {
+            let _ = $body;
+        });
+        $crate::test_utils::spawn_std(std_cmd)
     }};
 }
 
-pub async fn _spawn_with_id(id: &str) -> anyhow::Result<PathAccessIterable> {
-    let mut command = fspy::Command::new(::std::env::current_exe()?);
-    command.arg(id);
+#[doc(hidden)]
+#[allow(unused)]
+pub async fn spawn_std(std_cmd: std::process::Command) -> anyhow::Result<PathAccessIterable> {
+    let mut command = fspy::Command::new(std_cmd.get_program());
+    command.args(std_cmd.get_args());
+
     let termination = command.spawn().await?.wait_handle.await?;
     assert!(termination.status.success());
     Ok(termination.path_accesses)