Refactor integration tests and migrate to official MCP SDK

This commit refactors the integration test suite and replaces the custom
MCP client implementation with the official MCP Go SDK.

Changes:

1. Table-Driven Tests Refactoring:
   - Consolidated 5 individual test functions into 2 table-driven tests
   - TestIntegration_ToolCalls: 4 successful tool call scenarios
   - TestIntegration_ToolCallErrors: error handling scenarios
   - Reduced code duplication by ~50 lines
   - Added helper functions: setupInitializedClient, callToolAndGetResult

2. Removed TestMain:
   - Eliminated WireMock readiness check from TestMain
   - Removed unused imports (fmt, os)
   - Simplified test setup (13 lines removed)

3. Migrated to Official MCP Go SDK:
   - Replaced custom internal/testutil/mcp.go (202 lines)
   - Created internal/testutil/mcp_client.go (141 lines) using SDK
   - Uses official mcp.Client and mcp.ClientSession
   - Proper type-safe content handling with *mcp.TextContent
   - Better error handling (protocol vs tool errors)

Benefits:
- Total code reduction: 99 lines removed
- Better maintainability with table-driven tests
- Future-proof with official SDK
- Consistent with server-side SDK usage
- All tests pass (3 test functions, 5 subtests total)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: janisz

integration/integration_test.go

@@ -8,75 +8,67 @@ import (
 	"testing"
 	"time"
 
+	"github.com/modelcontextprotocol/go-sdk/mcp"
 	"github.com/stackrox/stackrox-mcp/internal/app"
 	"github.com/stackrox/stackrox-mcp/internal/config"
 	"github.com/stackrox/stackrox-mcp/internal/testutil"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-// Common response structures
-type (
-	// MCPContent represents MCP tool response content
-	MCPContent struct {
-		Type string `json:"type"`
-		Text string `json:"text"`
-	}
-
-	// MCPToolResult represents standard MCP tool call result
-	MCPToolResult struct {
-		Content []MCPContent `json:"content"`
-	}
-
-	// MCPListToolsResult represents tools/list response
-	MCPListToolsResult struct {
-		Tools []map[string]any `json:"tools"`
-	}
-)
+// setupInitializedClient creates an initialized MCP client for testing.
+func setupInitializedClient(t *testing.T) *testutil.MCPTestClient {
+	t.Helper()
 
-// TestIntegration_Initialize verifies the MCP initialize handshake.
-func TestIntegration_Initialize(t *testing.T) {
 	client, err := createMCPClient(t)
 	require.NoError(t, err, "Failed to create MCP client")
-	defer client.Close()
+	t.Cleanup(func() { client.Close() })
+
+	return client
+}
 
-	resp, err := client.Initialize()
+// callToolAndGetResult calls a tool and verifies it succeeds.
+func callToolAndGetResult(t *testing.T, client *testutil.MCPTestClient, toolName string, args map[string]any) *mcp.CallToolResult {
+	t.Helper()
+
+	ctx := context.Background()
+	result, err := client.CallTool(ctx, toolName, args)
 	require.NoError(t, err)
+	testutil.RequireNoError(t, result)
 
-	testutil.RequireNoError(t, resp)
+	return result
+}
 
-	var result map[string]any
-	testutil.UnmarshalResult(t, resp, &result)
+// getTextContent extracts text from the first content item.
+func getTextContent(t *testing.T, result *mcp.CallToolResult) string {
+	t.Helper()
+	require.NotEmpty(t, result.Content, "should have content in response")
+
+	textContent, ok := result.Content[0].(*mcp.TextContent)
+	require.True(t, ok, "expected TextContent, got %T", result.Content[0])
 
-	assert.Contains(t, result, "protocolVersion", "initialize response should include protocolVersion")
-	assert.Contains(t, result, "serverInfo", "initialize response should include serverInfo")
-	assert.Contains(t, result, "capabilities", "initialize response should include capabilities")
+	return textContent.Text
 }
 
 // TestIntegration_ListTools verifies that all expected tools are registered.
 func TestIntegration_ListTools(t *testing.T) {
 	client := setupInitializedClient(t)
 
-	// List tools
-	resp, err := client.ListTools()
+	ctx := context.Background()
+	result, err := client.ListTools(ctx)
 	require.NoError(t, err)
-	testutil.RequireNoError(t, resp)
-
-	var result MCPListToolsResult
-	testutil.UnmarshalResult(t, resp, &result)
 
 	// Verify we have tools registered
 	assert.NotEmpty(t, result.Tools, "should have tools registered")
 
 	// Check for specific tools we expect
 	toolNames := make([]string, 0, len(result.Tools))
 	for _, tool := range result.Tools {
-		if name, ok := tool["name"].(string); ok {
-			toolNames = append(toolNames, name)
-		}
+		toolNames = append(toolNames, tool.Name)
 	}
 
-	assert.Subset(t, toolNames, []string{"list_clusters", "get_deployments_for_cve"})
+	assert.Contains(t, toolNames, "get_deployments_for_cve", "should have get_deployments_for_cve tool")
+	assert.Contains(t, toolNames, "list_clusters", "should have list_clusters tool")
 }
 
 // TestIntegration_ToolCalls tests successful tool calls using table-driven tests.
@@ -113,9 +105,7 @@ func TestIntegration_ToolCalls(t *testing.T) {
 			client := setupInitializedClient(t)
 			result := callToolAndGetResult(t, client, tt.toolName, tt.args)
 
-			require.NotEmpty(t, result.Content, "should have content in response")
-
-			responseText := result.Content[0].Text
+			responseText := getTextContent(t, result)
 			for _, expected := range tt.expectedInText {
 				assert.Contains(t, responseText, expected)
 			}
@@ -141,43 +131,16 @@ func TestIntegration_ToolCallErrors(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			client := setupInitializedClient(t)
 
-			resp, err := client.CallTool(tt.toolName, tt.args)
-			require.NoError(t, err)
+			ctx := context.Background()
+			_, err := client.CallTool(ctx, tt.toolName, tt.args)
 
-			require.NotNil(t, resp.Error, "should receive error")
-			assert.Contains(t, resp.Error.Message, tt.expectedErrorMsg)
+			// Validation errors are returned as protocol errors, not tool errors
+			require.Error(t, err, "should receive protocol error for invalid params")
+			assert.Contains(t, err.Error(), tt.expectedErrorMsg)
 		})
 	}
 }
 
