feat(testing): add e2e test for release init --push (#2228)

- Adds e2e test case for 'release init --push'
- Mocks GitHub API calls for PR creation and labeling
- Updates command.go and release_notes.go to support testability

Part of #1013

Note: improving coverage for new code in command.go requires tests with
much setup. Given the e2e test uses the code, codecov report is ignored.

Author: jinseopkim0

e2e_test.go

@@ -30,8 +30,8 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
-	"github.com/google/go-github/v69/github"
 	"github.com/googleapis/librarian/internal/config"
+	"github.com/googleapis/librarian/internal/github"
 	"gopkg.in/yaml.v3"
 )
 
@@ -180,6 +180,7 @@ func TestCleanAndCopy(t *testing.T) {
 	cmd := exec.Command(
 		"go",
 		"run",
+		"-tags", "e2etest",
 		"github.com/googleapis/librarian/cmd/librarian",
 		"generate",
 		fmt.Sprintf("--api=%s", apiToGenerate),
@@ -406,15 +407,24 @@ func TestReleaseInit(t *testing.T) {
 		updatedState        string
 		wantChangelog       string
 		libraryID           string
+		push                bool
 		wantErr             bool
 	}{
 		{
-			name:                "runs successfully",
+			name:                "runs successfully without push",
 			initialRepoStateDir: "testdata/e2e/release/init/repo_init",
 			updatedState:        "testdata/e2e/release/init/updated-state.yaml",
 			wantChangelog:       "testdata/e2e/release/init/CHANGELOG.md",
 			libraryID:           "go-google-cloud-pubsub-v1",
 		},
+		{
+			name:                "runs successfully with push",
+			initialRepoStateDir: "testdata/e2e/release/init/repo_init",
+			updatedState:        "testdata/e2e/release/init/updated-state.yaml",
+			wantChangelog:       "testdata/e2e/release/init/CHANGELOG.md",
+			libraryID:           "go-google-cloud-pubsub-v1",
+			push:                true, // Enable --push for this case
+		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			workRoot := t.TempDir()
@@ -423,6 +433,17 @@ func TestReleaseInit(t *testing.T) {
 			if err := initRepo(t, repo, test.initialRepoStateDir); err != nil {
 				t.Fatalf("prepare test error = %v", err)
 			}
+
+			if test.push {
+				// Create a local bare repository to act as the remote for the push.
+				bareRepoDir := filepath.Join(t.TempDir(), "remote.git")
+				if err := os.MkdirAll(bareRepoDir, 0755); err != nil {
+					t.Fatalf("Failed to create bare repo dir: %v", err)
+				}
+				runGit(t, bareRepoDir, "init", "--bare")
+				runGit(t, repo, "remote", "set-url", "origin", bareRepoDir)
+			}
+
 			runGit(t, repo, "tag", "go-google-cloud-pubsub-v1-1.0.0")
 			// Add a new commit to simulate a change.
 			newFilePath := filepath.Join(repo, "google-cloud-pubsub/v1", "new-file.txt")
@@ -469,16 +490,58 @@ END_COMMIT_OVERRIDE
 			runGit(t, repo, "commit", "-m", commitMsg)
 			runGit(t, repo, "log", "--oneline", "go-google-cloud-pubsub-v1-1.0.0..HEAD", "--", "google-cloud-pubsub/v1")
 
-			cmd := exec.Command(
-				"go",
+			// Setup mock GitHub server for --push case
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if r.Header.Get("Authorization") != "Bearer fake-token" {
+					t.Errorf("missing or wrong authorization header: got %q", r.Header.Get("Authorization"))
+				}
+
+				// Mock endpoint for POST /repos/{owner}/{repo}/pulls
+				if r.Method == "POST" && strings.HasSuffix(r.URL.Path, "/pulls") {
+					var newPR github.NewPullRequest
+					if err := json.NewDecoder(r.Body).Decode(&newPR); err != nil {
+						t.Fatalf("failed to decode request body: %v", err)
+					}
+					if !strings.Contains(*newPR.Title, "chore: librarian release pull request") {
+						t.Errorf("unexpected PR title: got %q", *newPR.Title)
+					}
+					if *newPR.Base != "main" { // Assuming default branch
+						t.Errorf("unexpected PR base: got %q", *newPR.Base)
+					}
+					w.WriteHeader(http.StatusCreated)
+					fmt.Fprint(w, `{"number": 123, "html_url": "https://github.com/googleapis/librarian/pull/123"}`)
+					return
+				}
+
+				// Mock endpoint for POST /repos/{owner}/{repo}/issues/{number}/labels
+				if r.Method == "POST" && strings.Contains(r.URL.Path, "/issues/123/labels") {
+					w.WriteHeader(http.StatusOK)
+					fmt.Fprint(w, `[]`)
+					return
+				}
+				t.Fatalf("unexpected request: %s %s", r.Method, r.URL.Path)
+			}))
+			defer server.Close()
+
+			cmdArgs := []string{
 				"run",
+				"-tags", "e2etest",
 				"github.com/googleapis/librarian/cmd/librarian",
 				"release",
 				"init",
 				fmt.Sprintf("--repo=%s", repo),
 				fmt.Sprintf("--output=%s", workRoot),
 				fmt.Sprintf("--library=%s", test.libraryID),
-			)
+			}
+			if test.push {
+				cmdArgs = append(cmdArgs, "--push")
+				t.Logf("zle: server.URL: %s", server.URL)
+			}
+
+			cmd := exec.Command("go", cmdArgs...)
+			cmd.Env = os.Environ()
+			cmd.Env = append(cmd.Env, "LIBRARIAN_GITHUB_TOKEN=fake-token")
+			cmd.Env = append(cmd.Env, "LIBRARIAN_GITHUB_BASE_URL="+server.URL)
 			cmd.Stderr = os.Stderr
 			cmd.Stdout = os.Stdout
 			err := cmd.Run()

internal/github/github.go

@@ -22,6 +22,7 @@ import (
 	"io"
 	"log/slog"
 	"net/http"
+	"net/url"
 	"strings"
 
 	"github.com/google/go-github/v69/github"
@@ -31,6 +32,9 @@ import (
 // PullRequest is a type alias for the go-github type.
 type PullRequest = github.PullRequest
 
+// NewPullRequest is a type alias for the go-github type.
+type NewPullRequest = github.NewPullRequest
+
 // RepositoryCommit is a type alias for the go-github type.
 type RepositoryCommit = github.RepositoryCommit
 
@@ -58,6 +62,14 @@ func NewClient(accessToken string, repo *Repository) *Client {
 
 func newClientWithHTTP(accessToken string, repo *Repository, httpClient *http.Client) *Client {
 	client := github.NewClient(httpClient)
+	if repo.BaseURL != "" {
+		baseURL, _ := url.Parse(repo.BaseURL)
+		// Ensure the endpoint URL has a trailing slash.
+		if !strings.HasSuffix(baseURL.Path, "/") {
+			baseURL.Path += "/"
+		}
+		client.BaseURL = baseURL
+	}
 	if accessToken != "" {
 		client = client.WithAuthToken(accessToken)
 	}
@@ -80,6 +92,8 @@ type Repository struct {
 	Owner string
 	// The name of the repository.
 	Name string
+	// Base URL for API requests.
+	BaseURL string
 }
 
 // PullRequestMetadata identifies a pull request within a repository.

internal/librarian/command.go

@@ -127,30 +127,12 @@ func newCommandRunner(cfg *config.Config) (*commandRunner, error) {
 
 	image := deriveImage(cfg.Image, state)
 
-	var gitRepo *github.Repository
-	if isURL(cfg.Repo) {
-		gitRepo, err = github.ParseRemote(cfg.Repo)
-		if err != nil {
-			return nil, fmt.Errorf("failed to parse repo url: %w", err)
-		}
-	} else {
-		gitRepo, err = github.FetchGitHubRepoFromRemote(languageRepo)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get GitHub repo from remote: %w", err)
-		}
-	}
-	ghClient := github.NewClient(cfg.GitHubToken, gitRepo)
-
-	// If a custom GitHub API endpoint is provided (for testing),
-	// parse it and set it as the BaseURL on the GitHub client.
-	if cfg.GitHubAPIEndpoint != "" {
-		endpoint, err := url.Parse(cfg.GitHubAPIEndpoint)
-		if err != nil {
-			return nil, fmt.Errorf("failed to parse github-api-endpoint: %w", err)
-		}
-		ghClient.BaseURL = endpoint
+	gitHubRepo, err := GetGitHubRepository(cfg, languageRepo)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get GitHub repository: %w", err)
 	}
 
+	ghClient := github.NewClient(cfg.GitHubToken, gitHubRepo)
 	container, err := docker.New(cfg.WorkRoot, image, cfg.UserUID, cfg.UserGID)
 	if err != nil {
 		return nil, err
@@ -377,14 +359,13 @@ func commitAndPush(ctx context.Context, info *commitInfo) error {
 		return nil
 	}
 
-	// Ensure we have a GitHub repository
-	gitHubRepo, err := github.FetchGitHubRepoFromRemote(repo)
+	gitHubRepo, err := GetGitHubRepositoryFromGitRepo(info.repo)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get GitHub repository: %w", err)
 	}
 
 	title := fmt.Sprintf("chore: librarian %s pull request: %s", info.prType, datetimeNow)
-	prBody, err := createPRBody(info)
+	prBody, err := createPRBody(info, gitHubRepo)
 	if err != nil {
 		return fmt.Errorf("failed to create pull request body: %w", err)
 	}
@@ -414,12 +395,12 @@ func addLabelsToPullRequest(ctx context.Context, ghClient GitHubClient, pullRequ
 	return nil
 }
 
-func createPRBody(info *commitInfo) (string, error) {
+func createPRBody(info *commitInfo, gitHubRepo *github.Repository) (string, error) {
 	switch info.prType {
 	case generate:
 		return formatGenerationPRBody(info.sourceRepo, info.state, info.idToCommits, info.failedLibraries)
 	case release:
-		return formatReleaseNotes(info.repo, info.state)
+		return formatReleaseNotes(info.state, gitHubRepo)
 	default:
 		return "", fmt.Errorf("unrecognized pull request type: %s", info.prType)
 	}

internal/librarian/command_test.go

@@ -1405,6 +1405,7 @@ func TestCommitAndPush(t *testing.T) {
 			},
 			prType:         "generate",
 			push:           true,
+			state:          &config.LibrarianState{},
 			wantErr:        true,
 			expectedErrMsg: "could not find an 'origin' remote",
 		},

internal/librarian/release_notes.go

@@ -238,18 +238,15 @@ func findLatestGenerationCommit(repo gitrepo.Repository, state *config.Librarian
 }
 
 // formatReleaseNotes generates the body for a release pull request.
-func formatReleaseNotes(repo gitrepo.Repository, state *config.LibrarianState) (string, error) {
+func formatReleaseNotes(state *config.LibrarianState, ghRepo *github.Repository) (string, error) {
 	librarianVersion := cli.Version()
 	var releaseSections []*releaseNoteSection
 	for _, library := range state.Libraries {
 		if !library.ReleaseTriggered {
 			continue
 		}
 
-		section, err := formatLibraryReleaseNotes(repo, library)
-		if err != nil {
-			return "", fmt.Errorf("failed to format release notes for library %s: %w", library.ID, err)
-		}
+		section := formatLibraryReleaseNotes(library, ghRepo)
 		releaseSections = append(releaseSections, section)
 	}
 
@@ -269,12 +266,7 @@ func formatReleaseNotes(repo gitrepo.Repository, state *config.LibrarianState) (
 
 // formatLibraryReleaseNotes generates release notes in Markdown format for a single library.
 // It returns the generated release notes and the new version string.
-func formatLibraryReleaseNotes(repo gitrepo.Repository, library *config.LibraryState) (*releaseNoteSection, error) {
-	ghRepo, err := github.FetchGitHubRepoFromRemote(repo)
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch github repo from remote: %w", err)
-	}
-
+func formatLibraryReleaseNotes(library *config.LibraryState, ghRepo *github.Repository) *releaseNoteSection {
 	// The version should already be updated to the next version.
 	newVersion := library.Version
 	newTag := formatTag(library.TagFormat, library.ID, newVersion)
@@ -309,5 +301,5 @@ func formatLibraryReleaseNotes(repo gitrepo.Repository, library *config.LibraryS
 		CommitSections: sections,
 	}
 
-	return section, nil
+	return section
 }

internal/librarian/release_notes_test.go

@@ -29,6 +29,7 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/googleapis/librarian/internal/cli"
 	"github.com/googleapis/librarian/internal/config"
+	"github.com/googleapis/librarian/internal/github"
 	"github.com/googleapis/librarian/internal/gitrepo"
 )
 
@@ -488,7 +489,7 @@ func TestFormatReleaseNotes(t *testing.T) {
 	for _, test := range []struct {
 		name            string
 		state           *config.LibrarianState
-		repo            gitrepo.Repository
+		ghRepo          *github.Repository
 		wantReleaseNote string
 		wantErr         bool
 		wantErrPhrase   string
@@ -519,9 +520,7 @@ func TestFormatReleaseNotes(t *testing.T) {
 					},
 				},
 			},
-			repo: &MockRepository{
-				RemotesValue: []*git.Remote{git.NewRemote(nil, &gitconfig.RemoteConfig{Name: "origin", URLs: []string{"https://github.com/owner/repo.git"}})},
-			},
+			ghRepo: &github.Repository{Owner: "owner", Name: "repo"},
 			wantReleaseNote: fmt.Sprintf(`Librarian Version: %s
 Language Image: go:1.21
 <details><summary>my-library: 1.1.0</summary>
@@ -571,9 +570,7 @@ Language Image: go:1.21
 					},
 				},
 			},
-			repo: &MockRepository{
-				RemotesValue: []*git.Remote{git.NewRemote(nil, &gitconfig.RemoteConfig{Name: "origin", URLs: []string{"https://github.com/owner/repo.git"}})},
-			},
+			ghRepo: &github.Repository{Owner: "owner", Name: "repo"},
 			wantReleaseNote: fmt.Sprintf(`Librarian Version: %s
 Language Image: go:1.21
 <details><summary>my-library: 1.1.0</summary>
@@ -617,9 +614,7 @@ Language Image: go:1.21
 					},
 				},
 			},
-			repo: &MockRepository{
-				RemotesValue: []*git.Remote{git.NewRemote(nil, &gitconfig.RemoteConfig{Name: "origin", URLs: []string{"https://github.com/owner/repo.git"}})},
-			},
+			ghRepo: &github.Repository{Owner: "owner", Name: "repo"},
 			wantReleaseNote: fmt.Sprintf(`Librarian Version: %s
 Language Image: go:1.21
 <details><summary>my-library: 1.1.0</summary>
@@ -670,9 +665,7 @@ Language Image: go:1.21
 					},
 				},
 			},
-			repo: &MockRepository{
-				RemotesValue: []*git.Remote{git.NewRemote(nil, &gitconfig.RemoteConfig{Name: "origin", URLs: []string{"https://github.com/owner/repo.git"}})},
-			},
+			ghRepo: &github.Repository{Owner: "owner", Name: "repo"},
 			wantReleaseNote: fmt.Sprintf(`Librarian Version: %s
 Language Image: go:1.21
 <details><summary>lib-a: 1.1.0</summary>
@@ -723,9 +716,7 @@ Language Image: go:1.21
 					},
 				},
 			},
-			repo: &MockRepository{
-				RemotesValue: []*git.Remote{git.NewRemote(nil, &gitconfig.RemoteConfig{Name: "origin", URLs: []string{"https://github.com/owner/repo.git"}})},
-			},
+			ghRepo: &github.Repository{Owner: "owner", Name: "repo"},
 			wantReleaseNote: fmt.Sprintf(`Librarian Version: %s
 Language Image: go:1.21
 <details><summary>my-library: 1.1.0</summary>
@@ -745,31 +736,13 @@ Language Image: go:1.21
 				Image:     "go:1.21",
 				Libraries: []*config.LibraryState{},
 			},
-			repo:            &MockRepository{},
+			ghRepo:          &github.Repository{},
 			wantReleaseNote: fmt.Sprintf("Librarian Version: %s\nLanguage Image: go:1.21", librarianVersion),
 		},
-		{
-			name: "error getting commits",
-			state: &config.LibrarianState{
-				Image: "go:1.21",
-				Libraries: []*config.LibraryState{
-					{
-						ID:               "my-library",
-						Version:          "1.0.0",
-						ReleaseTriggered: true,
-					},
-				},
-			},
-			repo: &MockRepository{
-				RemotesError: errors.New("no remote repo"),
-			},
-			wantErr:       true,
-			wantErrPhrase: "failed to format release notes",
-		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			t.Parallel()
-			got, err := formatReleaseNotes(test.repo, test.state)
+			got, err := formatReleaseNotes(test.state, test.ghRepo)
 			if test.wantErr {
 				if err == nil {
 					t.Fatalf("%s should return error", test.name)