package github

import (

"bytes"

"context"

"encoding/json"

"fmt"

"io"

"net/http"

"strings"

"testing"

"time"

"github.com/github/github-mcp-server/internal/githubv4mock"

"github.com/github/github-mcp-server/internal/toolsnaps"

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

"github.com/google/go-github/v82/github"

"github.com/google/jsonschema-go/jsonschema"

"github.com/shurcooL/githubv4"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

)

var defaultGQLClient *githubv4.Client = githubv4.NewClient(newRepoAccessHTTPClient())

type repoAccessKey struct {

owner string

repo string

}

type repoAccessValue struct {

isPrivate bool

}

type repoAccessMockTransport struct {

responses map[repoAccessKey]repoAccessValue

}

func newRepoAccessHTTPClient() *http.Client {

responses := map[repoAccessKey]repoAccessValue{

{owner: "owner2", repo: "repo2"}: {isPrivate: true},

{owner: "owner", repo: "repo"}: {isPrivate: false},

}

return &http.Client{Transport: &repoAccessMockTransport{responses: responses}}

}

func (rt *repoAccessMockTransport) RoundTrip(req *http.Request) (*http.Response, error) {

if req.Body == nil {

return nil, fmt.Errorf("missing request body")

}

var payload struct {

Query string `json:"query"`

Variables map[string]any `json:"variables"`

}

if err := json.NewDecoder(req.Body).Decode(&payload); err != nil {

return nil, err

}

_ = req.Body.Close()

owner := toString(payload.Variables["owner"])

repo := toString(payload.Variables["name"])

value, ok := rt.responses[repoAccessKey{owner: owner, repo: repo}]

if !ok {

value = repoAccessValue{isPrivate: false}

}

responseBody, err := json.Marshal(map[string]any{

"data": map[string]any{

"viewer": map[string]any{

"login": "test-viewer",

},

"repository": map[string]any{

"isPrivate": value.isPrivate,

},

},

})

if err != nil {

return nil, err

}

resp := &http.Response{

StatusCode: http.StatusOK,

Header: make(http.Header),

Body: io.NopCloser(bytes.NewReader(responseBody)),

}

resp.Header.Set("Content-Type", "application/json")

return resp, nil

}

func toString(v any) string {

switch value := v.(type) {

case string:

return value

case fmt.Stringer:

return value.String()

case nil:

return ""

default:

return fmt.Sprintf("%v", value)

}

}

func Test_GetIssue(t *testing.T) {

// Verify tool definition once

serverTool := IssueRead(translations.NullTranslationHelper)

tool := serverTool.Tool

require.NoError(t, toolsnaps.Test(tool.Name, tool))

assert.Equal(t, "issue_read", tool.Name)

assert.NotEmpty(t, tool.Description)

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "method")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "owner")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "repo")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "issue_number")

assert.ElementsMatch(t, tool.InputSchema.(*jsonschema.Schema).Required, []string{"method", "owner", "repo", "issue_number"})

// Setup mock issue for success case

mockIssue := &github.Issue{

Number: github.Ptr(42),

Title: github.Ptr("Test Issue"),

Body: github.Ptr("This is a test issue"),

State: github.Ptr("open"),

HTMLURL: github.Ptr("https://github.com/owner/repo/issues/42"),

User: &github.User{

Login: github.Ptr("testuser"),

},

Repository: &github.Repository{

Name: github.Ptr("repo"),

Owner: &github.User{

Login: github.Ptr("owner"),

},

},

}

mockIssue2 := &github.Issue{

Number: github.Ptr(422),

Title: github.Ptr("Test Issue 2"),

Body: github.Ptr("This is a test issue 2"),

State: github.Ptr("open"),

HTMLURL: github.Ptr("https://github.com/owner/repo/issues/42"),

User: &github.User{

Login: github.Ptr("testuser2"),

},

Repository: &github.Repository{

Name: github.Ptr("repo2"),

Owner: &github.User{

Login: github.Ptr("owner2"),

},

},

}

