update tests

pkg/commands/oscommands/cmd_obj_builder.go

@@ -1,6 +1,7 @@
 package oscommands
 
 import (
+	"fmt"
 	"os"
 	"strings"
 
@@ -54,7 +55,23 @@ func (self *CmdObjBuilder) NewFromArgs(args []string) ICmdObj {
 }
 
 func (self *CmdObjBuilder) NewShell(commandStr string) ICmdObj {
-	return self.NewFromArgs([]string{self.platform.Shell, self.platform.ShellArg, commandStr})
+	quotedCommand := ""
+	// Windows does not seem to like quotes around the command
+	if self.platform.OS == "windows" {
+		quotedCommand = strings.NewReplacer(
+			"^", "^^",
+			"&", "^&",
+			"|", "^|",
+			"<", "^<",
+			">", "^>",
+			"%", "^%",
+		).Replace(commandStr)
+	} else {
+		quotedCommand = self.Quote(commandStr)
+	}
+
+	shellCommand := fmt.Sprintf("%s %s %s", self.platform.Shell, self.platform.ShellArg, quotedCommand)
+	return self.New(shellCommand)
 }
 
 func (self *CmdObjBuilder) CloneWithNewRunner(decorate func(ICmdObjRunner) ICmdObjRunner) *CmdObjBuilder {

pkg/commands/oscommands/dummies.go

@@ -6,25 +6,29 @@ import (
 
 // NewDummyOSCommand creates a new dummy OSCommand for testing
 func NewDummyOSCommand() *OSCommand {
-	return NewOSCommand(utils.NewDummyCommon())
+	osCmd := NewOSCommand(utils.NewDummyCommon(), dummyPlatform)
+
+	return osCmd
 }
 
 func NewDummyCmdObjBuilder(runner ICmdObjRunner) *CmdObjBuilder {
 	return &CmdObjBuilder{
 		runner:    runner,
 		logCmdObj: func(ICmdObj) {},
-		platform: &Platform{
-			OS:              "darwin",
-			Shell:           "bash",
-			ShellArg:        "-c",
-			OpenCommand:     "open {{filename}}",
-			OpenLinkCommand: "open {{link}}",
-		},
+		platform:  dummyPlatform,
 	}
 }
 
+var dummyPlatform = &Platform{
+	OS:              "darwin",
+	Shell:           "bash",
+	ShellArg:        "-c",
+	OpenCommand:     "open {{filename}}",
+	OpenLinkCommand: "open {{link}}",
+}
+
 func NewDummyOSCommandWithRunner(runner *FakeCmdObjRunner) *OSCommand {
-	osCommand := NewOSCommand(utils.NewDummyCommon())
+	osCommand := NewOSCommand(utils.NewDummyCommon(), dummyPlatform)
 	osCommand.Cmd = NewDummyCmdObjBuilder(runner)
 
 	return osCommand

pkg/commands/oscommands/fake_cmd_obj_runner.go

@@ -3,6 +3,7 @@ package oscommands
 import (
 	"bufio"
 	"fmt"
+	"regexp"
 	"strings"
 	"testing"
 
@@ -93,10 +94,24 @@ func (self *FakeCmdObjRunner) ExpectArgs(expectedArgs []string, output string, e
 	return self
 }
 
+func (self *FakeCmdObjRunner) ExpectGitArgs(expectedArgs []string, output string, err error) *FakeCmdObjRunner {
+	self.ExpectFunc(func(cmdObj ICmdObj) (string, error) {
+		// first arg is 'git' on unix and something like '"C:\\Program Files\\Git\\mingw64\\bin\\git.exe" on windows so we'll just ensure it ends in either 'git' or 'git.exe'
+		re := regexp.MustCompile(`git(\.exe)?$`)
+		args := cmdObj.GetCmd().Args
+		if !re.MatchString(args[0]) {
+			self.t.Errorf("expected first arg to end in .git or .git.exe but was %s", args[0])
+		}
+		assert.EqualValues(self.t, expectedArgs, args[1:], fmt.Sprintf("command %d did not match expectation", self.expectedCmdIndex+1))
+
+		return output, err
+	})
+
+	return self
+}
+
 func (self *FakeCmdObjRunner) CheckForMissingCalls() {
 	if self.expectedCmdIndex < len(self.expectedCmds) {
 		self.t.Errorf("expected command %d to be called, but was not", self.expectedCmdIndex+1)
 	}
-
-	return
 }

pkg/commands/oscommands/os.go

@@ -73,9 +73,7 @@ func NewCmdLogEntry(cmdStr string, span string, commandLine bool) CmdLogEntry {
 }
 
 // NewOSCommand os command runner
-func NewOSCommand(common *common.Common) *OSCommand {
-	platform := getPlatform()
-
+func NewOSCommand(common *common.Common, platform *Platform) *OSCommand {
 	c := &OSCommand{
 		Common:     common,
 		Platform:   platform,
@@ -138,7 +136,6 @@ func FileType(path string) string {
 	return "file"
 }
 
-// OpenFile opens a file with the given
 func (c *OSCommand) OpenFile(filename string) error {
 	commandTemplate := c.UserConfig.OS.OpenCommand
 	templateValues := map[string]string{
@@ -148,7 +145,6 @@ func (c *OSCommand) OpenFile(filename string) error {
 	return c.Cmd.NewShell(command).Run()
 }
 
-// OpenLink opens a file with the given
 func (c *OSCommand) OpenLink(link string) error {
 	c.LogCommand(fmt.Sprintf("Opening link '%s'", link), false)
 	commandTemplate := c.UserConfig.OS.OpenLinkCommand

pkg/commands/oscommands/os_default_platform.go

@@ -7,7 +7,7 @@ import (
 	"runtime"
 )
 
-func getPlatform() *Platform {
+func GetPlatform() *Platform {
 	return &Platform{
 		OS:              runtime.GOOS,
 		Shell:           "bash",

pkg/commands/oscommands/os_test_default.go

@@ -112,68 +112,3 @@ func TestOSCommandOpenFileLinux(t *testing.T) {
 		s.test(oSCmd.OpenFile(s.filename))
 	}
 }
-
-func TestOSCommandOpenFileWindows(t *testing.T) {
-	type scenario struct {
-		filename string
-		runner   *FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			filename: "test",
-			runner: NewFakeRunner(t).
-				ExpectArgs([]string{"cmd", "/c", "start", "", "test"}, "", errors.New("error")),
-			test: func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			filename: "test",
-			runner: NewFakeRunner(t).
-				ExpectArgs([]string{"cmd", "/c", "start", "", "test"}, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			filename: "filename with spaces",
-			runner: NewFakeRunner(t).
-				ExpectArgs([]string{"cmd", "/c", "start", "", "filename with spaces"}, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			filename: "let's_test_with_single_quote",
-			runner: NewFakeRunner(t).
-				ExpectArgs([]string{"cmd", "/c", "start", "", "let's_test_with_single_quote"}, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			filename: "$USER.txt",
-			runner: NewFakeRunner(t).
-				ExpectArgs([]string{"cmd", "/c", "start", "", "$USER.txt"}, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		oSCmd := NewDummyOSCommandWithRunner(s.runner)
-		platform := &Platform{
-			OS:       "windows",
-			Shell:    "cmd",
-			ShellArg: "/c",
-		}
-		oSCmd.Platform = platform
-		oSCmd.Cmd.platform = platform
-		oSCmd.UserConfig.OS.OpenCommand = `start "" {{filename}}`
-
-		s.test(oSCmd.OpenFile(s.filename))
-	}
-}

pkg/commands/oscommands/os_test_windows.go

@@ -4,18 +4,18 @@
 package oscommands
 
 import (
-	"os/exec"
 	"testing"
 
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
+	"github.com/go-errors/errors"
 	"github.com/stretchr/testify/assert"
 )
 
+// handling this in a separate file because str.ToArgv has different behaviour if we're on windows
+
 func TestOSCommandOpenFileWindows(t *testing.T) {
 	type scenario struct {
 		filename string
 		runner   *FakeCmdObjRunner
-		command  func(string, ...string) *exec.Cmd
 		test     func(error)
 	}
 

pkg/commands/oscommands/os_windows.go

@@ -1,6 +1,6 @@
 package oscommands
 
-func getPlatform() *Platform {
+func GetPlatform() *Platform {
 	return &Platform{
 		OS:       "windows",
 		Shell:    "cmd",