test(mcp): add comprehensive tests for analytics, server, and http

Improve test coverage from 88.8% to 95.6%:
- Add analytics_test.go with tests for all Analytics methods
- Add server tests for SetTransport, handleStatus, GetStatusTracker, IsReady
- Add HTTP tests for Start blocking, SSE endpoint, invalid addresses
- Add streaming handler tests for write error paths

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <[email protected]>

Author: shivasurya

sast-engine/mcp/analytics_test.go

@@ -0,0 +1,128 @@
+package mcp
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewAnalytics(t *testing.T) {
+	a := NewAnalytics("stdio")
+
+	assert.NotNil(t, a)
+	assert.Equal(t, "stdio", a.transport)
+	assert.False(t, a.startTime.IsZero())
+}
+
+func TestNewAnalytics_HTTP(t *testing.T) {
+	a := NewAnalytics("http")
+
+	assert.Equal(t, "http", a.transport)
+}
+
+func TestAnalytics_ReportServerStarted(t *testing.T) {
+	a := NewAnalytics("stdio")
+
+	// Should not panic even with analytics disabled.
+	a.ReportServerStarted()
+}
+
+func TestAnalytics_ReportServerStopped(t *testing.T) {
+	a := NewAnalytics("http")
+
+	// Should not panic.
+	a.ReportServerStopped()
+}
+
+func TestAnalytics_ReportToolCall(t *testing.T) {
+	a := NewAnalytics("stdio")
+
+	// Should not panic.
+	a.ReportToolCall("find_symbol", 150, true)
+	a.ReportToolCall("get_callers", 50, false)
+}
+
+func TestAnalytics_ReportIndexingStarted(t *testing.T) {
+	a := NewAnalytics("stdio")
+
+	// Should not panic.
+	a.ReportIndexingStarted()
+}
+
+func TestAnalytics_ReportIndexingComplete(t *testing.T) {
+	a := NewAnalytics("http")
+
+	stats := &IndexingStats{
+		Functions:     100,
+		CallEdges:     500,
+		Modules:       20,
+		Files:         50,
+		BuildDuration: 5 * time.Second,
+	}
+
+	// Should not panic.
+	a.ReportIndexingComplete(stats)
+}
+
+func TestAnalytics_ReportIndexingFailed(t *testing.T) {
+	a := NewAnalytics("stdio")
+
+	// Should not panic.
+	a.ReportIndexingFailed("parsing")
+	a.ReportIndexingFailed("call_graph")
+}
+
+func TestAnalytics_ReportClientConnected(t *testing.T) {
+	a := NewAnalytics("http")
+
+	// Should not panic.
+	a.ReportClientConnected("claude-code", "1.0.0")
+	a.ReportClientConnected("", "")
+}
+
+func TestAnalytics_StartToolCall(t *testing.T) {
+	a := NewAnalytics("stdio")
+
+	metrics := a.StartToolCall("find_symbol")
+
+	assert.NotNil(t, metrics)
+	assert.Equal(t, "find_symbol", metrics.ToolName)
+	assert.False(t, metrics.StartTime.IsZero())
+}
+
+func TestAnalytics_EndToolCall(t *testing.T) {
+	a := NewAnalytics("stdio")
+
+	metrics := a.StartToolCall("get_callers")
+	time.Sleep(1 * time.Millisecond) // Small delay to ensure duration > 0
+
+	// Should not panic.
+	a.EndToolCall(metrics, true)
+}
+
+func TestAnalytics_EndToolCall_Nil(t *testing.T) {
+	a := NewAnalytics("stdio")
+
+	// Should not panic with nil metrics.
+	a.EndToolCall(nil, true)
+}
+
+func TestAnalytics_EndToolCall_Failed(t *testing.T) {
+	a := NewAnalytics("http")
+
+	metrics := a.StartToolCall("resolve_import")
+
+	// Should not panic.
+	a.EndToolCall(metrics, false)
+}
+
+func TestToolCallMetrics(t *testing.T) {
+	metrics := &ToolCallMetrics{
+		StartTime: time.Now(),
+		ToolName:  "test_tool",
+	}
+
+	assert.Equal(t, "test_tool", metrics.ToolName)
+	assert.False(t, metrics.StartTime.IsZero())
+}

sast-engine/mcp/http_test.go

@@ -465,3 +465,192 @@ func TestHTTPServer_NoOriginHeader(t *testing.T) {
 	// Should use "*" as fallback.
 	assert.Equal(t, "*", rec.Header().Get("Access-Control-Allow-Origin"))
 }
