Refactor repo_paths.go to use git rev-parse

This changes GetRepoPaths() to pull information from `git rev-parse`
instead of effectively reimplementing git's logic for pathfinding. This
change fixes issues with bare repos, esp. versioned homedir use cases,
by aligning lazygit's path handling to what git itself does.

This change also enables lazygit to run from arbitrary subdirectories of
a repository, including correct handling of symlinks, including "deep"
symlinks into a repo, worktree, a repo's submodules, etc.

Integration tests are now resilient against unintended side effects from
the host's environment variables. Of necessity, $PATH and $TERM are the
only env vars allowed through now.

pkg/integration/components/env.go

@@ -0,0 +1,65 @@
+package components
+
+import (
+	"fmt"
+	"os"
+)
+
+const (
+	// These values will be passed to lazygit
+	LAZYGIT_ROOT_DIR          = "LAZYGIT_ROOT_DIR"
+	SANDBOX_ENV_VAR           = "SANDBOX"
+	TEST_NAME_ENV_VAR         = "TEST_NAME"
+	WAIT_FOR_DEBUGGER_ENV_VAR = "WAIT_FOR_DEBUGGER"
+
+	// These values will be passed to both lazygit and shell commands
+	GIT_CONFIG_GLOBAL_ENV_VAR = "GIT_CONFIG_GLOBAL"
+	// We pass PWD because if it's defined, Go will use it as the working directory
+	// rather than make a syscall to the OS, and that means symlinks won't be resolved,
+	// which is good to test for.
+	PWD = "PWD"
+
+	// We set $HOME and $GIT_CONFIG_NOGLOBAL during integrationt tests so
+	// that older versions of git that don't respect $GIT_CONFIG_GLOBAL
+	// will find the correct global config file for testing
+	HOME                = "HOME"
+	GIT_CONFIG_NOGLOBAL = "GIT_CONFIG_NOGLOBAL"
+
+	// These values will be passed through to lazygit and shell commands, with their
+	// values inherited from the host environment
+	PATH = "PATH"
+	TERM = "TERM"
+)
+
+// Tests will inherit these environment variables from the host environment, rather
+// than the test runner deciding the values itself.
+// All other environment variables present in the host environment will be ignored.
+// Having such a minimal list ensures that lazygit behaves the same across different test environments.
+var hostEnvironmentAllowlist = [...]string{
+	PATH,
+	TERM,
+}
+
+// Returns a copy of the environment filtered by
+// hostEnvironmentAllowlist
+func allowedHostEnvironment() []string {
+	env := []string{}
+	for _, envVar := range hostEnvironmentAllowlist {
+		env = append(env, fmt.Sprintf("%s=%s", envVar, os.Getenv(envVar)))
+	}
+	return env
+}
+
+func NewTestEnvironment(rootDir string) []string {
+	env := allowedHostEnvironment()
+
+	// Set $HOME to control the global git config location for git
+	// versions <= 2.31.8
+	env = append(env, fmt.Sprintf("%s=%s", HOME, testPath(rootDir)))
+
+	// $GIT_CONFIG_GLOBAL controls global git config location for git
+	// versions >= 2.32.0
+	env = append(env, fmt.Sprintf("%s=%s", GIT_CONFIG_GLOBAL_ENV_VAR, globalGitConfigPath(rootDir)))
+
+	return env
+}

pkg/integration/components/runner.go

@@ -13,14 +13,6 @@ import (
 	"github.com/samber/lo"
 )
 
