Test: Add 29 unit and integration tests for cache, response, schema, logging, and integration

Author: sjkim1127

tests/cache_test.rs

@@ -0,0 +1,122 @@
+//! Tests for the cache module
+
+use nexuscore_mcp::utils::cache::{ResultCache, file_hash, get_cache};
+use serde_json::json;
+use std::time::Duration;
+use std::thread;
+
+#[test]
+fn test_cache_insert_and_get() {
+    let mut cache = ResultCache::new(10, 60);
+    
+    let key = "test:abc123".to_string();
+    let value = json!({"result": "test_data"});
+    
+    cache.insert(key.clone(), value.clone());
+    
+    let retrieved = cache.get(&key);
+    assert!(retrieved.is_some());
+    assert_eq!(retrieved.unwrap()["result"], "test_data");
+}
+
+#[test]
+fn test_cache_miss() {
+    let cache = ResultCache::new(10, 60);
+    
+    let result = cache.get("nonexistent:key");
+    assert!(result.is_none());
+}
+
+#[test]
+fn test_cache_expiry() {
+    let mut cache = ResultCache::new(10, 1); // 1 second TTL
+    
+    let key = "test:expiry".to_string();
+    let value = json!({"data": "will_expire"});
+    
+    cache.insert(key.clone(), value);
+    
+    // Should exist immediately
+    assert!(cache.get(&key).is_some());
+    
+    // Wait for expiry
+    thread::sleep(Duration::from_secs(2));
+    
+    // Should be expired now
+    assert!(cache.get(&key).is_none());
+}
+
+#[test]
+fn test_cache_eviction() {
+    let mut cache = ResultCache::new(3, 60); // Max 3 entries
+    
+    cache.insert("key1".to_string(), json!(1));
+    cache.insert("key2".to_string(), json!(2));
+    cache.insert("key3".to_string(), json!(3));
+    
+    // Add 4th entry - should evict oldest
+    cache.insert("key4".to_string(), json!(4));
+    
+    // key1 should be evicted
+    assert!(cache.get("key1").is_none());
+    assert!(cache.get("key4").is_some());
+}
+
+#[test]
+fn test_cache_cleanup() {
+    let mut cache = ResultCache::new(10, 1);
+    
+    cache.insert("key1".to_string(), json!(1));
+    cache.insert("key2".to_string(), json!(2));
+    
+    thread::sleep(Duration::from_secs(2));
+    
+    cache.cleanup();
+    
+    // All entries should be removed after cleanup
+    assert!(cache.get("key1").is_none());
+    assert!(cache.get("key2").is_none());
+}
+
+#[test]
+fn test_global_cache() {
+    let cache = get_cache();
+    let mut guard = cache.lock().unwrap();
+    
+    guard.insert("global:test".to_string(), json!({"global": true}));
+    
+    let result = guard.get("global:test");
+    assert!(result.is_some());
+}
+
+#[cfg(test)]
+mod file_hash_tests {
+    use super::*;
+    use std::fs;
+    use std::io::Write;
+    
+    #[test]
+    fn test_file_hash_consistency() {
+        // Create temp file
+        let path = "test_hash_file.tmp";
+        let mut file = fs::File::create(path).unwrap();
+        file.write_all(b"test content for hashing").unwrap();
+        drop(file);
+        
+        // Hash should be consistent
+        let hash1 = file_hash(path).unwrap();
+        let hash2 = file_hash(path).unwrap();
+        
+        assert_eq!(hash1, hash2);
+        assert_eq!(hash1.len(), 64); // SHA256 = 64 hex chars
+        
+        // Cleanup
+        fs::remove_file(path).unwrap();
+    }
+    
+    #[test]
+    fn test_file_hash_nonexistent() {
+        let result = file_hash("nonexistent_file.xyz");
+        assert!(result.is_err());
+    }
+}

tests/integration_test.rs

