Add unit tests for internal/testutil and internal/toolsets/mock (#17)

Signed-off-by: Tomasz Janiszewski <tomek@redhat.com>
Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Co-authored-by: Mladen Todorovic <mtodor@gmail.com>

Author: 3 people

Makefile

@@ -56,7 +56,7 @@ test: ## Run unit tests
 .PHONY: test-coverage-and-junit
 test-coverage-and-junit: ## Run unit tests with coverage and junit output
 	go install github.com/jstemmer/go-junit-report/v2@v2.1.0
-	$(GOTEST) -v -cover -race -coverprofile=$(COVERAGE_OUT) ./... -json 2>&1 | go-junit-report -parser gojson > $(JUNIT_OUT)
+	$(GOTEST) -v -cover -race -coverprofile=$(COVERAGE_OUT) ./... 2>&1 | go-junit-report -set-exit-code -iocopy -out $(JUNIT_OUT)
 
 .PHONY: coverage-html
 coverage-html: test ## Generate and open HTML coverage report

internal/testutil/config_test.go

@@ -0,0 +1,26 @@
+package testutil
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWriteYAMLFile(t *testing.T) {
+	content := "key: value\nfoo: bar"
+
+	filePath := WriteYAMLFile(t, content)
+
+	fileName := filepath.Base(filePath)
+	assert.Contains(t, fileName, t.Name(), "File name should contain test name")
+
+	//nolint:gosec // Test code reading from known test file
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		t.Fatalf("Failed to read created file: %v", err)
+	}
+
+	assert.Equal(t, content, string(data))
+}

internal/testutil/ports_test.go

@@ -0,0 +1,41 @@
+package testutil
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetPortForTest_ReturnsPortInValidRange(t *testing.T) {
+	port := GetPortForTest(t)
+
+	assert.GreaterOrEqual(t, port, minPort)
+	assert.Less(t, port, maxPort)
+}
+
+func TestGetPortForTest_ReturnsDeterministicPort(t *testing.T) {
+	port1 := GetPortForTest(t)
+	port2 := GetPortForTest(t)
+
+	assert.Equal(t, port1, port2)
+}
+
+func TestGetPortForTest_DifferentTestNamesGetDifferentPorts(t *testing.T) {
+	ports := make(map[int]bool)
+
+	// Create subtests with different names
+	for range 10 {
+		t.Run("subtest", func(t *testing.T) {
+			port := GetPortForTest(t)
+			ports[port] = true
+		})
+	}
+
+	assert.Len(t, ports, 10)
+}
+
+func TestPortRangeConstants(t *testing.T) {
+	assert.Greater(t, minPort, 1024)
+	assert.LessOrEqual(t, maxPort, 65536)
+	assert.Equal(t, maxPort-minPort, 50000)
+}

internal/testutil/server_test.go

@@ -0,0 +1,149 @@
+package testutil
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestWaitForServerReady_Immediate(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	err := WaitForServerReady(server.URL, 1*time.Second)
+	assert.NoError(t, err)
+}
+
+func TestWaitForServerReady_AfterDelay(t *testing.T) {
+	var ready atomic.Bool
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		if ready.Load() {
+			w.WriteHeader(http.StatusOK)
+		} else {
+			w.WriteHeader(http.StatusServiceUnavailable)
+		}
+	}))
+	defer server.Close()
+
+	// Make server ready after a short delay
+	go func() {
+		time.Sleep(200 * time.Millisecond)
+		ready.Store(true)
+	}()
+
+	err := WaitForServerReady(server.URL, 2*time.Second)
+	assert.NoError(t, err)
+}
+
+func TestWaitForServerReady_NeverReady(t *testing.T) {
+	// Use an address that won't have a server
+	err := WaitForServerReady("http://localhost:59999", 300*time.Millisecond)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "did not become ready")
+}
+
+func TestWaitForServerReady_RespectsTimeout(t *testing.T) {
+	start := time.Now()
+	timeout := 300 * time.Millisecond
+
+	err := WaitForServerReady("http://localhost:59998", timeout)
+
+	elapsed := time.Since(start)
+
+	require.Error(t, err)
+
+	// Allow some margin for timing (timeout + 200ms for final attempt)
+	maxExpected := timeout + 300*time.Millisecond
+	assert.LessOrEqual(t, elapsed, maxExpected)
+	assert.GreaterOrEqual(t, elapsed, timeout)
+}
+
+func TestWaitForServerReady_ErrorMessage(t *testing.T) {
+	timeout := 250 * time.Millisecond
+
+	err := WaitForServerReady("http://localhost:59997", timeout)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "250ms")
+}
+
+func TestWaitForServerReady_StatusCodes(t *testing.T) {
+	tests := []struct {
+		name       string
+		statusCode int
+	}{
+		{"200 OK", http.StatusOK},
+		{"201 Created", http.StatusCreated},
+		{"404 Not Found", http.StatusNotFound},
+		{"500 Internal Server Error", http.StatusInternalServerError},
+	}
+
+	for _, testCase := range tests {
+		t.Run(testCase.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(testCase.statusCode)
+			}))
+			defer server.Close()
+
+			err := WaitForServerReady(server.URL, 1*time.Second)
+			assert.NoError(t, err)
+		})
+	}
+}
+
+func TestWaitForServerReady_InvalidURL(t *testing.T) {
+	err := WaitForServerReady("http://invalid-host-that-does-not-exist.local:12345", 200*time.Millisecond)
+	assert.Error(t, err)
+}
+
+func TestWaitForServerReadyIntegration(t *testing.T) {
+	t.Run("simulates real server startup scenario", func(t *testing.T) {
+		var server *httptest.Server
+
+		serverReady := make(chan struct{})
+
+		// Simulate server starting up in background
+		go func() {
+			time.Sleep(150 * time.Millisecond)
+
+			server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			}))
+
+			close(serverReady)
+		}()
+
+		// Wait for server to be created
+		<-serverReady
+
+		defer server.Close()
+
+		err := WaitForServerReady(server.URL, 2*time.Second)
+		assert.NoError(t, err)
+	})
+}
+
+func ExampleWaitForServerReady() {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	err := WaitForServerReady(server.URL, 5*time.Second)
+	if err != nil {
+		fmt.Printf("Server not ready: %v\n", err)
+
+		return
+	}
+
+	fmt.Println("Server is ready!")
+	// Output: Server is ready!
+}