tests := []struct {

name string

mockedClient *http.Client

requestArgs map[string]any

expectHandlerError bool

expectResultError bool

expectedIssue *github.Issue

expectedErrMsg string

lockdownEnabled bool

restPermission string

}{

{

name: "successful issue retrieval",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetReposIssuesByOwnerByRepoByIssueNumber: mockResponse(t, http.StatusOK, mockIssue),

}),

requestArgs: map[string]any{

"method": "get",

"owner": "owner2",

"repo": "repo2",

"issue_number": float64(42),

},

expectedIssue: mockIssue,

},

{

name: "issue not found",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetReposIssuesByOwnerByRepoByIssueNumber: mockResponse(t, http.StatusNotFound, `{"message": "Issue not found"}`),

}),

requestArgs: map[string]any{

"method": "get",

"owner": "owner",

"repo": "repo",

"issue_number": float64(999),

},

expectHandlerError: true,

expectedErrMsg: "failed to get issue",

},

{

name: "lockdown enabled - private repository",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetReposIssuesByOwnerByRepoByIssueNumber: mockResponse(t, http.StatusOK, mockIssue2),

}),

requestArgs: map[string]any{

"method": "get",

"owner": "owner2",

"repo": "repo2",

"issue_number": float64(422),

},

expectedIssue: mockIssue2,

lockdownEnabled: true,

restPermission: "none",

},

{

name: "lockdown enabled - user lacks push access",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetReposIssuesByOwnerByRepoByIssueNumber: mockResponse(t, http.StatusOK, mockIssue),

}),

requestArgs: map[string]any{

"method": "get",

"owner": "owner",

"repo": "repo",

"issue_number": float64(42),

},

expectResultError: true,

expectedErrMsg: "access to issue details is restricted by lockdown mode",

lockdownEnabled: true,

restPermission: "read",

},

}

for _, tc := range tests {

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

client := github.NewClient(tc.mockedClient)

var restClient *github.Client

if tc.restPermission != "" {

restClient = mockRESTPermissionServer(t, tc.restPermission, nil)

}

cache := stubRepoAccessCache(restClient, 15*time.Minute)

flags := stubFeatureFlags(map[string]bool{"lockdown-mode": tc.lockdownEnabled})

deps := BaseDeps{

Client: client,

GQLClient: defaultGQLClient,

RepoAccessCache: cache,

Flags: flags,

}

handler := serverTool.Handler(deps)

request := createMCPRequest(tc.requestArgs)

result, err := handler(ContextWithDeps(context.Background(), deps), &request)

if tc.expectHandlerError {

require.Error(t, err)

assert.Contains(t, err.Error(), tc.expectedErrMsg)

return

}

require.NoError(t, err)

require.NotNil(t, result)

if tc.expectResultError {

errorContent := getErrorResult(t, result)

assert.Contains(t, errorContent.Text, tc.expectedErrMsg)

return

}

textContent := getTextResult(t, result)

var returnedIssue MinimalIssue

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

require.NoError(t, err)

assert.Equal(t, tc.expectedIssue.GetNumber(), returnedIssue.Number)

assert.Equal(t, tc.expectedIssue.GetTitle(), returnedIssue.Title)

assert.Equal(t, tc.expectedIssue.GetBody(), returnedIssue.Body)

assert.Equal(t, tc.expectedIssue.GetState(), returnedIssue.State)

assert.Equal(t, tc.expectedIssue.GetHTMLURL(), returnedIssue.HTMLURL)

assert.Equal(t, tc.expectedIssue.GetUser().GetLogin(), returnedIssue.User.Login)

})

}

}

func Test_AddIssueComment(t *testing.T) {

// Verify tool definition once

serverTool := AddIssueComment(translations.NullTranslationHelper)

tool := serverTool.Tool

require.NoError(t, toolsnaps.Test(tool.Name, tool))

assert.Equal(t, "add_issue_comment", tool.Name)

assert.NotEmpty(t, tool.Description)

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "owner")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "repo")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "issue_number")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "body")

assert.ElementsMatch(t, tool.InputSchema.(*jsonschema.Schema).Required, []string{"owner", "repo", "issue_number", "body"})

