Add tests for dynamic toolset management tools

Tests cover:
- list_available_toolsets: verifies toolsets are listed with enabled status
- get_toolset_tools: verifies tools can be retrieved for a toolset
- enable_toolset: verifies toolset can be enabled and marked as enabled
- enable_toolset invalid: verifies proper error for non-existent toolset
- toolsets enum: verifies tools have proper enum values in schema

Author: SamMorrowDrums

pkg/github/dynamic_tools_test.go

@@ -0,0 +1,231 @@
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+
+	"github.com/github/github-mcp-server/pkg/registry"
+	"github.com/github/github-mcp-server/pkg/translations"
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// createDynamicRequest creates an MCP request with the given arguments for dynamic tools.
+func createDynamicRequest(args map[string]any) *mcp.CallToolRequest {
+	argsJSON, _ := json.Marshal(args)
+	return &mcp.CallToolRequest{
+		Params: &mcp.CallToolParamsRaw{
+			Arguments: json.RawMessage(argsJSON),
+		},
+	}
+}
+
+func TestDynamicTools_ListAvailableToolsets(t *testing.T) {
+	// Build a registry with no toolsets enabled (dynamic mode)
+	reg := NewRegistry(translations.NullTranslationHelper).
+		WithToolsets([]string{}).
+		Build()
+
+	// Create a mock server
+	server := mcp.NewServer(&mcp.Implementation{Name: "test"}, nil)
+
+	// Create dynamic tool dependencies
+	deps := DynamicToolDependencies{
+		Server:   server,
+		Registry: reg,
+		ToolDeps: nil,
+		T:        translations.NullTranslationHelper,
+	}
+
+	// Get the list_available_toolsets tool
+	tool := ListAvailableToolsets()
+	handler := tool.Handler(deps)
+
+	// Call the handler
+	result, err := handler(context.Background(), createDynamicRequest(map[string]any{}))
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	require.Len(t, result.Content, 1)
+
+	// Parse the result
+	var toolsets []map[string]string
+	textContent := result.Content[0].(*mcp.TextContent)
+	err = json.Unmarshal([]byte(textContent.Text), &toolsets)
+	require.NoError(t, err)
+
+	// Verify we got toolsets
+	assert.NotEmpty(t, toolsets, "should have available toolsets")
+
+	// Find the repos toolset and verify it's not enabled
+	var reposToolset map[string]string
+	for _, ts := range toolsets {
+		if ts["name"] == "repos" {
+			reposToolset = ts
+			break
+		}
+	}
+	require.NotNil(t, reposToolset, "repos toolset should exist")
+	assert.Equal(t, "false", reposToolset["currently_enabled"], "repos should not be enabled initially")
+}
+
+func TestDynamicTools_GetToolsetTools(t *testing.T) {
+	// Build a registry with no toolsets enabled (dynamic mode)
+	reg := NewRegistry(translations.NullTranslationHelper).
+		WithToolsets([]string{}).
+		Build()
+
+	// Create a mock server
+	server := mcp.NewServer(&mcp.Implementation{Name: "test"}, nil)
+
+	// Create dynamic tool dependencies
+	deps := DynamicToolDependencies{
+		Server:   server,
+		Registry: reg,
+		ToolDeps: nil,
+		T:        translations.NullTranslationHelper,
+	}
+
+	// Get the get_toolset_tools tool
+	tool := GetToolsetsTools(reg)
+	handler := tool.Handler(deps)
+
+	// Call the handler for repos toolset
+	result, err := handler(context.Background(), createDynamicRequest(map[string]any{
+		"toolset": "repos",
+	}))
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	require.Len(t, result.Content, 1)
+
+	// Parse the result
+	var tools []map[string]string
+	textContent := result.Content[0].(*mcp.TextContent)
+	err = json.Unmarshal([]byte(textContent.Text), &tools)
+	require.NoError(t, err)
+
+	// Verify we got tools for the repos toolset
+	assert.NotEmpty(t, tools, "repos toolset should have tools")
+
+	// Verify at least get_commit is there (a repos toolset tool)
+	var foundGetCommit bool
+	for _, tool := range tools {
+		if tool["name"] == "get_commit" {
+			foundGetCommit = true
+			break
+		}
+	}
+	assert.True(t, foundGetCommit, "get_commit should be in repos toolset")
+}
+
+func TestDynamicTools_EnableToolset(t *testing.T) {
+	// Build a registry with no toolsets enabled (dynamic mode)
+	reg := NewRegistry(translations.NullTranslationHelper).
+		WithToolsets([]string{}).
+		Build()
+
+	// Create a mock server
+	server := mcp.NewServer(&mcp.Implementation{Name: "test"}, nil)
+
+	// Create dynamic tool dependencies
+	deps := DynamicToolDependencies{
+		Server:   server,
+		Registry: reg,
+		ToolDeps: NewBaseDeps(nil, nil, nil, nil, translations.NullTranslationHelper, FeatureFlags{}, 0),
+		T:        translations.NullTranslationHelper,
+	}
+
+	// Verify repos is not enabled initially
+	assert.False(t, reg.IsToolsetEnabled(registry.ToolsetID("repos")))
+
+	// Get the enable_toolset tool
+	tool := EnableToolset(reg)
+	handler := tool.Handler(deps)
+
+	// Enable the repos toolset
+	result, err := handler(context.Background(), createDynamicRequest(map[string]any{
+		"toolset": "repos",
+	}))
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	require.Len(t, result.Content, 1)
+
+	// Verify the toolset is now enabled
+	assert.True(t, reg.IsToolsetEnabled(registry.ToolsetID("repos")), "repos should be enabled after enable_toolset")
+
+	// Verify the success message
+	textContent := result.Content[0].(*mcp.TextContent)
+	assert.Contains(t, textContent.Text, "enabled")
+
+	// Try enabling again - should say already enabled
+	result2, err := handler(context.Background(), createDynamicRequest(map[string]any{
+		"toolset": "repos",
+	}))
+	require.NoError(t, err)
+	textContent2 := result2.Content[0].(*mcp.TextContent)
+	assert.Contains(t, textContent2.Text, "already enabled")
+}
+
+func TestDynamicTools_EnableToolset_InvalidToolset(t *testing.T) {
+	// Build a registry with no toolsets enabled (dynamic mode)
+	reg := NewRegistry(translations.NullTranslationHelper).
+		WithToolsets([]string{}).
+		Build()
+
+	// Create a mock server
+	server := mcp.NewServer(&mcp.Implementation{Name: "test"}, nil)
+
+	// Create dynamic tool dependencies
+	deps := DynamicToolDependencies{
+		Server:   server,
+		Registry: reg,
+		ToolDeps: nil,
+		T:        translations.NullTranslationHelper,
+	}
+
+	// Get the enable_toolset tool
+	tool := EnableToolset(reg)
+	handler := tool.Handler(deps)
+
+	// Try to enable a non-existent toolset
+	result, err := handler(context.Background(), createDynamicRequest(map[string]any{
+		"toolset": "nonexistent",
+	}))
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	// Should be an error result
+	textContent := result.Content[0].(*mcp.TextContent)
+	assert.Contains(t, textContent.Text, "not found")
+}
+
+func TestDynamicTools_ToolsetsEnum(t *testing.T) {
+	// Build a registry
+	reg := NewRegistry(translations.NullTranslationHelper).Build()
+
+	// Get tools to verify they have proper enum values
+	tools := DynamicTools(reg)
+
+	// Find enable_toolset and get_toolset_tools
+	for _, tool := range tools {
+		if tool.Tool.Name == "enable_toolset" || tool.Tool.Name == "get_toolset_tools" {
+			// Verify the toolset property has an enum
+			schema := tool.Tool.InputSchema.(*jsonschema.Schema)
+			toolsetProp := schema.Properties["toolset"]
+			require.NotNil(t, toolsetProp, "toolset property should exist")
+			assert.NotEmpty(t, toolsetProp.Enum, "toolset property should have enum values")
+
+			// Verify repos is in the enum
+			var foundRepos bool
+			for _, v := range toolsetProp.Enum {
+				if v == registry.ToolsetID("repos") {
+					foundRepos = true
+					break
+				}
+			}
+			assert.True(t, foundRepos, "repos should be in toolset enum for %s", tool.Tool.Name)
+		}
+	}
+}