Fix execute action and command parsing

Author: bukka

conf/parser/factory/actions.go

@@ -147,6 +147,10 @@ func (f *NativeActionsFactory) parseAction(
 		benchAction := &types.BenchAction{Service: meta.serviceName}
 		err = f.structParser(data, benchAction, path)
 		action = benchAction
+	case "execute":
+		executeAction := &types.ExecuteAction{Service: meta.serviceName}
+		err = f.structParser(data, executeAction, path)
+		action = executeAction
 	case "expect":
 		customNameAllowed = true
 		action, err = f.parseExpectationAction(meta, data, path)

conf/parser/factory/actions_test.go

@@ -91,6 +91,27 @@ func TestNativeActionsFactory_ParseActions(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "Valid execute action",
+			actions: []interface{}{
+				"execute/serviceName",
+			},
+			mockParseCalls: []struct {
+				data map[string]interface{}
+				path string
+				err  error
+			}{
+				{
+					data: map[string]interface{}{},
+					path: staticPath,
+					err:  nil,
+				},
+			},
+			want: []types.Action{
+				&types.ExecuteAction{Service: "serviceName"},
+			},
+			wantErr: false,
+		},
 		{
 			name: "Invalid action format - too many elements",
 			actions: []interface{}{

conf/parser/factory/functions.go

@@ -110,12 +110,20 @@ func (f *FuncProvider) createCommand(data interface{}, fieldValue reflect.Value,
 	var command types.Command
 	switch v := data.(type) {
 	case string:
-		command = types.ShellCommand{
+		command = &types.ShellCommand{
 			Command: v,
 		}
-	case []string:
-		command = types.ArgsCommand{
-			Args: v,
+	case []interface{}:
+		args := make([]string, 0, len(v))
+		for _, item := range v {
+			if str, ok := item.(string); ok {
+				args = append(args, str)
+			} else {
+				return errors.Errorf("invalid command data at %s", f.loc.String())
+			}
+		}
+		command = &types.ArgsCommand{
+			Args: args,
 		}
 	default:
 		return errors.Errorf("unsupported type for command data at %s", f.loc.String())

conf/parser/factory/functions_test.go

@@ -158,6 +158,58 @@ func TestFuncProvider_GetFactoryFunc(t *testing.T) {
 			wantErr:       true,
 			errMsg:        "data must be an array, got int",
 		},
+		// Command
+		{
+			name:     "createCommand with string shell command",
+			funcName: "createCommand",
+			data:     "echo hello world",
+			expectedValue: &types.ShellCommand{
+				Command: "echo hello world",
+			},
+			wantErr: false,
+		},
+		{
+			name:     "createCommand with args array",
+			funcName: "createCommand",
+			data:     []interface{}{"ls", "-la", "/tmp"},
+			expectedValue: &types.ArgsCommand{
+				Args: []string{"ls", "-la", "/tmp"},
+			},
+			wantErr: false,
+		},
+		{
+			name:          "createCommand with args array containing non-string element",
+			funcName:      "createCommand",
+			data:          []interface{}{"ls", 123, "/tmp"},
+			expectedValue: &types.ShellCommand{}, // Use a concrete type that implements Command
+			wantErr:       true,
+			errMsg:        "invalid command data",
+		},
+		{
+			name:          "createCommand with invalid data type",
+			funcName:      "createCommand",
+			data:          123,                  // Invalid type for command data
+			expectedValue: &types.ArgsCommand{}, // Use a concrete type that implements Command
+			wantErr:       true,
+			errMsg:        "unsupported type for command data",
+		},
+		{
+			name:     "createCommand with empty args array",
+			funcName: "createCommand",
+			data:     []interface{}{},
+			expectedValue: &types.ArgsCommand{
+				Args: []string{},
+			},
+			wantErr: false,
+		},
+		{
+			name:          "createCommand with map data",
+			funcName:      "createCommand",
+			data:          map[string]interface{}{"command": "echo hello"},
+			expectedValue: &types.ShellCommand{}, // Use a concrete type that implements Command
+			wantErr:       true,
+			errMsg:        "unsupported type for command data",
+		},
 		// Container image
 		{
 			name:     "createContainerImage with name and tag",