fixing test warnings

Author: xav-db

helix-db/Cargo.toml

@@ -85,13 +85,3 @@ dev = ["debug-output", "server", "bench"]
 dev-instance = []
 default = ["server"]
 production = ["api-key","server"]
-
-# benches/tests
-[[test]]
-name = "bm25_benches"
-path = "benches/bm25_benches.rs"
-
-[[test]]
-name = "hnsw_benches"
-path = "benches/hnsw_benches.rs"
-

helix-db/src/helix_engine/storage_core/storage_migration_tests.rs

@@ -136,6 +136,7 @@ fn populate_old_properties(
 }
 
 /// Set storage metadata to a specific state
+#[allow(dead_code)]
 fn set_metadata(
     storage: &mut HelixGraphStorage,
     metadata: StorageMetadata,
@@ -396,7 +397,7 @@ fn test_convert_old_properties_invalid_bincode() {
 
 #[test]
 fn test_migrate_empty_database() {
-    let (mut storage, _temp_dir) = setup_test_storage();
+    let (storage, _temp_dir) = setup_test_storage();
 
     // Storage is already created with migrations run, but let's verify the state
     let txn = storage.graph_env.read_txn().unwrap();

helix-db/src/helix_engine/tests/concurrency_tests/hnsw_concurrent_tests.rs

@@ -83,15 +83,15 @@ fn test_concurrent_inserts_single_label() {
     let barrier = Arc::new(Barrier::new(num_threads));
 
     let handles: Vec<_> = (0..num_threads)
-        .map(|thread_id| {
+        .map(|_thread_id| {
             let env = Arc::clone(&env);
             let barrier = Arc::clone(&barrier);
 
             thread::spawn(move || {
                 // Wait for all threads to be ready
                 barrier.wait();
 
-                for i in 0..vectors_per_thread {
+                for _i in 0..vectors_per_thread {
                     // Each insert needs its own write transaction (serialized by LMDB)
                     let mut wtxn = env.write_txn().unwrap();
                     let arena = Bump::new();
@@ -236,14 +236,14 @@ fn test_concurrent_searches_during_inserts() {
     }
 
     // Spawn writer threads
-    for writer_id in 0..num_writers {
+    for _writer_id in 0..num_writers {
         let env = Arc::clone(&env);
         let barrier = Arc::clone(&barrier);
 
         handles.push(thread::spawn(move || {
             barrier.wait();
 
-            for i in 0..25 {
+            for _i in 0..25 {
                 let mut wtxn = env.write_txn().unwrap();
                 let arena = Bump::new();
 

helix-db/src/helix_engine/tests/concurrency_tests/hnsw_loom_tests.rs

@@ -273,9 +273,9 @@ fn loom_graph_operation_ordering() {
 
 #[test]
 fn loom_two_writers_one_reader() {
-    /// Model of two writers and one reader accessing shared counter
-    ///
-    /// Tests MVCC-like behavior where reader should see consistent state
+    // Model of two writers and one reader accessing shared counter
+    //
+    // Tests MVCC-like behavior where reader should see consistent state
 
     loom::model(|| {
         let value = Arc::new(AtomicU64::new(0));

helix-db/src/helix_engine/tests/concurrency_tests/integration_stress_tests.rs

@@ -251,7 +251,7 @@ fn test_stress_rapid_graph_growth() {
     assert!(total_reads > 100, "Should perform many traversals");
 
     // Verify graph integrity
-    let arena = Bump::new();
+    let _arena = Bump::new();
     let rtxn = storage.graph_env.read_txn().unwrap();
     let final_node_count = storage.nodes_db.len(&rtxn).unwrap();
     let final_edge_count = storage.edges_db.len(&rtxn).unwrap();

helix-db/src/helix_engine/tests/concurrency_tests/traversal_concurrent_tests.rs

@@ -82,7 +82,7 @@ fn test_concurrent_node_additions() {
     }
 
     // Verify: All nodes created
-    let arena = Bump::new();
+    let _arena = Bump::new();
     let rtxn = storage.graph_env.read_txn().unwrap();
     let count = storage.nodes_db.len(&rtxn).unwrap();
     assert_eq!(

helix-db/src/helix_engine/tests/traversal_tests/count_tests.rs

@@ -22,7 +22,6 @@ use crate::{
 use rand::Rng;
 use tempfile::TempDir;
 use bumpalo::Bump;
-use tokio::time;
 fn setup_test_db() -> (TempDir, Arc<HelixGraphStorage>) {
     let temp_dir = TempDir::new().unwrap();
     let db_path = temp_dir.path().to_str().unwrap();

helix-db/src/protocol/custom_serde/error_handling_tests.rs

@@ -77,7 +77,7 @@ mod error_handling_tests {
         }
 
         let arena2 = Bump::new();
-        let result = Node::from_bincode_bytes(id, &bytes, &arena2);
+        let _result = Node::from_bincode_bytes(id, &bytes, &arena2);
         // May or may not fail depending on where corruption occurs
         // This test documents behavior
     }
@@ -98,7 +98,7 @@ mod error_handling_tests {
         let id = 55555u128;
         let zeros = vec![0u8; 100];
 
-        let result = Node::from_bincode_bytes(id, &zeros, &arena);
+        let _result = Node::from_bincode_bytes(id, &zeros, &arena);
         // This might actually deserialize to some default values
         // Test documents behavior
     }
@@ -168,7 +168,7 @@ mod error_handling_tests {
         }
 
         let arena2 = Bump::new();
-        let result = Edge::from_bincode_bytes(id, &bytes, &arena2);
+        let _result = Edge::from_bincode_bytes(id, &bytes, &arena2);
         // Might succeed with corrupted IDs - test documents behavior
     }
 
@@ -188,7 +188,7 @@ mod error_handling_tests {
         let id = 333444u128;
         let zeros = vec![0u8; 100];
 
-        let result = Edge::from_bincode_bytes(id, &zeros, &arena);
+        let _result = Edge::from_bincode_bytes(id, &zeros, &arena);
         // May deserialize with zero values - test documents behavior
     }
 
@@ -218,7 +218,7 @@ mod error_handling_tests {
         let empty_data: &[u8] = &[];
 
         let arena2 = Bump::new();
-        let result = HVector::from_bincode_bytes(&arena2, Some(&props_bytes), empty_data, id);
+        let _result = HVector::from_bincode_bytes(&arena2, Some(&props_bytes), empty_data, id);
         // Should panic due to assertion in cast_raw_vector_data
     }
 
@@ -271,10 +271,10 @@ mod error_handling_tests {
         let arena = Bump::new();
         let id = 888999u128;
         let vector = create_simple_vector(&arena, id, "test", &[1.0]);
-        let props_bytes = bincode::serialize(&vector).unwrap();
-        let single_byte: &[u8] = &[0x42];
+        let _props_bytes = bincode::serialize(&vector).unwrap();
+        let _single_byte: &[u8] = &[0x42];
 
-        let arena2 = Bump::new();
+        let _arena2 = Bump::new();
         // Should panic due to misalignment
     }
 
@@ -299,7 +299,7 @@ mod error_handling_tests {
         }
 
         let arena2 = Bump::new();
-        let result = Node::from_bincode_bytes(id, &bytes, &arena2);
+        let _result = Node::from_bincode_bytes(id, &bytes, &arena2);
         // Behavior depends on exact corruption
     }
 
@@ -319,7 +319,7 @@ mod error_handling_tests {
         }
 
         let arena2 = Bump::new();
-        let result = Edge::from_bincode_bytes(id, &bytes, &arena2);
+        let _result = Edge::from_bincode_bytes(id, &bytes, &arena2);
         // May fail on UTF-8 validation
     }
 
@@ -345,7 +345,7 @@ mod error_handling_tests {
         }
 
         let arena2 = Bump::new();
-        let result = Node::from_bincode_bytes(id, &bytes, &arena2);
+        let _result = Node::from_bincode_bytes(id, &bytes, &arena2);
         // Should fail on UTF-8 validation
     }
 
@@ -364,7 +364,7 @@ mod error_handling_tests {
         }
 
         let arena2 = Bump::new();
-        let result = Edge::from_bincode_bytes(id, &bytes, &arena2);
+        let _result = Edge::from_bincode_bytes(id, &bytes, &arena2);
         // Should fail on UTF-8 validation
     }
 
@@ -384,7 +384,7 @@ mod error_handling_tests {
         }
 
         let arena2 = Bump::new();
-        let result = HVector::from_bincode_bytes(&arena2, Some(&props_bytes), data_bytes, id);
+        let _result = HVector::from_bincode_bytes(&arena2, Some(&props_bytes), data_bytes, id);
         // Should fail on UTF-8 validation
     }
 
@@ -404,7 +404,7 @@ mod error_handling_tests {
         }
 
         let arena2 = Bump::new();
-        let result = Node::from_bincode_bytes(id, &bytes, &arena2);
+        let _result = Node::from_bincode_bytes(id, &bytes, &arena2);
         // May fail on UTF-8 validation
     }
 
@@ -425,7 +425,7 @@ mod error_handling_tests {
         }
 
         let arena2 = Bump::new();
-        let result = Edge::from_bincode_bytes(id, &bytes, &arena2);
+        let _result = Edge::from_bincode_bytes(id, &bytes, &arena2);
         // May fail during property deserialization
     }
 

helix-db/src/protocol/custom_serde/test_utils.rs

@@ -378,6 +378,7 @@ pub fn nested_value_props() -> Vec<(&'static str, Value)> {
 }
 
 /// Creates a large number of properties for stress testing
+#[allow(dead_code)]
 pub fn many_props(count: usize) -> Vec<(String, Value)> {
     (0..count)
         .map(|i| (format!("key_{}", i), Value::I32(i as i32)))
@@ -487,6 +488,7 @@ pub fn assert_vectors_semantically_equal(vec1: &HVector, vec2: &HVector) {
 // ============================================================================
 
 /// Prints byte-level comparison of two byte arrays
+#[allow(dead_code)]
 pub fn print_byte_comparison(label: &str, bytes1: &[u8], bytes2: &[u8]) {
     println!("\n=== {} ===", label);
     println!("Bytes1 ({} total): {:02x?}", bytes1.len(), bytes1);
@@ -513,6 +515,7 @@ pub fn print_byte_comparison(label: &str, bytes1: &[u8], bytes2: &[u8]) {
 }
 
 /// Prints human-readable interpretation of bytes
+#[allow(dead_code)]
 pub fn print_byte_interpretation(label: &str, bytes: &[u8]) {
     println!("\n{} as string interpretation:", label);
     for (i, byte) in bytes.iter().enumerate() {
@@ -533,6 +536,7 @@ pub fn print_byte_interpretation(label: &str, bytes: &[u8]) {
 // ============================================================================
 
 /// Generates a random string of given length
+#[allow(dead_code)]
 pub fn random_string(len: usize) -> String {
     use rand::Rng;
     let mut rng = rand::rng();
@@ -542,6 +546,7 @@ pub fn random_string(len: usize) -> String {
 }
 
 /// Generates random valid UTF-8 strings including Unicode
+#[allow(dead_code)]
 pub fn random_utf8_string(len: usize) -> String {
     use rand::Rng;
     let mut rng = rand::rng();
@@ -552,13 +557,15 @@ pub fn random_utf8_string(len: usize) -> String {
 }
 
 /// Generates a random f64 vector of given dimensions
+#[allow(dead_code)]
 pub fn random_f64_vector(dimensions: usize) -> Vec<f64> {
     use rand::Rng;
     let mut rng = rand::rng();
     (0..dimensions).map(|_| rng.random_range(-1.0..1.0)).collect()
 }
 
 /// Generates a random Value for property testing
+#[allow(dead_code)]
 pub fn random_value() -> Value {
     use rand::Rng;
     let mut rng = rand::rng();

helix-db/src/protocol/custom_serde/vector_serde_tests.rs

@@ -16,7 +16,7 @@ mod vector_serialization_tests {
     use crate::helix_engine::vector_core::vector::HVector;
     use crate::helix_engine::vector_core::vector_without_data::VectorWithoutData;
     use crate::protocol::value::Value;
-    use bincode::Options;
+    
     use bumpalo::Bump;
 
     // ========================================================================