Initial version of find_closing_pull_requests

Author: lumaxis

e2e/e2e_test.go

@@ -21,6 +21,7 @@ import (
 	gogithub "github.com/google/go-github/v73/github"
 	mcpClient "github.com/mark3labs/mcp-go/client"
 	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -1624,3 +1625,155 @@ func TestPullRequestReviewDeletion(t *testing.T) {
 	require.NoError(t, err, "expected to unmarshal text content successfully")
 	require.Len(t, noReviews, 0, "expected to find no reviews")
 }
+
+func TestFindClosingPullRequests(t *testing.T) {
+	t.Parallel()
+
+	mcpClient := setupMCPClient(t, withToolsets([]string{"issues"}))
+
+	ctx := context.Background()
+
+	// Test with well-known GitHub repositories and issues
+	testCases := []struct {
+		name                    string
+		issues                  []interface{}
+		limit                   int
+		expectError             bool
+		expectedResults         int
+		expectSomeWithClosingPR bool
+	}{
+		{
+			name:            "Single issue test - should handle gracefully even if no closing PRs",
+			issues:          []interface{}{"octocat/Hello-World#1"},
+			limit:           5,
+			expectError:     false,
+			expectedResults: 1,
+		},
+		{
+			name:            "Multiple issues test",
+			issues:          []interface{}{"octocat/Hello-World#1", "github/docs#1"},
+			limit:           3,
+			expectError:     false,
+			expectedResults: 2,
+		},
+		{
+			name:        "Invalid issue format should return error",
+			issues:      []interface{}{"invalid-format"},
+			expectError: true,
+		},
+		{
+			name:        "Empty issues array should return error",
+			issues:      []interface{}{},
+			expectError: true,
+		},
+		{
+			name:        "Limit too high should return error",
+			issues:      []interface{}{"octocat/Hello-World#1"},
+			limit:       150,
+			expectError: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Prepare the request
+			findClosingPRsRequest := mcp.CallToolRequest{}
+			findClosingPRsRequest.Params.Name = "find_closing_pull_requests"
+
+			// Build arguments map
+			args := map[string]any{
+				"issues": tc.issues,
+			}
+			if tc.limit > 0 {
+				args["limit"] = tc.limit
+			}
+			findClosingPRsRequest.Params.Arguments = args
+
+			t.Logf("Calling find_closing_pull_requests with issues: %v", tc.issues)
+			resp, err := mcpClient.CallTool(ctx, findClosingPRsRequest)
+
+			if tc.expectError {
+				// We expect either an error or an error response
+				if err != nil {
+					t.Logf("Expected error occurred: %v", err)
+					return
+				}
+				require.True(t, resp.IsError, "Expected error response")
+				t.Logf("Expected error in response: %+v", resp)
+				return
+			}
+
+			require.NoError(t, err, "expected to call 'find_closing_pull_requests' tool successfully")
+			require.False(t, resp.IsError, fmt.Sprintf("expected result not to be an error: %+v", resp))
+
+			// Verify we got content
+			require.NotEmpty(t, resp.Content, "Expected response content")
+
+			textContent, ok := resp.Content[0].(mcp.TextContent)
+			require.True(t, ok, "expected content to be of type TextContent")
+
+			t.Logf("Response: %s", textContent.Text)
+
+			// Parse the JSON response
+			var response struct {
+				Results []struct {
+					Issue               string `json:"issue"`
+					Owner               string `json:"owner"`
+					Repo                string `json:"repo"`
+					IssueNumber         int    `json:"issueNumber"`
+					ClosingPullRequests []struct {
+						Number int    `json:"number"`
+						Title  string `json:"title"`
+						Body   string `json:"body"`
+						State  string `json:"state"`
+						URL    string `json:"url"`
+						Merged bool   `json:"merged"`
+					} `json:"closingPullRequests"`
+					TotalCount int    `json:"totalCount"`
+					Error      string `json:"error,omitempty"`
+				} `json:"results"`
+			}
+
+			err = json.Unmarshal([]byte(textContent.Text), &response)
+			require.NoError(t, err, "expected to unmarshal response successfully")
+
+			// Verify the response structure
+			require.Len(t, response.Results, tc.expectedResults, "Expected specific number of results")
+
+			// Log and verify each result
+			for i, result := range response.Results {
+				t.Logf("Result %d:", i+1)
+				t.Logf("  Issue: %s", result.Issue)
+				t.Logf("  Owner: %s, Repo: %s, Number: %d", result.Owner, result.Repo, result.IssueNumber)
+				t.Logf("  Total closing PRs: %d", result.TotalCount)
+				if result.Error != "" {
+					t.Logf("  Error: %s", result.Error)
+				}
+
+				// Verify basic structure
+				assert.NotEmpty(t, result.Issue, "Issue reference should not be empty")
+				assert.NotEmpty(t, result.Owner, "Owner should not be empty")
+				assert.NotEmpty(t, result.Repo, "Repo should not be empty")
+				assert.Greater(t, result.IssueNumber, 0, "Issue number should be positive")
+
+				// Log details of any closing PRs found
+				for j, pr := range result.ClosingPullRequests {
+					t.Logf("    Closing PR %d:", j+1)
+					t.Logf("      Number: %d", pr.Number)
+					t.Logf("      Title: %s", pr.Title)
+					t.Logf("      State: %s, Merged: %t", pr.State, pr.Merged)
+					t.Logf("      URL: %s", pr.URL)
+
+					// Verify PR structure
+					assert.Greater(t, pr.Number, 0, "PR number should be positive")
+					assert.NotEmpty(t, pr.Title, "PR title should not be empty")
+					assert.NotEmpty(t, pr.State, "PR state should not be empty")
+					assert.NotEmpty(t, pr.URL, "PR URL should not be empty")
+				}
+
+				// The actual count of closing PRs should match the returned array length
+				assert.Equal(t, len(result.ClosingPullRequests), result.TotalCount, "ClosingPullRequests length should match TotalCount")
+			}
+		})
+	}
+}