// Setup mock comment for success case

mockComment := &github.IssueComment{

ID: github.Ptr(int64(123)),

Body: github.Ptr("This is a test comment"),

User: &github.User{

Login: github.Ptr("testuser"),

},

HTMLURL: github.Ptr("https://github.com/owner/repo/issues/42#issuecomment-123"),

}

tests := []struct {

name string

mockedClient *http.Client

requestArgs map[string]any

expectError bool

expectedComment *github.IssueComment

expectedErrMsg string

}{

{

name: "successful comment creation",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

PostReposIssuesCommentsByOwnerByRepoByIssueNumber: mockResponse(t, http.StatusCreated, mockComment),

}),

requestArgs: map[string]any{

"owner": "owner",

"repo": "repo",

"issue_number": float64(42),

"body": "This is a test comment",

},

expectError: false,

expectedComment: mockComment,

},

{

name: "comment creation fails",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

PostReposIssuesCommentsByOwnerByRepoByIssueNumber: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {

w.WriteHeader(http.StatusUnprocessableEntity)

_, _ = w.Write([]byte(`{"message": "Invalid request"}`))

}),

}),

requestArgs: map[string]any{

"owner": "owner",

"repo": "repo",

"issue_number": float64(42),

"body": "",

},

expectError: false,

expectedErrMsg: "missing required parameter: body",

},

}

for _, tc := range tests {

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

// Setup client with mock

client := github.NewClient(tc.mockedClient)

deps := BaseDeps{

Client: client,

}

handler := serverTool.Handler(deps)

// Create call request

request := createMCPRequest(tc.requestArgs)

// Call handler

result, err := handler(ContextWithDeps(context.Background(), deps), &request)

// Verify results

if tc.expectError {

require.Error(t, err)

assert.Contains(t, err.Error(), tc.expectedErrMsg)

return

}

if tc.expectedErrMsg != "" {

require.NotNil(t, result)

textContent := getTextResult(t, result)

assert.Contains(t, textContent.Text, tc.expectedErrMsg)

return

}

require.NoError(t, err)

// Parse the result and get the text content if no error

textContent := getTextResult(t, result)

// Unmarshal and verify the result contains minimal response

var minimalResponse MinimalResponse

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

require.NoError(t, err)

assert.Equal(t, fmt.Sprintf("%d", tc.expectedComment.GetID()), minimalResponse.ID)

assert.Equal(t, tc.expectedComment.GetHTMLURL(), minimalResponse.URL)

})

}

}

func Test_SearchIssues(t *testing.T) {

// Verify tool definition once

serverTool := SearchIssues(translations.NullTranslationHelper)

tool := serverTool.Tool

require.NoError(t, toolsnaps.Test(tool.Name, tool))

assert.Equal(t, "search_issues", tool.Name)

assert.NotEmpty(t, tool.Description)

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "query")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "owner")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "repo")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "sort")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "order")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "perPage")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "page")

assert.ElementsMatch(t, tool.InputSchema.(*jsonschema.Schema).Required, []string{"query"})

// Setup mock search results

mockSearchResult := &github.IssuesSearchResult{

Total: github.Ptr(2),

IncompleteResults: github.Ptr(false),

Issues: []*github.Issue{

{

Number: github.Ptr(42),

Title: github.Ptr("Bug: Something is broken"),

Body: github.Ptr("This is a bug report"),

State: github.Ptr("open"),

HTMLURL: github.Ptr("https://github.com/owner/repo/issues/42"),

Comments: github.Ptr(5),

User: &github.User{

Login: github.Ptr("user1"),

},

},

{

Number: github.Ptr(43),

Title: github.Ptr("Feature: Add new functionality"),

Body: github.Ptr("This is a feature request"),

State: github.Ptr("open"),

HTMLURL: github.Ptr("https://github.com/owner/repo/issues/43"),

Comments: github.Ptr(3),

User: &github.User{

Login: github.Ptr("user2"),

},

},

},

}

