Add TestEnv for Nextest support (#120)

* template: remove glam, use spirv-std reexport

selecting the correct glam version manually when testing various spirv-std versions is hard

* Update `shader-crate-template`'s `spirv-std`

otherwise I can't build it

* Tests: Add `TestEnv`, to manage temp dir creation and cleanup, nextest compatible

* Tests: fix clippy

* Tests: fix windows test failing on CI

* Tests: document `TestEnv`

Author: Firestar99

Cargo.lock

@@ -7,7 +7,9 @@ members = [
 exclude = [
 	# This currently needs to be excluded because it depends on a version of `rust-gpu` that
 	# uses a toolchain whose Cargo version doesn't recognise version 4 of `Cargo.lock`.
-	"crates/shader-crate-template"
+	"crates/shader-crate-template",
+	# Testing infra may copy the `shader-crate-template` into subdirs of target
+	"target",
 ]
 
 resolver = "2"

Cargo.toml

@@ -27,6 +27,7 @@ semver.workspace = true
 dunce.workspace = true
 
 [dev-dependencies]
+tempfile.workspace = true
 test-log.workspace = true
 cargo_metadata = { workspace = true, features = ["builder"] }
 cargo-util-schemas = "0.8.2"

crates/cargo-gpu/Cargo.toml

@@ -181,8 +181,6 @@ mod test {
 
     #[test_log::test]
     fn builder_from_params() {
-        crate::test::tests_teardown();
-
         let shader_crate_path = crate::test::shader_crate_template_path();
         let output_dir = shader_crate_path.join("shaders");
 

crates/cargo-gpu/src/build.rs

@@ -86,11 +86,13 @@ impl Config {
 mod test {
     use super::*;
 
+    use crate::test::TestEnv;
     use std::io::Write as _;
 
     #[test_log::test]
     fn booleans_from_cli() {
-        let shader_crate_path = crate::test::shader_crate_test_path();
+        let _env = TestEnv::new();
+        let shader_crate_path = _env.setup_shader_crate().unwrap();
 
         let args = Config::clap_command_with_cargo_config(
             &shader_crate_path,
@@ -108,55 +110,66 @@ mod test {
 
     #[test_log::test]
     fn booleans_from_cargo() {
-        let shader_crate_path = crate::test::shader_crate_test_path();
-        let mut file = crate::test::overwrite_shader_cargo_toml(&shader_crate_path);
-        file.write_all(
-            [
-                "[package.metadata.rust-gpu.build]",
-                "release = false",
-                "[package.metadata.rust-gpu.install]",
-                "auto-install-rust-toolchain = true",
-            ]
-            .join("\n")
-            .as_bytes(),
-        )
-        .unwrap();
+        let _env = TestEnv::new();
+        let shader_crate_path = _env
+            .setup_shader_crate_with_cargo_toml(|file| {
+                file.write_all(
+                    [
+                        "[package.metadata.rust-gpu.build]",
+                        "release = false",
+                        "[package.metadata.rust-gpu.install]",
+                        "auto-install-rust-toolchain = true",
+                    ]
+                    .join("\n")
+                    .as_bytes(),
+                )
+            })
+            .unwrap();
 
         let args = Config::clap_command_with_cargo_config(&shader_crate_path, vec![]).unwrap();
         assert!(!args.build.spirv_builder.release);
         assert!(args.install.auto_install_rust_toolchain);
     }
 
-    fn update_cargo_output_dir() -> std::path::PathBuf {
-        let shader_crate_path = crate::test::shader_crate_test_path();
-        let mut file = crate::test::overwrite_shader_cargo_toml(&shader_crate_path);
-        file.write_all(
-            [
-                "[package.metadata.rust-gpu.build]",
-                "output-dir = \"/the/moon\"",
-            ]
-            .join("\n")
-            .as_bytes(),
-        )
-        .unwrap();
-        shader_crate_path
+    fn update_cargo_output_dir(_env: &TestEnv) -> std::path::PathBuf {
+        _env.setup_shader_crate_with_cargo_toml(|file| {
+            file.write_all(
+                [
+                    "[package.metadata.rust-gpu.build]",
+                    "output-dir = \"/the/moon\"",
+                ]
+                .join("\n")
+                .as_bytes(),
+            )
+        })
+        .unwrap()
     }
 
     #[test_log::test]
     fn string_from_cargo() {
-        let shader_crate_path = update_cargo_output_dir();
+        let _env = TestEnv::new();
+        let shader_crate_path = update_cargo_output_dir(&_env);
 
         let args = Config::clap_command_with_cargo_config(&shader_crate_path, vec![]).unwrap();
         if cfg!(target_os = "windows") {
-            assert_eq!(args.build.output_dir, std::path::Path::new("C:/the/moon"));
+            assert!(
+                args.build
+                    .output_dir
+                    .to_str()
+                    .unwrap()
+                    .ends_with("/the/moon"),
+                "Actual: {:?}",
+                args.build.output_dir
+            );
         } else {
             assert_eq!(args.build.output_dir, std::path::Path::new("/the/moon"));
         }
     }
 
     #[test_log::test]
     fn string_from_cargo_overwritten_by_cli() {
-        let shader_crate_path = update_cargo_output_dir();
+        let _env = TestEnv::new();
+        let shader_crate_path = update_cargo_output_dir(&_env);
 
         let args = Config::clap_command_with_cargo_config(
             &shader_crate_path,
@@ -173,17 +186,19 @@ mod test {
 
     #[test_log::test]
     fn arrays_from_cargo() {
-        let shader_crate_path = crate::test::shader_crate_test_path();
-        let mut file = crate::test::overwrite_shader_cargo_toml(&shader_crate_path);
-        file.write_all(
-            [
-                "[package.metadata.rust-gpu.build]",
-                "capabilities = [\"AtomicStorage\", \"Matrix\"]",
-            ]
-            .join("\n")
-            .as_bytes(),
-        )
-        .unwrap();
+        let _env = TestEnv::new();
+        let shader_crate_path = _env
+            .setup_shader_crate_with_cargo_toml(|file| {
+                file.write_all(
+                    [
+                        "[package.metadata.rust-gpu.build]",
+                        "capabilities = [\"AtomicStorage\", \"Matrix\"]",
+                    ]
+                    .join("\n")
+                    .as_bytes(),
+                )
+            })
+            .unwrap();
 
         let args = Config::clap_command_with_cargo_config(&shader_crate_path, vec![]).unwrap();
         assert_eq!(
@@ -197,7 +212,8 @@ mod test {
 
     #[test_log::test]
     fn rename_manifest_parse() {
-        let shader_crate_path = crate::test::shader_crate_test_path();
+        let _env = TestEnv::new();
+        let shader_crate_path = _env.setup_shader_crate().unwrap();
 
         let args = Config::clap_command_with_cargo_config(
             &shader_crate_path,

crates/cargo-gpu/src/config.rs

@@ -50,8 +50,6 @@
 //! conduct other post-processing, like converting the `spv` files into `wgsl` files,
 //! for example.
 
-use anyhow::Context as _;
-
 use crate::dump_usage::dump_full_usage_for_readme;
 use build::Build;
 use show::Show;
@@ -171,21 +169,19 @@ pub struct Cli {
 /// # Errors
 /// may fail if we can't find the user home directory
 #[inline]
+#[cfg(not(test))]
+#[expect(clippy::cfg_not_test, reason = "tests use different cache_dir")]
 pub fn cache_dir() -> anyhow::Result<std::path::PathBuf> {
-    let dir = directories::BaseDirs::new()
+    use anyhow::Context as _;
+    Ok(directories::BaseDirs::new()
         .with_context(|| "could not find the user home directory")?
         .cache_dir()
-        .join("rust-gpu");
-
-    Ok(if cfg!(test) {
-        let thread_id = std::thread::current().id();
-        let id = format!("{thread_id:?}").replace('(', "-").replace(')', "");
-        dir.join("tests").join(id)
-    } else {
-        dir
-    })
+        .join("rust-gpu"))
 }
 
+#[cfg(test)]
+pub use test::test_cache_dir as cache_dir;
+
 /// Returns a string suitable to use as a directory.
 ///
 /// Created from the spirv-builder source dep and the rustc channel.

crates/cargo-gpu/src/lib.rs

@@ -248,6 +248,7 @@ pub fn get_channel_from_rustc_codegen_spirv_build_script(
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::test::TestEnv;
     use cargo_metadata::{PackageBuilder, PackageId, Source};
     use cargo_util_schemas::manifest::PackageName;
 
@@ -259,7 +260,7 @@ mod test {
             source,
             SpirvSource::Git {
                 url: "https://github.com/Rust-GPU/rust-gpu".to_owned(),
-                rev: "86fc48032c4cd4afb74f1d81ae859711d20386a1".to_owned()
+                rev: "2aa4d4f8a8ba73103501562cfca17b8163e5a887".to_owned()
             }
         );
     }
@@ -272,6 +273,7 @@ mod test {
 
     #[test_log::test]
     fn cached_checkout_dir_sanity() {
+        let _env = TestEnv::new();
         let shader_template_path = crate::test::shader_crate_template_path();
         let source = SpirvSource::get_rust_gpu_deps_from_shader(&shader_template_path).unwrap();
         let dir = source.install_dir().unwrap();
@@ -281,7 +283,7 @@ mod test {
             .to_str()
             .map(std::string::ToString::to_string)
             .unwrap();
-        assert_eq!("https___github_com_Rust-GPU_rust-gpu+86fc4803", &name);
+        assert_eq!("https___github_com_Rust-GPU_rust-gpu+2aa4d4f8", &name);
     }
 
     #[test_log::test]

crates/cargo-gpu/src/spirv_source.rs

@@ -1,8 +1,90 @@
 //! utilities for tests
 #![cfg(test)]
 
-use crate::cache_dir;
+use anyhow::Context;
+use std::cell::RefCell;
+use std::fs::File;
 use std::io::Write as _;
+use std::path::PathBuf;
+use tempfile::TempDir;
+
+/// `TestEnv` sets up a temp dir in `./target/cargo-gpu-test/` that is used as the cache dir. Not initializing a
+/// `TestEnv` and asking for the cache dir will panic, to ensure you set it up. Calling [`Self::setup_shader_crate`]
+/// or [`Self::setup_shader_crate_with_cargo_toml`] will copy the `shader_crate_template` into the temp dir and return
+/// you the path to it, so each test now has it's unique copy and won't race to change the template in the repo.
+/// Dropping `TestEnv` will clean up the dir, except when panic unwinding, so you can debug failures.
+#[must_use]
+pub struct TestEnv(TempDir);
+
+impl TestEnv {
+    /// Create a new [`TestEnv`]
+    pub fn new() -> Self {
+        let target_dir = cargo_metadata::MetadataCommand::new()
+            .exec()
+            .unwrap()
+            .target_directory
+            .into_std_path_buf();
+        let tests_dir = target_dir.join("cargo-gpu-test");
+        std::fs::create_dir_all(&tests_dir).ok();
+        let test_dir = TempDir::new_in(tests_dir).unwrap();
+
+        let had_old = TESTDIR
+            .replace(Some(test_dir.path().to_path_buf()))
+            .is_some();
+        if had_old {
+            panic!("TestEnv is not reentrant!")
+        }
+
+        TestEnv(test_dir)
+    }
+
+    /// Copies the `shader_crate_template` to the temp dir and returns the path to the directory.
+    pub fn setup_shader_crate(&self) -> anyhow::Result<PathBuf> {
+        let shader_crate_path = crate::cache_dir().unwrap().join("shader_crate");
+        copy_dir_all(shader_crate_template_path(), &shader_crate_path)?;
+        Ok(shader_crate_path)
+    }
+
+    /// Like [`Self::setup_shader_crate`], copies the `shader_crate_template` to the temp dir and returns the path to
+    /// the directory. Additionally, takes a closure to allow you to overwrite the contents of the `Cargo.toml`.
+    /// This function will write the bare minimum for a valid crate, that is, give it a package name.
+    pub fn setup_shader_crate_with_cargo_toml(
+        &self,
+        f: impl FnOnce(&mut File) -> std::io::Result<()>,
+    ) -> anyhow::Result<PathBuf> {
+        let shader_crate_path = self.setup_shader_crate()?;
+        let cargo_toml = shader_crate_path.join("Cargo.toml");
+        let mut file = std::fs::OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .open(cargo_toml)?;
+        writeln!(file, "[package]")?;
+        writeln!(file, "name = \"test\"")?;
+        f(&mut file)?;
+        Ok(shader_crate_path)
+    }
+}
+
+impl Drop for TestEnv {
+    fn drop(&mut self) {
+        TESTDIR.replace(None).unwrap();
+        // when a test fails, keep directory
+        if std::thread::panicking() {
+            self.0.disable_cleanup(true);
+        }
+    }
+}
+
+thread_local! {
+    static TESTDIR: RefCell<Option<PathBuf>> = RefCell::new(None);
+}
+
+/// [`crate::cache_dir`] for testing, see [`TestEnv`]
+pub fn test_cache_dir() -> anyhow::Result<PathBuf> {
+    Ok(TESTDIR.with_borrow(|a| a.clone()).context(
+        "TestEnv is not initialized! Add `let _env = TestEnv::new();` to the beginning of your test",
+    )?)
+}
 
 fn copy_dir_all(
     src: impl AsRef<std::path::Path>,
@@ -21,33 +103,8 @@ fn copy_dir_all(
     Ok(())
 }
 
-pub fn shader_crate_template_path() -> std::path::PathBuf {
+/// Path to the `shader-crate-template` for copying or querying data
+pub fn shader_crate_template_path() -> PathBuf {
     let project_base = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
     project_base.join("../shader-crate-template")
 }
-
-pub fn shader_crate_test_path() -> std::path::PathBuf {
-    let shader_crate_path = crate::cache_dir().unwrap().join("shader_crate");
-    copy_dir_all(shader_crate_template_path(), shader_crate_path.clone()).unwrap();
-    shader_crate_path
-}
-
-pub fn overwrite_shader_cargo_toml(shader_crate_path: &std::path::Path) -> std::fs::File {
-    let cargo_toml = shader_crate_path.join("Cargo.toml");
-    let mut file = std::fs::OpenOptions::new()
-        .write(true)
-        .truncate(true)
-        .open(cargo_toml)
-        .unwrap();
-    writeln!(file, "[package]").unwrap();
-    writeln!(file, "name = \"test\"").unwrap();
-    file
-}
-
-pub fn tests_teardown() {
-    let cache_dir = cache_dir().unwrap();
-    if !cache_dir.exists() {
-        return;
-    }
-    std::fs::remove_dir_all(cache_dir).unwrap();
-}