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

Author: sapientpants

tests/client_tests.rs

@@ -220,3 +220,116 @@ async fn test_get_quality_gate_success() {
     assert_eq!(failing_condition.metric_key, "new_maintainability_rating");
     assert_eq!(failing_condition.actual_value, "2");
 }
+
+#[tokio::test]
+async fn test_list_projects_success() {
+    // Start a mock server
+    let mock_server = MockServer::start().await;
+
+    // Setup mock response for projects endpoint with the correct endpoint path
+    Mock::given(method("GET"))
+        .and(path("/api/components/search"))
+        .and(query_param("qualifiers", "TRK"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(
+            r#"{
+                "paging": {
+                    "pageIndex": 1,
+                    "pageSize": 50,
+                    "total": 2
+                },
+                "components": [
+                    {
+                        "key": "test-project-1",
+                        "name": "Test Project 1",
+                        "qualifier": "TRK"
+                    },
+                    {
+                        "key": "test-project-2",
+                        "name": "Test Project 2",
+                        "qualifier": "TRK"
+                    }
+                ]
+            }"#,
+        ))
+        .expect(1)
+        .mount(&mock_server)
+        .await;
+
+    // Create client with mock server URL
+    let client = SonarQubeClient::new(SonarQubeConfig {
+        base_url: mock_base_url(&mock_server),
+        token: mock_token(),
+        organization: None,
+    });
+
+    // Call function and verify results
+    let projects = client.list_projects(None, None, None).await.unwrap();
+
+    // Verify response data
+    assert_eq!(projects.paging.page_index, 1);
+    assert_eq!(projects.paging.page_size, 50);
+    assert_eq!(projects.paging.total, 2);
+    assert_eq!(projects.components.len(), 2);
+
+    // Verify project details
+    let first_project = &projects.components[0];
+    assert_eq!(first_project.key, "test-project-1");
+    assert_eq!(first_project.name, "Test Project 1");
+
+    let second_project = &projects.components[1];
+    assert_eq!(second_project.key, "test-project-2");
+    assert_eq!(second_project.name, "Test Project 2");
+}
+
+#[tokio::test]
+async fn test_list_projects_with_organization() {
+    // Start a mock server
+    let mock_server = MockServer::start().await;
+
+    // Setup mock response for projects endpoint with organization using the correct endpoint
+    Mock::given(method("GET"))
+        .and(path("/api/components/search"))
+        .and(query_param("qualifiers", "TRK"))
+        .and(query_param("organization", "my-org"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(
+            r#"{
+                "paging": {
+                    "pageIndex": 1,
+                    "pageSize": 100,
+                    "total": 1
+                },
+                "components": [
+                    {
+                        "key": "my-org-project",
+                        "name": "Organization Project",
+                        "qualifier": "TRK"
+                    }
+                ]
+            }"#,
+        ))
+        .expect(1)
+        .mount(&mock_server)
+        .await;
+
+    // Create client with mock server URL
+    let client = SonarQubeClient::new(SonarQubeConfig {
+        base_url: mock_base_url(&mock_server),
+        token: mock_token(),
+        organization: None, // We'll override this in the method call
+    });
+
+    // Call function with organization override
+    let projects = client
+        .list_projects(None, None, Some("my-org"))
+        .await
+        .unwrap();
+
+    // Verify response data
+    assert_eq!(projects.paging.total, 1);
+    assert_eq!(projects.components.len(), 1);
+
+    // Verify project details
+    let project = &projects.components[0];
+    assert_eq!(project.key, "my-org-project");
+    assert_eq!(project.name, "Organization Project");
+}

tests/prompts_tests.rs