tests := []struct {

name string

mockedClient *http.Client

requestArgs map[string]any

expectError bool

expectedResult *github.IssuesSearchResult

expectedErrMsg string

}{

{

name: "successful issues search with all parameters",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetSearchIssues: expectQueryParams(

t,

map[string]string{

"q": "is:issue repo:owner/repo is:open",

"sort": "created",

"order": "desc",

"page": "1",

"per_page": "30",

},

).andThen(

mockResponse(t, http.StatusOK, mockSearchResult),

),

}),

requestArgs: map[string]any{

"query": "repo:owner/repo is:open",

"sort": "created",

"order": "desc",

"page": float64(1),

"perPage": float64(30),

},

expectError: false,

expectedResult: mockSearchResult,

},

{

name: "issues search with owner and repo parameters",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetSearchIssues: expectQueryParams(

t,

map[string]string{

"q": "repo:test-owner/test-repo is:issue is:open",

"sort": "created",

"order": "asc",

"page": "1",

"per_page": "30",

},

).andThen(

mockResponse(t, http.StatusOK, mockSearchResult),

),

}),

requestArgs: map[string]any{

"query": "is:open",

"owner": "test-owner",

"repo": "test-repo",

"sort": "created",

"order": "asc",

},

expectError: false,

expectedResult: mockSearchResult,

},

{

name: "issues search with only owner parameter (should ignore it)",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetSearchIssues: expectQueryParams(

t,

map[string]string{

"q": "is:issue bug",

"page": "1",

"per_page": "30",

},

).andThen(

mockResponse(t, http.StatusOK, mockSearchResult),

),

}),

requestArgs: map[string]any{

"query": "bug",

"owner": "test-owner",

},

expectError: false,

expectedResult: mockSearchResult,

},

{

name: "issues search with only repo parameter (should ignore it)",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetSearchIssues: expectQueryParams(

t,

map[string]string{

"q": "is:issue feature",

"page": "1",

"per_page": "30",

},

).andThen(

mockResponse(t, http.StatusOK, mockSearchResult),

),

}),

requestArgs: map[string]any{

"query": "feature",

"repo": "test-repo",

},

expectError: false,

expectedResult: mockSearchResult,

},

{

name: "issues search with minimal parameters",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetSearchIssues: mockResponse(t, http.StatusOK, mockSearchResult),

}),

requestArgs: map[string]any{

"query": "is:issue repo:owner/repo is:open",

},

expectError: false,

expectedResult: mockSearchResult,

},

{

name: "query with existing is:issue filter - no duplication",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetSearchIssues: expectQueryParams(

t,

map[string]string{

"q": "repo:github/github-mcp-server is:issue is:open (label:critical OR label:urgent)",

"page": "1",

"per_page": "30",

},

).andThen(

mockResponse(t, http.StatusOK, mockSearchResult),

),

}),

requestArgs: map[string]any{

"query": "repo:github/github-mcp-server is:issue is:open (label:critical OR label:urgent)",

},

expectError: false,

expectedResult: mockSearchResult,

},

{

name: "query with existing repo: filter and conflicting owner/repo params - uses query filter",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetSearchIssues: expectQueryParams(

t,

map[string]string{

"q": "is:issue repo:github/github-mcp-server critical",

"page": "1",

"per_page": "30",

},

).andThen(

mockResponse(t, http.StatusOK, mockSearchResult),

),

}),

requestArgs: map[string]any{

"query": "repo:github/github-mcp-server critical",

"owner": "different-owner",

"repo": "different-repo",

},

expectError: false,

expectedResult: mockSearchResult,

},

{

name: "query with both is: and repo: filters already present",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetSearchIssues: expectQueryParams(

t,

map[string]string{

"q": "is:issue repo:octocat/Hello-World bug",

"page": "1",

"per_page": "30",

},

).andThen(

mockResponse(t, http.StatusOK, mockSearchResult),

),

}),

requestArgs: map[string]any{

"query": "is:issue repo:octocat/Hello-World bug",

},

expectError: false,

expectedResult: mockSearchResult,

},