-// setupInitializedClient creates and initializes an MCP client
-func setupInitializedClient(t *testing.T) *testutil.MCPClient {
-	t.Helper()
-
-	client, err := createMCPClient(t)
-	require.NoError(t, err, "Failed to create MCP client")
-	t.Cleanup(func() { client.Close() })
-
-	initResp, err := client.Initialize()
-	require.NoError(t, err)
-	testutil.RequireNoError(t, initResp)
-
-	return client
-}
-
-// callToolAndGetResult is a helper that calls a tool and unmarshals result
-func callToolAndGetResult(t *testing.T, client *testutil.MCPClient, toolName string, args map[string]any) *MCPToolResult {
-	t.Helper()
-
-	resp, err := client.CallTool(toolName, args)
-	require.NoError(t, err)
-	testutil.RequireNoError(t, resp)
-
-	var result MCPToolResult
-	testutil.UnmarshalResult(t, resp, &result)
-	return &result
-}
-
 // createTestConfig creates a test configuration for the MCP server.
 func createTestConfig() *config.Config {
 	return &config.Config{
@@ -206,7 +169,7 @@ func createTestConfig() *config.Config {
 }
 
 // createMCPClient is a helper function that creates an MCP client with the test configuration.
-func createMCPClient(t *testing.T) (*testutil.MCPClient, error) {
+func createMCPClient(t *testing.T) (*testutil.MCPTestClient, error) {
 	t.Helper()
 
 	cfg := createTestConfig()
@@ -216,5 +179,5 @@ func createMCPClient(t *testing.T) (*testutil.MCPClient, error) {
 		return app.Run(ctx, cfg, stdin, stdout)
 	}
 
-	return testutil.NewMCPClient(t, runFunc)
+	return testutil.NewMCPTestClient(t, runFunc)
 }