feat: write pr-body.txt to the work root when not pushing (#2395)

Fixes #2389

Author: jskeet

internal/librarian/command.go

@@ -41,6 +41,7 @@ const (
 	generate                = "generate"
 	release                 = "release"
 	defaultAPISourceBranch  = "master"
+	prBodyFile              = "pr-body.txt"
 	failedGenerationComment = `One or more libraries have failed to generate, please review PR description for a list of failed libraries.
 For each failed library, open a ticket in that library’s repository and then you may resolve this comment and merge.
 `
@@ -87,6 +88,7 @@ type commitInfo struct {
 	repo              gitrepo.Repository
 	sourceRepo        gitrepo.Repository
 	state             *config.LibrarianState
+	workRoot          string
 	failedGenerations int
 }
 
@@ -330,6 +332,7 @@ func getDirectoryFilenames(dir string) ([]string, error) {
 func commitAndPush(ctx context.Context, info *commitInfo) error {
 	if !info.push && !info.commit {
 		slog.Info("Push flag and Commit flag are not specified, skipping committing")
+		writePRBody(info)
 		return nil
 	}
 
@@ -387,6 +390,35 @@ func commitAndPush(ctx context.Context, info *commitInfo) error {
 	return addLabelsToPullRequest(ctx, info.ghClient, info.pullRequestLabels, pullRequestMetadata)
 }
 
+// writePRBody attempts to log the body of a PR that would have been created if the
+// -push flag had been specified. This logs any errors (e.g. if the GitHub repo can't be determined)
+// but deliberately does not return them, as a failure here should not interfere with the flow.
+func writePRBody(info *commitInfo) {
+	gitHubRepo, err := GetGitHubRepositoryFromGitRepo(info.repo)
+	if err != nil {
+		slog.Warn("Unable to create PR body; could not determine GitHub repo", "error", err)
+		return
+	}
+
+	prBody, err := createPRBody(info, gitHubRepo)
+	if err != nil {
+		slog.Warn("Unable to create PR body", "error", err)
+		return
+	}
+	// Note: we can't accurately predict whether or not a PR would have been created,
+	// as we're not checking whether the repo is clean or not. The intention is to be
+	// as light-touch as possible.
+	fullPath := filepath.Join(info.workRoot, prBodyFile)
+	// Ensure that "cat [path-to-pr-body.txt]" gives useful output.
+	prBody = prBody + "\n"
+	err = os.WriteFile(fullPath, []byte(prBody), 0644)
+	if err == nil {
+		slog.Info("Wrote body of pull request that might have been created", "file", fullPath)
+	} else {
+		slog.Warn("Unable to save PR body", "error", err)
+	}
+}
+
 // addLabelsToPullRequest adds a list of labels to a single pull request (specified by the id number).
 // Should only be called on a valid Github pull request.
 // Passing in `nil` for labels will no-op and an empty list for labels will clear all labels on the PR.

internal/librarian/command_test.go

@@ -1617,6 +1617,7 @@ func TestCommitAndPush(t *testing.T) {
 				repo:              repo,
 				state:             test.state,
 				failedGenerations: test.failedGenerations,
+				workRoot:          t.TempDir(),
 			}
 
 			err := commitAndPush(context.Background(), commitInfo)
@@ -1638,6 +1639,96 @@ func TestCommitAndPush(t *testing.T) {
 	}
 }
 
+func TestWritePRBody(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		info     *commitInfo
+		wantFile bool
+	}{
+		{
+			name: "success",
+			info: &commitInfo{
+				repo: &MockRepository{
+					Dir: t.TempDir(),
+					RemotesValue: []*gitrepo.Remote{
+						&gitrepo.Remote{
+							Name: "origin",
+							URLs: []string{"https://github.com/googleapis/librarian.git"},
+						},
+					},
+				},
+				prType:   "release",
+				state:    &config.LibrarianState{},
+				workRoot: t.TempDir(),
+			},
+			wantFile: true,
+		},
+		{
+			name: "invalid repo",
+			info: &commitInfo{
+				repo: &MockRepository{
+					Dir: t.TempDir(),
+					RemotesValue: []*gitrepo.Remote{
+						&gitrepo.Remote{
+							Name: "not-origin",
+							URLs: []string{"https://github.com/googleapis/librarian.git"},
+						},
+					},
+				},
+				prType:   "release",
+				workRoot: t.TempDir(),
+			},
+		},
+		{
+			name: "invalid-pr-type",
+			info: &commitInfo{
+				repo: &MockRepository{
+					Dir: t.TempDir(),
+					RemotesValue: []*gitrepo.Remote{
+						&gitrepo.Remote{
+							Name: "origin",
+							URLs: []string{"https://github.com/googleapis/librarian.git"},
+						},
+					},
+				},
+				prType:   "invalid-pr-type",
+				workRoot: t.TempDir(),
+			},
+		},
+		{
+			name: "unable to save file",
+			info: &commitInfo{
+				repo: &MockRepository{
+					Dir:          t.TempDir(),
+					AddAllStatus: make(git.Status),
+					RemotesValue: []*gitrepo.Remote{
+						&gitrepo.Remote{
+							Name: "origin",
+							URLs: []string{"https://github.com/googleapis/librarian.git"},
+						},
+					},
+				},
+				prType:   "release",
+				state:    &config.LibrarianState{},
+				workRoot: filepath.Join(t.TempDir(), "missing-directory"),
+			},
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			writePRBody(test.info)
+			possibleFilePath := filepath.Join(test.info.workRoot, prBodyFile)
+			_, err := os.Stat(possibleFilePath)
+			if err != nil && !os.IsNotExist(err) {
+				t.Fatalf("error other than IsNotExist finding status of %s", possibleFilePath)
+			}
+			gotFile := err == nil
+			if test.wantFile != gotFile {
+				t.Errorf("writePRBody() wantFile = %t, gotFile = %t", test.wantFile, gotFile)
+			}
+		})
+	}
+}
+
 func TestAddLabelsToPullRequest(t *testing.T) {
 	for _, test := range []struct {
 		name                  string

internal/librarian/generate.go

@@ -152,6 +152,7 @@ func (r *generateRunner) run(ctx context.Context) error {
 		repo:              r.repo,
 		sourceRepo:        r.sourceRepo,
 		state:             r.state,
+		workRoot:          r.workRoot,
 		failedGenerations: failedGenerations,
 	}
 

internal/librarian/release_init.go

@@ -105,6 +105,7 @@ func (r *initRunner) run(ctx context.Context) error {
 		repo:              r.repo,
 		sourceRepo:        r.sourceRepo,
 		state:             r.state,
+		workRoot:          r.workRoot,
 	}
 	if err := commitAndPush(ctx, commitInfo); err != nil {
 		return fmt.Errorf("failed to commit and push: %w", err)