🌱 [scanner] test: add unit tests for MCP and Stellar handler packages (#18186)

- Add handler_test.go: WaitWithDeadline deadline behavior, clusterErrorTracker
- Add helpers_test.go: withDemoFallback, respondClusterResources, demo mode detection
- Add query_test.go: query parameter parsing (cluster, namespace)
- Add setup_test.go: test environment helpers for MCP package
- Add solver_test.go: solver constants, safe auto actions, solveFullStore interface
- Add solver_workers_test.go: worker loop constants, context cancellation, digest configuration

All new tests pass. Covers input validation, demo mode responses, and error handling paths as requested.

Signed-off-by: GitHub Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: GitHub Copilot <223556219+Copilot@users.noreply.github.com>

Author: kubestellar-hive[bot]

pkg/api/handlers/mcp/handler_test.go

@@ -0,0 +1,139 @@
+package mcp
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestWaitWithDeadline(t *testing.T) {
+	tests := []struct {
+		name         string
+		goroutines   int
+		workDuration time.Duration
+		deadline     time.Duration
+		wantTimeout  bool
+	}{
+		{
+			name:         "all goroutines complete before deadline",
+			goroutines:   3,
+			workDuration: 10 * time.Millisecond,
+			deadline:     100 * time.Millisecond,
+			wantTimeout:  false,
+		},
+		{
+			name:         "deadline reached with goroutines still running",
+			goroutines:   3,
+			workDuration: 200 * time.Millisecond,
+			deadline:     50 * time.Millisecond,
+			wantTimeout:  true,
+		},
+		{
+			name:         "zero goroutines completes immediately",
+			goroutines:   0,
+			workDuration: 0,
+			deadline:     50 * time.Millisecond,
+			wantTimeout:  false,
+		},
+		{
+			name:         "deadline exactly at completion time",
+			goroutines:   2,
+			workDuration: 30 * time.Millisecond,
+			deadline:     100 * time.Millisecond,
+			wantTimeout:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var wg sync.WaitGroup
+			ctx, cancel := context.WithCancel(context.Background())
+
+			// Spawn goroutines that respect context cancellation
+			for i := 0; i < tt.goroutines; i++ {
+				wg.Add(1)
+				go func() {
+					defer wg.Done()
+					select {
+					case <-time.After(tt.workDuration):
+						// Normal completion
+					case <-ctx.Done():
+						// Cancelled by deadline
+					}
+				}()
+			}
+
+			timedOut := WaitWithDeadline(&wg, cancel, tt.deadline)
+			cancel() // Clean up
+
+			assert.Equal(t, tt.wantTimeout, timedOut, "WaitWithDeadline timeout mismatch")
+
+			// Verify cancel was called when deadline hit
+			if tt.wantTimeout {
+				select {
+				case <-ctx.Done():
+					// Expected: context was cancelled
+				case <-time.After(10 * time.Millisecond):
+					t.Error("context should have been cancelled when deadline hit")
+				}
+			}
+		})
+	}
+}
+
+func TestClusterErrorTracker(t *testing.T) {
+	t.Run("add single error", func(t *testing.T) {
+		tracker := &clusterErrorTracker{}
+		tracker.add("cluster-1", assert.AnError)
+
+		require.Len(t, tracker.errors, 1)
+		assert.Equal(t, "cluster-1", tracker.errors[0].Cluster)
+		assert.NotEmpty(t, tracker.errors[0].Message)
+	})
+
+	t.Run("add multiple errors concurrently", func(t *testing.T) {
+		tracker := &clusterErrorTracker{}
+		var wg sync.WaitGroup
+
+		// Add errors from multiple goroutines
+		for i := 0; i < 10; i++ {
+			wg.Add(1)
+			go func(idx int) {
+				defer wg.Done()
+				tracker.add("cluster-"+string(rune('0'+idx)), assert.AnError)
+			}(i)
+		}
+
+		wg.Wait()
+		assert.Len(t, tracker.errors, 10)
+	})
+
+	t.Run("annotate adds cluster errors to response", func(t *testing.T) {
+		tracker := &clusterErrorTracker{}
+		tracker.add("cluster-1", assert.AnError)
+		tracker.add("cluster-2", assert.AnError)
+
+		resp := map[string]interface{}{"items": []string{}}
+		annotated := tracker.annotate(resp)
+
+		require.Contains(t, annotated, "clusterErrors")
+		// clusterErrors is []handlers.ClusterError, not []interface{}
+		assert.Len(t, annotated["clusterErrors"], 2)
+	})
+
+	t.Run("nil tracker does not panic", func(t *testing.T) {
+		var tracker *clusterErrorTracker
+		resp := map[string]interface{}{"items": []string{}}
+
+		// Should not panic
+		assert.NotPanics(t, func() {
+			if tracker != nil {
+				tracker.annotate(resp)
+			}
+		})
+	})
+}