{

name: "complex query with multiple OR operators and existing filters",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetSearchIssues: expectQueryParams(

t,

map[string]string{

"q": "repo:github/github-mcp-server is:issue (label:critical OR label:urgent OR label:high-priority OR label:blocker)",

"page": "1",

"per_page": "30",

},

).andThen(

mockResponse(t, http.StatusOK, mockSearchResult),

),

}),

requestArgs: map[string]any{

"query": "repo:github/github-mcp-server is:issue (label:critical OR label:urgent OR label:high-priority OR label:blocker)",

},

expectError: false,

expectedResult: mockSearchResult,

},

{

name: "search issues fails",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

GetSearchIssues: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {

w.WriteHeader(http.StatusBadRequest)

_, _ = w.Write([]byte(`{"message": "Validation Failed"}`))

}),

}),

requestArgs: map[string]any{

"query": "invalid:query",

},

expectError: true,

expectedErrMsg: "failed to search issues",

},

}

for _, tc := range tests {

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

// Setup client with mock

client := github.NewClient(tc.mockedClient)

deps := BaseDeps{

Client: client,

}

handler := serverTool.Handler(deps)

// Create call request

request := createMCPRequest(tc.requestArgs)

// Call handler

result, err := handler(ContextWithDeps(context.Background(), deps), &request)

// Verify results

if tc.expectError {

require.NoError(t, err) // No Go error, but result should be an error

require.NotNil(t, result)

require.True(t, result.IsError, "expected result to be an error")

textContent := getErrorResult(t, result)

assert.Contains(t, textContent.Text, tc.expectedErrMsg)

return

}

require.NoError(t, err)

require.False(t, result.IsError, "expected result to not be an error")

// Parse the result and get the text content if no error

textContent := getTextResult(t, result)

// Unmarshal and verify the result

var returnedResult github.IssuesSearchResult

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

require.NoError(t, err)

assert.Equal(t, *tc.expectedResult.Total, *returnedResult.Total)

assert.Equal(t, *tc.expectedResult.IncompleteResults, *returnedResult.IncompleteResults)

assert.Len(t, returnedResult.Issues, len(tc.expectedResult.Issues))

for i, issue := range returnedResult.Issues {

assert.Equal(t, *tc.expectedResult.Issues[i].Number, *issue.Number)

assert.Equal(t, *tc.expectedResult.Issues[i].Title, *issue.Title)

assert.Equal(t, *tc.expectedResult.Issues[i].State, *issue.State)

assert.Equal(t, *tc.expectedResult.Issues[i].HTMLURL, *issue.HTMLURL)

assert.Equal(t, *tc.expectedResult.Issues[i].User.Login, *issue.User.Login)

}

})

}

}

func Test_CreateIssue(t *testing.T) {

// Verify tool definition once

serverTool := IssueWrite(translations.NullTranslationHelper)

tool := serverTool.Tool

require.NoError(t, toolsnaps.Test(tool.Name, tool))

assert.Equal(t, "issue_write", tool.Name)

assert.NotEmpty(t, tool.Description)

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "method")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "owner")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "repo")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "title")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "body")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "assignees")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "labels")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "milestone")

assert.Contains(t, tool.InputSchema.(*jsonschema.Schema).Properties, "type")

assert.ElementsMatch(t, tool.InputSchema.(*jsonschema.Schema).Required, []string{"method", "owner", "repo"})

// Setup mock issue for success case

mockIssue := &github.Issue{

Number: github.Ptr(123),

Title: github.Ptr("Test Issue"),

Body: github.Ptr("This is a test issue"),

State: github.Ptr("open"),

HTMLURL: github.Ptr("https://github.com/owner/repo/issues/123"),

Assignees: []*github.User{{Login: github.Ptr("user1")}, {Login: github.Ptr("user2")}},

Labels: []*github.Label{{Name: github.Ptr("bug")}, {Name: github.Ptr("help wanted")}},

Milestone: &github.Milestone{Number: github.Ptr(5)},

Type: &github.IssueType{Name: github.Ptr("Bug")},

}

