STACKITGit/cli
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #8953 from babakks/8426-add-pr-update-cmd-no-local-update

Browse source 
Add `pr update-branch` command
This commit is contained in:
William Martin 2024-07-17 20:03:29 +02:00 • committed by GitHub
commit d3d73d9390
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
7 changed files with 669 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

63
api/queries_pr.go
View file

@ -16,6 +16,14 @@ type PullRequestAndTotalCount struct {
SearchCapped bool
}
type PullRequestMergeable string
const (
PullRequestMergeableConflicting PullRequestMergeable = "CONFLICTING"
PullRequestMergeableMergeable PullRequestMergeable = "MERGEABLE"
PullRequestMergeableUnknown PullRequestMergeable = "UNKNOWN"
)
type PullRequest struct {
ID string
Number int
@ -27,7 +35,7 @@ type PullRequest struct {
HeadRefName string
HeadRefOid string
Body string
Mergeable string
Mergeable PullRequestMergeable
Additions int
Deletions int
ChangedFiles int
@ -607,6 +615,18 @@ func UpdatePullRequestReviews(client *Client, repo ghrepo.Interface, params gith
return err
}
func UpdatePullRequestBranch(client *Client, repo ghrepo.Interface, params githubv4.UpdatePullRequestBranchInput) error {
var mutation struct {
UpdatePullRequestBranch struct {
PullRequest struct {
ID string
}
} `graphql:"updatePullRequestBranch(input: $input)"`
}
variables := map[string]interface{}{"input": params}
return client.Mutate(repo.RepoHost(), "PullRequestUpdateBranch", &mutation, variables)
}
func isBlank(v interface{}) bool {
switch vv := v.(type) {
case string:
@ -696,3 +716,44 @@ func BranchDeleteRemote(client *Client, repo ghrepo.Interface, branch string) er
path := fmt.Sprintf("repos/%s/%s/git/refs/heads/%s", repo.RepoOwner(), repo.RepoName(), url.PathEscape(branch))
return client.REST(repo.RepoHost(), "DELETE", path, nil, nil)
}
type RefComparison struct {
AheadBy int
BehindBy int
Status string
}
func ComparePullRequestBaseBranchWith(client *Client, repo ghrepo.Interface, prNumber int, headRef string) (*RefComparison, error) {
query := `query ComparePullRequestBaseBranchWith($owner: String!, $repo: String!, $pullRequestNumber: Int!, $headRef: String!) {
repository(owner: $owner, name: $repo) {
pullRequest(number: $pullRequestNumber) {
baseRef {
compare (headRef: $headRef) {
aheadBy, behindBy, status
}
}
}
}
}`
var result struct {
Repository struct {
PullRequest struct {
BaseRef struct {
Compare RefComparison
}
}
}
}
variables := map[string]interface{}{
"owner": repo.RepoOwner(),
"repo": repo.RepoName(),
"pullRequestNumber": prNumber,
"headRef": headRef,
}
if err := client.GraphQL(repo.RepoHost(), query, variables, &result); err != nil {
return nil, err
}
return &result.Repository.PullRequest.BaseRef.Compare, nil
}

2
go.mod
View file

@ -36,7 +36,7 @@ require (
github.com/muhammadmuzzammil1998/jsonc v0.0.0-20201229145248-615b0916ca38
github.com/opentracing/opentracing-go v1.2.0
github.com/rivo/tview v0.0.0-20221029100920-c4a7e501810d
github.com/shurcooL/githubv4 v0.0.0-20230704064427-599ae7bbf278
github.com/shurcooL/githubv4 v0.0.0-20240120211514-18a1ae0e79dc
github.com/sigstore/protobuf-specs v0.3.2
github.com/sigstore/sigstore-go v0.3.0
github.com/spf13/cobra v1.8.1

4
go.sum
View file

@ -378,8 +378,8 @@ github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
github.com/shibumi/go-pathspec v1.3.0 h1:QUyMZhFo0Md5B8zV8x2tesohbb5kfbpTi9rBnKh5dkI=
github.com/shibumi/go-pathspec v1.3.0/go.mod h1:Xutfslp817l2I1cZvgcfeMQJG5QnU2lh5tVaaMCl3jE=
github.com/shurcooL/githubv4 v0.0.0-20230704064427-599ae7bbf278 h1:kdEGVAV4sO46DPtb8k793jiecUEhaX9ixoIBt41HEGU=
github.com/shurcooL/githubv4 v0.0.0-20230704064427-599ae7bbf278/go.mod h1:zqMwyHmnN/eDOZOdiTohqIUKUrTFX62PNlu7IJdu0q8=
github.com/shurcooL/githubv4 v0.0.0-20240120211514-18a1ae0e79dc h1:vH0NQbIDk+mJLvBliNGfcQgUmhlniWBDXC79oRxfZA0=
github.com/shurcooL/githubv4 v0.0.0-20240120211514-18a1ae0e79dc/go.mod h1:zqMwyHmnN/eDOZOdiTohqIUKUrTFX62PNlu7IJdu0q8=
github.com/shurcooL/graphql v0.0.0-20230722043721-ed46e5a46466 h1:17JxqqJY66GmZVHkmAsGEkcIu0oCe3AM420QDgGwZx0=
github.com/shurcooL/graphql v0.0.0-20230722043721-ed46e5a46466/go.mod h1:9dIRpgIY7hVhoqfe0/FcYp0bpInZaT7dc3BYOprrIUE=
github.com/sigstore/protobuf-specs v0.3.2 h1:nCVARCN+fHjlNCk3ThNXwrZRqIommIeNKWwQvORuRQo=

2
pkg/cmd/pr/pr.go
View file

@ -16,6 +16,7 @@ import (
cmdReopen "github.com/cli/cli/v2/pkg/cmd/pr/reopen"
cmdReview "github.com/cli/cli/v2/pkg/cmd/pr/review"
cmdStatus "github.com/cli/cli/v2/pkg/cmd/pr/status"
cmdUpdateBranch "github.com/cli/cli/v2/pkg/cmd/pr/update-branch"
cmdView "github.com/cli/cli/v2/pkg/cmd/pr/view"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/spf13/cobra"
@ -57,6 +58,7 @@ func NewCmdPR(f *cmdutil.Factory) *cobra.Command {
cmdChecks.NewCmdChecks(f, nil),
cmdReview.NewCmdReview(f, nil),
cmdMerge.NewCmdMerge(f, nil),
cmdUpdateBranch.NewCmdUpdateBranch(f, nil),
cmdReady.NewCmdReady(f, nil),
cmdComment.NewCmdComment(f, nil),
cmdClose.NewCmdClose(f, nil),

6
pkg/cmd/pr/status/status.go
View file

@ -276,14 +276,14 @@ func printPrs(io *iostreams.IOStreams, totalCount int, prs ...api.PullRequest) {
fmt.Fprint(w, cs.Green(fmt.Sprintf("✓ %s Approved", s)))
}
if pr.Mergeable == "MERGEABLE" {
if pr.Mergeable == api.PullRequestMergeableMergeable {
// prefer "No merge conflicts" to "Mergeable" as there is more to mergeability
// than the git status. Missing or failing required checks prevent merging
// even though a PR is technically mergeable, which is often a source of confusion.
fmt.Fprintf(w, " %s", cs.Green("✓ No merge conflicts"))
} else if pr.Mergeable == "CONFLICTING" {
} else if pr.Mergeable == api.PullRequestMergeableConflicting {
fmt.Fprintf(w, " %s", cs.Red("× Merge conflicts"))
} else if pr.Mergeable == "UNKNOWN" {
} else if pr.Mergeable == api.PullRequestMergeableUnknown {
fmt.Fprintf(w, " %s", cs.Yellow("! Merge conflict status unknown"))
}

153
pkg/cmd/pr/update-branch/update_branch.go Normal file
View file

@ -0,0 +1,153 @@
package update_branch
import (
"fmt"
"net/http"
"strings"
"github.com/MakeNowJust/heredoc"
"github.com/cli/cli/v2/api"
"github.com/cli/cli/v2/git"
"github.com/cli/cli/v2/internal/ghrepo"
shared "github.com/cli/cli/v2/pkg/cmd/pr/shared"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/shurcooL/githubv4"
"github.com/spf13/cobra"
)
type UpdateBranchOptions struct {
HttpClient func() (*http.Client, error)
IO *iostreams.IOStreams
GitClient *git.Client
Finder shared.PRFinder
SelectorArg string
Rebase bool
}
func NewCmdUpdateBranch(f *cmdutil.Factory, runF func(*UpdateBranchOptions) error) *cobra.Command {
opts := &UpdateBranchOptions{
IO: f.IOStreams,
HttpClient: f.HttpClient,
GitClient: f.GitClient,
}
cmd := &cobra.Command{
Use: "update-branch [<number> | <url> | <branch>]",
Short: "Update a pull request branch",
Long: heredoc.Docf(`
Update a pull request branch with latest changes of the base branch.
Without an argument, the pull request that belongs to the current branch is selected.
The default behavior is to update with a merge commit (i.e., merging the base branch
into the the PR's branch). To reconcile the changes with rebasing on top of the base
branch, the %[1]s--rebase%[1]s option should be provided.
`, "`"),
Example: heredoc.Doc(`
$ gh pr update-branch 23
$ gh pr update-branch 23 --rebase
$ gh pr update-branch 23 --repo owner/repo
`),
Args: cobra.MaximumNArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
opts.Finder = shared.NewFinder(f)
if repoOverride, _ := cmd.Flags().GetString("repo"); repoOverride != "" && len(args) == 0 {
return cmdutil.FlagErrorf("argument required when using the --repo flag")
}
if len(args) > 0 {
opts.SelectorArg = args[0]
}
if runF != nil {
return runF(opts)
}
return updateBranchRun(opts)
},
}
cmd.Flags().BoolVar(&opts.Rebase, "rebase", false, "Update PR branch by rebasing on top of latest base branch")
return cmd
}
func updateBranchRun(opts *UpdateBranchOptions) error {
findOptions := shared.FindOptions{
Selector: opts.SelectorArg,
Fields: []string{"id", "number", "headRefName", "headRefOid", "headRepositoryOwner", "mergeable"},
}
pr, repo, err := opts.Finder.Find(findOptions)
if err != nil {
return err
}
cs := opts.IO.ColorScheme()
if pr.Mergeable == api.PullRequestMergeableConflicting {
fmt.Fprintf(opts.IO.ErrOut, "%s Cannot update PR branch due to conflicts\n", cs.FailureIcon())
return cmdutil.SilentError
}
httpClient, err := opts.HttpClient()
if err != nil {
return err
}
apiClient := api.NewClientFromHTTP(httpClient)
headRef := pr.HeadRefName
if pr.HeadRepositoryOwner.Login != repo.RepoOwner() {
// Only prepend the `owner:` to comparison head ref if the PR head
// branch is on another repo (e.g., a fork).
headRef = pr.HeadRepositoryOwner.Login + ":" + headRef
}
opts.IO.StartProgressIndicator()
comparison, err := api.ComparePullRequestBaseBranchWith(apiClient, repo, pr.Number, headRef)
opts.IO.StopProgressIndicator()
if err != nil {
return err
}
if comparison.BehindBy == 0 {
// The PR branch is not behind the base branch, so it'a already up-to-date.
fmt.Fprintf(opts.IO.Out, "%s PR branch already up-to-date\n", cs.SuccessIcon())
return nil
}
opts.IO.StartProgressIndicator()
err = updatePullRequestBranch(apiClient, repo, pr.ID, pr.HeadRefOid, opts.Rebase)
opts.IO.StopProgressIndicator()
if err != nil {
// TODO: this is a best effort approach and not a resilient way of handling API errors.
if strings.Contains(err.Error(), "GraphQL: merge conflict between base and head (updatePullRequestBranch)") {
fmt.Fprintf(opts.IO.ErrOut, "%s Cannot update PR branch due to conflicts\n", cs.FailureIcon())
return cmdutil.SilentError
}
return err
}
fmt.Fprintf(opts.IO.Out, "%s PR branch updated\n", cs.SuccessIcon())
return nil
}
// updatePullRequestBranch calls the GraphQL API endpoint to update the given PR
// branch with latest changes of its base.
func updatePullRequestBranch(apiClient *api.Client, repo ghrepo.Interface, pullRequestID string, expectedHeadOid string, rebase bool) error {
updateMethod := githubv4.PullRequestBranchUpdateMethodMerge
if rebase {
updateMethod = githubv4.PullRequestBranchUpdateMethodRebase
}
params := githubv4.UpdatePullRequestBranchInput{
PullRequestID: pullRequestID,
ExpectedHeadOid: (*githubv4.GitObjectID)(&expectedHeadOid),
UpdateMethod: &updateMethod,
}
return api.UpdatePullRequestBranch(apiClient, repo, params)
}

446
pkg/cmd/pr/update-branch/update_branch_test.go Normal file
View file

@ -0,0 +1,446 @@
package update_branch
import (
"bytes"
"net/http"
"testing"
"github.com/cli/cli/v2/api"
"github.com/cli/cli/v2/git"
"github.com/cli/cli/v2/internal/ghrepo"
shared "github.com/cli/cli/v2/pkg/cmd/pr/shared"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/cli/cli/v2/pkg/httpmock"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/google/shlex"
"github.com/stretchr/testify/assert"
)
func TestNewCmdUpdateBranch(t *testing.T) {
tests := []struct {
name string
input string
output UpdateBranchOptions
wantsErr string
}{
{
name: "no argument",
input: "",
output: UpdateBranchOptions{},
},
{
name: "with argument",
input: "23",
output: UpdateBranchOptions{
SelectorArg: "23",
},
},
{
name: "no argument, --rebase",
input: "--rebase",
output: UpdateBranchOptions{
Rebase: true,
},
},
{
name: "with argument, --rebase",
input: "23 --rebase",
output: UpdateBranchOptions{
SelectorArg: "23",
Rebase: true,
},
},
{
name: "no argument, --repo",
input: "--repo owner/repo",
wantsErr: "argument required when using the --repo flag",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ios, _, _, _ := iostreams.Test()
ios.SetStdoutTTY(true)
ios.SetStdinTTY(true)
ios.SetStderrTTY(true)
f := &cmdutil.Factory{
IOStreams: ios,
}
var gotOpts *UpdateBranchOptions
cmd := NewCmdUpdateBranch(f, func(opts *UpdateBranchOptions) error {
gotOpts = opts
return nil
})
cmd.PersistentFlags().StringP("repo", "R", "", "")
argv, err := shlex.Split(tt.input)
assert.NoError(t, err)
cmd.SetArgs(argv)
cmd.SetIn(&bytes.Buffer{})
cmd.SetOut(&bytes.Buffer{})
cmd.SetErr(&bytes.Buffer{})
_, err = cmd.ExecuteC()
if tt.wantsErr != "" {
assert.EqualError(t, err, tt.wantsErr)
return
}
assert.NoError(t, err)
assert.Equal(t, tt.output.SelectorArg, gotOpts.SelectorArg)
assert.Equal(t, tt.output.Rebase, gotOpts.Rebase)
})
}
}
func Test_updateBranchRun(t *testing.T) {
defaultInput := func() UpdateBranchOptions {
return UpdateBranchOptions{
Finder: shared.NewMockFinder("123", &api.PullRequest{
ID: "123",
Number: 123,
HeadRefOid: "head-ref-oid",
HeadRefName: "head-ref-name",
HeadRepositoryOwner: api.Owner{Login: "head-repository-owner"},
Mergeable: api.PullRequestMergeableMergeable,
}, ghrepo.New("OWNER", "REPO")),
}
}
tests := []struct {
name string
input *UpdateBranchOptions
httpStubs func(*testing.T, *httpmock.Registry)
stdout string
stderr string
wantsErr string
}{
{
name: "failure, pr not found",
input: &UpdateBranchOptions{
Finder: shared.NewMockFinder("", nil, nil),
SelectorArg: "123",
},
wantsErr: "no pull requests found",
},
{
name: "success, already up-to-date",
input: &UpdateBranchOptions{
SelectorArg: "123",
},
httpStubs: func(t *testing.T, reg *httpmock.Registry) {
reg.Register(
httpmock.GraphQL(`query ComparePullRequestBaseBranchWith\b`),
httpmock.GraphQLQuery(`{
"data": {
"repository": {
"pullRequest": {
"baseRef": {
"compare": {
"aheadBy": 999,
"behindBy": 0,
"Status": "AHEAD"
}
}
}
}
}
}`, func(_ string, inputs map[string]interface{}) {
assert.Equal(t, float64(123), inputs["pullRequestNumber"])
assert.Equal(t, "head-repository-owner:head-ref-name", inputs["headRef"])
}))
},
stdout: "✓ PR branch already up-to-date\n",
},
{
name: "success, already up-to-date, PR branch on the same repo as base",
input: &UpdateBranchOptions{
SelectorArg: "123",
Finder: shared.NewMockFinder("123", &api.PullRequest{
ID: "123",
Number: 123,
HeadRefOid: "head-ref-oid",
HeadRefName: "head-ref-name",
HeadRepositoryOwner: api.Owner{Login: "OWNER"},
Mergeable: api.PullRequestMergeableMergeable,
}, ghrepo.New("OWNER", "REPO")),
},
httpStubs: func(t *testing.T, reg *httpmock.Registry) {
reg.Register(
httpmock.GraphQL(`query ComparePullRequestBaseBranchWith\b`),
httpmock.GraphQLQuery(`{
"data": {
"repository": {
"pullRequest": {
"baseRef": {
"compare": {
"aheadBy": 999,
"behindBy": 0,
"Status": "AHEAD"
}
}
}
}
}
}`, func(_ string, inputs map[string]interface{}) {
assert.Equal(t, float64(123), inputs["pullRequestNumber"])
assert.Equal(t, "head-ref-name", inputs["headRef"])
}))
},
stdout: "✓ PR branch already up-to-date\n",
},
{
name: "failure, not mergeable due to conflicts",
input: &UpdateBranchOptions{
SelectorArg: "123",
Finder: shared.NewMockFinder("123", &api.PullRequest{
ID: "123",
Number: 123,
HeadRefOid: "head-ref-oid",
HeadRefName: "head-ref-name",
HeadRepositoryOwner: api.Owner{Login: "OWNER"},
Mergeable: api.PullRequestMergeableConflicting,
}, ghrepo.New("OWNER", "REPO")),
},
stderr: "X Cannot update PR branch due to conflicts\n",
wantsErr: cmdutil.SilentError.Error(),
},
{
name: "success, merge",
input: &UpdateBranchOptions{
SelectorArg: "123",
},
httpStubs: func(t *testing.T, reg *httpmock.Registry) {
reg.Register(
httpmock.GraphQL(`query ComparePullRequestBaseBranchWith\b`),
httpmock.GraphQLQuery(`{
"data": {
"repository": {
"pullRequest": {
"baseRef": {
"compare": {
"aheadBy": 0,
"behindBy": 999,
"Status": "BEHIND"
}
}
}
}
}
}`, func(_ string, inputs map[string]interface{}) {
assert.Equal(t, float64(123), inputs["pullRequestNumber"])
assert.Equal(t, "head-repository-owner:head-ref-name", inputs["headRef"])
}))
reg.Register(
httpmock.GraphQL(`mutation PullRequestUpdateBranch\b`),
httpmock.GraphQLMutation(`{
"data": {
"updatePullRequestBranch": {
"pullRequest": {}
}
}
}`, func(inputs map[string]interface{}) {
assert.Equal(t, "123", inputs["pullRequestId"])
assert.Equal(t, "head-ref-oid", inputs["expectedHeadOid"])
assert.Equal(t, "MERGE", inputs["updateMethod"])
}))
},
stdout: "✓ PR branch updated\n",
},
{
name: "success, rebase",
input: &UpdateBranchOptions{
SelectorArg: "123",
Rebase: true,
},
httpStubs: func(t *testing.T, reg *httpmock.Registry) {
reg.Register(
httpmock.GraphQL(`query ComparePullRequestBaseBranchWith\b`),
httpmock.GraphQLQuery(`{
"data": {
"repository": {
"pullRequest": {
"baseRef": {
"compare": {
"aheadBy": 0,
"behindBy": 999,
"Status": "BEHIND"
}
}
}
}
}
}`, func(_ string, inputs map[string]interface{}) {
assert.Equal(t, float64(123), inputs["pullRequestNumber"])
assert.Equal(t, "head-repository-owner:head-ref-name", inputs["headRef"])
}))
reg.Register(
httpmock.GraphQL(`mutation PullRequestUpdateBranch\b`),
httpmock.GraphQLMutation(`{
"data": {
"updatePullRequestBranch": {
"pullRequest": {}
}
}
}`, func(inputs map[string]interface{}) {
assert.Equal(t, "123", inputs["pullRequestId"])
assert.Equal(t, "head-ref-oid", inputs["expectedHeadOid"])
assert.Equal(t, "REBASE", inputs["updateMethod"])
}))
},
stdout: "✓ PR branch updated\n",
},
{
name: "failure, API error on ref comparison request",
input: &UpdateBranchOptions{
SelectorArg: "123",
},
httpStubs: func(t *testing.T, reg *httpmock.Registry) {
reg.Register(
httpmock.GraphQL(`query ComparePullRequestBaseBranchWith\b`),
httpmock.GraphQLQuery(`{
"data": {},
"errors": [
{
"message": "some error"
}
]
}`, func(_ string, inputs map[string]interface{}) {
assert.Equal(t, float64(123), inputs["pullRequestNumber"])
assert.Equal(t, "head-repository-owner:head-ref-name", inputs["headRef"])
}))
},
wantsErr: "GraphQL: some error",
},
{
name: "failure, merge conflict error on update request",
input: &UpdateBranchOptions{
SelectorArg: "123",
},
httpStubs: func(t *testing.T, reg *httpmock.Registry) {
reg.Register(
httpmock.GraphQL(`query ComparePullRequestBaseBranchWith\b`),
httpmock.GraphQLQuery(`{
"data": {
"repository": {
"pullRequest": {
"baseRef": {
"compare": {
"aheadBy": 999,
"behindBy": 999,
"Status": "BEHIND"
}
}
}
}
}
}`, func(_ string, inputs map[string]interface{}) {
assert.Equal(t, float64(123), inputs["pullRequestNumber"])
assert.Equal(t, "head-repository-owner:head-ref-name", inputs["headRef"])
}))
reg.Register(
httpmock.GraphQL(`mutation PullRequestUpdateBranch\b`),
httpmock.GraphQLMutation(`{
"data": {},
"errors": [
{
"message": "merge conflict between base and head (updatePullRequestBranch)"
}
]
}`, func(inputs map[string]interface{}) {
assert.Equal(t, "123", inputs["pullRequestId"])
assert.Equal(t, "head-ref-oid", inputs["expectedHeadOid"])
assert.Equal(t, "MERGE", inputs["updateMethod"])
}))
},
stderr: "X Cannot update PR branch due to conflicts\n",
wantsErr: cmdutil.SilentError.Error(),
},
{
name: "failure, API error on update request",
input: &UpdateBranchOptions{
SelectorArg: "123",
},
httpStubs: func(t *testing.T, reg *httpmock.Registry) {
reg.Register(
httpmock.GraphQL(`query ComparePullRequestBaseBranchWith\b`),
httpmock.GraphQLQuery(`{
"data": {
"repository": {
"pullRequest": {
"baseRef": {
"compare": {
"aheadBy": 0,
"behindBy": 999,
"Status": "BEHIND"
}
}
}
}
}
}`, func(_ string, inputs map[string]interface{}) {
assert.Equal(t, float64(123), inputs["pullRequestNumber"])
assert.Equal(t, "head-repository-owner:head-ref-name", inputs["headRef"])
}))
reg.Register(
httpmock.GraphQL(`mutation PullRequestUpdateBranch\b`),
httpmock.GraphQLMutation(`{
"data": {},
"errors": [
{
"message": "some error"
}
]
}`, func(inputs map[string]interface{}) {
assert.Equal(t, "123", inputs["pullRequestId"])
assert.Equal(t, "head-ref-oid", inputs["expectedHeadOid"])
assert.Equal(t, "MERGE", inputs["updateMethod"])
}))
},
wantsErr: "GraphQL: some error",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ios, _, stdout, stderr := iostreams.Test()
ios.SetStdoutTTY(true)
ios.SetStdinTTY(true)
ios.SetStderrTTY(true)
reg := &httpmock.Registry{}
defer reg.Verify(t)
if tt.httpStubs != nil {
tt.httpStubs(t, reg)
}
tt.input.GitClient = &git.Client{
GhPath: "some/path/gh",
GitPath: "some/path/git",
}
if tt.input.Finder == nil {
tt.input.Finder = defaultInput().Finder
}
httpClient := func() (*http.Client, error) { return &http.Client{Transport: reg}, nil }
tt.input.IO = ios
tt.input.HttpClient = httpClient
err := updateBranchRun(tt.input)
if tt.wantsErr != "" {
assert.EqualError(t, err, tt.wantsErr)
return
} else {
assert.NoError(t, err)
}
assert.Equal(t, tt.stdout, stdout.String())
assert.Equal(t, tt.stderr, stderr.String())
})
}
}