-const (
-	LAZYGIT_ROOT_DIR          = "LAZYGIT_ROOT_DIR"
-	TEST_NAME_ENV_VAR         = "TEST_NAME"
-	SANDBOX_ENV_VAR           = "SANDBOX"
-	WAIT_FOR_DEBUGGER_ENV_VAR = "WAIT_FOR_DEBUGGER"
-	GIT_CONFIG_GLOBAL_ENV_VAR = "GIT_CONFIG_GLOBAL"
-)
-
 type RunTestArgs struct {
 	Tests           []*IntegrationTest
 	Logf            func(format string, formatArgs ...interface{})
@@ -161,18 +153,27 @@ func buildLazygit(testArgs RunTestArgs) error {
 // Sets up the fixture for test and returns the working directory to invoke
 // lazygit in.
 func createFixture(test *IntegrationTest, paths Paths, rootDir string) string {
-	shell := NewShell(paths.ActualRepo(), func(errorMsg string) { panic(errorMsg) })
-	shell.Init()
+	env := NewTestEnvironment(rootDir)
 
-	os.Setenv(GIT_CONFIG_GLOBAL_ENV_VAR, globalGitConfigPath(rootDir))
+	env = append(env, fmt.Sprintf("%s=%s", PWD, paths.ActualRepo()))
+	shell := NewShell(
+		paths.ActualRepo(),
+		env,
+		func(errorMsg string) { panic(errorMsg) },
+	)
+	shell.Init()
 
 	test.SetupRepo(shell)
 
 	return shell.dir
 }
 
+func testPath(rootdir string) string {
+	return filepath.Join(rootdir, "test")
+}
+
 func globalGitConfigPath(rootDir string) string {
-	return filepath.Join(rootDir, "test", "global_git_config")
+	return filepath.Join(testPath(rootDir), "global_git_config")
 }
 
 func getGitVersion() (*git_commands.GitVersion, error) {
@@ -215,9 +216,16 @@ func getLazygitCommand(
 	})
 	cmdArgs = append(cmdArgs, resolvedExtraArgs...)
 
-	cmdObj := osCommand.Cmd.New(cmdArgs)
+	// Use a limited environment for test isolation, including pass through
+	// of just allowed host environment variables
+	cmdObj := osCommand.Cmd.NewWithEnviron(cmdArgs, NewTestEnvironment(rootDir))
 
+	// Integration tests related to symlink behavior need a PWD that
+	// preserves symlinks. By default, SetWd will set a symlink-resolved
+	// value for PWD. Here, we override that with the path (that may)
+	// contain a symlink to simulate behavior in a user's shell correctly.
 	cmdObj.SetWd(workingDir)
+	cmdObj.AddEnvVars(fmt.Sprintf("%s=%s", PWD, workingDir))
 
 	cmdObj.AddEnvVars(fmt.Sprintf("%s=%s", LAZYGIT_ROOT_DIR, rootDir))
 

pkg/integration/components/shell.go

@@ -19,6 +19,9 @@ import (
 type Shell struct {
 	// working directory the shell is invoked in
 	dir string
+	// passed into each command
+	env []string
+
 	// when running the shell outside the gui we can directly panic on failure,
 	// but inside the gui we need to close the gui before panicking
 	fail func(string)
@@ -26,14 +29,15 @@ type Shell struct {
 	randomFileContentIndex int
 }
 
-func NewShell(dir string, fail func(string)) *Shell {
-	return &Shell{dir: dir, fail: fail}
+func NewShell(dir string, env []string, fail func(string)) *Shell {
+	return &Shell{dir: dir, env: env, fail: fail}
 }
 
 func (self *Shell) RunCommand(args []string) *Shell {
 	return self.RunCommandWithEnv(args, []string{})
 }
 
+// Run a command with additional environment variables set
 func (self *Shell) RunCommandWithEnv(args []string, env []string) *Shell {
 	output, err := self.runCommandWithOutputAndEnv(args, env)
 	if err != nil {
@@ -58,7 +62,7 @@ func (self *Shell) runCommandWithOutput(args []string) (string, error) {
 
 func (self *Shell) runCommandWithOutputAndEnv(args []string, env []string) (string, error) {
 	cmd := exec.Command(args[0], args[1:]...)
-	cmd.Env = append(os.Environ(), env...)
+	cmd.Env = append(self.env, env...)
 	cmd.Dir = self.dir
 
 	output, err := cmd.CombinedOutput()
@@ -461,8 +465,8 @@ func (self *Shell) CopyFile(source string, destination string) *Shell {
 	return self
 }
 
-// NOTE: this only takes effect before running the test;
-// the test will still run in the original directory
+// The final value passed to Chdir() during setup
+// will be the directory the test is run from.
 func (self *Shell) Chdir(path string) *Shell {
 	self.dir = filepath.Join(self.dir, path)
 

pkg/integration/components/test.go

@@ -182,7 +182,13 @@ func (self *IntegrationTest) Run(gui integrationTypes.GuiDriver) {
 		panic(err)
 	}
 
-	shell := NewShell(pwd, func(errorMsg string) { gui.Fail(errorMsg) })
+	shell := NewShell(
+		pwd,
+		// passing the full environment because it's already been filtered down
+		// in the parent process.
+		os.Environ(),
+		func(errorMsg string) { gui.Fail(errorMsg) },
+	)
 	keys := gui.Keys()
 	testDriver := NewTestDriver(gui, shell, keys, InputDelay())