add more unit tests to cover parsing and serialization of prompts

Signed-off-by: Nader Ziada <[email protected]>

Author: nader-ziada

pkg/api/prompt_parsing_test.go

@@ -0,0 +1,272 @@
+package api
+
+import (
+	"testing"
+
+	"github.com/containers/kubernetes-mcp-server/pkg/config"
+	"github.com/stretchr/testify/suite"
+)
+
+// PromptParsingTestSuite tests TOML parsing of prompts through the config system
+type PromptParsingTestSuite struct {
+	suite.Suite
+}
+
+func (s *PromptParsingTestSuite) TestParseSinglePrompt() {
+	s.Run("parses single prompt with all fields", func() {
+		configData := `
+[[prompts]]
+name = "test-prompt"
+title = "Test Prompt"
+description = "A test prompt for validation"
+
+[[prompts.arguments]]
+name = "pod_name"
+description = "Name of the pod"
+required = true
+
+[[prompts.arguments]]
+name = "namespace"
+description = "Namespace of the pod"
+required = false
+
+[[prompts.messages]]
+role = "user"
+content = "Describe pod {{pod_name}} in namespace {{namespace}}"
+
+[[prompts.messages]]
+role = "assistant"
+content = "I'll help you with pod {{pod_name}}"
+`
+
+		cfg, err := config.ReadToml([]byte(configData))
+		s.Require().NoError(err, "failed to parse config")
+
+		parsedPrompts := cfg.GetParsedPrompts()
+		s.Require().NotNil(parsedPrompts, "parsed prompts should not be nil")
+
+		prompts, ok := parsedPrompts.([]Prompt)
+		s.Require().True(ok, "parsed prompts should be []Prompt")
+		s.Require().Len(prompts, 1, "should have exactly one prompt")
+
+		prompt := prompts[0]
+		s.Equal("test-prompt", prompt.Name)
+		s.Equal("Test Prompt", prompt.Title)
+		s.Equal("A test prompt for validation", prompt.Description)
+
+		// Verify arguments
+		s.Require().Len(prompt.Arguments, 2)
+		s.Equal("pod_name", prompt.Arguments[0].Name)
+		s.True(prompt.Arguments[0].Required)
+		s.Equal("namespace", prompt.Arguments[1].Name)
+		s.False(prompt.Arguments[1].Required)
+
+		// Verify templates
+		s.Require().Len(prompt.Templates, 2)
+		s.Equal("user", prompt.Templates[0].Role)
+		s.Contains(prompt.Templates[0].Content, "{{pod_name}}")
+		s.Equal("assistant", prompt.Templates[1].Role)
+	})
+
+	s.Run("parses prompt with minimal fields", func() {
+		configData := `
+[[prompts]]
+name = "minimal-prompt"
+description = "Minimal prompt"
+
+[[prompts.messages]]
+role = "user"
+content = "Hello"
+`
+
+		cfg, err := config.ReadToml([]byte(configData))
+		s.Require().NoError(err)
+
+		parsedPrompts := cfg.GetParsedPrompts()
+		prompts, ok := parsedPrompts.([]Prompt)
+		s.Require().True(ok)
+		s.Require().Len(prompts, 1)
+
+		prompt := prompts[0]
+		s.Equal("minimal-prompt", prompt.Name)
+		s.Empty(prompt.Title, "title should be empty")
+		s.Empty(prompt.Arguments, "arguments should be empty")
+		s.Require().Len(prompt.Templates, 1)
+	})
+}
+
+func (s *PromptParsingTestSuite) TestParseMultiplePrompts() {
+	s.Run("parses multiple prompts correctly", func() {
+		configData := `
+[[prompts]]
+name = "prompt-1"
+description = "First prompt"
+
+[[prompts.messages]]
+role = "user"
+content = "Message 1"
+
+[[prompts]]
+name = "prompt-2"
+description = "Second prompt"
+
+[[prompts.arguments]]
+name = "arg1"
+required = true
+
+[[prompts.messages]]
+role = "user"
+content = "Message 2 with {{arg1}}"
+
+[[prompts]]
+name = "prompt-3"
+description = "Third prompt"
+
+[[prompts.messages]]
+role = "assistant"
+content = "Message 3"
+`
+
+		cfg, err := config.ReadToml([]byte(configData))
+		s.Require().NoError(err)
+
+		parsedPrompts := cfg.GetParsedPrompts()
+		prompts, ok := parsedPrompts.([]Prompt)
+		s.Require().True(ok)
+		s.Require().Len(prompts, 3, "should parse all three prompts")
+
+		s.Equal("prompt-1", prompts[0].Name)
+		s.Equal("prompt-2", prompts[1].Name)
+		s.Equal("prompt-3", prompts[2].Name)
+
+		// Verify second prompt has arguments
+		s.Require().Len(prompts[1].Arguments, 1)
+		s.Equal("arg1", prompts[1].Arguments[0].Name)
+		s.True(prompts[1].Arguments[0].Required)
+	})
+}
+
+func (s *PromptParsingTestSuite) TestParsePromptsWithRequiredAndOptionalArgs() {
+	s.Run("correctly parses required vs optional arguments", func() {
+		configData := `
+[[prompts]]
+name = "mixed-args-prompt"
+description = "Prompt with mixed argument requirements"
+
+[[prompts.arguments]]
+name = "required_arg1"
+description = "Required argument 1"
+required = true
+
+[[prompts.arguments]]
+name = "required_arg2"
+description = "Required argument 2"
+required = true
+
+[[prompts.arguments]]
+name = "optional_arg1"
+description = "Optional argument 1"
+required = false
+
+[[prompts.arguments]]
+name = "optional_arg2"
+description = "Optional argument 2"
+required = false
+
+[[prompts.messages]]
+role = "user"
+content = "Test {{required_arg1}} {{optional_arg1}}"
+`
+
+		cfg, err := config.ReadToml([]byte(configData))
+		s.Require().NoError(err)
+
+		parsedPrompts := cfg.GetParsedPrompts()
+		prompts, ok := parsedPrompts.([]Prompt)
+		s.Require().True(ok)
+		s.Require().Len(prompts, 1)
+
+		prompt := prompts[0]
+		s.Require().Len(prompt.Arguments, 4)
+
+		// Count required vs optional
+		requiredCount := 0
+		optionalCount := 0
+		for _, arg := range prompt.Arguments {
+			if arg.Required {
+				requiredCount++
+			} else {
+				optionalCount++
+			}
+		}
+
+		s.Equal(2, requiredCount, "should have 2 required arguments")
+		s.Equal(2, optionalCount, "should have 2 optional arguments")
+	})
+}
+
+func (s *PromptParsingTestSuite) TestParseNoPrompts() {
+	s.Run("handles config without prompts", func() {
+		configData := `
+log_level = 2
+`
+
+		cfg, err := config.ReadToml([]byte(configData))
+		s.Require().NoError(err)
+
+		parsedPrompts := cfg.GetParsedPrompts()
+		s.Nil(parsedPrompts, "should return nil when no prompts defined")
+	})
+}
+
+func (s *PromptParsingTestSuite) TestParseInvalidPromptTOML() {
+	s.Run("returns error for invalid TOML", func() {
+		configData := `
+[[prompts]]
+name = "invalid
+description = "Missing quote
+`
+
+		_, err := config.ReadToml([]byte(configData))
+		s.Error(err, "should return error for invalid TOML")
+	})
+}
+
+func (s *PromptParsingTestSuite) TestPromptLoaderIntegration() {
+	s.Run("PromptLoader correctly loads from parsed config", func() {
+		configData := `
+[[prompts]]
+name = "loader-test"
+description = "Test prompt loader"
+
+[[prompts.arguments]]
+name = "arg1"
+required = true
+
+[[prompts.messages]]
+role = "user"
+content = "Hello {{arg1}}"
+`
+
+		cfg, err := config.ReadToml([]byte(configData))
+		s.Require().NoError(err)
+
+		loader := NewPromptLoader()
+		err = loader.LoadFromParsedConfig(cfg.GetParsedPrompts())
+		s.Require().NoError(err)
+
+		serverPrompts := loader.GetServerPrompts()
+		s.Require().Len(serverPrompts, 1)
+
+		serverPrompt := serverPrompts[0]
+		s.Equal("loader-test", serverPrompt.Prompt.Name)
+		s.Equal("Test prompt loader", serverPrompt.Prompt.Description)
+		s.Require().Len(serverPrompt.Prompt.Arguments, 1)
+		s.Equal("arg1", serverPrompt.Prompt.Arguments[0].Name)
+		s.NotNil(serverPrompt.Handler, "handler should be created")
+	})
+}
+
+func TestPromptParsing(t *testing.T) {
+	suite.Run(t, new(PromptParsingTestSuite))
+}