updating specs

pkg/commands/oscommands/cmd_obj.go

@@ -8,6 +8,9 @@ import (
 // command line.
 type ICmdObj interface {
 	GetCmd() *exec.Cmd
+	// outputs string representation of command. Note that if the command was built
+	// using NewFromArgs, the output won't be quite the same as what you would type
+	// into a terminal e.g. 'sh -c git commit' as opposed to 'sh -c "git commit"'
 	ToString() string
 	AddEnvVars(...string) ICmdObj
 	GetEnvVars() []string

pkg/commands/oscommands/cmd_obj_builder.go

@@ -19,9 +19,6 @@ type ICmdObjBuilder interface {
 	Quote(str string) string
 }
 
-// poor man's version of explicitly saying that struct X implements interface Y
-var _ ICmdObjBuilder = &CmdObjBuilder{}
-
 type CmdObjBuilder struct {
 	runner    ICmdObjRunner
 	logCmdObj func(ICmdObj)
@@ -31,6 +28,9 @@ type CmdObjBuilder struct {
 	platform *Platform
 }
 
+// poor man's version of explicitly saying that struct X implements interface Y
+var _ ICmdObjBuilder = &CmdObjBuilder{}
+
 func (self *CmdObjBuilder) New(cmdStr string) ICmdObj {
 	args := str.ToArgv(cmdStr)
 	cmd := self.command(args[0], args[1:]...)

pkg/commands/oscommands/cmd_obj_runner.go

@@ -14,19 +14,19 @@ type ICmdObjRunner interface {
 	RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error
 }
 
-type RunExpectation func(ICmdObj) (string, error)
-
-type Runner struct {
+type cmdObjRunner struct {
 	log       *logrus.Entry
 	logCmdObj func(ICmdObj)
 }
 
-func (self *Runner) Run(cmdObj ICmdObj) error {
+var _ ICmdObjRunner = &cmdObjRunner{}
+
+func (self *cmdObjRunner) Run(cmdObj ICmdObj) error {
 	_, err := self.RunWithOutput(cmdObj)
 	return err
 }
 
-func (self *Runner) RunWithOutput(cmdObj ICmdObj) (string, error) {
+func (self *cmdObjRunner) RunWithOutput(cmdObj ICmdObj) (string, error) {
 	self.logCmdObj(cmdObj)
 	output, err := sanitisedCommandOutput(cmdObj.GetCmd().CombinedOutput())
 	if err != nil {
@@ -35,7 +35,7 @@ func (self *Runner) RunWithOutput(cmdObj ICmdObj) (string, error) {
 	return output, err
 }
 
-func (self *Runner) RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error {
+func (self *cmdObjRunner) RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error {
 	cmd := cmdObj.GetCmd()
 	stdoutPipe, err := cmd.StdoutPipe()
 	if err != nil {

pkg/commands/oscommands/dummies.go

@@ -1,6 +1,7 @@
 package oscommands
 
 import (
+	"github.com/jesseduffield/lazygit/pkg/secureexec"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
@@ -8,3 +9,18 @@ import (
 func NewDummyOSCommand() *OSCommand {
 	return NewOSCommand(utils.NewDummyCommon())
 }
+
+func NewCmdObjBuilderDummy(runner ICmdObjRunner) ICmdObjBuilder {
+	return &CmdObjBuilder{
+		runner:    runner,
+		logCmdObj: func(ICmdObj) {},
+		command:   secureexec.Command,
+		platform: &Platform{
+			OS:              "darwin",
+			Shell:           "bash",
+			ShellArg:        "-c",
+			OpenCommand:     "open {{filename}}",
+			OpenLinkCommand: "open {{link}}",
+		},
+	}
+}

pkg/commands/oscommands/fake_runner.go

@@ -0,0 +1,82 @@
+package oscommands
+
+import (
+	"bufio"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/go-errors/errors"
+	"github.com/stretchr/testify/assert"
+)
+
+type FakeCmdObjRunner struct {
+	t                *testing.T
+	expectedCmds     []func(ICmdObj) (string, error)
+	expectedCmdIndex int
+}
+
+var _ ICmdObjRunner = &FakeCmdObjRunner{}
+
+func NewFakeRunner(t *testing.T) *FakeCmdObjRunner {
+	return &FakeCmdObjRunner{t: t}
+}
+
+func (self *FakeCmdObjRunner) Run(cmdObj ICmdObj) error {
+	_, err := self.RunWithOutput(cmdObj)
+	return err
+}
+
+func (self *FakeCmdObjRunner) RunWithOutput(cmdObj ICmdObj) (string, error) {
+	if self.expectedCmdIndex > len(self.expectedCmds)-1 {
+		self.t.Errorf("ran too many commands. Unexpected command: `%s`", cmdObj.ToString())
+		return "", errors.New("ran too many commands")
+	}
+
+	expectedCmd := self.expectedCmds[self.expectedCmdIndex]
+	self.expectedCmdIndex++
+
+	return expectedCmd(cmdObj)
+}
+
+func (self *FakeCmdObjRunner) RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error {
+	output, err := self.RunWithOutput(cmdObj)
+	if err != nil {
+		return err
+	}
+
+	scanner := bufio.NewScanner(strings.NewReader(output))
+	scanner.Split(bufio.ScanLines)
+	for scanner.Scan() {
+		line := scanner.Text()
+		stop, err := onLine(line)
+		if err != nil {
+			return err
+		}
+		if stop {
+			break
+		}
+	}
+
+	return nil
+}
+
+func (self *FakeCmdObjRunner) ExpectFunc(fn func(cmdObj ICmdObj) (string, error)) *FakeCmdObjRunner {
+	self.expectedCmds = append(self.expectedCmds, fn)
+
+	return self
+}
+
+func (self *FakeCmdObjRunner) Expect(expectedCmdStr string, output string, err error) *FakeCmdObjRunner {
+	self.ExpectFunc(func(cmdObj ICmdObj) (string, error) {
+		cmdStr := cmdObj.ToString()
+		if cmdStr != expectedCmdStr {
+			assert.Equal(self.t, expectedCmdStr, cmdStr, fmt.Sprintf("expected command %d to be %s, but was %s", self.expectedCmdIndex+1, expectedCmdStr, cmdStr))
+			return "", errors.New("expected cmd")
+		}
+
+		return output, err
+	})
+
+	return self
+}

pkg/commands/oscommands/os.go

@@ -17,27 +17,6 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
-// Platform stores the os state
-type Platform struct {
-	OS              string
-	Shell           string
-	ShellArg        string
-	OpenCommand     string
-	OpenLinkCommand string
-}
-
-type ICommander interface {
-	Run(ICmdObj) error
-	RunWithOutput(ICmdObj) (string, error)
-}
-
-type RealCommander struct {
-}
-
-func (self *RealCommander) Run(cmdObj ICmdObj) error {
-	return cmdObj.GetCmd().Run()
-}
-
 // OSCommand holds all the os commands
 type OSCommand struct {
 	*common.Common
@@ -56,6 +35,15 @@ type OSCommand struct {
 	Cmd *CmdObjBuilder
 }
 
+// Platform stores the os state
+type Platform struct {
+	OS              string
+	Shell           string
+	ShellArg        string
+	OpenCommand     string
+	OpenLinkCommand string
+}
+
 // TODO: make these fields private
 type CmdLogEntry struct {
 	// e.g. 'git commit -m "haha"'
@@ -99,7 +87,7 @@ func NewOSCommand(common *common.Common) *OSCommand {
 		removeFile: os.RemoveAll,
 	}
 
-	runner := &Runner{log: common.Log, logCmdObj: c.LogCmdObj}
+	runner := &cmdObjRunner{log: common.Log, logCmdObj: c.LogCmdObj}
 	c.Cmd = &CmdObjBuilder{runner: runner, command: command, logCmdObj: c.LogCmdObj, platform: platform}
 
 	return c
@@ -117,7 +105,7 @@ func (c *OSCommand) WithSpan(span string) *OSCommand {
 	*newOSCommand = *c
 	newOSCommand.CmdLogSpan = span
 	newOSCommand.Cmd.logCmdObj = newOSCommand.LogCmdObj
-	newOSCommand.Cmd.runner = &Runner{log: c.Log, logCmdObj: newOSCommand.LogCmdObj}
+	newOSCommand.Cmd.runner = &cmdObjRunner{log: c.Log, logCmdObj: newOSCommand.LogCmdObj}
 	return newOSCommand
 }