tests := []struct {

name string

mockedClient *http.Client

requestArgs map[string]any

expectError bool

expectedIssue *github.Issue

expectedErrMsg string

}{

{

name: "successful issue creation with all fields",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

PostReposIssuesByOwnerByRepo: expectRequestBody(t, map[string]any{

"title": "Test Issue",

"body": "This is a test issue",

"labels": []any{"bug", "help wanted"},

"assignees": []any{"user1", "user2"},

"milestone": float64(5),

"type": "Bug",

}).andThen(

mockResponse(t, http.StatusCreated, mockIssue),

),

}),

requestArgs: map[string]any{

"method": "create",

"owner": "owner",

"repo": "repo",

"title": "Test Issue",

"body": "This is a test issue",

"assignees": []any{"user1", "user2"},

"labels": []any{"bug", "help wanted"},

"milestone": float64(5),

"type": "Bug",

},

expectError: false,

expectedIssue: mockIssue,

},

{

name: "successful issue creation with minimal fields",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

PostReposIssuesByOwnerByRepo: mockResponse(t, http.StatusCreated, &github.Issue{

Number: github.Ptr(124),

Title: github.Ptr("Minimal Issue"),

HTMLURL: github.Ptr("https://github.com/owner/repo/issues/124"),

State: github.Ptr("open"),

}),

}),

requestArgs: map[string]any{

"method": "create",

"owner": "owner",

"repo": "repo",

"title": "Minimal Issue",

"assignees": nil, // Expect no failure with nil optional value.

},

expectError: false,

expectedIssue: &github.Issue{

Number: github.Ptr(124),

Title: github.Ptr("Minimal Issue"),

HTMLURL: github.Ptr("https://github.com/owner/repo/issues/124"),

State: github.Ptr("open"),

},

},

{

name: "issue creation fails",

mockedClient: MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

PostReposIssuesByOwnerByRepo: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {

w.WriteHeader(http.StatusUnprocessableEntity)

_, _ = w.Write([]byte(`{"message": "Validation failed"}`))

}),

}),

requestArgs: map[string]any{

"method": "create",

"owner": "owner",

"repo": "repo",

"title": "",

},

expectError: false,

expectedErrMsg: "missing required parameter: title",

},

}

for _, tc := range tests {

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

// Setup client with mock

client := github.NewClient(tc.mockedClient)

gqlClient := githubv4.NewClient(nil)

deps := BaseDeps{

Client: client,

GQLClient: gqlClient,

}

handler := serverTool.Handler(deps)

// Create call request

request := createMCPRequest(tc.requestArgs)

// Call handler

result, err := handler(ContextWithDeps(context.Background(), deps), &request)

// Verify results

if tc.expectError {

require.Error(t, err)

assert.Contains(t, err.Error(), tc.expectedErrMsg)

return

}

if tc.expectedErrMsg != "" {

require.NotNil(t, result)

textContent := getTextResult(t, result)

assert.Contains(t, textContent.Text, tc.expectedErrMsg)

return

}

require.NoError(t, err)

textContent := getTextResult(t, result)

// Unmarshal and verify the minimal result

var returnedIssue MinimalResponse

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

require.NoError(t, err)

assert.Equal(t, tc.expectedIssue.GetHTMLURL(), returnedIssue.URL)

})

}

}

// Test_IssueWrite_InsidersMode_UIGate verifies the insiders mode UI gate

// behavior: UI clients get a form message, non-UI clients execute directly.

func Test_IssueWrite_InsidersMode_UIGate(t *testing.T) {

t.Parallel()

mockIssue := &github.Issue{

Number: github.Ptr(1),

Title: github.Ptr("Test"),

HTMLURL: github.Ptr("https://github.com/owner/repo/issues/1"),

}

serverTool := IssueWrite(translations.NullTranslationHelper)

client := github.NewClient(MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

PostReposIssuesByOwnerByRepo: mockResponse(t, http.StatusCreated, mockIssue),

}))

deps := BaseDeps{

Client: client,

GQLClient: githubv4.NewClient(nil),

Flags: FeatureFlags{InsidersMode: true},

}

handler := serverTool.Handler(deps)

