Fixing test indeterminacy

side-node/src/init/mod.rs

@@ -34,7 +34,7 @@ fn ensure_side_directory_exists(side_dir: &PathBuf) -> Result<(), std::io::Error
 
 #[cfg(test)]
 mod tests {
-    use std::{fs, path::Path};
+    use std::{fs, path::Path, str::FromStr};
 
     use fastcrypto::{
         ed25519::Ed25519KeyPair,
@@ -43,50 +43,57 @@ mod tests {
 
     use super::*;
 
-    fn default_side_node_config() -> SideNodeConfig {
-        SideNodeConfig {
-            name: "alice".to_string(),
-        }
+    /// Generates a SideNodeConfig with a unique name for each test.
+    /// This is necessary because the tests run in parallel and we
+    /// don't want them to interfere with each other - without a unique
+    /// name, the tests would all try to write to the same directory and we
+    /// get test indeterminacy
+    fn side_node_config() -> (SideNodeConfig, String) {
+        let name = format!("test-{}", uuid::Uuid::new_v4()).to_string();
+        (SideNodeConfig { name: name.clone() }, name)
     }
 
     #[test]
     fn creates_side_node_directory() {
-        let mut test_home = PathBuf::new();
-        let side_dir = "/tmp/side";
+        let (config, name) = side_node_config();
+        let side_dir = format!("/tmp/side/{name}");
 
-        // clean up any previous test runs
-        fs::remove_dir_all(side_dir).expect("couldn't remove side directory during test");
+        let mut test_home = PathBuf::new();
 
         test_home.push(side_dir);
         let node_dir = Path::new(&test_home).parent().unwrap().to_str().unwrap();
-        let _ = init(test_home.clone(), default_side_node_config());
+        let _ = init(test_home.clone(), config);
         assert!(std::path::Path::new(node_dir).exists());
     }
 
     #[test]
     fn creates_key_file() {
-        let mut file_path = PathBuf::new();
-        file_path.push("/tmp/side");
-        let side_dir = file_path.clone();
-        file_path.push(utils::KEY_FILE);
+        let (config, name) = side_node_config();
+        let side_dir = format!("/tmp/side/{name}");
 
-        let _ = init(side_dir.clone(), default_side_node_config());
-        assert!(file_path.exists());
+        let mut key_file_path = PathBuf::new();
+        key_file_path.push(side_dir.clone());
+        key_file_path.push(utils::KEY_FILE);
+
+        let _ = init(PathBuf::from_str(&side_dir).unwrap(), config);
+        assert!(key_file_path.exists());
 
         // check that the pem is readable
-        let data = fs::read_to_string(file_path).expect("couldn't read key file");
+        let data = fs::read_to_string(key_file_path).expect("couldn't read key file");
         let keys = Ed25519KeyPair::decode_base64(&data).expect("couldn't load keypair from file");
         assert_eq!(keys.public().as_bytes().len(), 32);
     }
 
     #[test]
     fn creates_config_file() {
-        let mut file_path = PathBuf::new();
-        file_path.push("/tmp/side");
-        let side_dir = file_path.clone();
-        file_path.push(utils::CONFIG_FILE);
+        let (config, name) = side_node_config();
+        let side_dir = format!("/tmp/side/{name}");
 
-        let _ = init(side_dir.clone(), default_side_node_config());
-        assert!(file_path.exists());
+        let mut config_file_path = PathBuf::new();
+        config_file_path.push(side_dir.clone());
+        config_file_path.push(utils::CONFIG_FILE);
+
+        let _ = init(PathBuf::from_str(&side_dir).unwrap(), config);
+        assert!(config_file_path.exists());
     }
 }