chore: import upstream snapshot with attribution

2026-07-13 12:37:57 +08:00
commit e30f8ba47c
533 changed files with 115926 additions and 0 deletions
@@ -0,0 +1,84 @@
+package github
+
+import (
+	"context"
+	"testing"
+
+	"github.com/github/github-mcp-server/pkg/translations"
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// Test_FieldsParamVariants_MutuallyExclusive guards the dual-variant
+// registration for the fields_param feature flag. The flag-enabled tools and
+// their Legacy* counterparts share a tool name, so exactly one of each pair must
+// survive inventory filtering for any flag state. If both ever leaked, a client
+// could be offered two tools with the same name. This asserts that each gated
+// tool is present exactly once, advertising the `fields` parameter only when
+// fields_param is enabled.
+func Test_FieldsParamVariants_MutuallyExclusive(t *testing.T) {
+	gatedTools := []string{
+		"search_code",
+		"get_file_contents",
+		"list_issues",
+		"list_releases",
+		"list_pull_requests",
+		"search_issues",
+		"search_pull_requests",
+		"list_commits",
+	}
+
+	for _, tc := range []struct {
+		name          string
+		flagEnabled   bool
+		expectFields  bool
+		featureChecks func(context.Context, string) (bool, error)
+	}{
+		{
+			name:          "flag off registers the legacy variant without fields",
+			flagEnabled:   false,
+			expectFields:  false,
+			featureChecks: featureCheckerFor(), // fields_param disabled
+		},
+		{
+			name:          "flag on registers the fields variant with fields",
+			flagEnabled:   true,
+			expectFields:  true,
+			featureChecks: featureCheckerFor(FeatureFlagFieldsParam),
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			inv, err := NewInventory(translations.NullTranslationHelper).
+				WithToolsets([]string{"all"}).
+				WithFeatureChecker(tc.featureChecks).
+				Build()
+			require.NoError(t, err)
+
+			available := inv.AvailableTools(context.Background())
+
+			counts := make(map[string]int, len(available))
+			for _, tool := range available {
+				counts[tool.Tool.Name]++
+			}
+
+			// Each gated tool must be present exactly once (never both variants)
+			// and advertise `fields` only when the flag is enabled.
+			for _, name := range gatedTools {
+				require.Equalf(t, 1, counts[name], "expected exactly one %q for flagEnabled=%v; dual variants must be mutually exclusive", name, tc.flagEnabled)
+
+				tool := requireToolByName(t, available, name)
+				schema, ok := tool.Tool.InputSchema.(*jsonschema.Schema)
+				require.Truef(t, ok, "%q InputSchema should be *jsonschema.Schema", name)
+
+				if tc.expectFields {
+					assert.Containsf(t, schema.Properties, "fields", "%q should advertise fields when flag is on", name)
+					assert.Equalf(t, FeatureFlagFieldsParam, tool.FeatureFlagEnable, "%q should be the flag-enabled variant", name)
+				} else {
+					assert.NotContainsf(t, schema.Properties, "fields", "%q must not advertise fields when flag is off", name)
+					assert.Containsf(t, tool.FeatureFlagDisable, FeatureFlagFieldsParam, "%q should be the legacy (flag-disabled) variant", name)
+				}
+			}
+		})
+	}
+}