Add tests to increase code coverage for utilities, resources, prompts, and tools modules

Author: sapientpants

tests/main_tests.rs

@@ -0,0 +1,194 @@
+use clap::Parser;
+use std::str::FromStr;
+
+// Import the Args struct from main.rs
+// We can't directly import it as it's not public, so we recreate it here
+#[derive(Parser, Debug, PartialEq)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// list resources
+    #[arg(long, default_value = "false")]
+    resources: bool,
+    /// list prompts
+    #[arg(long, default_value = "false")]
+    prompts: bool,
+    /// list tools
+    #[arg(long, default_value = "false")]
+    tools: bool,
+    /// start MCP server
+    #[arg(long, default_value = "false")]
+    mcp: bool,
+    /// output as json-rpc format
+    #[arg(long, default_value = "false")]
+    json: bool,
+}
+
+impl Args {
+    fn is_args_available(&self) -> bool {
+        self.prompts || self.resources || self.tools
+    }
+}
+
+#[test]
+fn test_args_default_values() {
+    // Parse empty arguments
+    let args = Args::parse_from(["program"]);
+
+    // Verify default values
+    assert_eq!(args.resources, false);
+    assert_eq!(args.prompts, false);
+    assert_eq!(args.tools, false);
+    assert_eq!(args.mcp, false);
+    assert_eq!(args.json, false);
+}
+
+#[test]
+fn test_args_with_resources() {
+    // Parse with resources flag
+    let args = Args::parse_from(["program", "--resources"]);
+
+    // Verify values
+    assert_eq!(args.resources, true);
+    assert_eq!(args.prompts, false);
+    assert_eq!(args.tools, false);
+    assert_eq!(args.mcp, false);
+    assert_eq!(args.json, false);
+}
+
+#[test]
+fn test_args_with_prompts() {
+    // Parse with prompts flag
+    let args = Args::parse_from(["program", "--prompts"]);
+
+    // Verify values
+    assert_eq!(args.resources, false);
+    assert_eq!(args.prompts, true);
+    assert_eq!(args.tools, false);
+    assert_eq!(args.mcp, false);
+    assert_eq!(args.json, false);
+}
+
+#[test]
+fn test_args_with_tools() {
+    // Parse with tools flag
+    let args = Args::parse_from(["program", "--tools"]);
+
+    // Verify values
+    assert_eq!(args.resources, false);
+    assert_eq!(args.prompts, false);
+    assert_eq!(args.tools, true);
+    assert_eq!(args.mcp, false);
+    assert_eq!(args.json, false);
+}
+
+#[test]
+fn test_args_with_mcp() {
+    // Parse with mcp flag
+    let args = Args::parse_from(["program", "--mcp"]);
+
+    // Verify values
+    assert_eq!(args.resources, false);
+    assert_eq!(args.prompts, false);
+    assert_eq!(args.tools, false);
+    assert_eq!(args.mcp, true);
+    assert_eq!(args.json, false);
+}
+
+#[test]
+fn test_args_with_json() {
+    // Parse with json flag
+    let args = Args::parse_from(["program", "--json"]);
+
+    // Verify values
+    assert_eq!(args.resources, false);
+    assert_eq!(args.prompts, false);
+    assert_eq!(args.tools, false);
+    assert_eq!(args.mcp, false);
+    assert_eq!(args.json, true);
+}
+
+#[test]
+fn test_args_with_multiple_flags() {
+    // Parse with multiple flags
+    let args = Args::parse_from(["program", "--resources", "--json", "--tools"]);
+
+    // Verify values
+    assert_eq!(args.resources, true);
+    assert_eq!(args.prompts, false);
+    assert_eq!(args.tools, true);
+    assert_eq!(args.mcp, false);
+    assert_eq!(args.json, true);
+}
+
+#[test]
+fn test_is_args_available() {
+    // Test with no flags
+    let args = Args {
+        resources: false,
+        prompts: false,
+        tools: false,
+        mcp: false,
+        json: false,
+    };
+    assert_eq!(args.is_args_available(), false);
+
+    // Test with resources flag
+    let args = Args {
+        resources: true,
+        prompts: false,
+        tools: false,
+        mcp: false,
+        json: false,
+    };
+    assert_eq!(args.is_args_available(), true);
+
+    // Test with prompts flag
+    let args = Args {
+        resources: false,
+        prompts: true,
+        tools: false,
+        mcp: false,
+        json: false,
+    };
+    assert_eq!(args.is_args_available(), true);
+
+    // Test with tools flag
+    let args = Args {
+        resources: false,
+        prompts: false,
+        tools: true,
+        mcp: false,
+        json: false,
+    };
+    assert_eq!(args.is_args_available(), true);
+
+    // Test with mcp flag (should not affect is_args_available)
+    let args = Args {
+        resources: false,
+        prompts: false,
+        tools: false,
+        mcp: true,
+        json: false,
+    };
+    assert_eq!(args.is_args_available(), false);
+
+    // Test with json flag (should not affect is_args_available)
+    let args = Args {
+        resources: false,
+        prompts: false,
+        tools: false,
+        mcp: false,
+        json: true,
+    };
+    assert_eq!(args.is_args_available(), false);
+
+    // Test with multiple flags
+    let args = Args {
+        resources: true,
+        prompts: true,
+        tools: true,
+        mcp: true,
+        json: true,
+    };
+    assert_eq!(args.is_args_available(), true);
+}

tests/sonarqube_tools_tests.rs