pkg/api/handlers/mcp/helpers_test.go

@@ -0,0 +1,138 @@
+package mcp
+
+import (
+	"encoding/json"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/kubestellar/console/pkg/k8s"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestWithDemoFallback(t *testing.T) {
+	t.Run("returns demo data in demo mode", func(t *testing.T) {
+		app := fiber.New()
+		handler := &MCPHandlers{k8sClient: nil}
+
+		demoData := map[string]string{"status": "demo"}
+
+		app.Get("/test", func(c *fiber.Ctx) error {
+			c.Locals("demoMode", true)
+			return handler.withDemoFallback(c, "test-data", demoData, func(client *k8s.MultiClusterClient) error {
+				return c.JSON(map[string]string{"status": "real"})
+			})
+		})
+
+		req := httptest.NewRequest("GET", "/test", nil)
+		resp, err := app.Test(req, -1)
+		require.NoError(t, err)
+		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		err = json.NewDecoder(resp.Body).Decode(&result)
+		require.NoError(t, err)
+		assert.Equal(t, "demo", result["status"])
+	})
+
+	t.Run("returns error when k8s client is nil in non-demo mode", func(t *testing.T) {
+		app := fiber.New()
+		handler := &MCPHandlers{k8sClient: nil}
+
+		app.Get("/test", func(c *fiber.Ctx) error {
+			c.Locals("demoMode", false)
+			return handler.withDemoFallback(c, "test-data", map[string]string{}, func(client *k8s.MultiClusterClient) error {
+				return c.JSON(map[string]string{"status": "real"})
+			})
+		})
+
+		req := httptest.NewRequest("GET", "/test", nil)
+		resp, err := app.Test(req, -1)
+		require.NoError(t, err)
+		assert.Equal(t, fiber.StatusServiceUnavailable, resp.StatusCode)
+	})
+
+	t.Run("executes handler when k8s client is available", func(t *testing.T) {
+		app := fiber.New()
+		// Create a mock k8s client (nil is fine for this test since we just check it's passed)
+		handler := &MCPHandlers{k8sClient: &k8s.MultiClusterClient{}}
+
+		app.Get("/test", func(c *fiber.Ctx) error {
+			c.Locals("demoMode", false)
+			return handler.withDemoFallback(c, "test-data", map[string]string{}, func(client *k8s.MultiClusterClient) error {
+				assert.NotNil(t, client)
+				return c.JSON(map[string]string{"status": "real"})
+			})
+		})
+
+		req := httptest.NewRequest("GET", "/test", nil)
+		resp, err := app.Test(req, -1)
+		require.NoError(t, err)
+		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		err = json.NewDecoder(resp.Body).Decode(&result)
+		require.NoError(t, err)
+		assert.Equal(t, "real", result["status"])
+	})
+}
+
+func TestRespondClusterResources(t *testing.T) {
+	t.Run("responds with items and source", func(t *testing.T) {
+		app := fiber.New()
+		app.Get("/test", func(c *fiber.Ctx) error {
+			items := []string{"item1", "item2", "item3"}
+			return respondClusterResources(c, "pods", items, nil)
+		})
+
+		req := httptest.NewRequest("GET", "/test", nil)
+		resp, err := app.Test(req, -1)
+		require.NoError(t, err)
+		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		err = json.NewDecoder(resp.Body).Decode(&result)
+		require.NoError(t, err)
+		assert.Equal(t, "k8s", result["source"])
+		assert.Contains(t, result, "pods")
+	})
+
+	t.Run("includes cluster errors when tracker provided", func(t *testing.T) {
+		app := fiber.New()
+		app.Get("/test", func(c *fiber.Ctx) error {
+			items := []string{"item1"}
+			tracker := &clusterErrorTracker{}
+			tracker.add("cluster-1", assert.AnError)
+			return respondClusterResources(c, "pods", items, tracker)
+		})
+
+		req := httptest.NewRequest("GET", "/test", nil)
+		resp, err := app.Test(req, -1)
+		require.NoError(t, err)
+		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		err = json.NewDecoder(resp.Body).Decode(&result)
+		require.NoError(t, err)
+		assert.Contains(t, result, "clusterErrors")
+	})
+
+	t.Run("handles empty items", func(t *testing.T) {
+		app := fiber.New()
+		app.Get("/test", func(c *fiber.Ctx) error {
+			items := []string{}
+			return respondClusterResources(c, "pods", items, nil)
+		})
+
+		req := httptest.NewRequest("GET", "/test", nil)
+		resp, err := app.Test(req, -1)
+		require.NoError(t, err)
+
+		var result map[string]interface{}
+		err = json.NewDecoder(resp.Body).Decode(&result)
+		require.NoError(t, err)
+		pods := result["pods"].([]interface{})
+		assert.Len(t, pods, 0)
+	})
+}