pkg/github/find_closing_prs_integration_test.go

@@ -0,0 +1,164 @@
+//go:build e2e
+
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"testing"
+
+	"github.com/github/github-mcp-server/pkg/translations"
+	"github.com/google/go-github/v73/github"
+	"github.com/shurcooL/githubv4"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestFindClosingPullRequestsIntegration tests the FindClosingPullRequests tool with real GitHub API calls
+func TestFindClosingPullRequestsIntegration(t *testing.T) {
+	// This test requires a GitHub token
+	token := os.Getenv("GITHUB_MCP_SERVER_E2E_TOKEN")
+	if token == "" {
+		t.Skip("GITHUB_MCP_SERVER_E2E_TOKEN environment variable is not set")
+	}
+
+	// Create GitHub clients
+	httpClient := github.NewClient(nil).WithAuthToken(token).Client()
+	gqlClient := githubv4.NewClient(httpClient)
+
+	getGQLClient := func(ctx context.Context) (*githubv4.Client, error) {
+		return gqlClient, nil
+	}
+
+	// Create the tool
+	tool, handler := FindClosingPullRequests(getGQLClient, translations.NullTranslationHelper)
+
+	// Test cases with known GitHub issues that were closed by PRs
+	testCases := []struct {
+		name                   string
+		issues                 []string
+		expectedResults        int
+		expectSomeClosingPRs   bool
+		expectSpecificIssue    string
+		expectSpecificPRNumber int
+	}{
+		{
+			name:                 "Single issue - VS Code well-known closed issue",
+			issues:               []string{"microsoft/vscode#123456"}, // This is a made-up issue for testing
+			expectedResults:      1,
+			expectSomeClosingPRs: false, // We expect this to not exist or have no closing PRs
+		},
+		{
+			name:                 "Multiple issues with mixed results",
+			issues:               []string{"octocat/Hello-World#1", "microsoft/vscode#999999"},
+			expectedResults:      2,
+			expectSomeClosingPRs: false, // These are likely non-existent or have no closing PRs
+		},
+		{
+			name:            "Issue from a popular repo - React",
+			issues:          []string{"facebook/react#1"}, // Very first issue in React repo
+			expectedResults: 1,
+		},
+	}
+
+	ctx := context.Background()
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Create request arguments
+			args := map[string]interface{}{
+				"issues": tc.issues,
+				"limit":  5,
+			}
+
+			// Create mock request
+			request := mockCallToolRequest{
+				arguments: args,
+			}
+
+			// Call the handler
+			result, err := handler(ctx, request)
+
+			if err != nil {
+				t.Logf("Error calling tool: %v", err)
+				// For integration tests, we might expect some errors for non-existent issues
+				// Let's check if it's a reasonable error
+				assert.Contains(t, err.Error(), "failed to")
+				return
+			}
+
+			require.NotNil(t, result)
+			assert.False(t, result.IsError, "Expected successful result")
+
+			// Parse the response
+			textContent, ok := result.Content[0].(map[string]interface{})
+			if !ok {
+				// Try to get as text content
+				if len(result.Content) > 0 {
+					if textResult, ok := result.Content[0].(string); ok {
+						t.Logf("Response: %s", textResult)
+
+						// Parse JSON response
+						var response struct {
+							Results []FindClosingPRsResult `json:"results"`
+						}
+						err := json.Unmarshal([]byte(textResult), &response)
+						require.NoError(t, err, "Failed to parse JSON response")
+
+						// Verify structure
+						assert.Len(t, response.Results, tc.expectedResults, "Expected specific number of results")
+
+						for i, result := range response.Results {
+							t.Logf("Issue %d: %s", i+1, result.Issue)
+							t.Logf("  Owner: %s, Repo: %s, Number: %d", result.Owner, result.Repo, result.IssueNumber)
+							t.Logf("  Total closing PRs: %d", result.TotalCount)
+							t.Logf("  Error: %s", result.Error)
+
+							// Verify basic structure
+							assert.NotEmpty(t, result.Issue, "Issue reference should not be empty")
+							assert.NotEmpty(t, result.Owner, "Owner should not be empty")
+							assert.NotEmpty(t, result.Repo, "Repo should not be empty")
+							assert.Greater(t, result.IssueNumber, 0, "Issue number should be positive")
+
+							// Log closing PRs if any
+							for j, pr := range result.ClosingPullRequests {
+								t.Logf("    PR %d: #%d - %s", j+1, pr.Number, pr.Title)
+								t.Logf("      State: %s, Merged: %t", pr.State, pr.Merged)
+								t.Logf("      URL: %s", pr.URL)
+							}
+
+							// Check for expected specific results
+							if tc.expectSpecificIssue != "" && result.Issue == tc.expectSpecificIssue {
+								if tc.expectSpecificPRNumber > 0 {
+									found := false
+									for _, pr := range result.ClosingPullRequests {
+										if pr.Number == tc.expectSpecificPRNumber {
+											found = true
+											break
+										}
+									}
+									assert.True(t, found, "Expected to find specific PR number")
+								}
+							}
+						}
+
+						return
+					}
+				}
+				t.Fatalf("Unexpected content type: %T", result.Content[0])
+			}
+
+			t.Logf("Response content: %+v", textContent)
+		})
+	}
+}
+
+// mockCallToolRequest implements the mcp.CallToolRequest interface for testing
+type mockCallToolRequest struct {
+	arguments map[string]interface{}
+}
+
+func (m mockCallToolRequest) GetArguments() map[string]interface{} {
+	return m.arguments
+}