package inventory
import (
"os"
"strings"
"testing"
)
// createTestInventory creates an inventory with the specified toolsets for testing.
// All toolsets are enabled by default using WithToolsets([]string{"all"}).
func createTestInventory(toolsets []ToolsetMetadata) *Inventory {
// Create tools for each toolset so they show up in AvailableToolsets()
var tools []ServerTool
for _, ts := range toolsets {
tools = append(tools, ServerTool{
Toolset: ts,
})
}
inv, _ := NewBuilder().
SetTools(tools).
WithToolsets([]string{"all"}).
Build()
return inv
}
func TestGenerateInstructions(t *testing.T) {
tests := []struct {
name string
toolsets []ToolsetMetadata
expectedEmpty bool
}{
{
name: "empty toolsets",
toolsets: []ToolsetMetadata{},
expectedEmpty: false, // base instructions are always included
},
{
name: "toolset with instructions",
toolsets: []ToolsetMetadata{
{
ID: "test",
Description: "Test toolset",
InstructionsFunc: func(_ *Inventory) string {
return "Test instructions"
},
},
},
expectedEmpty: false,
},
{
name: "toolset without instructions",
toolsets: []ToolsetMetadata{
{
ID: "test",
Description: "Test toolset",
},
},
expectedEmpty: false, // base instructions still included
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
inv := createTestInventory(tt.toolsets)
result := generateInstructions(inv)
if tt.expectedEmpty {
if result != "" {
t.Errorf("Expected empty instructions but got: %s", result)
}
} else {
if result == "" {
t.Errorf("Expected non-empty instructions but got empty result")
}
}
})
}
}
func TestGenerateInstructionsWithDisableFlag(t *testing.T) {
tests := []struct {
name string
disableEnvValue string
expectedEmpty bool
}{
{
name: "DISABLE_INSTRUCTIONS=true returns empty",
disableEnvValue: "true",
expectedEmpty: true,
},
{
name: "DISABLE_INSTRUCTIONS=false returns normal instructions",
disableEnvValue: "false",
expectedEmpty: false,
},
{
name: "DISABLE_INSTRUCTIONS unset returns normal instructions",
disableEnvValue: "",
expectedEmpty: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Save original env value
originalValue := os.Getenv("DISABLE_INSTRUCTIONS")
defer func() {
if originalValue == "" {
os.Unsetenv("DISABLE_INSTRUCTIONS")
} else {
os.Setenv("DISABLE_INSTRUCTIONS", originalValue)
}
}()
// Set test env value
if tt.disableEnvValue == "" {
os.Unsetenv("DISABLE_INSTRUCTIONS")
} else {
os.Setenv("DISABLE_INSTRUCTIONS", tt.disableEnvValue)
}
inv := createTestInventory([]ToolsetMetadata{
{ID: "test", Description: "Test"},
})
result := generateInstructions(inv)
if tt.expectedEmpty {
if result != "" {
t.Errorf("Expected empty instructions but got: %s", result)
}
} else {
if result == "" {
t.Errorf("Expected non-empty instructions but got empty result")
}
}
})
}
}
func TestToolsetInstructionsFunc(t *testing.T) {
tests := []struct {
name string
toolsets []ToolsetMetadata
expectedToContain string
notExpectedToContain string
}{
{
name: "toolset with context-aware instructions includes extra text when dependency present",
toolsets: []ToolsetMetadata{
{ID: "repos", Description: "Repos"},
{
ID: "pull_requests",
Description: "PRs",
InstructionsFunc: func(inv *Inventory) string {
instructions := "PR base instructions"
if inv.HasToolset("repos") {
instructions += " PR template instructions"
}
return instructions
},
},
},
expectedToContain: "PR template instructions",
},
{
name: "toolset with context-aware instructions excludes extra text when dependency missing",
toolsets: []ToolsetMetadata{
{
ID: "pull_requests",
Description: "PRs",
InstructionsFunc: func(inv *Inventory) string {
instructions := "PR base instructions"
if inv.HasToolset("repos") {
instructions += " PR template instructions"
}
return instructions
},
},
},
notExpectedToContain: "PR template instructions",
},
{
name: "toolset without InstructionsFunc returns no toolset-specific instructions",
toolsets: []ToolsetMetadata{
{ID: "test", Description: "Test without instructions"},
},
notExpectedToContain: "## Test",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
inv := createTestInventory(tt.toolsets)
result := generateInstructions(inv)
if tt.expectedToContain != "" && !strings.Contains(result, tt.expectedToContain) {
t.Errorf("Expected result to contain '%s', but it did not. Result: %s", tt.expectedToContain, result)
}
if tt.notExpectedToContain != "" && strings.Contains(result, tt.notExpectedToContain) {
t.Errorf("Did not expect result to contain '%s', but it did. Result: %s", tt.notExpectedToContain, result)
}
})
}
}
// TestGenerateInstructionsOnlyEnabledToolsets verifies that generateInstructions
// only includes instructions from enabled toolsets, not all available toolsets.
// This is a regression test for https://github.com/github/github-mcp-server/issues/1897
func TestGenerateInstructionsOnlyEnabledToolsets(t *testing.T) {
// Create tools for multiple toolsets
reposToolset := ToolsetMetadata{
ID: "repos",
Description: "Repository tools",
InstructionsFunc: func(_ *Inventory) string {
return "REPOS_INSTRUCTIONS"
},
}
issuesToolset := ToolsetMetadata{
ID: "issues",
Description: "Issue tools",
InstructionsFunc: func(_ *Inventory) string {
return "ISSUES_INSTRUCTIONS"
},
}
prsToolset := ToolsetMetadata{
ID: "pull_requests",
Description: "PR tools",
InstructionsFunc: func(_ *Inventory) string {
return "PRS_INSTRUCTIONS"
},
}
tools := []ServerTool{
{Toolset: reposToolset},
{Toolset: issuesToolset},
{Toolset: prsToolset},
}
// Build inventory with only "repos" toolset enabled
inv, err := NewBuilder().
SetTools(tools).
WithToolsets([]string{"repos"}).
Build()
if err != nil {
t.Fatalf("Failed to build inventory: %v", err)
}
result := generateInstructions(inv)
// Should contain instructions from enabled toolset
if !strings.Contains(result, "REPOS_INSTRUCTIONS") {
t.Errorf("Expected instructions to contain 'REPOS_INSTRUCTIONS' for enabled toolset, but it did not. Result: %s", result)
}
// Should NOT contain instructions from non-enabled toolsets
if strings.Contains(result, "ISSUES_INSTRUCTIONS") {
t.Errorf("Did not expect instructions to contain 'ISSUES_INSTRUCTIONS' for disabled toolset, but it did. Result: %s", result)
}
if strings.Contains(result, "PRS_INSTRUCTIONS") {
t.Errorf("Did not expect instructions to contain 'PRS_INSTRUCTIONS' for disabled toolset, but it did. Result: %s", result)
}
}