+
+func TestHTTPServer_Start_AlreadyRunning(t *testing.T) {
+	mcpServer := createTestServer()
+	config := &HTTPConfig{Address: "127.0.0.1:0"}
+	httpServer := NewHTTPServer(mcpServer, config)
+
+	// Start async first.
+	err := httpServer.StartAsync()
+	require.NoError(t, err)
+	defer func() {
+		ctx := context.Background()
+		_ = httpServer.Shutdown(ctx)
+	}()
+
+	// Try to start synchronously - should fail.
+	err = httpServer.Start()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "already running")
+}
+
+func TestHTTPServer_Start_Blocking(t *testing.T) {
+	mcpServer := createTestServer()
+	config := &HTTPConfig{Address: "127.0.0.1:0"}
+	httpServer := NewHTTPServer(mcpServer, config)
+
+	// Start in goroutine since it blocks.
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- httpServer.Start()
+	}()
+
+	// Give server time to start.
+	time.Sleep(50 * time.Millisecond)
+
+	// Verify it's running.
+	assert.True(t, httpServer.IsRunning())
+
+	// Shutdown.
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	err := httpServer.Shutdown(ctx)
+	require.NoError(t, err)
+
+	// Wait for Start() to return.
+	select {
+	case err := <-errCh:
+		// Server closed error is expected.
+		assert.Contains(t, err.Error(), "Server closed")
+	case <-time.After(5 * time.Second):
+		t.Fatal("timeout waiting for Start to return")
+	}
+}
+
+func TestSSEServer_ServeSSE(t *testing.T) {
+	mcpServer := createTestServer()
+	httpServer := NewHTTPServer(mcpServer, nil)
+	sseServer := NewSSEServer(httpServer)
+
+	// Create a request with a cancellable context.
+	ctx, cancel := context.WithCancel(context.Background())
+	req := httptest.NewRequest(http.MethodGet, "/sse", nil).WithContext(ctx)
+	req.Header.Set("Origin", "http://example.com")
+
+	rec := httptest.NewRecorder()
+
+	// Run ServeSSE in a goroutine since it blocks.
+	done := make(chan struct{})
+	go func() {
+		sseServer.ServeSSE(rec, req)
+		close(done)
+	}()
+
+	// Give it time to set headers and send connected event.
+	time.Sleep(50 * time.Millisecond)
+
+	// Cancel context to close connection.
+	cancel()
+
+	// Wait for ServeSSE to return.
+	select {
+	case <-done:
+		// Good, it returned.
+	case <-time.After(5 * time.Second):
+		t.Fatal("timeout waiting for ServeSSE to return")
+	}
+
+	// Verify SSE headers.
+	assert.Equal(t, "text/event-stream", rec.Header().Get("Content-Type"))
+	assert.Equal(t, "no-cache", rec.Header().Get("Cache-Control"))
+	assert.Equal(t, "keep-alive", rec.Header().Get("Connection"))
+
+	// Verify connected event was sent.
+	assert.Contains(t, rec.Body.String(), "event: connected")
+	assert.Contains(t, rec.Body.String(), "status")
+}
+
+// mockResponseWriter doesn't implement http.Flusher.
+type noFlushResponseWriter struct {
+	http.ResponseWriter
+}
+
+func TestSSEServer_ServeSSE_NoFlusher(t *testing.T) {
+	mcpServer := createTestServer()
+	httpServer := NewHTTPServer(mcpServer, nil)
+	sseServer := NewSSEServer(httpServer)
+
+	req := httptest.NewRequest(http.MethodGet, "/sse", nil)
+
+	// Use a writer that doesn't implement Flusher.
+	rec := httptest.NewRecorder()
+	noFlush := &noFlushResponseWriter{rec}
+
+	sseServer.ServeSSE(noFlush, req)
+
+	// Should return error response.
+	assert.Equal(t, http.StatusInternalServerError, rec.Code)
+	assert.Contains(t, rec.Body.String(), "SSE not supported")
+}
+
+func TestHTTPServer_Shutdown_WithContext(t *testing.T) {
+	mcpServer := createTestServer()
+	config := &HTTPConfig{Address: "127.0.0.1:0"}
+	httpServer := NewHTTPServer(mcpServer, config)
+
+	err := httpServer.StartAsync()
+	require.NoError(t, err)
+
+	// Shutdown with cancelled context should still work.
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+
+	err = httpServer.Shutdown(ctx)
+	assert.NoError(t, err)
+	assert.False(t, httpServer.IsRunning())
+}
+
+func TestHTTPServer_Start_InvalidAddress(t *testing.T) {
+	mcpServer := createTestServer()
+	// Use an invalid address that should fail to listen.
+	config := &HTTPConfig{Address: "invalid:address:format:99999"}
+	httpServer := NewHTTPServer(mcpServer, config)
+
+	err := httpServer.Start()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to listen")
+	assert.False(t, httpServer.IsRunning())
+}
+
+func TestHTTPServer_StartAsync_InvalidAddress(t *testing.T) {
+	mcpServer := createTestServer()
+	// Use an invalid address that should fail to listen.
+	config := &HTTPConfig{Address: "invalid:address:format:99999"}
+	httpServer := NewHTTPServer(mcpServer, config)
+
+	err := httpServer.StartAsync()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to listen")
+	assert.False(t, httpServer.IsRunning())
+}
+
+// errorWriter always returns an error.
+type errorWriter struct{}
+
+func (e *errorWriter) Write(p []byte) (n int, err error) {
+	return 0, io.ErrClosedPipe
+}
+
+func TestStreamingHTTPHandler_HandleStream_WriteError(t *testing.T) {
+	mcpServer := createTestServer()
+	handler := NewStreamingHTTPHandler(mcpServer)
+
+	input := `{"jsonrpc":"2.0","id":1,"method":"ping"}` + "\n"
+	reader := strings.NewReader(input)
+
+	err := handler.HandleStream(reader, &errorWriter{})
+	assert.Error(t, err)
+}
+
+func TestStreamingHTTPHandler_HandleStream_WriteErrorOnParseError(t *testing.T) {
+	mcpServer := createTestServer()
+	handler := NewStreamingHTTPHandler(mcpServer)
+
+	// Invalid JSON to trigger parse error, which then tries to write.
+	input := "not valid json\n"
+	reader := strings.NewReader(input)
+
+	err := handler.HandleStream(reader, &errorWriter{})
+	assert.Error(t, err)
+}