package github

import (

"context"

"encoding/json"

"testing"

"github.com/github/github-mcp-server/pkg/translations"

"github.com/modelcontextprotocol/go-sdk/mcp"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

"github.com/github/github-mcp-server/pkg/inventory"

"github.com/github/github-mcp-server/pkg/scopes"

"github.com/github/github-mcp-server/pkg/utils"

)

// RemoteMCPEnthusiasticGreeting is a dummy test feature flag .

const RemoteMCPEnthusiasticGreeting = "remote_mcp_enthusiastic_greeting"

// FeatureChecker is an interface for checking if a feature flag is enabled.

type FeatureChecker interface {

// IsFeatureEnabled checks if a feature flag is enabled.

IsFeatureEnabled(ctx context.Context, flagName string) bool

}

// HelloWorld returns a simple greeting tool that demonstrates feature flag conditional behavior.

// This tool is for testing and demonstration purposes only.

func HelloWorldTool(t translations.TranslationHelperFunc) inventory.ServerTool {

return NewTool(

ToolsetMetadataContext, // Use existing "context" toolset

mcp.Tool{

Name: "hello_world",

Description: t("TOOL_HELLO_WORLD_DESCRIPTION", "A simple greeting tool that demonstrates feature flag conditional behavior"),

Annotations: &mcp.ToolAnnotations{

Title: t("TOOL_HELLO_WORLD_TITLE", "Hello World"),

ReadOnlyHint: true,

},

},

[]scopes.Scope{},

func(ctx context.Context, deps ToolDependencies, _ *mcp.CallToolRequest, _ map[string]any) (*mcp.CallToolResult, any, error) {

// Check feature flag to determine greeting style

greeting := "Hello, world!"

if deps.IsFeatureEnabled(ctx, RemoteMCPEnthusiasticGreeting) {

greeting += " Welcome to the future of MCP! 🎉"

}

if deps.GetFlags(ctx).InsidersMode {

greeting += " Experimental features are enabled! 🚀"

}

// Build response

response := map[string]any{

"greeting": greeting,

}

jsonBytes, err := json.Marshal(response)

if err != nil {

return utils.NewToolResultError("failed to marshal response"), nil, nil

}

return utils.NewToolResultText(string(jsonBytes)), nil, nil

},

)

}

func TestHelloWorld_ConditionalBehavior_Featureflag(t *testing.T) {

t.Parallel()

tests := []struct {

name string

featureFlagEnabled bool

inputName string

expectedGreeting string

}{

{

name: "Feature flag disabled - default greeting",

featureFlagEnabled: false,

expectedGreeting: "Hello, world!",

},

{

name: "Feature flag enabled - enthusiastic greeting",

featureFlagEnabled: true,

expectedGreeting: "Hello, world! Welcome to the future of MCP! 🎉",

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

t.Parallel()

// Create feature checker based on test case

checker := func(_ context.Context, flagName string) (bool, error) {

if flagName == RemoteMCPEnthusiasticGreeting {

return tt.featureFlagEnabled, nil

}

return false, nil

}

// Create deps with the checker

deps := NewBaseDeps(

nil, nil, nil, nil,

translations.NullTranslationHelper,

FeatureFlags{},

0,

checker,

stubExporters(),

)

// Get the tool and its handler

tool := HelloWorldTool(translations.NullTranslationHelper)

handler := tool.Handler(deps)

// Call the handler with deps in context

ctx := ContextWithDeps(context.Background(), deps)

result, err := handler(ctx, &mcp.CallToolRequest{

Params: &mcp.CallToolParamsRaw{

Arguments: json.RawMessage(`{}`),

},

})

require.NoError(t, err)

require.NotNil(t, result)

require.Len(t, result.Content, 1)

// Parse the response - should be TextContent

textContent, ok := result.Content[0].(*mcp.TextContent)

require.True(t, ok, "expected content to be TextContent")

var response map[string]any

err = json.Unmarshal([]byte(textContent.Text), &response)

require.NoError(t, err)

// Verify the greeting matches expected based on feature flag

assert.Equal(t, tt.expectedGreeting, response["greeting"])

})

}

}

func TestResolveFeatureFlags(t *testing.T) {

t.Parallel()

tests := []struct {

name string

enabledFeatures []string

insidersMode bool

expectedFlags []string

unexpectedFlags []string

}{

{

name: "no features, no insiders",

enabledFeatures: nil,

insidersMode: false,

expectedFlags: nil,

unexpectedFlags: []string{MCPAppsFeatureFlag},

},

{

name: "explicit feature enabled",

enabledFeatures: []string{MCPAppsFeatureFlag},

insidersMode: false,

expectedFlags: []string{MCPAppsFeatureFlag},

},

{

name: "insiders mode enables insiders flags",

enabledFeatures: nil,

insidersMode: true,

expectedFlags: InsidersFeatureFlags,

},

{

name: "unknown flags are filtered out",

enabledFeatures: []string{"unknown_flag", "another_unknown"},

insidersMode: false,

unexpectedFlags: []string{"unknown_flag", "another_unknown"},

},

{

name: "mix of known and unknown flags",

enabledFeatures: []string{MCPAppsFeatureFlag, "unknown_flag"},

insidersMode: false,

expectedFlags: []string{MCPAppsFeatureFlag},

unexpectedFlags: []string{"unknown_flag"},

},

{

name: "explicit plus insiders deduplicates",

enabledFeatures: []string{MCPAppsFeatureFlag},

insidersMode: true,

expectedFlags: []string{MCPAppsFeatureFlag},

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

t.Parallel()

result := ResolveFeatureFlags(tt.enabledFeatures, tt.insidersMode)

for _, flag := range tt.expectedFlags {

assert.True(t, result[flag], "expected flag %q to be enabled", flag)

}

for _, flag := range tt.unexpectedFlags {

assert.False(t, result[flag], "expected flag %q to not be enabled", flag)

}

})

}

}

func TestHelloWorld_ConditionalBehavior_Config(t *testing.T) {

t.Parallel()

tests := []struct {

name string

insidersMode bool

expectedGreeting string

}{

{

name: "Experimental disabled - default greeting",

insidersMode: false,

expectedGreeting: "Hello, world!",

},

{

name: "Experimental enabled - experimental greeting",

insidersMode: true,

expectedGreeting: "Hello, world! Experimental features are enabled! 🚀",

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

t.Parallel()

// Create deps with the checker

deps := NewBaseDeps(

nil, nil, nil, nil,

translations.NullTranslationHelper,

FeatureFlags{InsidersMode: tt.insidersMode},

0,

nil,

stubExporters(),

)

// Get the tool and its handler

tool := HelloWorldTool(translations.NullTranslationHelper)

handler := tool.Handler(deps)

// Call the handler with deps in context

ctx := ContextWithDeps(context.Background(), deps)

result, err := handler(ctx, &mcp.CallToolRequest{

Params: &mcp.CallToolParamsRaw{

Arguments: json.RawMessage(`{}`),

},

})

require.NoError(t, err)

require.NotNil(t, result)

require.Len(t, result.Content, 1)

// Parse the response - should be TextContent

textContent, ok := result.Content[0].(*mcp.TextContent)

require.True(t, ok, "expected content to be TextContent")

var response map[string]any

err = json.Unmarshal([]byte(textContent.Text), &response)

require.NoError(t, err)

// Verify the greeting matches expected based on feature flag

assert.Equal(t, tt.expectedGreeting, response["greeting"])

})

}

}