@@ -0,0 +1,42 @@
+mod helpers;
+
+use sonarqube_mcp_server::mcp::prompts::*;
+use sonarqube_mcp_server::mcp::types::*;
+
+#[tokio::test]
+async fn test_prompts_list() {
+    // Call prompts_list function
+    let result = prompts_list(None).await.unwrap();
+
+    // Verify next_cursor is None
+    assert!(result.next_cursor.is_none());
+
+    // The prompts list may be empty in this implementation
+    // If there are prompts, verify they have required fields
+    for prompt in &result.prompts {
+        assert!(!prompt.name.is_empty());
+        // Check optional fields if they exist
+        if let Some(description) = &prompt.description {
+            assert!(!description.is_empty());
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_prompts_get() {
+    // Create a request with a prompt name
+    let request = GetPromptRequest {
+        name: "test-prompt".to_string(),
+        arguments: None,
+    };
+
+    // Call prompts_get function
+    let result = prompts_get(request).await.unwrap();
+
+    // Verify the response content
+    assert!(!result.description.is_empty());
+    assert!(result.description.contains("test-prompt"));
+
+    // For now, messages is None since we don't have defined prompts
+    assert!(result.messages.is_none());
+}

tests/resources_tests.rs

@@ -0,0 +1,48 @@
+mod helpers;
+
+use sonarqube_mcp_server::mcp::resources::*;
+use sonarqube_mcp_server::mcp::types::*;
+use url::Url;
+
+#[tokio::test]
+async fn test_resources_list() {
+    // Call resources_list function
+    let result = resources_list(None).await.unwrap();
+
+    // Verify the response contains resources
+    assert!(
+        !result.resources.is_empty(),
+        "Resources list should not be empty"
+    );
+
+    // Verify next_cursor is None
+    assert!(result.next_cursor.is_none());
+
+    // Verify the resources have required fields
+    for resource in &result.resources {
+        assert!(!resource.name.is_empty());
+        assert!(resource.uri.to_string().len() > 0);
+    }
+}
+
+#[tokio::test]
+async fn test_resource_read() {
+    // Create a request with a URI
+    let request = ReadResourceRequest {
+        uri: Url::parse("resource:logs").unwrap(),
+        meta: None,
+    };
+
+    // Call resource_read function
+    let result = resource_read(request).await.unwrap();
+
+    // Verify the response content
+    assert_eq!(result.content.uri.to_string(), "resource:logs");
+    assert_eq!(result.content.mime_type, Some("text/plain".to_string()));
+    assert!(result.content.text.is_some());
+    assert!(result.content.blob.is_none());
+
+    // Verify the text content
+    let text = result.content.text.unwrap();
+    assert!(!text.is_empty());
+}

tests/tools_tests.rs

@@ -3,6 +3,7 @@ mod helpers;
 use helpers::{load_fixture, mock_base_url, mock_token, test_project_key};
 use sonarqube_mcp_server::mcp::sonarqube::client::SonarQubeClient;
 use sonarqube_mcp_server::mcp::sonarqube::types::*;
+use sonarqube_mcp_server::mcp::tools::tools_list;
 use wiremock::{
     matchers::{method, path, query_param},
     Mock, MockServer, ResponseTemplate,
@@ -192,3 +193,78 @@ async fn test_sonarqube_get_metrics_tool_with_error() {
         _ => panic!("Expected ProjectNotFound error, got: {:?}", result),
     }
 }
+
+#[tokio::test]
+async fn test_tools_list() {
+    // Call tools_list function
+    let result = tools_list(None).await.unwrap();
+
+    // Verify the response contains tools
+    assert!(!result.tools.is_empty(), "Tools list should not be empty");
+
+    // Verify the response contains SonarQube tools
+    let sonarqube_tools = result
+        .tools
+        .iter()
+        .filter(|t| t.name.starts_with("sonarqube"));
+    assert!(
+        sonarqube_tools.count() > 0,
+        "Should contain SonarQube tools"
+    );
+
+    // Verify next_cursor is None
+    assert!(result.next_cursor.is_none());
+}
+
+#[tokio::test]
+#[ignore] // This is a placeholder test that requires setting the global client
+async fn test_sonarqube_list_projects_tool() {
+    // Start a mock server
+    let mock_server = MockServer::start().await;
+
+    // Setup mock response for projects endpoint
+    Mock::given(method("GET"))
+        .and(path("/api/components/search"))
+        .and(query_param("qualifiers", "TRK"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(
+            r#"{
+                "paging": {
+                    "pageIndex": 1,
+                    "pageSize": 100,
+                    "total": 2
+                },
+                "components": [
+                    {
+                        "key": "test-project-1",
+                        "name": "Test Project 1",
+                        "qualifier": "TRK"
+                    },
+                    {
+                        "key": "test-project-2",
+                        "name": "Test Project 2",
+                        "qualifier": "TRK"
+                    }
+                ]
+            }"#,
+        ))
+        .mount(&mock_server)
+        .await;
+
+    // Create client with mock server URL and set the global client for tools
+    let _client = SonarQubeClient::new(SonarQubeConfig {
+        base_url: mock_base_url(&mock_server),
+        token: mock_token(),
+        organization: None,
+    });
+
+    // Since we can't easily set the global client in tests, we'll skip this test for now
+    // This is a placeholder to show how the test would be structured
+
+    // The actual implementation would require setting the global SONARQUBE_CLIENT
+    // and calling the sonarqube_list_projects function with a request
+
+    // Ideally, we would:
+    // 1. Set the global client
+    // 2. Call sonarqube_list_projects
+    // 3. Verify the response contains expected projects
+}

tests/utilities_tests.rs

@@ -0,0 +1,69 @@
+mod helpers;
+
+use sonarqube_mcp_server::mcp::types::*;
+use sonarqube_mcp_server::mcp::utilities::*;
+
+#[tokio::test]
+async fn test_initialize() {
+    // Create a proper initialize request
+    let request = InitializeRequest {
+        protocol_version: "1.0".to_string(),
+        capabilities: ClientCapabilities::default(),
+        client_info: Implementation {
+            name: "test-client".to_string(),
+            version: "1.0.0".to_string(),
+        },
+    };
+
+    // Call initialize function
+    let result = initialize(request).await.unwrap();
+
+    // Verify response fields contain expected values
+    // Note: The actual name may vary depending on the application configuration
+    assert!(!result.server_info.name.is_empty());
+    assert!(!result.protocol_version.is_empty());
+
+    // Check capabilities
+    assert!(result.capabilities.prompts.is_some());
+    assert!(result.capabilities.tools.is_some());
+}
+
+#[tokio::test]
+async fn test_ping() {
+    let request = PingRequest {};
+    let result = ping(request).await.unwrap();
+
+    // Empty result should be returned
+    assert_eq!(
+        serde_json::to_string(&result).unwrap(),
+        serde_json::to_string(&EmptyResult {}).unwrap()
+    );
+}
+
+#[tokio::test]
+async fn test_logging_set_level() {
+    let request = SetLevelRequest {
+        level: "debug".to_string(),
+    };
+
+    let result = logging_set_level(request).await.unwrap();
+
+    // LoggingResponse should be returned
+    assert_eq!(
+        serde_json::to_string(&result).unwrap(),
+        serde_json::to_string(&LoggingResponse {}).unwrap()
+    );
+}
+
+#[tokio::test]
+async fn test_roots_list() {
+    let result = roots_list(None).await.unwrap();
+
+    // Verify the response contains at least one root
+    assert!(!result.roots.is_empty());
+
+    // Verify the first root has a name and URL
+    let first_root = &result.roots[0];
+    assert!(!first_root.name.is_empty());
+    assert!(!first_root.url.is_empty());
+}