@@ -0,0 +1,198 @@
+mod helpers;
+
+use sonarqube_mcp_server::mcp::sonarqube::tools::{
+    register_sonarqube_tools, sonarqube_get_issues, sonarqube_get_metrics,
+    sonarqube_get_quality_gate, sonarqube_list_projects,
+};
+use sonarqube_mcp_server::mcp::sonarqube::types::*;
+use sonarqube_mcp_server::mcp::types::CallToolResultContent;
+use std::env;
+
+#[test]
+fn test_init_sonarqube_client_missing_url() {
+    // Save original environment variables
+    let original_url = env::var("SONARQUBE_URL").ok();
+    let original_token = env::var("SONARQUBE_TOKEN").ok();
+
+    // Unset environment variables
+    env::remove_var("SONARQUBE_URL");
+    env::remove_var("SONARQUBE_TOKEN");
+
+    // Try to initialize client
+    let result = sonarqube_mcp_server::mcp::sonarqube::tools::init_sonarqube_client();
+
+    // Verify error
+    assert!(result.is_err());
+    match result {
+        Err(SonarError::Config(msg)) => {
+            assert!(msg.contains("SONARQUBE_URL"));
+        }
+        _ => panic!("Expected Config error"),
+    }
+
+    // Restore environment variables
+    if let Some(url) = original_url {
+        env::set_var("SONARQUBE_URL", url);
+    }
+    if let Some(token) = original_token {
+        env::set_var("SONARQUBE_TOKEN", token);
+    }
+}
+
+#[test]
+fn test_init_sonarqube_client_missing_token() {
+    // Save original environment variables
+    let original_url = env::var("SONARQUBE_URL").ok();
+    let original_token = env::var("SONARQUBE_TOKEN").ok();
+
+    // Set URL but unset token
+    env::set_var("SONARQUBE_URL", "https://sonarqube.example.com");
+    env::remove_var("SONARQUBE_TOKEN");
+
+    // Try to initialize client
+    let result = sonarqube_mcp_server::mcp::sonarqube::tools::init_sonarqube_client();
+
+    // Verify error
+    assert!(result.is_err());
+    match result {
+        Err(SonarError::Config(msg)) => {
+            assert!(msg.contains("SONARQUBE_TOKEN"));
+        }
+        _ => panic!("Expected Config error"),
+    }
+
+    // Restore environment variables
+    if let Some(url) = original_url {
+        env::set_var("SONARQUBE_URL", url);
+    } else {
+        env::remove_var("SONARQUBE_URL");
+    }
+    if let Some(token) = original_token {
+        env::set_var("SONARQUBE_TOKEN", token);
+    }
+}
+
+#[test]
+fn test_register_sonarqube_tools() {
+    // Create a router builder
+    let builder = rpc_router::RouterBuilder::default();
+
+    // Register SonarQube tools
+    let _builder = register_sonarqube_tools(builder);
+
+    // We can't easily test the router functionality without mocking,
+    // so we just verify that the function doesn't panic
+    assert!(true);
+}
+
+// Test handlers without a client - they should all return errors
+
+#[tokio::test]
+async fn test_sonarqube_get_metrics_no_client() {
+    // We're testing without initializing the client
+
+    // Call the tool handler
+    let request = SonarQubeMetricsRequest {
+        project_key: "test-project".to_string(),
+        metrics: None,
+    };
+    let result = sonarqube_get_metrics(request).await;
+
+    // Since there's no global client initialized, this should error
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn test_sonarqube_get_issues_no_client() {
+    // We're testing without initializing the client
+
+    // Call the tool handler
+    let request = SonarQubeIssuesRequest {
+        project_key: "test-project".to_string(),
+        severities: None,
+        types: None,
+        statuses: None,
+        impact_severities: None,
+        impact_software_qualities: None,
+        assigned_to_me: None,
+        assignees: None,
+        authors: None,
+        code_variants: None,
+        created_after: None,
+        created_before: None,
+        created_in_last: None,
+        cwe: None,
+        directories: None,
+        facets: None,
+        files: None,
+        issue_statuses: None,
+        languages: None,
+        owasp_top10: None,
+        owasp_top10_2021: None,
+        resolutions: None,
+        resolved: None,
+        rules: None,
+        sans_top25: None,
+        sonarsource_security: None,
+        tags: None,
+        sort_field: None,
+        asc: None,
+        page: None,
+        page_size: None,
+    };
+    let result = sonarqube_get_issues(request).await;
+
+    // Since there's no global client initialized, this should error
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn test_sonarqube_get_quality_gate_no_client() {
+    // We're testing without initializing the client
+
+    // Call the tool handler
+    let request = SonarQubeQualityGateRequest {
+        project_key: "test-project".to_string(),
+    };
+    let result = sonarqube_get_quality_gate(request).await;
+
+    // Since there's no global client initialized, this should error
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn test_sonarqube_list_projects_no_client() {
+    // We're testing without initializing the client
+
+    // Call the tool handler
+    let request = SonarQubeListProjectsRequest {
+        page: None,
+        page_size: None,
+        organization: None,
+    };
+    let result = sonarqube_list_projects(request).await;
+
+    // Since there's no global client initialized, this should error
+    assert!(result.is_err());
+}
+
+// Integration test - we'll create a test that ensures the CallToolResultContent is correctly formatted
+#[test]
+fn test_call_tool_result_content_formatting() {
+    // Test text content
+    let text_content = CallToolResultContent::Text {
+        text: "Test result".to_string(),
+    };
+
+    // Verify JSON serialization
+    let json = serde_json::to_string(&text_content).unwrap();
+    assert!(json.contains(r#""type":"text""#));
+    assert!(json.contains(r#""text":"Test result""#));
+
+    // Test deserialization
+    let deserialized: CallToolResultContent = serde_json::from_str(&json).unwrap();
+    match deserialized {
+        CallToolResultContent::Text { text } => assert_eq!(text, "Test result"),
+        _ => panic!("Expected Text variant"),
+    }
+}