@@ -0,0 +1,136 @@
+//! Integration tests for NexusCore MCP
+
+use nexuscore_mcp::tools::Tool;
+use nexuscore_mcp::utils::response::StandardResponse;
+use serde_json::json;
+
+/// Helper to run async tests
+fn block_on<F: std::future::Future>(f: F) -> F::Output {
+    tokio::runtime::Runtime::new().unwrap().block_on(f)
+}
+
+/// Test that all tools return valid StandardResponse format
+#[cfg(test)]
+mod response_format_tests {
+    use super::*;
+    
+    fn validate_response(result: serde_json::Value) {
+        // Must have these fields
+        assert!(result.get("tool").is_some(), "Missing 'tool' field");
+        assert!(result.get("status").is_some(), "Missing 'status' field");
+        assert!(result.get("timestamp").is_some(), "Missing 'timestamp' field");
+        
+        // Status must be one of: success, error, partial
+        let status = result["status"].as_str().unwrap();
+        assert!(
+            ["success", "error", "partial"].contains(&status),
+            "Invalid status: {}", status
+        );
+        
+        // If error, must have error field
+        if status == "error" {
+            assert!(result.get("error").is_some(), "Error response missing 'error' field");
+        }
+    }
+    
+    #[test]
+    fn test_success_response_format() {
+        let result = StandardResponse::success("test", json!({"data": 1}));
+        validate_response(result.clone());
+        assert_eq!(result["status"], "success");
+    }
+    
+    #[test]
+    fn test_error_response_format() {
+        let result = StandardResponse::error("test", "fail");
+        validate_response(result.clone());
+        assert_eq!(result["status"], "error");
+    }
+    
+    #[test]
+    fn test_cached_response_format() {
+        let result = StandardResponse::success_cached("test", json!({}));
+        validate_response(result.clone());
+        assert_eq!(result["metadata"]["cached"], true);
+    }
+}
+
+/// Schema validation tests
+#[cfg(test)]
+mod schema_validation_tests {
+    use super::*;
+    use nexuscore_mcp::tools::{ToolSchema, ParamDef};
+    
+    fn validate_json_schema(schema: serde_json::Value) {
+        assert_eq!(schema["type"], "object");
+        assert!(schema.get("properties").is_some());
+        assert!(schema.get("required").is_some());
+    }
+    
+    #[test]
+    fn test_empty_schema_valid() {
+        let schema = ToolSchema::empty();
+        validate_json_schema(schema.to_json());
+    }
+    
+    #[test]
+    fn test_schema_with_required_params() {
+        let schema = ToolSchema::new(vec![
+            ParamDef::new("pid", "number", true, "PID"),
+            ParamDef::new("path", "string", true, "Path"),
+        ]);
+        
+        let json = schema.to_json();
+        validate_json_schema(json.clone());
+        
+        let required = json["required"].as_array().unwrap();
+        assert_eq!(required.len(), 2);
+    }
+}
+
+/// Tool naming convention tests
+#[cfg(test)]
+mod naming_convention_tests {
+    use super::*;
+    use nexuscore_mcp::tools::common::metrics::MetricsTool;
+    
+    #[test]
+    fn test_tool_name_snake_case() {
+        let tool = MetricsTool;
+        let name = tool.name();
+        
+        // Name should be snake_case
+        assert!(name.chars().all(|c| c.is_lowercase() || c == '_' || c.is_numeric()));
+        assert!(!name.contains('-'));
+        assert!(!name.contains(' '));
+    }
+    
+    #[test]
+    fn test_tool_has_description() {
+        let tool = MetricsTool;
+        let desc = tool.description();
+        
+        assert!(!desc.is_empty());
+        assert!(desc.len() > 10); // Should be meaningful
+    }
+}
+
+/// Metrics tool integration test
+#[cfg(test)]
+mod metrics_integration_tests {
+    use super::*;
+    use nexuscore_mcp::tools::common::metrics::MetricsTool;
+    
+    #[test]
+    fn test_metrics_tool_execution() {
+        let tool = MetricsTool;
+        
+        let result = block_on(tool.execute(json!({})));
+        assert!(result.is_ok());
+        
+        let response = result.unwrap();
+        assert_eq!(response["status"], "success");
+        assert!(response["data"].get("total_calls").is_some());
+        assert!(response["data"].get("cache_hit_rate").is_some());
+    }
+}

tests/logging_test.rs

@@ -0,0 +1,95 @@
+//! Tests for the logging module
+
+use nexuscore_mcp::utils::logging::{get_metrics, PerfMetrics};
+use serde_json::json;
+
+#[test]
+fn test_perf_metrics_new() {
+    let metrics = PerfMetrics::new();
+    let stats = metrics.get_stats();
+    
+    assert_eq!(stats["total_calls"], 0);
+    assert_eq!(stats["cache_hits"], 0);
+    assert_eq!(stats["cache_misses"], 0);
+    assert_eq!(stats["total_duration_ms"], 0);
+}
+
+#[test]
+fn test_perf_metrics_record_call() {
+    let metrics = PerfMetrics::new();
+    
+    metrics.record_call(100, false); // cache miss
+    metrics.record_call(50, true);   // cache hit
+    metrics.record_call(75, false);  // cache miss
+    
+    let stats = metrics.get_stats();
+    
+    assert_eq!(stats["total_calls"], 3);
+    assert_eq!(stats["cache_hits"], 1);
+    assert_eq!(stats["cache_misses"], 2);
+    assert_eq!(stats["total_duration_ms"], 225);
+}
+
+#[test]
+fn test_cache_hit_rate_calculation() {
+    let metrics = PerfMetrics::new();
+    
+    // 2 hits, 2 misses = 50% hit rate
+    metrics.record_call(10, true);
+    metrics.record_call(10, true);
+    metrics.record_call(10, false);
+    metrics.record_call(10, false);
+    
+    let stats = metrics.get_stats();
+    let hit_rate = stats["cache_hit_rate"].as_f64().unwrap();
+    
+    assert!((hit_rate - 50.0).abs() < 0.01);
+}
+
+#[test]
+fn test_cache_hit_rate_zero_calls() {
+    let metrics = PerfMetrics::new();
+    let stats = metrics.get_stats();
+    
+    // Should be 0 when no calls recorded
+    assert_eq!(stats["cache_hit_rate"], 0.0);
+}
+
+#[test]
+fn test_global_metrics() {
+    let metrics = get_metrics();
+    
+    // Should always return the same instance
+    let metrics2 = get_metrics();
+    
+    metrics.record_call(10, false);
+    
+    // Both references should see the same data
+    let stats = metrics2.get_stats();
+    assert!(stats["total_calls"].as_u64().unwrap() > 0);
+}
+
+#[test]
+fn test_metrics_thread_safety() {
+    use std::thread;
+    use std::sync::Arc;
+    
+    let metrics = Arc::new(PerfMetrics::new());
+    let mut handles = vec![];
+    
+    for _ in 0..10 {
+        let m = Arc::clone(&metrics);
+        handles.push(thread::spawn(move || {
+            for _ in 0..100 {
+                m.record_call(1, false);
+            }
+        }));
+    }
+    
+    for handle in handles {
+        handle.join().unwrap();
+    }
+    
+    let stats = metrics.get_stats();
+    assert_eq!(stats["total_calls"], 1000);
+}