feat: publish-release automation only triggers CloudBuild if a repository contains a merged pull request with label release:pending (#1789)

fix: #1786

---------

Co-authored-by: Min Zhu <[email protected]>

Author: catchyzheng

internal/automation/trigger.go

@@ -20,10 +20,12 @@ import (
 	"fmt"
 	"iter"
 	"log/slog"
+	"os"
 
 	cloudbuild "cloud.google.com/go/cloudbuild/apiv1/v2"
 	"cloud.google.com/go/cloudbuild/apiv1/v2/cloudbuildpb"
 	"github.com/googleapis/gax-go/v2"
+	"github.com/googleapis/librarian/internal/github"
 )
 
 var triggerNameByCommandName = map[string]string{
@@ -34,6 +36,11 @@ var triggerNameByCommandName = map[string]string{
 
 const region = "global"
 
+// GitHubClient handles communication with the GitHub API.
+type GitHubClient interface {
+	FindMergedPullRequestsWithPendingReleaseLabel(ctx context.Context, owner, repo string) ([]*github.PullRequest, error)
+}
+
 type wrappedCloudBuildClient struct {
 	client *cloudbuild.Client
 }
@@ -64,10 +71,14 @@ func RunCommand(ctx context.Context, command string, projectId string, push bool
 	wrappedClient := &wrappedCloudBuildClient{
 		client: c,
 	}
-	return runCommandWithClient(ctx, wrappedClient, command, projectId, push)
+	ghClient, err := github.NewClient(os.Getenv("LIBRARIAN_GITHUB_TOKEN"), &github.Repository{})
+	if err != nil {
+		return fmt.Errorf("error creating github client: %w", err)
+	}
+	return runCommandWithClient(ctx, wrappedClient, ghClient, command, projectId, push)
 }
 
-func runCommandWithClient(ctx context.Context, client CloudBuildClient, command string, projectId string, push bool) error {
+func runCommandWithClient(ctx context.Context, client CloudBuildClient, ghClient GitHubClient, command string, projectId string, push bool) error {
 	// validate command is allowed
 	triggerName := triggerNameByCommandName[command]
 	if triggerName == "" {
@@ -91,6 +102,18 @@ func runCommandWithClient(ctx context.Context, client CloudBuildClient, command
 			"_GITHUB_TOKEN_SECRET_NAME": repository.SecretName,
 			"_PUSH":                     fmt.Sprintf("%v", push),
 		}
+		if command == "publish-release" {
+			prs, err := ghClient.FindMergedPullRequestsWithPendingReleaseLabel(ctx, "googleapis", repository.Name)
+			if err != nil {
+				slog.Error("Error finding merged pull requests for publish-release", slog.Any("err", err), slog.String("repository", repository.Name))
+				errs = append(errs, err)
+				continue
+			}
+			if len(prs) == 0 {
+				slog.Info("No pull requests with label 'release:pending' found. Skipping 'publish-release' trigger.", slog.String("repository", repository.Name))
+				continue
+			}
+		}
 		err = runCloudBuildTriggerByName(ctx, client, projectId, region, triggerName, substitutions)
 		if err != nil {
 			slog.Error("Error triggering cloudbuild", slog.Any("err", err))

internal/automation/trigger_test.go

@@ -20,8 +20,18 @@ import (
 	"testing"
 
 	"cloud.google.com/go/cloudbuild/apiv1/v2/cloudbuildpb"
+	"github.com/google/go-github/v69/github"
 )
 
+type mockGitHubClient struct {
+	prs []*github.PullRequest
+	err error
+}
+
+func (m *mockGitHubClient) FindMergedPullRequestsWithPendingReleaseLabel(ctx context.Context, owner, repo string) ([]*github.PullRequest, error) {
+	return m.prs, m.err
+}
+
 func TestRunCommandWithClient(t *testing.T) {
 	for _, test := range []struct {
 		name          string
@@ -31,6 +41,8 @@ func TestRunCommandWithClient(t *testing.T) {
 		runError      error
 		wantErr       bool
 		buildTriggers []*cloudbuildpb.BuildTrigger
+		ghPRs         []*github.PullRequest
+		ghError       error
 	}{
 		{
 			name:    "runs generate trigger",
@@ -97,14 +109,57 @@ func TestRunCommandWithClient(t *testing.T) {
 				},
 			},
 		},
+		{
+			name:    "runs publish-release trigger",
+			command: "publish-release",
+			push:    true,
+			wantErr: false,
+			buildTriggers: []*cloudbuildpb.BuildTrigger{
+				{
+					Name: "publish-release",
+					Id:   "publish-release-trigger-id",
+				},
+			},
+			ghPRs: []*github.PullRequest{{}},
+		},
+		{
+			name:    "skips publish-release with no PRs",
+			command: "publish-release",
+			push:    true,
+			wantErr: false,
+			buildTriggers: []*cloudbuildpb.BuildTrigger{
+				{
+					Name: "publish-release",
+					Id:   "publish-release-trigger-id",
+				},
+			},
+			ghPRs: []*github.PullRequest{},
+		},
+		{
+			name:    "error finding PRs for publish-release",
+			command: "publish-release",
+			push:    true,
+			wantErr: true,
+			buildTriggers: []*cloudbuildpb.BuildTrigger{
+				{
+					Name: "publish-release",
+					Id:   "publish-release-trigger-id",
+				},
+			},
+			ghError: fmt.Errorf("github error"),
+		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			ctx := context.Background()
 			client := &mockCloudBuildClient{
 				runError:      test.runError,
 				buildTriggers: test.buildTriggers,
 			}
-			err := runCommandWithClient(ctx, client, test.command, "some-project", test.push)
+			ghClient := &mockGitHubClient{
+				prs: test.ghPRs,
+				err: test.ghError,
+			}
+			err := runCommandWithClient(ctx, client, ghClient, test.command, "some-project", test.push)
 			if test.wantErr && err == nil {
 				t.Errorf("expected error, but did not return one")
 			} else if !test.wantErr && err != nil {

internal/github/github.go

@@ -244,3 +244,40 @@ func (c *Client) CreateIssueComment(ctx context.Context, number int, comment str
 	})
 	return err
 }
+
+// hasLabel checks if a pull request has a given label.
+func hasLabel(pr *PullRequest, labelName string) bool {
+	for _, l := range pr.Labels {
+		if l.GetName() == labelName {
+			return true
+		}
+	}
+	return false
+}
+
+// FindMergedPullRequestsWithPendingReleaseLabel finds all merged pull requests with the "release:pending" label.
+func (c *Client) FindMergedPullRequestsWithPendingReleaseLabel(ctx context.Context, owner, repo string) ([]*PullRequest, error) {
+	var allPRs []*PullRequest
+	opt := &github.PullRequestListOptions{
+		State: "closed",
+		ListOptions: github.ListOptions{
+			PerPage: 100,
+		},
+	}
+	for {
+		prs, resp, err := c.PullRequests.List(ctx, owner, repo, opt)
+		if err != nil {
+			return nil, err
+		}
+		for _, pr := range prs {
+			if pr.GetMerged() && hasLabel(pr, "release:pending") {
+				allPRs = append(allPRs, pr)
+			}
+		}
+		if resp.NextPage == 0 {
+			break
+		}
+		opt.Page = resp.NextPage
+	}
+	return allPRs, nil
+}

internal/github/github_test.go

@@ -934,3 +934,72 @@ func TestCreateIssueComment(t *testing.T) {
 		})
 	}
 }
+
+func TestFindMergedPullRequestsWithPendingReleaseLabel(t *testing.T) {
+	t.Parallel()
+	for _, test := range []struct {
+		name          string
+		handler       http.HandlerFunc
+		wantPRs       []*PullRequest
+		wantErr       bool
+		wantErrSubstr string
+	}{
+		{
+			name: "Success with single page",
+			handler: func(w http.ResponseWriter, r *http.Request) {
+				if r.URL.Query().Get("state") != "closed" {
+					t.Errorf("unexpected state: got %q", r.URL.Query().Get("state"))
+				}
+				pr1 := github.PullRequest{Number: github.Ptr(1), Labels: []*github.Label{{Name: github.Ptr("release:pending")}}}
+				pr2 := github.PullRequest{Number: github.Ptr(2), Labels: []*github.Label{{Name: github.Ptr("other-label")}}}
+				pr3 := github.PullRequest{Number: github.Ptr(4), Merged: github.Ptr(true), Labels: []*github.Label{{Name: github.Ptr("release:pending")}}}
+				prs := []*github.PullRequest{&pr1, &pr2, &pr3}
+				b, err := json.Marshal(prs)
+				if err != nil {
+					t.Fatalf("json.Marshal() failed: %v", err)
+				}
+				fmt.Fprint(w, string(b))
+			},
+			wantPRs: []*PullRequest{
+				{Number: github.Ptr(4), Merged: github.Ptr(true), Labels: []*github.Label{{Name: github.Ptr("release:pending")}}},
+			},
+		},
+		{
+			name: "API error",
+			handler: func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusInternalServerError)
+			},
+			wantErr:       true,
+			wantErrSubstr: "500",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			server := httptest.NewServer(test.handler)
+			defer server.Close()
+
+			repo := &Repository{Owner: "owner", Name: "repo"}
+			client, err := newClientWithHTTP("fake-token", repo, server.Client())
+			if err != nil {
+				t.Fatalf("newClientWithHTTP() error = %v", err)
+			}
+			client.BaseURL, _ = url.Parse(server.URL + "/")
+
+			prs, err := client.FindMergedPullRequestsWithPendingReleaseLabel(context.Background(), "owner", "repo")
+
+			if test.wantErr {
+				if err == nil {
+					t.Errorf("FindMergedPullRequestsWithPendingReleaseLabel() err = nil, want error containing %q", test.wantErrSubstr)
+				} else if !strings.Contains(err.Error(), test.wantErrSubstr) {
+					t.Errorf("FindMergedPullRequestsWithPendingReleaseLabel() err = %v, want error containing %q", err, test.wantErrSubstr)
+				}
+			} else if err != nil {
+				t.Errorf("FindMergedPullRequestsWithPendingReleaseLabel() err = %v, want nil", err)
+			}
+
+			if diff := cmp.Diff(test.wantPRs, prs); diff != "" {
+				t.Errorf("FindMergedPullRequestsWithPendingReleaseLabel() prs mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}