feat(tests): refactoring

Author: Mte90

Cargo.toml

@@ -67,6 +67,14 @@ serial_test = "3"
 futures = "0.3"
 mockito = "1"
 
+[[test]]
+name = "unit_tests"
+path = "tests/unit/mod.rs"
+
+[[test]]
+name = "integration_tests"
+path = "tests/integration/mod.rs"
+
 [profile.release]
 opt-level = 3
 lto = true

README.md

@@ -2,7 +2,8 @@
 [![License](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](http://www.gnu.org/licenses/gpl-3.0)   
 
 A CLI-based security vulnerability scanner that combines static analysis, LLM-powered discovery, and ticket system cross-referencing (generated with Regolo.AI).  
-[Example Report](example-report.html) generated with [Regolo.AI](https://regolo.ai/) models on [ins1gn1a/VulnServer-Linux](https://github.com/ins1gn1a/VulnServer-Linux).
+[Example Report](example-report.html) generated with [Regolo.AI](https://regolo.ai/) models on [ins1gn1a/VulnServer-Linux](https://github.com/ins1gn1a/VulnServer-Linux).  
+Code coverage at [Codecov.io](https://app.codecov.io/gh/CodeAtCode/baco-scanner/tree/master).
 
 ## Features
 

codecov.yml

@@ -12,7 +12,7 @@ coverage:
         target: 80%
 
 ignore:
-  - "./tests/*.rs"
+  - "tests/**/*.rs"
 
 comment:
   layout: " diff, flags, files"

src/agent/executor.rs

@@ -172,3 +172,303 @@ pub async fn execute_tool_calls(
 
     (tools_used, test_source_path, compile_path, messages)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::agent::sandbox::ToolSandbox;
+    use crate::agent::tool_schema::ToolRegistry;
+    use crate::agent::ToolCall;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_create_empty_finding() {
+        let finding = create_empty_finding("test.rs", 1, vec!["tool1".to_string()], Some("test-model".to_string()));
+
+        assert!(finding.finding.id.is_empty());
+        assert!(finding.finding.title.is_empty());
+        assert!(finding.finding.description.is_empty());
+        assert_eq!(finding.finding.severity, Severity::Low);
+        assert_eq!(finding.finding.confidence_score, 0.0);
+        assert_eq!(finding.finding.file_path, "test.rs");
+        assert!(finding.finding.line_number.is_none());
+        assert_eq!(finding.agent_turns, 1);
+        assert_eq!(finding.tools_used, vec!["tool1".to_string()]);
+        assert_eq!(finding.finding.llm_model, Some("test-model".to_string()));
+        assert!(finding.finding.agent_mode);
+    }
+
+    #[test]
+    fn test_create_empty_finding_no_model() {
+        let finding = create_empty_finding("test.rs", 1, vec![], None);
+
+        assert!(finding.finding.llm_model.is_none());
+        assert_eq!(finding.agent_turns, 1);
+    }
+
+    #[test]
+    fn test_create_audit_finding() {
+        let reasoning = "No vulnerabilities found after thorough analysis";
+        let finding = create_audit_finding("test.rs", 2, vec!["file_read".to_string()], reasoning.to_string(), Some("model".to_string()));
+
+        assert!(finding.finding.id.starts_with("agent-"));
+        assert_eq!(finding.finding.title, "Security Audit - No Critical Vulnerabilities Detected");
+        assert_eq!(finding.finding.description, reasoning);
+        assert_eq!(finding.finding.severity, Severity::Medium);
+        assert_eq!(finding.finding.confidence_score, 0.7);
+        assert_eq!(finding.finding.file_path, "test.rs");
+        assert_eq!(finding.agent_turns, 2);
+        assert_eq!(finding.tools_used, vec!["file_read".to_string()]);
+    }
+
+    #[test]
+    fn test_create_audit_finding_no_model() {
+        let finding = create_audit_finding("test.rs", 1, vec![], "reasoning".to_string(), None);
+
+        assert!(finding.finding.llm_model.is_none());
+    }
+
+    #[tokio::test]
+    async fn test_execute_tool_calls_single_tool() {
+        let mut registry = ToolRegistry::new();
+        registry.register(Box::new(crate::agent::tools::FileReadTool));
+        
+        let tmpdir = tempfile::tempdir().unwrap();
+        let path = tmpdir.path().join("test.txt");
+        std::fs::write(&path, "hello").unwrap();
+        
+        let sandbox = ToolSandbox::new(tmpdir.path().to_path_buf(), 30);
+        let progress_cb: ProgressCallback = Arc::new(|_| {});
+        
+        let response = ChatResponse {
+            content: "".to_string(),
+            tool_calls: vec![ToolCall {
+                id: Some("call_1".to_string()),
+                name: "file_read".to_string(),
+                arguments: serde_json::json!({ "path": "test.txt" }),
+            }],
+            raw: serde_json::json!({}),
+            model_used: "test".to_string(),
+        };
+        
+        let messages = vec![ChatMessage::user("test")];
+        
+        let (tools_used, test_path, compile_path, messages) = execute_tool_calls(
+            &registry,
+            &sandbox,
+            &response,
+            messages,
+            &progress_cb,
+            tmpdir.path(),
+            1,
+            10,
+            "Turn",
+        ).await;
+        
+        assert_eq!(tools_used, vec!["file_read".to_string()]);
+        assert!(test_path.is_none());
+        assert!(compile_path.is_none());
+        assert_eq!(messages.len(), 3); // original + assistant call + user result
+    }
+
+    #[tokio::test]
+    async fn test_execute_tool_calls_file_write_path_capture() {
+        let mut registry = ToolRegistry::new();
+        registry.register(Box::new(crate::agent::tools::FileWriteTool));
+        
+        let tmpdir = tempfile::tempdir().unwrap();
+        let sandbox = ToolSandbox::new(tmpdir.path().to_path_buf(), 30);
+        let progress_cb: ProgressCallback = Arc::new(|_| {});
+        
+        let response = ChatResponse {
+            content: "".to_string(),
+            tool_calls: vec![ToolCall {
+                id: Some("call_1".to_string()),
+                name: "file_write".to_string(),
+                arguments: serde_json::json!({ "path": "test.rs", "content": "fn main() {}" }),
+            }],
+            raw: serde_json::json!({}),
+            model_used: "test".to_string(),
+        };
+        
+        let messages = vec![ChatMessage::user("test")];
+        
+        let (tools_used, test_path, compile_path, _) = execute_tool_calls(
+            &registry,
+            &sandbox,
+            &response,
+            messages,
+            &progress_cb,
+            tmpdir.path(),
+            1,
+            10,
+            "Turn",
+        ).await;
+        
+        assert_eq!(tools_used, vec!["file_write".to_string()]);
+        assert!(test_path.is_some());
+        assert!(compile_path.is_none());
+    }
+
+    #[tokio::test]
+    async fn test_execute_tool_calls_test_compile_path_capture() {
+        let mut registry = ToolRegistry::new();
+        registry.register(Box::new(crate::agent::tools::TestCompileTool));
+        
+        let tmpdir = tempfile::tempdir().unwrap();
+        let sandbox = ToolSandbox::new(tmpdir.path().to_path_buf(), 30);
+        let progress_cb: ProgressCallback = Arc::new(|_| {});
+        
+        let response = ChatResponse {
+            content: "".to_string(),
+            tool_calls: vec![ToolCall {
+                id: Some("call_1".to_string()),
+                name: "test_compile".to_string(),
+                arguments: serde_json::json!({ "source_path": "test.rs", "language": "rust" }),
+            }],
+            raw: serde_json::json!({}),
+            model_used: "test".to_string(),
+        };
+        
+        let messages = vec![ChatMessage::user("test")];
+        
+        let (tools_used, test_path, compile_path, _) = execute_tool_calls(
+            &registry,
+            &sandbox,
+            &response,
+            messages,
+            &progress_cb,
+            tmpdir.path(),
+            1,
+            10,
+            "Turn",
+        ).await;
+        
+        assert_eq!(tools_used, vec!["test_compile".to_string()]);
+        assert!(test_path.is_none());
+        assert!(compile_path.is_some());
+    }
+
+    #[tokio::test]
+    async fn test_execute_tool_calls_unknown_tool() {
+        let registry = ToolRegistry::new();
+        let tmpdir = tempfile::tempdir().unwrap();
+        let sandbox = ToolSandbox::new(tmpdir.path().to_path_buf(), 30);
+        let progress_cb: ProgressCallback = Arc::new(|_| {});
+        
+        let response = ChatResponse {
+            content: "".to_string(),
+            tool_calls: vec![ToolCall {
+                id: Some("call_1".to_string()),
+                name: "unknown_tool".to_string(),
+                arguments: serde_json::json!({}),
+            }],
+            raw: serde_json::json!({}),
+            model_used: "test".to_string(),
+        };
+        
+        let messages = vec![ChatMessage::user("test")];
+        
+        let (tools_used, _, _, messages) = execute_tool_calls(
+            &registry,
+            &sandbox,
+            &response,
+            messages,
+            &progress_cb,
+            tmpdir.path(),
+            1,
+            10,
+            "Turn",
+        ).await;
+        
+        assert!(tools_used.is_empty());
+        assert_eq!(messages.len(), 1); // No new messages since tool not found
+    }
+
+    #[tokio::test]
+    async fn test_execute_tool_calls_tool_error() {
+        let mut registry = ToolRegistry::new();
+        registry.register(Box::new(crate::agent::tools::FileReadTool));
+        
+        let tmpdir = tempfile::tempdir().unwrap();
+        let sandbox = ToolSandbox::new(tmpdir.path().to_path_buf(), 30);
+        let progress_cb: ProgressCallback = Arc::new(|_| {});
+        
+        let response = ChatResponse {
+            content: "".to_string(),
+            tool_calls: vec![ToolCall {
+                id: Some("call_1".to_string()),
+                name: "file_read".to_string(),
+                arguments: serde_json::json!({ "path": "nonexistent.txt" }),
+            }],
+            raw: serde_json::json!({}),
+            model_used: "test".to_string(),
+        };
+        
+        let messages = vec![ChatMessage::user("test")];
+        
+        let (_, _, _, messages) = execute_tool_calls(
+            &registry,
+            &sandbox,
+            &response,
+            messages,
+            &progress_cb,
+            tmpdir.path(),
+            1,
+            10,
+            "Turn",
+        ).await;
+        
+        // Should have assistant call + user error message
+        assert_eq!(messages.len(), 3);
+        assert!(messages[2].content.contains("error"));
+    }
+
+    #[tokio::test]
+    async fn test_execute_tool_calls_multiple_tools() {
+        let mut registry = ToolRegistry::new();
+        registry.register(Box::new(crate::agent::tools::FileReadTool));
+        registry.register(Box::new(crate::agent::tools::FileWriteTool));
+        
+        let tmpdir = tempfile::tempdir().unwrap();
+        let sandbox = ToolSandbox::new(tmpdir.path().to_path_buf(), 30);
+        let progress_cb: ProgressCallback = Arc::new(|_| {});
+        
+        let response = ChatResponse {
+            content: "".to_string(),
+            tool_calls: vec![
+                ToolCall {
+                    id: Some("call_1".to_string()),
+                    name: "file_read".to_string(),
+                    arguments: serde_json::json!({ "path": "test.txt" }),
+                },
+                ToolCall {
+                    id: Some("call_2".to_string()),
+                    name: "file_write".to_string(),
+                    arguments: serde_json::json!({ "path": "out.txt", "content": "test" }),
+                },
+            ],
+            raw: serde_json::json!({}),
+            model_used: "test".to_string(),
+        };
+        
+        let messages = vec![ChatMessage::user("test")];
+        
+        let (tools_used, test_path, _, _) = execute_tool_calls(
+            &registry,
+            &sandbox,
+            &response,
+            messages,
+            &progress_cb,
+            tmpdir.path(),
+            1,
+            10,
+            "Turn",
+        ).await;
+        
+        assert_eq!(tools_used.len(), 2);
+        assert!(tools_used.contains(&"file_read".to_string()));
+        assert!(tools_used.contains(&"file_write".to_string()));
+        assert!(test_path.is_some());
+    }
+}