test: trace shared_memory in fspy tests

Author: branchseer

Cargo.lock

@@ -46,6 +46,7 @@ tempfile = { workspace = true }
 anyhow = { workspace = true }
 csv-async = { workspace = true }
 ctor = { workspace = true }
+test-log = { 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

@@ -3,6 +3,7 @@ mod test_utils;
 use std::env::{current_dir, vars_os};
 
 use fspy::{AccessMode, PathAccessIterable};
+use test_log::test;
 use test_utils::assert_contains;
 
 async fn track_node_script(script: &str) -> anyhow::Result<PathAccessIterable> {
@@ -17,21 +18,21 @@ async fn track_node_script(script: &str) -> anyhow::Result<PathAccessIterable> {
     Ok(termination.path_accesses)
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn read_sync() -> anyhow::Result<()> {
     let accesses = track_node_script("try { fs.readFileSync('hello') } catch {}").await?;
     assert_contains(&accesses, current_dir().unwrap().join("hello").as_path(), AccessMode::Read);
     Ok(())
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn read_dir_sync() -> anyhow::Result<()> {
     let accesses = track_node_script("try { fs.readdirSync('.') } catch {}").await?;
     assert_contains(&accesses, &current_dir().unwrap(), AccessMode::ReadDir);
     Ok(())
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn subprocess() -> anyhow::Result<()> {
     let cmd = if cfg!(windows) {
         r"'cmd', ['/c', 'type hello']"

crates/fspy/tests/node_fs.rs

@@ -8,9 +8,10 @@ use std::{
 };
 
 use fspy::AccessMode;
+use test_log::test;
 use test_utils::assert_contains;
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn open_read() -> anyhow::Result<()> {
     let accesses = track_child!({
         let _ = File::open("hello");
@@ -21,7 +22,7 @@ async fn open_read() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn open_write() -> anyhow::Result<()> {
     let accesses = track_child!({
         let path = format!("{}/hello", env!("CARGO_TARGET_TMPDIR"));
@@ -37,7 +38,7 @@ async fn open_write() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn readdir() -> anyhow::Result<()> {
     let accesses = track_child!({
         let path = format!("{}/hello", env!("CARGO_TARGET_TMPDIR"));
@@ -53,7 +54,7 @@ async fn readdir() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn subprocess() -> anyhow::Result<()> {
     let accesses = track_child!({
         let mut command = if cfg!(windows) {

crates/fspy/tests/rust_std.rs

@@ -3,10 +3,11 @@ mod test_utils;
 use std::{env::current_dir, path::Path, process::Stdio};
 
 use fspy::AccessMode;
+use test_log::test;
 use test_utils::assert_contains;
 use tokio::fs::OpenOptions;
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn open_read() -> anyhow::Result<()> {
     let accesses = track_child!({
         tokio::runtime::Builder::new_current_thread().enable_io().build().unwrap().block_on(
@@ -21,7 +22,7 @@ async fn open_read() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn open_write() -> anyhow::Result<()> {
     let accesses = track_child!({
         let path = format!("{}/hello", env!("CARGO_TARGET_TMPDIR"));
@@ -42,7 +43,7 @@ async fn open_write() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn readdir() -> anyhow::Result<()> {
     let accesses = track_child!({
         let path = format!("{}/hello", env!("CARGO_TARGET_TMPDIR"));
@@ -63,7 +64,7 @@ async fn readdir() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn subprocess() -> anyhow::Result<()> {
     let accesses = track_child!({
         tokio::runtime::Builder::new_current_thread().enable_io().build().unwrap().block_on(

crates/fspy/tests/rust_tokio.rs

@@ -9,6 +9,7 @@ use std::{
 
 use fspy::PathAccessIterable;
 use fspy_shared_unix::is_dynamically_linked_to_libc;
+use test_log::test;
 
 use crate::test_utils::assert_contains;
 
@@ -49,61 +50,61 @@ async fn track_test_bin(args: &[&str], cwd: Option<&str>) -> PathAccessIterable
     termination.path_accesses
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn open_read() {
     let accesses = track_test_bin(&["open_read", "/hello"], None).await;
     assert_contains(&accesses, Path::new("/hello"), fspy::AccessMode::Read);
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn open_write() {
     let accesses = track_test_bin(&["open_write", "/hello"], None).await;
     assert_contains(&accesses, Path::new("/hello"), fspy::AccessMode::Write);
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn open_readwrite() {
     let accesses = track_test_bin(&["open_readwrite", "/hello"], None).await;
     assert_contains(&accesses, Path::new("/hello"), fspy::AccessMode::ReadWrite);
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn openat2_read() {
     let accesses = track_test_bin(&["openat2_read", "/hello"], None).await;
     assert_contains(&accesses, Path::new("/hello"), fspy::AccessMode::Read);
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn openat2_write() {
     let accesses = track_test_bin(&["openat2_write", "/hello"], None).await;
     assert_contains(&accesses, Path::new("/hello"), fspy::AccessMode::Write);
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn openat2_readwrite() {
     let accesses = track_test_bin(&["openat2_readwrite", "/hello"], None).await;
     assert_contains(&accesses, Path::new("/hello"), fspy::AccessMode::ReadWrite);
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn open_relative() {
     let accesses = track_test_bin(&["open_read", "hello"], Some("/home")).await;
     assert_contains(&accesses, Path::new("/home/hello"), fspy::AccessMode::Read);
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn readdir() {
     let accesses = track_test_bin(&["readdir", "/home"], None).await;
     assert_contains(&accesses, Path::new("/home"), fspy::AccessMode::ReadDir);
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn stat() {
     let accesses = track_test_bin(&["stat", "/hello"], None).await;
     assert_contains(&accesses, Path::new("/hello"), fspy::AccessMode::Read);
 }
 
-#[tokio::test]
+#[test(tokio::test)]
 async fn execve() {
     let accesses = track_test_bin(&["execve", "/hello"], None).await;
     assert_contains(&accesses, Path::new("/hello"), fspy::AccessMode::Read);

crates/fspy/tests/static_executable.rs

@@ -9,7 +9,7 @@ allocator-api2 = { workspace = true }
 bincode = { workspace = true }
 bstr = { workspace = true }
 bytemuck = { workspace = true, features = ["must_cast"] }
-shared_memory = { workspace = true }
+shared_memory = { workspace = true, features = ["logging"] }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 uuid = { workspace = true, features = ["v4"] }
@@ -24,4 +24,4 @@ winsafe = { workspace = true }
 assert2 = { workspace = true }
 ctor = { workspace = true }
 fspy_test_utils = { workspace = true }
-shared_memory = { workspace = true }
+shared_memory = { workspace = true, features = ["logging"] }