[#390] Ensure toolchain command execution returns failure when command is not found

- Also improve smoke tests to verify behaviour for both a failing command and a command not found

Author: mengdaming

src/toolchain/command_runner.go

@@ -91,6 +91,12 @@ func (r *CommandRunner) Run(cmd *Command) (result CommandResult) {
 	errStart := r.command.Start()
 	if errStart != nil {
 		report.PostError("Failed to run command: ", errStart.Error())
+		// We currently return fail status when command cannot be launched.
+		// This is to replicate previous implementation's behaviour where
+		// we could not differentiate between failure to launch and failure from execution.
+		// We could later on use a different return value in this situation,
+		// but we need to ensure first that TCR engine can handle it correctly.
+		result.Status = CommandStatusFail
 		r.command = nil
 		return result
 	}

src/toolchain/smoke_test.go

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2023 Murex
+Copyright (c) 2024 Murex
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -31,19 +31,57 @@ const (
 	toolchainName = "gradle-wrapper"
 )
 
-func Test_toolchain_returns_error_when_build_fails(t *testing.T) {
+func Test_toolchain_returns_error_when_build_command_is_not_found(t *testing.T) {
+	// Command does not exist in testDataRootDir
 	assertErrorWhenBuildFails(t, toolchainName, testDataRootDir)
 }
 
+func Test_toolchain_returns_error_when_build_command_fails(t *testing.T) {
+	tchn, _ := Get(toolchainName)
+	// Add a built-in toolchain from a valid one, but with invalid build command arguments.
+	// This allows to actually run the build command and get an execution error out of it
+	failingName := tchn.GetName() + "-failing-build"
+	var failingCommands []Command
+	for _, cmd := range tchn.GetBuildCommands() {
+		failingCommands = append(failingCommands, Command{
+			Os:        cmd.Os,
+			Arch:      cmd.Arch,
+			Path:      cmd.Path,
+			Arguments: []string{"-invalid-argument"},
+		})
+	}
+	_ = addBuiltIn(New(failingName, failingCommands, tchn.GetTestCommands(), tchn.GetTestResultDir()))
+	assertErrorWhenBuildFails(t, failingName, testDataDirJava)
+}
+
 func Test_toolchain_returns_ok_when_build_passes(t *testing.T) {
 	utils.SlowTestTag(t)
 	assertNoErrorWhenBuildPasses(t, toolchainName, testDataDirJava)
 }
 
-func Test_toolchain_returns_error_when_tests_fail(t *testing.T) {
+func Test_toolchain_returns_error_when_test_command_is_not_found(t *testing.T) {
+	// Command does not exist in testDataRootDir
 	assertErrorWhenTestFails(t, toolchainName, testDataRootDir)
 }
 
+func Test_toolchain_returns_error_when_test_command_fails(t *testing.T) {
+	// Add a built-in toolchain from a valid one, but with invalid test command arguments.
+	// This allows to actually run the test command and get an execution error out of it
+	tchn, _ := Get(toolchainName)
+	failingName := tchn.GetName() + "-failing-test"
+	var failingCommands []Command
+	for _, cmd := range tchn.GetTestCommands() {
+		failingCommands = append(failingCommands, Command{
+			Os:        cmd.Os,
+			Arch:      cmd.Arch,
+			Path:      cmd.Path,
+			Arguments: []string{"-invalid-argument"},
+		})
+	}
+	_ = addBuiltIn(New(failingName, tchn.GetBuildCommands(), failingCommands, tchn.GetTestResultDir()))
+	assertErrorWhenTestFails(t, failingName, testDataDirJava)
+}
+
 func Test_toolchain_returns_ok_when_tests_pass(t *testing.T) {
 	utils.SlowTestTag(t)
 	assertNoErrorWhenTestPasses(t, toolchainName, testDataDirJava)