Add test cases on toolchain command runner

Author: mengdaming

src/engine/tcr.go

@@ -524,7 +524,7 @@ func (tcr *TCREngine) RunTCRCycle() {
 
 // AbortCommand triggers interruption of an ongoing TCR cycle operation
 func (tcr *TCREngine) AbortCommand() {
-	tcr.toolchain.AbortExecution()
+	_ = tcr.toolchain.AbortExecution()
 }
 
 func (tcr *TCREngine) createTCREvent(testResult toolchain.TestCommandResult) (event events.TCREvent) {

src/toolchain/command_runner.go

@@ -64,12 +64,12 @@ const (
 )
 
 // commandRunner singleton instance
-var commandRunner = getCommandRunner()
+var commandRunner = &CommandRunner{
+	command: nil,
+}
 
 func getCommandRunner() *CommandRunner {
-	return &CommandRunner{
-		command: nil,
-	}
+	return commandRunner
 }
 
 // Run launches the execution of the provided command
@@ -123,13 +123,15 @@ func (*CommandRunner) reportCommandTrace(readCloser io.ReadCloser) {
 }
 
 // AbortRunningCommand triggers aborting of any command that is currently running
-func (r *CommandRunner) AbortRunningCommand() {
+func (r *CommandRunner) AbortRunningCommand() bool {
 	if r.command == nil || r.command.Process == nil {
 		report.PostWarning("There is no command running at this time")
-		return
+		return false
 	}
 	report.PostWarning("Aborting command: \"", r.command.String(), "\"")
 	_ = r.command.Process.Kill()
 	// Calling Kill() may be a bit too brutal (may leave children process alive)
 	//_ = r.command.Process.Signal(os.Kill)
+	r.command = nil
+	return true
 }

src/toolchain/command_runner_test.go

@@ -26,11 +26,11 @@ import (
 	"fmt"
 	"github.com/stretchr/testify/assert"
 	"testing"
+	"time"
 )
 
 func Test_command_result_outcome(t *testing.T) {
-
-	testFlags := []struct {
+	testCases := []struct {
 		status         CommandStatus
 		expectedPassed bool
 		expectedFailed bool
@@ -39,11 +39,87 @@ func Test_command_result_outcome(t *testing.T) {
 		{"fail", false, true},
 		{"unknown", false, false},
 	}
-	for _, tt := range testFlags {
+	for _, tt := range testCases {
 		t.Run(fmt.Sprint(tt.status, "_status"), func(t *testing.T) {
 			result := CommandResult{Status: tt.status}
 			assert.Equal(t, tt.expectedPassed, result.Passed())
 			assert.Equal(t, tt.expectedFailed, result.Failed())
 		})
 	}
 }
+
+func Test_run_command(t *testing.T) {
+	testCases := []struct {
+		desc           string
+		command        Command
+		expectedStatus CommandStatus
+	}{
+		{
+			"unknown command",
+			Command{Path: "unknown-command"},
+			CommandStatusFail,
+		},
+		{
+			"passing command",
+			Command{Path: "true"},
+			CommandStatusPass,
+		},
+		{
+			"failing command",
+			Command{Path: "false"},
+			CommandStatusFail,
+		},
+	}
+
+	for _, tt := range testCases {
+		t.Run(tt.desc, func(t *testing.T) {
+			result := getCommandRunner().Run(&tt.command)
+			assert.Equal(t, tt.expectedStatus, result.Status)
+		})
+	}
+}
+
+func Test_abort_command(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		command  *Command
+		expected bool
+	}{
+		{
+			"with no running command",
+			nil,
+			false,
+		},
+		{
+			"with running command",
+			&Command{Path: "sleep", Arguments: []string{"10"}},
+			true,
+		},
+	}
+
+	for _, tt := range testCases {
+		t.Run(tt.desc, func(t *testing.T) {
+			if tt.command != nil {
+				logProcess(t, "before run")
+				go getCommandRunner().Run(tt.command)
+				logProcess(t, "after run")
+				// wait for the new command process to start
+				for getCommandRunner().command == nil {
+					time.Sleep(10 * time.Millisecond)
+				}
+				logProcess(t, "after waiting")
+			}
+			logProcess(t, "before abort")
+			result := getCommandRunner().AbortRunningCommand()
+			logProcess(t, "after abort")
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func logProcess(t *testing.T, stage string) {
+	t.Log(stage, ": ", getCommandRunner().command)
+	if getCommandRunner().command != nil {
+		t.Log("== process: ", getCommandRunner().command.Process)
+	}
+}

src/toolchain/toolchain.go

@@ -70,7 +70,7 @@ type (
 		checkTestCommand() error
 		runsOnPlatform(osName OsName, archName ArchName) bool
 		CheckCommandAccess(cmdPath string) (string, error)
-		AbortExecution()
+		AbortExecution() bool
 	}
 )
 
@@ -164,8 +164,8 @@ func (tchn Toolchain) RunTests() TestCommandResult {
 }
 
 // AbortExecution asks the toolchain to abort any command currently executing
-func (Toolchain) AbortExecution() {
-	commandRunner.AbortRunningCommand()
+func (Toolchain) AbortExecution() bool {
+	return commandRunner.AbortRunningCommand()
 }
 
 // BuildCommandPath returns the build command path for this toolchain