improve tests

Author: expede

darn_core/src/darn.rs

@@ -1527,15 +1527,25 @@ pub enum SyncError {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::sync::Once;
+
+    /// Ensure a global signer exists before any workspace test runs.
+    ///
+    /// In CI there is no `~/.config/darn/signer/` so `Darn::init` would
+    /// fail with `InvalidKeyLength`. This one-time setup generates a
+    /// signer if none exists. It's idempotent and thread-safe.
+    static ENSURE_SIGNER: Once = Once::new();
 
     fn with_temp_home<F, R>(f: F) -> R
     where
         F: FnOnce(&Path) -> R,
     {
+        ENSURE_SIGNER.call_once(|| {
+            let signer_dir = config::global_signer_dir().expect("resolve signer dir");
+            crate::signer::load_or_generate(&signer_dir).expect("ensure signer exists");
+        });
+
         let dir = tempfile::tempdir().expect("create tempdir");
-        // Note: We can't easily override HOME in tests, so these tests
-        // will use the real global signer. Integration tests would be
-        // better for testing with isolated HOME.
         f(dir.path())
     }
 

darn_core/src/directory.rs

@@ -523,11 +523,13 @@ pub enum DeserializeError {
     InvalidSchema(String),
 }
 
+#[allow(clippy::panic)]
 #[allow(clippy::panic)]
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    use bolero::check;
     use testresult::TestResult;
 
     /// Generate a random 16-byte ID (zero-padded to 32) matching our convention
@@ -612,64 +614,68 @@ mod tests {
         assert!(removed.is_none());
     }
 
+    #[allow(clippy::expect_used)]
     #[test]
-    fn automerge_roundtrip_empty() -> TestResult {
-        let dir = Directory::new("empty");
-
-        let am = dir.to_automerge()?;
-        let loaded = Directory::from_automerge(&am)?;
-
-        assert_eq!(loaded.name, "empty");
-        assert!(loaded.is_empty());
-        Ok(())
-    }
-
-    #[test]
-    fn automerge_roundtrip_with_entries() -> TestResult {
-        let mut dir = Directory::root();
-        let file_id = random_id()?;
-        let folder_id = random_id()?;
-
-        dir.add_file("README.md", file_id);
-        dir.add_folder("src", folder_id);
-
-        let am = dir.to_automerge()?;
-        let loaded = Directory::from_automerge(&am)?;
+    fn directory_automerge_roundtrip() {
+        check!()
+            .with_type::<(String, Vec<(String, bool, [u8; 16])>)>()
+            .for_each(|(name, entries)| {
+                let mut dir = Directory::new(name);
+                for (entry_name, is_folder, id_bytes) in entries {
+                    // Pad 16 bytes to 32 (our automerge-repo convention)
+                    let mut full = [0u8; 32];
+                    full[..16].copy_from_slice(id_bytes);
+                    let id = SedimentreeId::new(full);
+
+                    if *is_folder {
+                        dir.add_folder(entry_name, id);
+                    } else {
+                        dir.add_file(entry_name, id);
+                    }
+                }
 
-        assert_eq!(loaded.name, "");
-        assert_eq!(loaded.len(), 2);
+                let am = dir.to_automerge().expect("to_automerge");
+                let loaded = Directory::from_automerge(&am).expect("from_automerge");
 
-        let readme = loaded.get("README.md").ok_or("README.md not found")?;
-        assert_eq!(readme.entry_type, EntryType::File);
-        assert_eq!(readme.sedimentree_id, file_id);
+                assert_eq!(loaded.name, dir.name);
+                assert_eq!(loaded.len(), dir.len());
 
-        let src = loaded.get("src").ok_or("src not found")?;
-        assert_eq!(src.entry_type, EntryType::Folder);
-        assert_eq!(src.sedimentree_id, folder_id);
-        Ok(())
+                for entry in &dir.entries {
+                    let found = loaded.get(&entry.name).expect("entry should exist");
+                    assert_eq!(found.entry_type, entry.entry_type);
+                    assert_eq!(found.sedimentree_id, entry.sedimentree_id);
+                }
+            });
     }
 
+    #[allow(clippy::expect_used)]
     #[test]
-    fn bs58check_roundtrip() -> TestResult {
-        let mut payload = [0u8; 16];
-        getrandom::getrandom(&mut payload)?;
-
-        let encoded = bs58check_encode(&payload);
-        let decoded = bs58check_decode(&encoded)?;
-        assert_eq!(decoded, payload);
-        Ok(())
+    fn bs58check_roundtrip() {
+        check!()
+            .with_type::<[u8; 16]>()
+            .for_each(|payload: &[u8; 16]| {
+                let encoded = bs58check_encode(payload);
+                let decoded = bs58check_decode(&encoded).expect("decode");
+                assert_eq!(&decoded, payload);
+            });
     }
 
+    #[allow(clippy::expect_used)]
     #[test]
-    fn sedimentree_url_roundtrip() -> TestResult {
-        let id = random_id()?;
-        let url = sedimentree_id_to_url(id);
-
-        assert!(url.starts_with("automerge:"));
-
-        let recovered = url_to_sedimentree_id(&url)?;
-        assert_eq!(recovered, id);
-        Ok(())
+    fn sedimentree_url_roundtrip() {
+        check!()
+            .with_type::<[u8; 16]>()
+            .for_each(|id_bytes: &[u8; 16]| {
+                let mut full = [0u8; 32];
+                full[..16].copy_from_slice(id_bytes);
+                let id = SedimentreeId::new(full);
+
+                let url = sedimentree_id_to_url(id);
+                assert!(url.starts_with("automerge:"));
+
+                let recovered = url_to_sedimentree_id(&url).expect("parse url");
+                assert_eq!(recovered, id);
+            });
     }
 
     #[test]

darn_core/src/discover.rs

@@ -518,34 +518,29 @@ where
     (final_results, final_errors, cancel.is_cancelled())
 }
 
-#[allow(clippy::expect_used, clippy::unwrap_used, clippy::panic)]
+#[allow(clippy::panic)]
 #[cfg(test)]
 mod tests {
     use super::*;
+    use bolero::check;
 
     #[test]
-    fn sharded_cache_insert_and_get() {
-        let cache = ShardedDirCache::new();
-        let path = PathBuf::from("src/foo/bar");
-        let id = SedimentreeId::new([42; 32]);
-
-        assert!(cache.get(&path).is_none());
-
-        cache.insert(path.clone(), id);
-
-        assert_eq!(cache.get(&path), Some(id));
-    }
-
-    #[test]
-    fn sharded_cache_different_paths_different_shards() {
-        let cache = ShardedDirCache::new();
-
-        // Insert many paths to exercise multiple shards
-        for i in 0..100_u8 {
-            let path = PathBuf::from(format!("dir{i}/file.txt"));
-            let id = SedimentreeId::new([i; 32]);
-            cache.insert(path.clone(), id);
-            assert_eq!(cache.get(&path), Some(id));
-        }
+    fn sharded_cache_insert_then_get() {
+        check!()
+            .with_type::<Vec<(String, [u8; 32])>>()
+            .for_each(|entries: &Vec<(String, [u8; 32])>| {
+                let cache = ShardedDirCache::new();
+
+                for (path_str, id_bytes) in entries {
+                    let path = PathBuf::from(path_str);
+                    let id = SedimentreeId::new(*id_bytes);
+                    cache.insert(path.clone(), id);
+                    assert_eq!(
+                        cache.get(&path),
+                        Some(id),
+                        "get after insert should return the value"
+                    );
+                }
+            });
     }
 }