t.Run("UI client without _ui_submitted returns form message", func(t *testing.T) {

request := createMCPRequestWithSession(t, ClientNameVSCodeInsiders, true, map[string]any{

"method": "create",

"owner": "owner",

"repo": "repo",

"title": "Test",

})

result, err := handler(ContextWithDeps(context.Background(), deps), &request)

require.NoError(t, err)

textContent := getTextResult(t, result)

assert.Contains(t, textContent.Text, "Ready to create an issue")

})

t.Run("UI client with _ui_submitted executes directly", func(t *testing.T) {

request := createMCPRequestWithSession(t, ClientNameVSCodeInsiders, true, map[string]any{

"method": "create",

"owner": "owner",

"repo": "repo",

"title": "Test",

"_ui_submitted": true,

})

result, err := handler(ContextWithDeps(context.Background(), deps), &request)

require.NoError(t, err)

textContent := getTextResult(t, result)

assert.Contains(t, textContent.Text, "https://github.com/owner/repo/issues/1",

"tool should return the created issue URL")

})

t.Run("non-UI client executes directly without _ui_submitted", func(t *testing.T) {

request := createMCPRequest(map[string]any{

"method": "create",

"owner": "owner",

"repo": "repo",

"title": "Test",

})

result, err := handler(ContextWithDeps(context.Background(), deps), &request)

require.NoError(t, err)

textContent := getTextResult(t, result)

assert.Contains(t, textContent.Text, "https://github.com/owner/repo/issues/1",

"non-UI client should execute directly")

})

t.Run("UI client with state change skips form and executes directly", func(t *testing.T) {

mockBaseIssue := &github.Issue{

Number: github.Ptr(1),

Title: github.Ptr("Test"),

State: github.Ptr("open"),

HTMLURL: github.Ptr("https://github.com/owner/repo/issues/1"),

}

issueIDQueryResponse := githubv4mock.DataResponse(map[string]any{

"repository": map[string]any{

"issue": map[string]any{

"id": "I_kwDOA0xdyM50BPaO",

},

},

})

closeSuccessResponse := githubv4mock.DataResponse(map[string]any{

"closeIssue": map[string]any{

"issue": map[string]any{

"id": "I_kwDOA0xdyM50BPaO",

"number": 1,

"url": "https://github.com/owner/repo/issues/1",

"state": "CLOSED",

},

},

})

completedReason := IssueClosedStateReasonCompleted

closeClient := github.NewClient(MockHTTPClientWithHandlers(map[string]http.HandlerFunc{

PatchReposIssuesByOwnerByRepoByIssueNumber: mockResponse(t, http.StatusOK, mockBaseIssue),

}))

closeGQLClient := githubv4.NewClient(githubv4mock.NewMockedHTTPClient(

githubv4mock.NewQueryMatcher(

struct {

Repository struct {

Issue struct {

ID githubv4.ID

} `graphql:"issue(number: $issueNumber)"`

} `graphql:"repository(owner: $owner, name: $repo)"`

}{},

map[string]any{

"owner": githubv4.String("owner"),

"repo": githubv4.String("repo"),

"issueNumber": githubv4.Int(1),

},

issueIDQueryResponse,

),

githubv4mock.NewMutationMatcher(

struct {

CloseIssue struct {

Issue struct {

ID githubv4.ID

Number githubv4.Int

URL githubv4.String

State githubv4.String

}

} `graphql:"closeIssue(input: $input)"`

}{},

CloseIssueInput{

IssueID: "I_kwDOA0xdyM50BPaO",

StateReason: &completedReason,

},

nil,

closeSuccessResponse,

),

))

closeDeps := BaseDeps{

Client: closeClient,

GQLClient: closeGQLClient,

Flags: FeatureFlags{InsidersMode: true},

}

closeHandler := serverTool.Handler(closeDeps)

request := createMCPRequestWithSession(t, ClientNameVSCodeInsiders, true, map[string]any{

"method": "update",

"owner": "owner",

"repo": "repo",

"issue_number": float64(1),

"state": "closed",

"state_reason": "completed",

})