diff --git a/impl/runner.go b/impl/runner.go index 5328ee3..362db1b 100644 --- a/impl/runner.go +++ b/impl/runner.go @@ -137,12 +137,12 @@ func (wr *workflowRunnerImpl) Run(input interface{}) (output interface{}, err er wr.RunnerCtx.SetInput(input) // Run tasks sequentially wr.RunnerCtx.SetStatus(ctx.RunningStatus) - doRunner, err := NewDoTaskRunner(wr.Workflow.Do, wr) + doRunner, err := NewDoTaskRunner(wr.Workflow.Do) if err != nil { return nil, err } wr.RunnerCtx.SetStartedAt(time.Now()) - output, err = doRunner.Run(wr.RunnerCtx.GetInput()) + output, err = doRunner.Run(wr.RunnerCtx.GetInput(), wr) if err != nil { return nil, err } diff --git a/impl/task_runner.go b/impl/task_runner.go index 6d9069d..ea7b6dd 100644 --- a/impl/task_runner.go +++ b/impl/task_runner.go @@ -28,7 +28,7 @@ var _ TaskRunner = &ForTaskRunner{} var _ TaskRunner = &DoTaskRunner{} type TaskRunner interface { - Run(input interface{}) (interface{}, error) + Run(input interface{}, taskSupport TaskSupport) (interface{}, error) GetTaskName() string } diff --git a/impl/task_runner_call_http.go b/impl/task_runner_call_http.go new file mode 100644 index 0000000..3093506 --- /dev/null +++ b/impl/task_runner_call_http.go @@ -0,0 +1,44 @@ +// Copyright 2025 The Serverless Workflow Specification Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package impl + +import ( + "fmt" + + "github.com/serverlessworkflow/sdk-go/v3/model" +) + +type CallHTTPTaskRunner struct { + TaskName string +} + +func NewCallHttpRunner(taskName string, task *model.CallHTTP) (taskRunner *CallHTTPTaskRunner, err error) { + if task == nil { + err = model.NewErrValidation(fmt.Errorf("invalid For task %s", taskName), taskName) + } else { + taskRunner = new(CallHTTPTaskRunner) + taskRunner.TaskName = taskName + } + return +} + +func (f *CallHTTPTaskRunner) Run(input interface{}, taskSupport TaskSupport) (interface{}, error) { + return input, nil + +} + +func (f *CallHTTPTaskRunner) GetTaskName() string { + return f.TaskName +} diff --git a/impl/task_runner_do.go b/impl/task_runner_do.go index 81ef374..0301009 100644 --- a/impl/task_runner_do.go +++ b/impl/task_runner_do.go @@ -23,38 +23,38 @@ import ( ) // NewTaskRunner creates a TaskRunner instance based on the task type. -func NewTaskRunner(taskName string, task model.Task, taskSupport TaskSupport) (TaskRunner, error) { +func NewTaskRunner(taskName string, task model.Task, workflowDef *model.Workflow) (TaskRunner, error) { switch t := task.(type) { case *model.SetTask: - return NewSetTaskRunner(taskName, t, taskSupport) + return NewSetTaskRunner(taskName, t) case *model.RaiseTask: - return NewRaiseTaskRunner(taskName, t, taskSupport) + return NewRaiseTaskRunner(taskName, t, workflowDef) case *model.DoTask: - return NewDoTaskRunner(t.Do, taskSupport) + return NewDoTaskRunner(t.Do) case *model.ForTask: - return NewForTaskRunner(taskName, t, taskSupport) + return NewForTaskRunner(taskName, t) + case *model.CallHTTP: + return NewCallHttpRunner(taskName, t) default: return nil, fmt.Errorf("unsupported task type '%T' for task '%s'", t, taskName) } } -func NewDoTaskRunner(taskList *model.TaskList, taskSupport TaskSupport) (*DoTaskRunner, error) { +func NewDoTaskRunner(taskList *model.TaskList) (*DoTaskRunner, error) { return &DoTaskRunner{ - TaskList: taskList, - TaskSupport: taskSupport, + TaskList: taskList, }, nil } type DoTaskRunner struct { - TaskList *model.TaskList - TaskSupport TaskSupport + TaskList *model.TaskList } -func (d *DoTaskRunner) Run(input interface{}) (output interface{}, err error) { +func (d *DoTaskRunner) Run(input interface{}, taskSupport TaskSupport) (output interface{}, err error) { if d.TaskList == nil { return input, nil } - return d.runTasks(input, d.TaskList) + return d.runTasks(input, taskSupport) } func (d *DoTaskRunner) GetTaskName() string { @@ -62,71 +62,71 @@ func (d *DoTaskRunner) GetTaskName() string { } // runTasks runs all defined tasks sequentially. -func (d *DoTaskRunner) runTasks(input interface{}, tasks *model.TaskList) (output interface{}, err error) { +func (d *DoTaskRunner) runTasks(input interface{}, taskSupport TaskSupport) (output interface{}, err error) { output = input - if tasks == nil { + if d.TaskList == nil { return output, nil } idx := 0 - currentTask := (*tasks)[idx] + currentTask := (*d.TaskList)[idx] for currentTask != nil { - if err = d.TaskSupport.SetTaskDef(currentTask); err != nil { + if err = taskSupport.SetTaskDef(currentTask); err != nil { return nil, err } - if err = d.TaskSupport.SetTaskReferenceFromName(currentTask.Key); err != nil { + if err = taskSupport.SetTaskReferenceFromName(currentTask.Key); err != nil { return nil, err } - if shouldRun, err := d.shouldRunTask(input, currentTask); err != nil { + if shouldRun, err := d.shouldRunTask(input, taskSupport, currentTask); err != nil { return output, err } else if !shouldRun { - idx, currentTask = tasks.Next(idx) + idx, currentTask = d.TaskList.Next(idx) continue } - d.TaskSupport.SetTaskStatus(currentTask.Key, ctx.PendingStatus) + taskSupport.SetTaskStatus(currentTask.Key, ctx.PendingStatus) // Check if this task is a SwitchTask and handle it if switchTask, ok := currentTask.Task.(*model.SwitchTask); ok { - flowDirective, err := d.evaluateSwitchTask(input, currentTask.Key, switchTask) + flowDirective, err := d.evaluateSwitchTask(input, taskSupport, currentTask.Key, switchTask) if err != nil { - d.TaskSupport.SetTaskStatus(currentTask.Key, ctx.FaultedStatus) + taskSupport.SetTaskStatus(currentTask.Key, ctx.FaultedStatus) return output, err } - d.TaskSupport.SetTaskStatus(currentTask.Key, ctx.CompletedStatus) + taskSupport.SetTaskStatus(currentTask.Key, ctx.CompletedStatus) // Process FlowDirective: update idx/currentTask accordingly - idx, currentTask = tasks.KeyAndIndex(flowDirective.Value) + idx, currentTask = d.TaskList.KeyAndIndex(flowDirective.Value) if currentTask == nil { return nil, fmt.Errorf("flow directive target '%s' not found", flowDirective.Value) } continue } - runner, err := NewTaskRunner(currentTask.Key, currentTask.Task, d.TaskSupport) + runner, err := NewTaskRunner(currentTask.Key, currentTask.Task, taskSupport.GetWorkflowDef()) if err != nil { return output, err } - d.TaskSupport.SetTaskStatus(currentTask.Key, ctx.RunningStatus) - if output, err = d.runTask(input, runner, currentTask.Task.GetBase()); err != nil { - d.TaskSupport.SetTaskStatus(currentTask.Key, ctx.FaultedStatus) + taskSupport.SetTaskStatus(currentTask.Key, ctx.RunningStatus) + if output, err = d.runTask(input, taskSupport, runner, currentTask.Task.GetBase()); err != nil { + taskSupport.SetTaskStatus(currentTask.Key, ctx.FaultedStatus) return output, err } - d.TaskSupport.SetTaskStatus(currentTask.Key, ctx.CompletedStatus) + taskSupport.SetTaskStatus(currentTask.Key, ctx.CompletedStatus) input = deepCloneValue(output) - idx, currentTask = tasks.Next(idx) + idx, currentTask = d.TaskList.Next(idx) } return output, nil } -func (d *DoTaskRunner) shouldRunTask(input interface{}, task *model.TaskItem) (bool, error) { +func (d *DoTaskRunner) shouldRunTask(input interface{}, taskSupport TaskSupport, task *model.TaskItem) (bool, error) { if task.GetBase().If != nil { - output, err := traverseAndEvaluateBool(task.GetBase().If.String(), input, d.TaskSupport.GetContext()) + output, err := traverseAndEvaluateBool(task.GetBase().If.String(), input, taskSupport.GetContext()) if err != nil { return false, model.NewErrExpression(err, task.Key) } @@ -135,7 +135,7 @@ func (d *DoTaskRunner) shouldRunTask(input interface{}, task *model.TaskItem) (b return true, nil } -func (d *DoTaskRunner) evaluateSwitchTask(input interface{}, taskKey string, switchTask *model.SwitchTask) (*model.FlowDirective, error) { +func (d *DoTaskRunner) evaluateSwitchTask(input interface{}, taskSupport TaskSupport, taskKey string, switchTask *model.SwitchTask) (*model.FlowDirective, error) { var defaultThen *model.FlowDirective for _, switchItem := range switchTask.Switch { for _, switchCase := range switchItem { @@ -143,7 +143,7 @@ func (d *DoTaskRunner) evaluateSwitchTask(input interface{}, taskKey string, swi defaultThen = switchCase.Then continue } - result, err := traverseAndEvaluateBool(model.NormalizeExpr(switchCase.When.String()), input, d.TaskSupport.GetContext()) + result, err := traverseAndEvaluateBool(model.NormalizeExpr(switchCase.When.String()), input, taskSupport.GetContext()) if err != nil { return nil, model.NewErrExpression(err, taskKey) } @@ -162,31 +162,31 @@ func (d *DoTaskRunner) evaluateSwitchTask(input interface{}, taskKey string, swi } // runTask executes an individual task. -func (d *DoTaskRunner) runTask(input interface{}, runner TaskRunner, task *model.TaskBase) (output interface{}, err error) { +func (d *DoTaskRunner) runTask(input interface{}, taskSupport TaskSupport, runner TaskRunner, task *model.TaskBase) (output interface{}, err error) { taskName := runner.GetTaskName() - d.TaskSupport.SetTaskStartedAt(time.Now()) - d.TaskSupport.SetTaskRawInput(input) - d.TaskSupport.SetTaskName(taskName) + taskSupport.SetTaskStartedAt(time.Now()) + taskSupport.SetTaskRawInput(input) + taskSupport.SetTaskName(taskName) if task.Input != nil { - if input, err = d.processTaskInput(task, input, taskName); err != nil { + if input, err = d.processTaskInput(task, input, taskSupport, taskName); err != nil { return nil, err } } - output, err = runner.Run(input) + output, err = runner.Run(input, taskSupport) if err != nil { return nil, err } - d.TaskSupport.SetTaskRawOutput(output) + taskSupport.SetTaskRawOutput(output) - if output, err = d.processTaskOutput(task, output, taskName); err != nil { + if output, err = d.processTaskOutput(task, output, taskSupport, taskName); err != nil { return nil, err } - if err = d.processTaskExport(task, output, taskName); err != nil { + if err = d.processTaskExport(task, output, taskSupport, taskName); err != nil { return nil, err } @@ -194,7 +194,7 @@ func (d *DoTaskRunner) runTask(input interface{}, runner TaskRunner, task *model } // processTaskInput processes task input validation and transformation. -func (d *DoTaskRunner) processTaskInput(task *model.TaskBase, taskInput interface{}, taskName string) (output interface{}, err error) { +func (d *DoTaskRunner) processTaskInput(task *model.TaskBase, taskInput interface{}, taskSupport TaskSupport, taskName string) (output interface{}, err error) { if task.Input == nil { return taskInput, nil } @@ -203,7 +203,7 @@ func (d *DoTaskRunner) processTaskInput(task *model.TaskBase, taskInput interfac return nil, err } - if output, err = traverseAndEvaluate(task.Input.From, taskInput, taskName, d.TaskSupport.GetContext()); err != nil { + if output, err = traverseAndEvaluate(task.Input.From, taskInput, taskName, taskSupport.GetContext()); err != nil { return nil, err } @@ -211,12 +211,12 @@ func (d *DoTaskRunner) processTaskInput(task *model.TaskBase, taskInput interfac } // processTaskOutput processes task output validation and transformation. -func (d *DoTaskRunner) processTaskOutput(task *model.TaskBase, taskOutput interface{}, taskName string) (output interface{}, err error) { +func (d *DoTaskRunner) processTaskOutput(task *model.TaskBase, taskOutput interface{}, taskSupport TaskSupport, taskName string) (output interface{}, err error) { if task.Output == nil { return taskOutput, nil } - if output, err = traverseAndEvaluate(task.Output.As, taskOutput, taskName, d.TaskSupport.GetContext()); err != nil { + if output, err = traverseAndEvaluate(task.Output.As, taskOutput, taskName, taskSupport.GetContext()); err != nil { return nil, err } @@ -227,12 +227,12 @@ func (d *DoTaskRunner) processTaskOutput(task *model.TaskBase, taskOutput interf return output, nil } -func (d *DoTaskRunner) processTaskExport(task *model.TaskBase, taskOutput interface{}, taskName string) (err error) { +func (d *DoTaskRunner) processTaskExport(task *model.TaskBase, taskOutput interface{}, taskSupport TaskSupport, taskName string) (err error) { if task.Export == nil { return nil } - output, err := traverseAndEvaluate(task.Export.As, taskOutput, taskName, d.TaskSupport.GetContext()) + output, err := traverseAndEvaluate(task.Export.As, taskOutput, taskName, taskSupport.GetContext()) if err != nil { return err } @@ -241,7 +241,7 @@ func (d *DoTaskRunner) processTaskExport(task *model.TaskBase, taskOutput interf return nil } - d.TaskSupport.SetWorkflowInstanceCtx(output) + taskSupport.SetWorkflowInstanceCtx(output) return nil } diff --git a/impl/task_runner_for.go b/impl/task_runner_for.go index fb7bcff..a53348d 100644 --- a/impl/task_runner_for.go +++ b/impl/task_runner_for.go @@ -28,38 +28,36 @@ const ( forTaskDefaultAt = "$index" ) -func NewForTaskRunner(taskName string, task *model.ForTask, taskSupport TaskSupport) (*ForTaskRunner, error) { +func NewForTaskRunner(taskName string, task *model.ForTask) (*ForTaskRunner, error) { if task == nil || task.Do == nil { return nil, model.NewErrValidation(fmt.Errorf("invalid For task %s", taskName), taskName) } - doRunner, err := NewDoTaskRunner(task.Do, taskSupport) + doRunner, err := NewDoTaskRunner(task.Do) if err != nil { return nil, err } return &ForTaskRunner{ - Task: task, - TaskName: taskName, - DoRunner: doRunner, - TaskSupport: taskSupport, + Task: task, + TaskName: taskName, + DoRunner: doRunner, }, nil } type ForTaskRunner struct { - Task *model.ForTask - TaskName string - DoRunner *DoTaskRunner - TaskSupport TaskSupport + Task *model.ForTask + TaskName string + DoRunner *DoTaskRunner } -func (f *ForTaskRunner) Run(input interface{}) (interface{}, error) { +func (f *ForTaskRunner) Run(input interface{}, taskSupport TaskSupport) (interface{}, error) { defer func() { // clear local variables - f.TaskSupport.RemoveLocalExprVars(f.Task.For.Each, f.Task.For.At) + taskSupport.RemoveLocalExprVars(f.Task.For.Each, f.Task.For.At) }() f.sanitizeFor() - in, err := expr.TraverseAndEvaluate(f.Task.For.In, input, f.TaskSupport.GetContext()) + in, err := expr.TraverseAndEvaluate(f.Task.For.In, input, taskSupport.GetContext()) if err != nil { return nil, err } @@ -71,11 +69,11 @@ func (f *ForTaskRunner) Run(input interface{}) (interface{}, error) { for i := 0; i < rv.Len(); i++ { item := rv.Index(i).Interface() - if forOutput, err = f.processForItem(i, item, forOutput); err != nil { + if forOutput, err = f.processForItem(i, item, taskSupport, forOutput); err != nil { return nil, err } if f.Task.While != "" { - whileIsTrue, err := traverseAndEvaluateBool(f.Task.While, forOutput, f.TaskSupport.GetContext()) + whileIsTrue, err := traverseAndEvaluateBool(f.Task.While, forOutput, taskSupport.GetContext()) if err != nil { return nil, err } @@ -87,7 +85,7 @@ func (f *ForTaskRunner) Run(input interface{}) (interface{}, error) { case reflect.Invalid: return input, nil default: - if forOutput, err = f.processForItem(0, in, forOutput); err != nil { + if forOutput, err = f.processForItem(0, in, taskSupport, forOutput); err != nil { return nil, err } } @@ -95,16 +93,16 @@ func (f *ForTaskRunner) Run(input interface{}) (interface{}, error) { return forOutput, nil } -func (f *ForTaskRunner) processForItem(idx int, item interface{}, forOutput interface{}) (interface{}, error) { +func (f *ForTaskRunner) processForItem(idx int, item interface{}, taskSupport TaskSupport, forOutput interface{}) (interface{}, error) { forVars := map[string]interface{}{ f.Task.For.At: idx, f.Task.For.Each: item, } // Instead of Set, we Add since other tasks in this very same context might be adding variables to the context - f.TaskSupport.AddLocalExprVars(forVars) + taskSupport.AddLocalExprVars(forVars) // output from previous iterations are merged together var err error - forOutput, err = f.DoRunner.Run(forOutput) + forOutput, err = f.DoRunner.Run(forOutput, taskSupport) if err != nil { return nil, err } diff --git a/impl/task_runner_raise.go b/impl/task_runner_raise.go index b59f01d..0de588f 100644 --- a/impl/task_runner_raise.go +++ b/impl/task_runner_raise.go @@ -20,8 +20,8 @@ import ( "github.com/serverlessworkflow/sdk-go/v3/model" ) -func NewRaiseTaskRunner(taskName string, task *model.RaiseTask, taskSupport TaskSupport) (*RaiseTaskRunner, error) { - if err := resolveErrorDefinition(task, taskSupport.GetWorkflowDef()); err != nil { +func NewRaiseTaskRunner(taskName string, task *model.RaiseTask, workflowDef *model.Workflow) (*RaiseTaskRunner, error) { + if err := resolveErrorDefinition(task, workflowDef); err != nil { return nil, err } @@ -29,9 +29,8 @@ func NewRaiseTaskRunner(taskName string, task *model.RaiseTask, taskSupport Task return nil, model.NewErrValidation(fmt.Errorf("no raise configuration provided for RaiseTask %s", taskName), taskName) } return &RaiseTaskRunner{ - Task: task, - TaskName: taskName, - TaskSupport: taskSupport, + Task: task, + TaskName: taskName, }, nil } @@ -53,9 +52,8 @@ func resolveErrorDefinition(t *model.RaiseTask, workflowDef *model.Workflow) err } type RaiseTaskRunner struct { - Task *model.RaiseTask - TaskName string - TaskSupport TaskSupport + Task *model.RaiseTask + TaskName string } var raiseErrFuncMapping = map[string]func(error, string) *model.Error{ @@ -69,22 +67,22 @@ var raiseErrFuncMapping = map[string]func(error, string) *model.Error{ model.ErrorTypeTimeout: model.NewErrTimeout, } -func (r *RaiseTaskRunner) Run(input interface{}) (output interface{}, err error) { +func (r *RaiseTaskRunner) Run(input interface{}, taskSupport TaskSupport) (output interface{}, err error) { output = input // TODO: make this an external func so we can call it after getting the reference? Or we can get the reference from the workflow definition var detailResult interface{} - detailResult, err = traverseAndEvaluate(r.Task.Raise.Error.Definition.Detail.AsObjectOrRuntimeExpr(), input, r.TaskName, r.TaskSupport.GetContext()) + detailResult, err = traverseAndEvaluate(r.Task.Raise.Error.Definition.Detail.AsObjectOrRuntimeExpr(), input, r.TaskName, taskSupport.GetContext()) if err != nil { return nil, err } var titleResult interface{} - titleResult, err = traverseAndEvaluate(r.Task.Raise.Error.Definition.Title.AsObjectOrRuntimeExpr(), input, r.TaskName, r.TaskSupport.GetContext()) + titleResult, err = traverseAndEvaluate(r.Task.Raise.Error.Definition.Title.AsObjectOrRuntimeExpr(), input, r.TaskName, taskSupport.GetContext()) if err != nil { return nil, err } - instance := r.TaskSupport.GetTaskReference() + instance := taskSupport.GetTaskReference() var raiseErr *model.Error if raiseErrF, ok := raiseErrFuncMapping[r.Task.Raise.Error.Definition.Type.String()]; ok { diff --git a/impl/task_runner_raise_test.go b/impl/task_runner_raise_test.go index 0c55f3a..3de0aae 100644 --- a/impl/task_runner_raise_test.go +++ b/impl/task_runner_raise_test.go @@ -45,10 +45,11 @@ func TestRaiseTaskRunner_WithDefinedError(t *testing.T) { assert.NoError(t, err) wfCtx.SetTaskReference("task_raise_defined") - runner, err := NewRaiseTaskRunner("task_raise_defined", raiseTask, newTaskSupport(withRunnerCtx(wfCtx))) + taskSupport := newTaskSupport(withRunnerCtx(wfCtx)) + runner, err := NewRaiseTaskRunner("task_raise_defined", raiseTask, taskSupport.GetWorkflowDef()) assert.NoError(t, err) - output, err := runner.Run(input) + output, err := runner.Run(input, taskSupport) assert.Equal(t, output, input) assert.Error(t, err) @@ -76,7 +77,7 @@ func TestRaiseTaskRunner_WithReferencedError(t *testing.T) { }, } - runner, err := NewRaiseTaskRunner("task_raise_ref", raiseTask, newTaskSupport()) + runner, err := NewRaiseTaskRunner("task_raise_ref", raiseTask, &model.Workflow{}) assert.Error(t, err) assert.Nil(t, runner) } @@ -103,10 +104,11 @@ func TestRaiseTaskRunner_TimeoutErrorWithExpression(t *testing.T) { assert.NoError(t, err) wfCtx.SetTaskReference("task_raise_timeout_expr") - runner, err := NewRaiseTaskRunner("task_raise_timeout_expr", raiseTask, newTaskSupport(withRunnerCtx(wfCtx))) + taskSupport := newTaskSupport(withRunnerCtx(wfCtx)) + runner, err := NewRaiseTaskRunner("task_raise_timeout_expr", raiseTask, taskSupport.GetWorkflowDef()) assert.NoError(t, err) - output, err := runner.Run(input) + output, err := runner.Run(input, taskSupport) assert.Equal(t, input, output) assert.Error(t, err) diff --git a/impl/task_runner_set.go b/impl/task_runner_set.go index fc40e74..40ff185 100644 --- a/impl/task_runner_set.go +++ b/impl/task_runner_set.go @@ -20,30 +20,28 @@ import ( "github.com/serverlessworkflow/sdk-go/v3/model" ) -func NewSetTaskRunner(taskName string, task *model.SetTask, taskSupport TaskSupport) (*SetTaskRunner, error) { +func NewSetTaskRunner(taskName string, task *model.SetTask) (*SetTaskRunner, error) { if task == nil || task.Set == nil { return nil, model.NewErrValidation(fmt.Errorf("no set configuration provided for SetTask %s", taskName), taskName) } return &SetTaskRunner{ - Task: task, - TaskName: taskName, - TaskSupport: taskSupport, + Task: task, + TaskName: taskName, }, nil } type SetTaskRunner struct { - Task *model.SetTask - TaskName string - TaskSupport TaskSupport + Task *model.SetTask + TaskName string } func (s *SetTaskRunner) GetTaskName() string { return s.TaskName } -func (s *SetTaskRunner) Run(input interface{}) (output interface{}, err error) { +func (s *SetTaskRunner) Run(input interface{}, taskSupport TaskSupport) (output interface{}, err error) { setObject := deepClone(s.Task.Set) - result, err := traverseAndEvaluate(model.NewObjectOrRuntimeExpr(setObject), input, s.TaskName, s.TaskSupport.GetContext()) + result, err := traverseAndEvaluate(model.NewObjectOrRuntimeExpr(setObject), input, s.TaskName, taskSupport.GetContext()) if err != nil { return nil, err } diff --git a/impl/task_set_test.go b/impl/task_set_test.go index c1d5534..c02d76d 100644 --- a/impl/task_set_test.go +++ b/impl/task_set_test.go @@ -45,10 +45,10 @@ func TestSetTaskExecutor_Exec(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task1", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task1", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -79,10 +79,10 @@ func TestSetTaskExecutor_StaticValues(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_static", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_static", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -109,10 +109,10 @@ func TestSetTaskExecutor_RuntimeExpressions(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_runtime_expr", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_runtime_expr", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -141,10 +141,10 @@ func TestSetTaskExecutor_NestedStructures(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_nested_structures", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_nested_structures", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -176,10 +176,10 @@ func TestSetTaskExecutor_StaticAndDynamicValues(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_static_dynamic", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_static_dynamic", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -201,10 +201,10 @@ func TestSetTaskExecutor_MissingInputData(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_missing_input", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_missing_input", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) assert.Nil(t, output.(map[string]interface{})["value"]) } @@ -220,10 +220,10 @@ func TestSetTaskExecutor_ExpressionsWithFunctions(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_expr_functions", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_expr_functions", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -246,10 +246,10 @@ func TestSetTaskExecutor_ConditionalExpressions(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_conditional_expr", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_conditional_expr", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -273,10 +273,10 @@ func TestSetTaskExecutor_ArrayDynamicIndex(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_array_indexing", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_array_indexing", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -299,10 +299,10 @@ func TestSetTaskExecutor_NestedConditionalLogic(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_nested_condition", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_nested_condition", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -323,10 +323,10 @@ func TestSetTaskExecutor_DefaultValues(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_default_values", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_default_values", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -363,10 +363,10 @@ func TestSetTaskExecutor_ComplexNestedStructures(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_complex_nested", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_complex_nested", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{ @@ -399,10 +399,10 @@ func TestSetTaskExecutor_MultipleExpressions(t *testing.T) { }, } - executor, err := NewSetTaskRunner("task_multiple_expr", setTask, newTaskSupport()) + executor, err := NewSetTaskRunner("task_multiple_expr", setTask) assert.NoError(t, err) - output, err := executor.Run(input) + output, err := executor.Run(input, newTaskSupport()) assert.NoError(t, err) expectedOutput := map[string]interface{}{