internal/toolsets/mock/tool_test.go

@@ -0,0 +1,142 @@
+package mock
+
+import (
+	"testing"
+
+	"github.com/stackrox/stackrox-mcp/internal/toolsets"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewTool(t *testing.T) {
+	t.Run("creates tool with provided values", func(t *testing.T) {
+		name := "test-tool"
+		readOnly := true
+
+		tool := NewTool(name, readOnly)
+
+		assert.Equal(t, name, tool.NameValue)
+		assert.Equal(t, readOnly, tool.ReadOnlyValue)
+		assert.False(t, tool.RegisterCalled)
+	})
+}
+
+func TestTool_IsReadOnly(t *testing.T) {
+	t.Run("returns true when read-only", func(t *testing.T) {
+		tool := NewTool("readonly", true)
+
+		assert.True(t, tool.IsReadOnly())
+	})
+
+	t.Run("returns false when writable", func(t *testing.T) {
+		tool := NewTool("writable", false)
+
+		assert.False(t, tool.IsReadOnly())
+	})
+}
+
+func TestTool_GetTool(t *testing.T) {
+	t.Run("returns MCP tool definition", func(t *testing.T) {
+		name := "test-tool"
+		tool := NewTool(name, true)
+
+		mcpTool := tool.GetTool()
+
+		require.NotNil(t, mcpTool)
+		assert.Equal(t, name, mcpTool.Name)
+		assert.NotEmpty(t, mcpTool.Description)
+
+		expectedDesc := "Mock tool for testing"
+		assert.Equal(t, expectedDesc, mcpTool.Description)
+	})
+
+	t.Run("returns new tool instance each time", func(t *testing.T) {
+		tool := NewTool("test", true)
+
+		mcpTool1 := tool.GetTool()
+		mcpTool2 := tool.GetTool()
+
+		// Should be different instances
+		assert.NotSame(t, mcpTool1, mcpTool2)
+
+		// But with same values
+		assert.Equal(t, mcpTool1.Name, mcpTool2.Name)
+	})
+}
+
+func TestTool_RegisterWith(t *testing.T) {
+	t.Run("sets RegisterCalled flag", func(t *testing.T) {
+		tool := NewTool("register-test", true)
+
+		assert.False(t, tool.RegisterCalled)
+
+		tool.RegisterWith(nil)
+
+		assert.True(t, tool.RegisterCalled)
+
+		// Can be called multiple times
+		tool.RegisterWith(nil)
+
+		assert.True(t, tool.RegisterCalled)
+	})
+}
+
+func TestTool_InterfaceCompliance(t *testing.T) {
+	t.Run("implements toolsets.Tool interface", func(*testing.T) {
+		var _ toolsets.Tool = (*Tool)(nil)
+	})
+}
+
+func TestTool_AsInterface(t *testing.T) {
+	var toolInstance toolsets.Tool = NewTool("interface-test", true)
+
+	assert.Equal(t, "interface-test", toolInstance.GetName())
+	assert.True(t, toolInstance.IsReadOnly())
+
+	mcpTool := toolInstance.GetTool()
+	assert.NotNil(t, mcpTool)
+
+	toolInstance.RegisterWith(nil)
+}
+
+func TestTool_ReadOnlyWorkflow(t *testing.T) {
+	tool := NewTool("read-tool", true)
+
+	assert.True(t, tool.IsReadOnly())
+	assert.False(t, tool.RegisterCalled)
+
+	mcpTool := tool.GetTool()
+	assert.Equal(t, "read-tool", mcpTool.Name)
+
+	tool.RegisterWith(nil)
+
+	assert.True(t, tool.RegisterCalled)
+}
+
+func TestTool_WritableWorkflow(t *testing.T) {
+	tool := NewTool("write-tool", false)
+
+	assert.False(t, tool.IsReadOnly())
+
+	_ = tool.GetTool()
+	tool.RegisterWith(nil)
+
+	assert.True(t, tool.RegisterCalled)
+}
+
+func TestTool_InToolset(t *testing.T) {
+	tool1 := NewTool("tool1", true)
+	tool2 := NewTool("tool2", false)
+
+	tools := []toolsets.Tool{tool1, tool2}
+
+	for _, toolInstance := range tools {
+		assert.NotEmpty(t, toolInstance.GetName())
+
+		_ = toolInstance.GetTool()
+		toolInstance.RegisterWith(nil)
+	}
+
+	assert.True(t, tool1.RegisterCalled)
+	assert.True(t, tool2.RegisterCalled)
+}