-`query`: Search query using GitHub pull request search syntax (string, required)

-`owner`: Repository owner (string, optional)

-`repo`: Repository name (string, optional)

-`sort`: Sort field by number of matches of categories, defaults to best match (string, optional)

- Enum: "comments", "reactions", "reactions-+1", "reactions--1", "reactions-smile", "reactions-thinking_face", "reactions-heart", "reactions-tada", "interactions", "created", "updated"

-`sort`: Sort field (string, optional)

-`order`: Sort order (string, optional)

- Enum: "asc", "desc"

-`page`: Page number (number, optional)

-`perPage`: Results per page (number, optional)

-`owner`: Repository owner (string, required)

-`repo`: Repository name (string, required)

-`pullNumber`: Pull request number (number, required)

-`sort`: Sort field (string, optional)

-`direction`: Sort direction (string, optional)

-`perPage`: Results per page (number, optional)

-`page`: Page number (number, optional)

-**get_pull_request_status** - Get the combined status of all status checks for a pull request

require.Equal(t,3,len(comments),"expected to find three review comments")

}

funcTestListIssues(t*testing.T) {

t.Parallel()

mcpClient:=setupMCPClient(t)

ctx:=context.Background()

getMeRequest:= mcp.CallToolRequest{}

getMeRequest.Params.Name="get_me"

t.Log("Getting current user...")

resp,err:=mcpClient.CallTool(ctx,getMeRequest)

require.NoError(t,err,"expected to call 'get_me' tool successfully")

require.False(t,resp.IsError,fmt.Sprintf("expected result not to be an error: %+v",resp))

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

require.Len(t,resp.Content,1,"expected content to have one item")

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

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

vartrimmedGetMeTextstruct {

}

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

require.NoError(t,err,"expected to unmarshal text content successfully")

currentOwner:=trimmedGetMeText.Login

repoName:=fmt.Sprintf("github-mcp-server-e2e-%s-%d",t.Name(),time.Now().UnixMilli())

createRepoRequest:= mcp.CallToolRequest{}

createRepoRequest.Params.Name="create_repository"

createRepoRequest.Params.Arguments=map[string]any{

"name":repoName,

"private":true,

"autoInit":true,

}

t.Logf("Creating repository %s/%s...",currentOwner,repoName)

resp,err:=mcpClient.CallTool(ctx,createRepoRequest)

require.NoError(t,err,"expected to call 'create_repository' tool successfully")

require.False(t,resp.IsError,fmt.Sprintf("expected result not to be an error: %+v",resp))

t.Cleanup(func() {

ghClient:=getRESTClient(t)

t.Logf("Deleting repository %s/%s...",currentOwner,repoName)

ghClient.Repositories.Delete(context.Background(),currentOwner,repoName)

})

createBranchRequest:= mcp.CallToolRequest{}

createBranchRequest.Params.Name="create_branch"

createBranchRequest.Params.Arguments=map[string]any{

"owner":currentOwner,

"repo":repoName,

"branch":"test-branch",

"from_branch":"main",

}

t.Logf("Creating branch in %s/%s...",currentOwner,repoName)

resp,err=mcpClient.CallTool(ctx,createBranchRequest)

require.NoError(t,err,"expected to call 'create_branch' tool successfully")

require.False(t,resp.IsError,fmt.Sprintf("expected result not to be an error: %+v",resp))

commitRequest:= mcp.CallToolRequest{}

commitRequest.Params.Name="create_or_update_file"

commitRequest.Params.Arguments=map[string]any{

"owner":currentOwner,

"repo":repoName,

"path":"test-file.txt",

"content":fmt.Sprintf("Created by e2e test %s\nwith multiple lines",t.Name()),

"message":"Add test file",

"branch":"test-branch",

}

t.Logf("Creating commit with new file in %s/%s...",currentOwner,repoName)

resp,err=mcpClient.CallTool(ctx,commitRequest)

require.NoError(t,err,"expected to call 'create_or_update_file' tool successfully")

require.False(t,resp.IsError,fmt.Sprintf("expected result not to be an error: %+v",resp))

textContent,ok=resp.Content[0].(mcp.TextContent)

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

vartrimmedCommitTextstruct {

Commitstruct {

}`json:"commit"`

}

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

require.NoError(t,err,"expected to unmarshal text content successfully")

prRequest:= mcp.CallToolRequest{}

prRequest.Params.Name="create_pull_request"

prRequest.Params.Arguments=map[string]any{

"owner":currentOwner,

"repo":repoName,

"title":"Test PR",

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

"head":"test-branch",

"base":"main",

}

t.Logf("Creating pull request in %s/%s...",currentOwner,repoName)

resp,err=mcpClient.CallTool(ctx,prRequest)

require.NoError(t,err,"expected to call 'create_pull_request' tool successfully")

require.False(t,resp.IsError,fmt.Sprintf("expected result not to be an error: %+v",resp))

createPendingPullRequestReviewRequest:= mcp.CallToolRequest{}

createPendingPullRequestReviewRequest.Params.Name="create_pending_pull_request_review"

createPendingPullRequestReviewRequest.Params.Arguments=map[string]any{

"owner":currentOwner,

"repo":repoName,

"pullNumber":1,

}

t.Logf("Creating pending review for pull request in %s/%s...",currentOwner,repoName)

resp,err=mcpClient.CallTool(ctx,createPendingPullRequestReviewRequest)

require.NoError(t,err,"expected to call 'create_pending_pull_request_review' tool successfully")

require.False(t,resp.IsError,fmt.Sprintf("expected result not to be an error: %+v",resp))

textContent,ok=resp.Content[0].(mcp.TextContent)

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

require.Equal(t,"pending pull request created",textContent.Text)

t.Logf("Creating an issue in %s/%s...",currentOwner,repoName)

createIssueRequest:= mcp.CallToolRequest{}

createIssueRequest.Params.Name="create_issue"

createIssueRequest.Params.Arguments=map[string]any{

"owner":currentOwner,

"repo":repoName,

"title":"Test Issue",

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

}

resp,err=mcpClient.CallTool(ctx,createIssueRequest)

require.NoError(t,err,"expected to call 'create_issue' tool successfully")

require.False(t,resp.IsError,fmt.Sprintf("expected result not to be an error: %+v",resp))

listIssuesRequest:= mcp.CallToolRequest{}

listIssuesRequest.Params.Name="list_issues"

listIssuesRequest.Params.Arguments=map[string]any{

"owner":currentOwner,

"repo":repoName,

}

t.Logf("Listing issues in %s/%s...",currentOwner,repoName)

resp,err=mcpClient.CallTool(ctx,listIssuesRequest)

require.NoError(t,err,"expected to call 'list_issues' tool successfully")

require.False(t,resp.IsError,fmt.Sprintf("expected result not to be an error: %+v",resp))

textContent,ok=resp.Content[0].(mcp.TextContent)

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

varissues []struct {

}

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

require.NoError(t,err,"expected to unmarshal text content successfully")

require.Len(t,issues,1,"expected to find one issue")

}

funcTestPullRequestReviewDeletion(t*testing.T) {

t.Parallel()