Update shell detection

cmd/state-installer/test/integration/installer_int_test.go

@@ -39,7 +39,7 @@ func (suite *InstallerIntegrationTestSuite) TestInstallFromLocalSource() {
 	suite.NoError(err)
 
 	// Run installer with source-path flag (ie. install from this local path)
-	cp := ts.SpawnCmdWithOpts(
+	cp := ts.SpawnCmdInsideShellWithOpts(
 		suite.installerExe,
 		e2e.OptArgs(installationDir(ts), "-n"),
 		e2e.OptAppendEnv(constants.DisableUpdates+"=false"),
@@ -56,7 +56,7 @@ func (suite *InstallerIntegrationTestSuite) TestInstallFromLocalSource() {
 	cp.ExpectExitCode(0)
 
 	// Ensure installing overtop doesn't result in errors
-	cp = ts.SpawnCmdWithOpts(
+	cp = ts.SpawnCmdInsideShellWithOpts(
 		suite.installerExe,
 		e2e.OptArgs(installationDir(ts), "-n"),
 		e2e.OptAppendEnv(constants.DisableUpdates+"=false"),
@@ -171,7 +171,7 @@ func (suite *InstallerIntegrationTestSuite) TestInstallErrorTips() {
 	dir, err := os.MkdirTemp("", "system*")
 	suite.NoError(err)
 
-	cp := ts.SpawnCmdWithOpts(
+	cp := ts.SpawnCmdInsideShellWithOpts(
 		suite.installerExe,
 		e2e.OptArgs(installationDir(ts), "--activate", "ActiveState-CLI/Python3", "-n"),
 		e2e.OptAppendEnv(constants.DisableUpdates+"=true"),

internal/subshell/subshell.go

@@ -182,20 +182,18 @@ func DetectShell(cfg sscommon.Configurable) (string, string) {
 		}
 	}()
 
-	binary = os.Getenv("SHELL")
-	if binary == "" && runtime.GOOS == "windows" {
-		binary = detectShellWindows()
+	binary = detectShellParent()
+	logging.Debug("Configured shell: %s", binary)
+	if binary == "" {
+		binary = configured
 	}
 
 	if binary == "" {
-		binary = configured
+		binary = os.Getenv(SHELL_ENV_VAR)
 	}
+
 	if binary == "" {
-		if runtime.GOOS == "windows" {
-			binary = "cmd.exe"
-		} else {
-			binary = "bash"
-		}
+		binary = OS_DEFULAT
 	}
 
 	path := resolveBinaryPath(binary)
@@ -239,24 +237,23 @@ func DetectShell(cfg sscommon.Configurable) (string, string) {
 	return name, path
 }
 
-func detectShellWindows() string {
-	// Windows does not provide a way of identifying which shell we are running in, so we have to look at the parent
-	// process.
-
+func detectShellParent() string {
+	logging.Debug("Detecting shell from parent process")
 	p, err := process.NewProcess(int32(os.Getppid()))
 	if err != nil && !errors.As(err, ptr.To(&os.PathError{})) {
-		panic(err)
+		logging.Error("Failed to get parent process: %v", err)
 	}
 
-	for p != nil {
+	for p != nil && p.Pid != 0 {
 		name, err := p.Name()
 		if err == nil {
-			if strings.Contains(name, "cmd.exe") || strings.Contains(name, "powershell.exe") {
+			logging.Debug("Searching for supported shell in parent process: %s", name)
+			if supportedShellName(name) {
 				return name
 			}
 		}
 		p, _ = p.Parent()
 	}
 
-	return os.Getenv("ComSpec")
+	return ""
 }

internal/subshell/subshell_lin_mac.go

@@ -18,3 +18,17 @@ var supportedShells = []SubShell{
 	&fish.SubShell{},
 	&cmd.SubShell{},
 }
+
+const (
+	SHELL_ENV_VAR = "SHELL"
+	OS_DEFULAT    = "bash"
+)
+
+func supportedShellName(name string) bool {
+	for _, subshell := range supportedShells {
+		if name == subshell.Shell() {
+			return true
+		}
+	}
+	return false
+}

internal/subshell/subshell_win.go

@@ -3,8 +3,30 @@
 
 package subshell
 
-import "github.com/ActiveState/cli/internal/subshell/cmd"
+import (
+	"fmt"
+
+	"github.com/ActiveState/cli/internal/subshell/bash"
+	"github.com/ActiveState/cli/internal/subshell/cmd"
+	"github.com/ActiveState/cli/internal/subshell/pwsh"
+)
 
 var supportedShells = []SubShell{
 	&cmd.SubShell{},
+	&pwsh.SubShell{},
+	&bash.SubShell{},
+}
+
+const (
+	SHELL_ENV_VAR = "COMSPEC"
+	OS_DEFULAT    = "cmd.exe"
+)
+
+func supportedShellName(name string) bool {
+	for _, subshell := range supportedShells {
+		if name == fmt.Sprintf("%s.exe", subshell.Shell()) {
+			return true
+		}
+	}
+	return false
 }

internal/testhelpers/e2e/session.go

@@ -189,6 +189,12 @@ func new(t *testing.T, retainDirs, updatePath bool, extraEnv ...string) *Session
 		require.NoError(session.T, err)
 	}
 
+	if runtime.GOOS == "windows" {
+		if err := cfg.Set(subshell.ConfigKeyShell, "cmd.exe"); err != nil {
+			require.NoError(session.T, err)
+		}
+	}
+
 	return session
 }
 

internal/testhelpers/e2e/session_unix.go

@@ -13,3 +13,21 @@ var (
 	RuntimeSourcingTimeoutOpt      = termtest.OptExpectTimeout(3 * time.Minute)
 	RuntimeBuildSourcingTimeoutOpt = termtest.OptExpectTimeout(6 * time.Minute)
 )
+
+// SpawnInsideShell spawns the state tool executable to be tested with arguments.
+// On Unix systems, this function is equivalent to Spawn.
+func (s *Session) SpawnInsideShell(args ...string) *SpawnedCmd {
+	return s.SpawnCmd(s.Exe, args...)
+}
+
+// SpawnCmdInsideShellWithOpts spawns the state tool executable to be tested with arguments and options.
+// On Unix systems, this function is equivalent to SpawnCmdWithOpts.
+func (s *Session) SpawnCmdInsideShellWithOpts(exe string, opts ...SpawnOptSetter) *SpawnedCmd {
+	return s.SpawnCmdWithOpts(exe, opts...)
+}
+
+// SpawnInsideShell spawns the state tool executable to be tested with arguments.
+// On Unix systems, this function is equivalent to SpawnWithOpts.
+func (s *Session) SpawnInsideShellWithOpts(opts ...SpawnOptSetter) *SpawnedCmd {
+	return s.SpawnCmdWithOpts(s.Exe, opts...)
+}

internal/testhelpers/e2e/session_windows.go

@@ -4,12 +4,48 @@
 package e2e
 
 import (
+	"runtime"
 	"time"
 
+	"github.com/ActiveState/cli/internal/condition"
 	"github.com/ActiveState/termtest"
 )
 
 var (
 	RuntimeSourcingTimeoutOpt      = termtest.OptExpectTimeout(3 * time.Minute)
 	RuntimeBuildSourcingTimeoutOpt = termtest.OptExpectTimeout(6 * time.Minute)
 )
+
+// SpawnInsideShell spawns the state tool executable to be tested with arguments.
+// This function differs from Spawn in that it runs the command in a shell on Windows CI.
+// Our Windows integration tests are run on bash. Due to the way the PTY library runs a new
+// command we need to run the command inside a shell in order to setup the correct process
+// tree. Without this integration tests run in bash will incorrectly identify the partent shell
+// as bash, rather than the actual shell that is running the command
+func (s *Session) SpawnInsideShell(args ...string) *SpawnedCmd {
+	opts := []SpawnOptSetter{OptArgs(args...)}
+	if runtime.GOOS == "windows" && condition.OnCI() {
+		opts = append(opts, OptRunInsideShell(true))
+	}
+	return s.SpawnCmdWithOpts(s.Exe, opts...)
+}
+
+// SpawnCmdInsideShellWithOpts spawns the executable to be tested with arguments and options.
+// This function differs from SpawnCmdWithOpts in that it runs the command in a shell on Windows CI.
+// See SpawnInsideShell for more information.
+func (s *Session) SpawnCmdInsideShellWithOpts(exe string, opts ...SpawnOptSetter) *SpawnedCmd {
+	if runtime.GOOS == "windows" && condition.OnCI() {
+		opts = append(opts, OptRunInsideShell(true))
+	}
+	return s.SpawnCmdWithOpts(exe, opts...)
+}
+
+// SpawnInsideShell spawns the state tool executable to be tested with arguments.
+// This function differs from SpawnWithOpts in that it runs the command in a shell on Windows CI.
+// See SpawnInsideShell for more information.
+func (s *Session) SpawnInsideShellWithOpts(opts ...SpawnOptSetter) *SpawnedCmd {
+	if runtime.GOOS == "windows" && condition.OnCI() {
+		opts = append(opts, OptRunInsideShell(true))
+	}
+	return s.SpawnCmdWithOpts(s.Exe, opts...)
+}

internal/testhelpers/e2e/spawn.go

@@ -74,7 +74,7 @@ func (s *SpawnedCmd) ExpectInput(opts ...termtest.SetExpectOpt) error {
 	expect := `expect'input from posix shell`
 	if cmdName != "bash" && shellName != "bash" && runtime.GOOS == "windows" {
 		if strings.Contains(cmdName, "powershell") || strings.Contains(shellName, "powershell") {
-			send = "echo \"`<expect input from powershell`>\""
+			send = "echo \"<expect input from powershell>\""
 			expect = `<expect input from powershell>`
 		} else {
 			send = `echo ^<expect input from cmd prompt^>`

test/integration/activate_int_test.go

@@ -54,7 +54,7 @@ func (suite *ActivateIntegrationTestSuite) TestActivateWithoutRuntime() {
 	close := suite.addForegroundSvc(ts)
 	defer close()
 
-	cp := ts.Spawn("activate", "ActiveState-CLI/Empty")
+	cp := ts.SpawnInsideShell("activate", "ActiveState-CLI/Empty")
 	cp.Expect("Activated")
 	cp.ExpectInput()
 
@@ -134,7 +134,7 @@ func (suite *ActivateIntegrationTestSuite) TestActivateUsingCommitID() {
 	close := suite.addForegroundSvc(ts)
 	defer close()
 
-	cp := ts.Spawn("activate", "ActiveState-CLI/Empty#6d79f2ae-f8b5-46bd-917a-d4b2558ec7b8", "--path", ts.Dirs.Work)
+	cp := ts.SpawnInsideShell("activate", "ActiveState-CLI/Empty#6d79f2ae-f8b5-46bd-917a-d4b2558ec7b8", "--path", ts.Dirs.Work)
 	cp.Expect("Activated")
 	cp.ExpectInput()
 
@@ -149,7 +149,7 @@ func (suite *ActivateIntegrationTestSuite) TestActivateNotOnPath() {
 	close := suite.addForegroundSvc(ts)
 	defer close()
 
-	cp := ts.Spawn("activate", "activestate-cli/empty", "--path", ts.Dirs.Work)
+	cp := ts.SpawnInsideShell("activate", "activestate-cli/empty", "--path", ts.Dirs.Work)
 	cp.Expect("Activated")
 	cp.ExpectInput()
 
@@ -177,7 +177,7 @@ func (suite *ActivateIntegrationTestSuite) TestActivatePythonByHostOnly() {
 	defer close()
 
 	projectName := "Python-LinuxWorks"
-	cp := ts.Spawn("activate", "cli-integration-tests/"+projectName, "--path="+ts.Dirs.Work)
+	cp := ts.SpawnInsideShell("activate", "cli-integration-tests/"+projectName, "--path="+ts.Dirs.Work)
 
 	if runtime.GOOS == "linux" {
 		cp.Expect("Creating a Virtual Environment")
@@ -218,7 +218,7 @@ func (suite *ActivateIntegrationTestSuite) activatePython(version string, extraE
 
 	namespace := "ActiveState-CLI/Python" + version
 
-	cp := ts.SpawnWithOpts(
+	cp := ts.SpawnInsideShellWithOpts(
 		e2e.OptArgs("activate", namespace),
 		e2e.OptAppendEnv(extraEnv...),
 	)
@@ -294,7 +294,7 @@ func (suite *ActivateIntegrationTestSuite) TestActivate_PythonPath() {
 
 	namespace := "ActiveState-CLI/Python3"
 
-	cp := ts.Spawn("activate", namespace)
+	cp := ts.SpawnInsideShell("activate", namespace)
 
 	cp.Expect("Activated", e2e.RuntimeSourcingTimeoutOpt)
 	// ensure that shell is functional
@@ -334,7 +334,7 @@ func (suite *ActivateIntegrationTestSuite) TestActivate_SpaceInCacheDir() {
 	err := fileutils.MkdirUnlessExists(cacheDir)
 	suite.Require().NoError(err)
 
-	cp := ts.SpawnWithOpts(
+	cp := ts.SpawnInsideShellWithOpts(
 		e2e.OptArgs("activate", "ActiveState-CLI/Python3"),
 		e2e.OptAppendEnv(fmt.Sprintf("%s=%s", constants.CacheEnvVarName, cacheDir)),
 	)
@@ -358,7 +358,7 @@ func (suite *ActivateIntegrationTestSuite) TestActivatePerlCamel() {
 	close := suite.addForegroundSvc(ts)
 	defer close()
 
-	cp := ts.Spawn("activate", "ActiveState-CLI/Perl")
+	cp := ts.SpawnInsideShell("activate", "ActiveState-CLI/Perl")
 
 	cp.Expect("Downloading", termtest.OptExpectTimeout(40*time.Second))
 	cp.Expect("Installing", termtest.OptExpectTimeout(140*time.Second))
@@ -399,7 +399,7 @@ version: %s
 	ts.PrepareCommitIdFile("6d79f2ae-f8b5-46bd-917a-d4b2558ec7b8")
 
 	// Activate in the subdirectory
-	c2 := ts.SpawnWithOpts(
+	c2 := ts.SpawnInsideShellWithOpts(
 		e2e.OptArgs("activate"),
 		e2e.OptWD(filepath.Join(ts.Dirs.Work, "foo", "bar", "baz")),
 	)
@@ -474,15 +474,15 @@ func (suite *ActivateIntegrationTestSuite) TestActivate_FromCache() {
 
 	// Note: cannot use Empty project since we need artifacts to download and install.
 	// Pick the langless project, which just has some small, non-language artifacts.
-	cp := ts.Spawn("activate", "ActiveState-CLI/langless", "--path", ts.Dirs.Work)
+	cp := ts.SpawnInsideShell("activate", "ActiveState-CLI/langless", "--path", ts.Dirs.Work)
 	cp.Expect("Activated", e2e.RuntimeSourcingTimeoutOpt)
 
 	suite.assertCompletedStatusBarReport(cp.Output())
 	cp.SendLine("exit")
 	cp.ExpectExitCode(0)
 
 	// next activation is cached
-	cp = ts.Spawn("activate", "ActiveState-CLI/langless", "--path", ts.Dirs.Work)
+	cp = ts.SpawnInsideShell("activate", "ActiveState-CLI/langless", "--path", ts.Dirs.Work)
 
 	cp.ExpectInput(e2e.RuntimeSourcingTimeoutOpt)
 	cp.SendLine("exit")

test/integration/deploy_int_test.go

@@ -168,6 +168,7 @@ func (suite *DeployIntegrationTestSuite) TestDeployPython() {
 			"cmd.exe",
 			e2e.OptArgs("/k", filepath.Join(targetPath, "bin", "shell.bat")),
 			e2e.OptAppendEnv("PATHEXT=.COM;.EXE;.BAT;.LNK", "SHELL="),
+			e2e.OptRunInsideShell(true),
 		)
 	} else {
 		cp = ts.SpawnCmdWithOpts(

test/integration/shell_int_test.go

@@ -466,7 +466,7 @@ events:`, lang, splat), 1)
 	suite.Require().NoError(fileutils.WriteFile(asyFilename, []byte(contents)))
 
 	// Verify that running a script as a command with an argument containing special characters works.
-	cp = ts.Spawn("shell")
+	cp = ts.SpawnInsideShell("shell")
 	cp.Expect("Activated", e2e.RuntimeSourcingTimeoutOpt)
 	cp.ExpectInput()
 	cp.SendLine(`args "<3"`)