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

Merge pull request #2858 from dpromanko/dpromanko/remove-set-cmd-prepare

Browse source 
Remove use of run.SetPrepareCmd in tests
This commit is contained in:
Mislav Marohnić 2021-01-28 22:38:50 +01:00 • committed by GitHub
commit d771bef106
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 276 additions and 594 deletions
Download patch file Download diff file Expand all files Collapse all files

15
internal/run/run.go
View file

@ -22,21 +22,6 @@ var PrepareCmd = func(cmd *exec.Cmd) Runnable {
return &cmdWithStderr{cmd}
}
// Deprecated: use Stub
func SetPrepareCmd(fn func(*exec.Cmd) Runnable) func() {
origPrepare := PrepareCmd
PrepareCmd = func(cmd *exec.Cmd) Runnable {
// normalize git executable name for consistency in tests
if baseName := filepath.Base(cmd.Args[0]); baseName == "git" || baseName == "git.exe" {
cmd.Args[0] = "git"
}
return fn(cmd)
}
return func() {
PrepareCmd = origPrepare
}
}
// cmdWithStderr augments exec.Cmd by adding stderr to the error message
type cmdWithStderr struct {
*exec.Cmd

31
internal/run/stub.go
View file

@ -3,6 +3,7 @@ package run
import (
"fmt"
"os/exec"
"path/filepath"
"regexp"
"strings"
)
@ -12,9 +13,11 @@ type T interface {
Errorf(string, ...interface{})
}
// Stub installs a catch-all for all external commands invoked from gh. It returns a restore func that, when
// invoked from tests, fails the current test if some stubs that were registered were never matched.
func Stub() (*CommandStubber, func(T)) {
cs := &CommandStubber{}
teardown := SetPrepareCmd(func(cmd *exec.Cmd) Runnable {
teardown := setPrepareCmd(func(cmd *exec.Cmd) Runnable {
s := cs.find(cmd.Args)
if s == nil {
panic(fmt.Sprintf("no exec stub for `%s`", strings.Join(cmd.Args, " ")))
@ -43,13 +46,33 @@ func Stub() (*CommandStubber, func(T)) {
}
}
func setPrepareCmd(fn func(*exec.Cmd) Runnable) func() {
origPrepare := PrepareCmd
PrepareCmd = func(cmd *exec.Cmd) Runnable {
// normalize git executable name for consistency in tests
if baseName := filepath.Base(cmd.Args[0]); baseName == "git" || baseName == "git.exe" {
cmd.Args[0] = "git"
}
return fn(cmd)
}
return func() {
PrepareCmd = origPrepare
}
}
// CommandStubber stubs out invocations to external commands.
type CommandStubber struct {
stubs []*commandStub
}
func (cs *CommandStubber) Register(p string, exitStatus int, output string, callbacks ...CommandCallback) {
// Register a stub for an external command. Pattern is a regular expression, output is the standard output
// from a command. Pass callbacks to inspect raw arguments that the command was invoked with.
func (cs *CommandStubber) Register(pattern string, exitStatus int, output string, callbacks ...CommandCallback) {
if len(pattern) < 1 {
panic("cannot use empty regexp pattern")
}
cs.stubs = append(cs.stubs, &commandStub{
pattern: regexp.MustCompile(p),
pattern: regexp.MustCompile(pattern),
exitStatus: exitStatus,
stdout: output,
callbacks: callbacks,
@ -76,6 +99,7 @@ type commandStub struct {
callbacks []CommandCallback
}
// Run satisfies Runnable
func (s *commandStub) Run() error {
if s.exitStatus != 0 {
return fmt.Errorf("%s exited with status %d", s.pattern, s.exitStatus)
@ -83,6 +107,7 @@ func (s *commandStub) Run() error {
return nil
}
// Output satisfies Runnable
func (s *commandStub) Output() ([]byte, error) {
if s.exitStatus != 0 {
return []byte(nil), fmt.Errorf("%s exited with status %d", s.pattern, s.exitStatus)

96
pkg/cmd/issue/create/create_test.go
View file

@ -7,7 +7,6 @@ import (
"io/ioutil"
"net/http"
"os"
"os/exec"
"strings"
"testing"
@ -281,13 +280,14 @@ func TestIssueCreate_continueInBrowser(t *testing.T) {
},
})
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git rev-parse --show-toplevel`, 0, "")
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/new?body=body&title=hello", url)
})
defer restoreCmd()
output, err := runCommand(http, true, `-b body`)
if err != nil {
@ -296,17 +296,11 @@ func TestIssueCreate_continueInBrowser(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, heredoc.Doc(`
Creating issue in OWNER/REPO
Opening github.com/OWNER/REPO/issues/new in your browser.
`), output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := strings.ReplaceAll(seenCmd.Args[len(seenCmd.Args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/new?body=body&title=hello", url)
}
func TestIssueCreate_metadata(t *testing.T) {
@ -419,24 +413,20 @@ func TestIssueCreate_web(t *testing.T) {
`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git rev-parse --show-toplevel`, 0, "")
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/new?assignees=MonaLisa", url)
})
defer restoreCmd()
output, err := runCommand(http, true, `--web -a @me`)
if err != nil {
t.Errorf("error running command `issue create`: %v", err)
}
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, "https://github.com/OWNER/REPO/issues/new?assignees=MonaLisa", url)
assert.Equal(t, "", output.String())
assert.Equal(t, "Opening github.com/OWNER/REPO/issues/new in your browser.\n", output.Stderr())
}
@ -445,24 +435,20 @@ func TestIssueCreate_webTitleBody(t *testing.T) {
http := &httpmock.Registry{}
defer http.Verify(t)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git rev-parse --show-toplevel`, 0, "")
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/new?body=mybody&title=mytitle", url)
})
defer restoreCmd()
output, err := runCommand(http, true, `-w -t mytitle -b mybody`)
if err != nil {
t.Errorf("error running command `issue create`: %v", err)
}
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := strings.ReplaceAll(seenCmd.Args[len(seenCmd.Args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/new?body=mybody&title=mytitle", url)
assert.Equal(t, "", output.String())
assert.Equal(t, "Opening github.com/OWNER/REPO/issues/new in your browser.\n", output.Stderr())
}
@ -480,24 +466,20 @@ func TestIssueCreate_webTitleBodyAtMeAssignee(t *testing.T) {
`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git rev-parse --show-toplevel`, 0, "")
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/new?assignees=MonaLisa&body=mybody&title=mytitle", url)
})
defer restoreCmd()
output, err := runCommand(http, true, `-w -t mytitle -b mybody -a @me`)
if err != nil {
t.Errorf("error running command `issue create`: %v", err)
}
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := strings.ReplaceAll(seenCmd.Args[len(seenCmd.Args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/new?assignees=MonaLisa&body=mybody&title=mytitle", url)
assert.Equal(t, "", output.String())
assert.Equal(t, "Opening github.com/OWNER/REPO/issues/new in your browser.\n", output.Stderr())
}
@ -580,24 +562,20 @@ func TestIssueCreate_webProject(t *testing.T) {
} } } }
`))
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git rev-parse --show-toplevel`, 0, "")
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/new?projects=OWNER%2FREPO%2F1&title=Title", url)
})
defer restoreCmd()
output, err := runCommand(http, true, `-w -t Title -p Cleanup`)
if err != nil {
t.Errorf("error running command `issue create`: %v", err)
}
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := strings.ReplaceAll(seenCmd.Args[len(seenCmd.Args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/new?projects=OWNER%2FREPO%2F1&title=Title", url)
assert.Equal(t, "", output.String())
assert.Equal(t, "Opening github.com/OWNER/REPO/issues/new in your browser.\n", output.Stderr())
}

22
pkg/cmd/issue/list/list_test.go
View file

@ -5,8 +5,8 @@ import (
"encoding/json"
"io/ioutil"
"net/http"
"os/exec"
"regexp"
"strings"
"testing"
"github.com/MakeNowJust/heredoc"
@ -235,29 +235,21 @@ func TestIssueList_web(t *testing.T) {
http := &httpmock.Registry{}
defer http.Verify(t)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues?q=is%3Aissue+assignee%3Apeter+label%3Abug+label%3Adocs+author%3Ajohn+mentions%3Afrank+milestone%3Av1.1", url)
})
defer restoreCmd()
output, err := runCommand(http, true, "--web -a peter -A john -l bug -l docs -L 10 -s all --mention frank --milestone v1.1")
if err != nil {
t.Errorf("error running command `issue list` with `--web` flag: %v", err)
}
expectedURL := "https://github.com/OWNER/REPO/issues?q=is%3Aissue+assignee%3Apeter+label%3Abug+label%3Adocs+author%3Ajohn+mentions%3Afrank+milestone%3Av1.1"
assert.Equal(t, "", output.String())
assert.Equal(t, "Opening github.com/OWNER/REPO/issues in your browser.\n", output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, expectedURL, url)
}
func TestIssueList_milestoneNotFound(t *testing.T) {

69
pkg/cmd/issue/view/view_test.go
View file

@ -5,7 +5,7 @@ import (
"fmt"
"io/ioutil"
"net/http"
"os/exec"
"strings"
"testing"
"time"
@ -72,13 +72,13 @@ func TestIssueView_web(t *testing.T) {
`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/123", url)
})
defer restoreCmd()
output, err := runCommand(http, true, "-w 123")
if err != nil {
@ -87,12 +87,6 @@ func TestIssueView_web(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, "Opening github.com/OWNER/REPO/issues/123 in your browser.\n", output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, "https://github.com/OWNER/REPO/issues/123", url)
}
func TestIssueView_web_numberArgWithHash(t *testing.T) {
@ -109,13 +103,13 @@ func TestIssueView_web_numberArgWithHash(t *testing.T) {
`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/123", url)
})
defer restoreCmd()
output, err := runCommand(http, true, "-w \"#123\"")
if err != nil {
@ -124,12 +118,6 @@ func TestIssueView_web_numberArgWithHash(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, "Opening github.com/OWNER/REPO/issues/123 in your browser.\n", output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, "https://github.com/OWNER/REPO/issues/123", url)
}
func TestIssueView_nontty_Preview(t *testing.T) {
@ -301,22 +289,13 @@ func TestIssueView_web_notFound(t *testing.T) {
`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
})
defer restoreCmd()
_, cmdTeardown := run.Stub()
defer cmdTeardown(t)
_, err := runCommand(http, true, "-w 9999")
if err == nil || err.Error() != "GraphQL error: Could not resolve to an Issue with the number of 9999." {
t.Errorf("error running command `issue view`: %v", err)
}
if seenCmd != nil {
t.Fatal("did not expect any command to run")
}
}
func TestIssueView_disabledIssues(t *testing.T) {
@ -353,13 +332,13 @@ func TestIssueView_web_urlArg(t *testing.T) {
`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/issues/123", url)
})
defer restoreCmd()
output, err := runCommand(http, true, "-w https://github.com/OWNER/REPO/issues/123")
if err != nil {
@ -367,12 +346,6 @@ func TestIssueView_web_urlArg(t *testing.T) {
}
assert.Equal(t, "", output.String())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, "https://github.com/OWNER/REPO/issues/123", url)
}
func TestIssueView_tty_Comments(t *testing.T) {

356
pkg/cmd/pr/checkout/checkout_test.go
View file

@ -3,11 +3,8 @@ package checkout
import (
"bytes"
"encoding/json"
"errors"
"io/ioutil"
"net/http"
"os/exec"
"strings"
"testing"
"github.com/cli/cli/api"
@ -24,18 +21,6 @@ import (
"github.com/stretchr/testify/assert"
)
type errorStub struct {
message string
}
func (s errorStub) Output() ([]byte, error) {
return nil, errors.New(s.message)
}
func (s errorStub) Run() error {
return errors.New(s.message)
}
func runCommand(rt http.RoundTripper, remotes context.Remotes, branch string, cli string) (*test.CmdOut, error) {
io, _, stdout, stderr := iostreams.Test()
@ -108,18 +93,14 @@ func TestPRCheckout_sameRepo(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git show-ref --verify -- refs/heads/feature":
return &errorStub{"exit status: 1"}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin \+refs/heads/feature:refs/remotes/origin/feature`, 0, "")
cs.Register(`git show-ref --verify -- refs/heads/feature`, 1, "")
cs.Register(`git checkout -b feature --no-track origin/feature`, 0, "")
cs.Register(`git config branch\.feature\.remote origin`, 0, "")
cs.Register(`git config branch\.feature\.merge refs/heads/feature`, 0, "")
output, err := runCommand(http, nil, "master", `123`)
if !assert.NoError(t, err) {
@ -127,13 +108,6 @@ func TestPRCheckout_sameRepo(t *testing.T) {
}
assert.Equal(t, "", output.String())
if !assert.Equal(t, 4, len(ranCommands)) {
return
}
assert.Equal(t, "git fetch origin +refs/heads/feature:refs/remotes/origin/feature", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git checkout -b feature --no-track origin/feature", strings.Join(ranCommands[1], " "))
assert.Equal(t, "git config branch.feature.remote origin", strings.Join(ranCommands[2], " "))
assert.Equal(t, "git config branch.feature.merge refs/heads/feature", strings.Join(ranCommands[3], " "))
}
func TestPRCheckout_urlArg(t *testing.T) {
@ -154,25 +128,18 @@ func TestPRCheckout_urlArg(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git show-ref --verify -- refs/heads/feature":
return &errorStub{"exit status: 1"}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin \+refs/heads/feature:refs/remotes/origin/feature`, 0, "")
cs.Register(`git show-ref --verify -- refs/heads/feature`, 1, "")
cs.Register(`git checkout -b feature --no-track origin/feature`, 0, "")
cs.Register(`git config branch\.feature\.remote origin`, 0, "")
cs.Register(`git config branch\.feature\.merge refs/heads/feature`, 0, "")
output, err := runCommand(http, nil, "master", `https://github.com/OWNER/REPO/pull/123/files`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 4, len(ranCommands))
assert.Equal(t, "git checkout -b feature --no-track origin/feature", strings.Join(ranCommands[1], " "))
}
func TestPRCheckout_urlArg_differentBase(t *testing.T) {
@ -194,18 +161,14 @@ func TestPRCheckout_urlArg_differentBase(t *testing.T) {
`))
http.StubRepoInfoResponse("OWNER", "REPO", "master")
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git show-ref --verify -- refs/heads/feature":
return &errorStub{"exit status: 1"}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch https://github\.com/OTHER/POE\.git refs/pull/123/head:feature`, 0, "")
cs.Register(`git config branch\.feature\.merge`, 1, "")
cs.Register(`git checkout feature`, 0, "")
cs.Register(`git config branch\.feature\.remote https://github\.com/OTHER/POE\.git`, 0, "")
cs.Register(`git config branch\.feature\.merge refs/pull/123/head`, 0, "")
output, err := runCommand(http, nil, "master", `https://github.com/OTHER/POE/pull/123/files`)
assert.NoError(t, err)
@ -222,10 +185,6 @@ func TestPRCheckout_urlArg_differentBase(t *testing.T) {
assert.Equal(t, "OTHER", reqBody.Variables.Owner)
assert.Equal(t, "POE", reqBody.Variables.Repo)
assert.Equal(t, 5, len(ranCommands))
assert.Equal(t, "git fetch https://github.com/OTHER/POE.git refs/pull/123/head:feature", strings.Join(ranCommands[1], " "))
assert.Equal(t, "git config branch.feature.remote https://github.com/OTHER/POE.git", strings.Join(ranCommands[3], " "))
}
func TestPRCheckout_branchArg(t *testing.T) {
@ -247,25 +206,18 @@ func TestPRCheckout_branchArg(t *testing.T) {
] } } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git show-ref --verify -- refs/heads/feature":
return &errorStub{"exit status: 1"}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin refs/pull/123/head:feature`, 0, "")
cs.Register(`git config branch\.feature\.merge`, 1, "")
cs.Register(`git checkout feature`, 0, "")
cs.Register(`git config branch\.feature\.remote origin`, 0, "")
cs.Register(`git config branch\.feature\.merge refs/pull/123/head`, 0, "")
output, err := runCommand(http, nil, "master", `hubot:feature`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 5, len(ranCommands))
assert.Equal(t, "git fetch origin refs/pull/123/head:feature", strings.Join(ranCommands[1], " "))
}
func TestPRCheckout_existingBranch(t *testing.T) {
@ -287,27 +239,17 @@ func TestPRCheckout_existingBranch(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git show-ref --verify -- refs/heads/feature":
return &test.OutputStub{}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin \+refs/heads/feature:refs/remotes/origin/feature`, 0, "")
cs.Register(`git show-ref --verify -- refs/heads/feature`, 0, "")
cs.Register(`git checkout feature`, 0, "")
cs.Register(`git merge --ff-only refs/remotes/origin/feature`, 0, "")
output, err := runCommand(http, nil, "master", `123`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 3, len(ranCommands))
assert.Equal(t, "git fetch origin +refs/heads/feature:refs/remotes/origin/feature", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git checkout feature", strings.Join(ranCommands[1], " "))
assert.Equal(t, "git merge --ff-only refs/remotes/origin/feature", strings.Join(ranCommands[2], " "))
}
func TestPRCheckout_differentRepo_remoteExists(t *testing.T) {
@ -340,28 +282,18 @@ func TestPRCheckout_differentRepo_remoteExists(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git show-ref --verify -- refs/heads/feature":
return &errorStub{"exit status: 1"}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch robot-fork \+refs/heads/feature:refs/remotes/robot-fork/feature`, 0, "")
cs.Register(`git show-ref --verify -- refs/heads/feature`, 1, "")
cs.Register(`git checkout -b feature --no-track robot-fork/feature`, 0, "")
cs.Register(`git config branch\.feature\.remote robot-fork`, 0, "")
cs.Register(`git config branch\.feature\.merge refs/heads/feature`, 0, "")
output, err := runCommand(http, remotes, "master", `123`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 4, len(ranCommands))
assert.Equal(t, "git fetch robot-fork +refs/heads/feature:refs/remotes/robot-fork/feature", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git checkout -b feature --no-track robot-fork/feature", strings.Join(ranCommands[1], " "))
assert.Equal(t, "git config branch.feature.remote robot-fork", strings.Join(ranCommands[2], " "))
assert.Equal(t, "git config branch.feature.merge refs/heads/feature", strings.Join(ranCommands[3], " "))
}
func TestPRCheckout_differentRepo(t *testing.T) {
@ -383,28 +315,18 @@ func TestPRCheckout_differentRepo(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git config branch.feature.merge":
return &errorStub{"exit status 1"}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin refs/pull/123/head:feature`, 0, "")
cs.Register(`git config branch\.feature\.merge`, 1, "")
cs.Register(`git checkout feature`, 0, "")
cs.Register(`git config branch\.feature\.remote origin`, 0, "")
cs.Register(`git config branch\.feature\.merge refs/pull/123/head`, 0, "")
output, err := runCommand(http, nil, "master", `123`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 4, len(ranCommands))
assert.Equal(t, "git fetch origin refs/pull/123/head:feature", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git checkout feature", strings.Join(ranCommands[1], " "))
assert.Equal(t, "git config branch.feature.remote origin", strings.Join(ranCommands[2], " "))
assert.Equal(t, "git config branch.feature.merge refs/pull/123/head", strings.Join(ranCommands[3], " "))
}
func TestPRCheckout_differentRepo_existingBranch(t *testing.T) {
@ -426,26 +348,16 @@ func TestPRCheckout_differentRepo_existingBranch(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git config branch.feature.merge":
return &test.OutputStub{Out: []byte("refs/heads/feature\n")}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin refs/pull/123/head:feature`, 0, "")
cs.Register(`git config branch\.feature\.merge`, 0, "refs/heads/feature\n")
cs.Register(`git checkout feature`, 0, "")
output, err := runCommand(http, nil, "master", `123`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 2, len(ranCommands))
assert.Equal(t, "git fetch origin refs/pull/123/head:feature", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git checkout feature", strings.Join(ranCommands[1], " "))
}
func TestPRCheckout_detachedHead(t *testing.T) {
@ -467,26 +379,16 @@ func TestPRCheckout_detachedHead(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git config branch.feature.merge":
return &test.OutputStub{Out: []byte("refs/heads/feature\n")}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin refs/pull/123/head:feature`, 0, "")
cs.Register(`git config branch\.feature\.merge`, 0, "refs/heads/feature\n")
cs.Register(`git checkout feature`, 0, "")
output, err := runCommand(http, nil, "", `123`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 2, len(ranCommands))
assert.Equal(t, "git fetch origin refs/pull/123/head:feature", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git checkout feature", strings.Join(ranCommands[1], " "))
}
func TestPRCheckout_differentRepo_currentBranch(t *testing.T) {
@ -508,26 +410,16 @@ func TestPRCheckout_differentRepo_currentBranch(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git config branch.feature.merge":
return &test.OutputStub{Out: []byte("refs/heads/feature\n")}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin refs/pull/123/head`, 0, "")
cs.Register(`git config branch\.feature\.merge`, 0, "refs/heads/feature\n")
cs.Register(`git merge --ff-only FETCH_HEAD`, 0, "")
output, err := runCommand(http, nil, "feature", `123`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 2, len(ranCommands))
assert.Equal(t, "git fetch origin refs/pull/123/head", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git merge --ff-only FETCH_HEAD", strings.Join(ranCommands[1], " "))
}
func TestPRCheckout_differentRepo_invalidBranchName(t *testing.T) {
@ -549,12 +441,8 @@ func TestPRCheckout_differentRepo_invalidBranchName(t *testing.T) {
} } } }
`))
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
t.Errorf("unexpected external invocation: %v", cmd.Args)
return &test.OutputStub{}
})
defer restoreCmd()
_, cmdTeardown := run.Stub()
defer cmdTeardown(t)
output, err := runCommand(http, nil, "master", `123`)
assert.EqualError(t, err, `invalid branch name: "-foo"`)
@ -580,28 +468,18 @@ func TestPRCheckout_maintainerCanModify(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git config branch.feature.merge":
return &errorStub{"exit status 1"}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin refs/pull/123/head:feature`, 0, "")
cs.Register(`git config branch\.feature\.merge`, 1, "")
cs.Register(`git checkout feature`, 0, "")
cs.Register(`git config branch\.feature\.remote https://github\.com/hubot/REPO\.git`, 0, "")
cs.Register(`git config branch\.feature\.merge refs/heads/feature`, 0, "")
output, err := runCommand(http, nil, "master", `123`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 4, len(ranCommands))
assert.Equal(t, "git fetch origin refs/pull/123/head:feature", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git checkout feature", strings.Join(ranCommands[1], " "))
assert.Equal(t, "git config branch.feature.remote https://github.com/hubot/REPO.git", strings.Join(ranCommands[2], " "))
assert.Equal(t, "git config branch.feature.merge refs/heads/feature", strings.Join(ranCommands[3], " "))
}
func TestPRCheckout_recurseSubmodules(t *testing.T) {
@ -622,29 +500,19 @@ func TestPRCheckout_recurseSubmodules(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git show-ref --verify -- refs/heads/feature":
return &test.OutputStub{}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin \+refs/heads/feature:refs/remotes/origin/feature`, 0, "")
cs.Register(`git show-ref --verify -- refs/heads/feature`, 0, "")
cs.Register(`git checkout feature`, 0, "")
cs.Register(`git merge --ff-only refs/remotes/origin/feature`, 0, "")
cs.Register(`git submodule sync --recursive`, 0, "")
cs.Register(`git submodule update --init --recursive`, 0, "")
output, err := runCommand(http, nil, "master", `123 --recurse-submodules`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 5, len(ranCommands))
assert.Equal(t, "git fetch origin +refs/heads/feature:refs/remotes/origin/feature", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git checkout feature", strings.Join(ranCommands[1], " "))
assert.Equal(t, "git merge --ff-only refs/remotes/origin/feature", strings.Join(ranCommands[2], " "))
assert.Equal(t, "git submodule sync --recursive", strings.Join(ranCommands[3], " "))
assert.Equal(t, "git submodule update --init --recursive", strings.Join(ranCommands[4], " "))
}
func TestPRCheckout_force(t *testing.T) {
@ -665,28 +533,18 @@ func TestPRCheckout_force(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case "git show-ref --verify -- refs/heads/feature":
return &test.OutputStub{}
default:
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git fetch origin \+refs/heads/feature:refs/remotes/origin/feature`, 0, "")
cs.Register(`git show-ref --verify -- refs/heads/feature`, 0, "")
cs.Register(`git checkout feature`, 0, "")
cs.Register(`git reset --hard refs/remotes/origin/feature`, 0, "")
output, err := runCommand(http, nil, "master", `123 --force`)
assert.NoError(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, len(ranCommands), 3)
assert.Equal(t, "git fetch origin +refs/heads/feature:refs/remotes/origin/feature", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git checkout feature", strings.Join(ranCommands[1], " "))
assert.Equal(t, "git reset --hard refs/remotes/origin/feature", strings.Join(ranCommands[2], " "))
}
func TestPRCheckout_detach(t *testing.T) {
@ -708,19 +566,13 @@ func TestPRCheckout_detach(t *testing.T) {
} } } }
`))
ranCommands := [][]string{}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
ranCommands = append(ranCommands, cmd.Args)
return &test.OutputStub{}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git checkout --detach FETCH_HEAD`, 0, "")
cs.Register(`git fetch origin refs/pull/123/head`, 0, "")
output, err := runCommand(http, nil, "", `123 --detach`)
assert.Nil(t, err)
assert.Equal(t, "", output.String())
assert.Equal(t, 2, len(ranCommands))
assert.Equal(t, "git fetch origin refs/pull/123/head", strings.Join(ranCommands[0], " "))
assert.Equal(t, "git checkout --detach FETCH_HEAD", strings.Join(ranCommands[1], " "))
}

23
pkg/cmd/pr/list/list_test.go
View file

@ -4,7 +4,6 @@ import (
"bytes"
"io/ioutil"
"net/http"
"os/exec"
"strings"
"testing"
@ -72,7 +71,7 @@ func TestPRList(t *testing.T) {
assert.Equal(t, heredoc.Doc(`
Showing 3 of 3 open pull requests in OWNER/REPO
#32 New feature feature
#29 Fixed bad bug hubot:bug-fix
#28 Improve documentation docs
@ -199,27 +198,19 @@ func TestPRList_web(t *testing.T) {
http := initFakeHTTP()
defer http.Verify(t)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/pulls?q=is%3Apr+is%3Amerged+assignee%3Apeter+label%3Abug+label%3Adocs+base%3Atrunk", url)
})
defer restoreCmd()
output, err := runCommand(http, true, "--web -a peter -l bug -l docs -L 10 -s merged -B trunk")
if err != nil {
t.Errorf("error running command `pr list` with `--web` flag: %v", err)
}
expectedURL := "https://github.com/OWNER/REPO/pulls?q=is%3Apr+is%3Amerged+assignee%3Apeter+label%3Abug+label%3Adocs+base%3Atrunk"
assert.Equal(t, "", output.String())
assert.Equal(t, "Opening github.com/OWNER/REPO/pulls in your browser.\n", output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, url, expectedURL)
}

137
pkg/cmd/pr/view/view_test.go
View file

@ -5,7 +5,6 @@ import (
"fmt"
"io/ioutil"
"net/http"
"os/exec"
"strings"
"testing"
@ -564,18 +563,14 @@ func TestPRView_web_currentBranch(t *testing.T) {
defer http.Verify(t)
http.Register(httpmock.GraphQL(`query PullRequestForBranch\b`), httpmock.FileResponse("./fixtures/prView.json"))
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case `git config --get-regexp ^branch\.blueberries\.(remote|merge)$`:
return &test.OutputStub{}
default:
seenCmd = cmd
return &test.OutputStub{}
}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git config --get-regexp.+branch\\\.blueberries\\\.`, 0, "")
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/pull/10", url)
})
defer restoreCmd()
output, err := runCommand(http, "blueberries", true, "-w")
if err != nil {
@ -584,14 +579,6 @@ func TestPRView_web_currentBranch(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, "Opening github.com/OWNER/REPO/pull/10 in your browser.\n", output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
if url != "https://github.com/OWNER/REPO/pull/10" {
t.Errorf("got: %q", url)
}
}
func TestPRView_web_noResultsForBranch(t *testing.T) {
@ -599,27 +586,15 @@ func TestPRView_web_noResultsForBranch(t *testing.T) {
defer http.Verify(t)
http.Register(httpmock.GraphQL(`query PullRequestForBranch\b`), httpmock.FileResponse("./fixtures/prView_NoActiveBranch.json"))
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
switch strings.Join(cmd.Args, " ") {
case `git config --get-regexp ^branch\.blueberries\.(remote|merge)$`:
return &test.OutputStub{}
default:
seenCmd = cmd
return &test.OutputStub{}
}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git config --get-regexp.+branch\\\.blueberries\\\.`, 0, "")
_, err := runCommand(http, "blueberries", true, "-w")
if err == nil || err.Error() != `no pull requests found for branch "blueberries"` {
t.Errorf("error running command `pr view`: %v", err)
}
if seenCmd != nil {
t.Fatalf("unexpected command: %v", seenCmd.Args)
}
}
func TestPRView_web_numberArg(t *testing.T) {
@ -634,13 +609,13 @@ func TestPRView_web_numberArg(t *testing.T) {
} } } }`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/pull/23", url)
})
defer restoreCmd()
output, err := runCommand(http, "master", true, "-w 23")
if err != nil {
@ -648,12 +623,6 @@ func TestPRView_web_numberArg(t *testing.T) {
}
assert.Equal(t, "", output.String())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, "https://github.com/OWNER/REPO/pull/23", url)
}
func TestPRView_web_numberArgWithHash(t *testing.T) {
@ -668,13 +637,13 @@ func TestPRView_web_numberArgWithHash(t *testing.T) {
} } } }`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/pull/23", url)
})
defer restoreCmd()
output, err := runCommand(http, "master", true, `-w "#23"`)
if err != nil {
@ -682,12 +651,6 @@ func TestPRView_web_numberArgWithHash(t *testing.T) {
}
assert.Equal(t, "", output.String())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, "https://github.com/OWNER/REPO/pull/23", url)
}
func TestPRView_web_urlArg(t *testing.T) {
@ -702,13 +665,13 @@ func TestPRView_web_urlArg(t *testing.T) {
} } } }`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/pull/23", url)
})
defer restoreCmd()
output, err := runCommand(http, "master", true, "-w https://github.com/OWNER/REPO/pull/23/files")
if err != nil {
@ -716,12 +679,6 @@ func TestPRView_web_urlArg(t *testing.T) {
}
assert.Equal(t, "", output.String())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, "https://github.com/OWNER/REPO/pull/23", url)
}
func TestPRView_web_branchArg(t *testing.T) {
@ -738,13 +695,13 @@ func TestPRView_web_branchArg(t *testing.T) {
] } } } }`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/OWNER/REPO/pull/23", url)
})
defer restoreCmd()
output, err := runCommand(http, "master", true, "-w blueberries")
if err != nil {
@ -752,12 +709,6 @@ func TestPRView_web_branchArg(t *testing.T) {
}
assert.Equal(t, "", output.String())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, "https://github.com/OWNER/REPO/pull/23", url)
}
func TestPRView_web_branchWithOwnerArg(t *testing.T) {
@ -775,13 +726,13 @@ func TestPRView_web_branchWithOwnerArg(t *testing.T) {
] } } } }`),
)
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`https://github\.com`, 0, "", func(args []string) {
url := strings.ReplaceAll(args[len(args)-1], "^", "")
assert.Equal(t, "https://github.com/hubot/REPO/pull/23", url)
})
defer restoreCmd()
output, err := runCommand(http, "master", true, "-w hubot:blueberries")
if err != nil {
@ -789,12 +740,6 @@ func TestPRView_web_branchWithOwnerArg(t *testing.T) {
}
assert.Equal(t, "", output.String())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
url := seenCmd.Args[len(seenCmd.Args)-1]
assert.Equal(t, "https://github.com/hubot/REPO/pull/23", url)
}
func TestPRView_tty_Comments(t *testing.T) {

121
pkg/cmd/repo/create/create_test.go
View file

@ -3,11 +3,8 @@ package create
import (
"bytes"
"encoding/json"
"errors"
"io/ioutil"
"net/http"
"os/exec"
"strings"
"testing"
"github.com/cli/cli/internal/config"
@ -84,13 +81,11 @@ func TestRepoCreate(t *testing.T) {
httpClient := &http.Client{Transport: reg}
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git remote add -f origin https://github\.com/OWNER/REPO\.git`, 0, "")
cs.Register(`git rev-parse --show-toplevel`, 0, "")
as, surveyTearDown := prompt.InitAskStubber()
defer surveyTearDown()
@ -116,11 +111,6 @@ func TestRepoCreate(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, "✓ Created repository OWNER/REPO on GitHub\n✓ Added remote https://github.com/OWNER/REPO.git\n", output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
assert.Equal(t, "git remote add -f origin https://github.com/OWNER/REPO.git", strings.Join(seenCmd.Args, " "))
var reqBody struct {
Query string
Variables struct {
@ -163,25 +153,12 @@ func TestRepoCreate_outsideGitWorkDir(t *testing.T) {
httpClient := &http.Client{Transport: reg}
var seenCmds []*exec.Cmd
cmdOutputs := []test.OutputStub{
{
Error: errors.New("Not a git repository"),
},
{},
{},
}
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
if len(cmdOutputs) == 0 {
t.Fatal("Too many calls to git command")
}
out := cmdOutputs[0]
cmdOutputs = cmdOutputs[1:]
seenCmds = append(seenCmds, cmd)
return &out
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git rev-parse --show-toplevel`, 1, "")
cs.Register(`git init REPO`, 0, "")
cs.Register(`git -C REPO remote add origin https://github\.com/OWNER/REPO\.git`, 0, "")
output, err := runCommand(httpClient, "REPO --private --confirm", false)
if err != nil {
@ -191,14 +168,6 @@ func TestRepoCreate_outsideGitWorkDir(t *testing.T) {
assert.Equal(t, "https://github.com/OWNER/REPO\n", output.String())
assert.Equal(t, "", output.Stderr())
if len(seenCmds) != 3 {
t.Fatal("expected three commands to run")
}
assert.Equal(t, "git rev-parse --show-toplevel", strings.Join(seenCmds[0].Args, " "))
assert.Equal(t, "git init REPO", strings.Join(seenCmds[1].Args, " "))
assert.Equal(t, "git -C REPO remote add origin https://github.com/OWNER/REPO.git", strings.Join(seenCmds[2].Args, " "))
var reqBody struct {
Query string
Variables struct {
@ -245,13 +214,11 @@ func TestRepoCreate_org(t *testing.T) {
} } }`))
httpClient := &http.Client{Transport: reg}
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git remote add -f origin https://github\.com/ORG/REPO\.git`, 0, "")
cs.Register(`git rev-parse --show-toplevel`, 0, "")
as, surveyTearDown := prompt.InitAskStubber()
defer surveyTearDown()
@ -277,11 +244,6 @@ func TestRepoCreate_org(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, "✓ Created repository ORG/REPO on GitHub\n✓ Added remote https://github.com/ORG/REPO.git\n", output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
assert.Equal(t, "git remote add -f origin https://github.com/ORG/REPO.git", strings.Join(seenCmd.Args, " "))
var reqBody struct {
Query string
Variables struct {
@ -328,13 +290,11 @@ func TestRepoCreate_orgWithTeam(t *testing.T) {
} } }`))
httpClient := &http.Client{Transport: reg}
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git remote add -f origin https://github\.com/ORG/REPO\.git`, 0, "")
cs.Register(`git rev-parse --show-toplevel`, 0, "")
as, surveyTearDown := prompt.InitAskStubber()
defer surveyTearDown()
@ -360,11 +320,6 @@ func TestRepoCreate_orgWithTeam(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, "✓ Created repository ORG/REPO on GitHub\n✓ Added remote https://github.com/ORG/REPO.git\n", output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
assert.Equal(t, "git remote add -f origin https://github.com/ORG/REPO.git", strings.Join(seenCmd.Args, " "))
var reqBody struct {
Query string
Variables struct {
@ -412,13 +367,11 @@ func TestRepoCreate_template(t *testing.T) {
httpClient := &http.Client{Transport: reg}
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git remote add -f origin https://github\.com/OWNER/REPO\.git`, 0, "")
cs.Register(`git rev-parse --show-toplevel`, 0, "")
as, surveyTearDown := prompt.InitAskStubber()
defer surveyTearDown()
@ -444,11 +397,6 @@ func TestRepoCreate_template(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, "✓ Created repository OWNER/REPO on GitHub\n✓ Added remote https://github.com/OWNER/REPO.git\n", output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
assert.Equal(t, "git remote add -f origin https://github.com/OWNER/REPO.git", strings.Join(seenCmd.Args, " "))
var reqBody struct {
Query string
Variables struct {
@ -493,13 +441,11 @@ func TestRepoCreate_withoutNameArg(t *testing.T) {
} } }`))
httpClient := &http.Client{Transport: reg}
var seenCmd *exec.Cmd
//nolint:staticcheck // SA1019 TODO: rewrite to use run.Stub
restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
seenCmd = cmd
return &test.OutputStub{}
})
defer restoreCmd()
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git remote add -f origin https://github\.com/OWNER/REPO\.git`, 0, "")
cs.Register(`git rev-parse --show-toplevel`, 0, "")
as, surveyTearDown := prompt.InitAskStubber()
defer surveyTearDown()
@ -533,11 +479,6 @@ func TestRepoCreate_withoutNameArg(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, "✓ Created repository OWNER/REPO on GitHub\n✓ Added remote https://github.com/OWNER/REPO.git\n", output.Stderr())
if seenCmd == nil {
t.Fatal("expected a command to run")
}
assert.Equal(t, "git remote add -f origin https://github.com/OWNER/REPO.git", strings.Join(seenCmd.Args, " "))
var reqBody struct {
Query string
Variables struct {