diff --git a/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go b/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go index 82c33d30f34..811d1454844 100644 --- a/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go +++ b/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go @@ -32,6 +32,7 @@ import ( "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" "github.com/tektoncd/pipeline/pkg/reconciler/pipeline/dag" "github.com/tektoncd/pipeline/pkg/reconciler/taskrun/resources" + testhelpers "github.com/tektoncd/pipeline/pkg/reconciler/testing" resolutioncommon "github.com/tektoncd/pipeline/pkg/resolution/common" "github.com/tektoncd/pipeline/pkg/trustedresources" "github.com/tektoncd/pipeline/test/diff" @@ -59,169 +60,173 @@ func nopGetTaskRun(string) (*v1.TaskRun, error) { return nil, errors.New("GetTaskRun should not be called") } -var pts = []v1.PipelineTask{{ - Name: "mytask1", - TaskRef: &v1.TaskRef{Name: "task"}, -}, { - Name: "mytask2", - TaskRef: &v1.TaskRef{Name: "task"}, -}, { - Name: "mytask3", - TaskRef: &v1.TaskRef{Name: "task"}, -}, { - Name: "mytask4", - TaskRef: &v1.TaskRef{Name: "task"}, - Retries: 1, -}, { - Name: "mytask5", - TaskRef: &v1.TaskRef{Name: "cancelledTask"}, - Retries: 2, -}, { - Name: "mytask6", - TaskRef: &v1.TaskRef{Name: "task"}, -}, { - Name: "mytask7", - TaskRef: &v1.TaskRef{Name: "taskWithOneParent"}, - RunAfter: []string{"mytask6"}, -}, { - Name: "mytask8", - TaskRef: &v1.TaskRef{Name: "taskWithTwoParents"}, - RunAfter: []string{"mytask1", "mytask6"}, -}, { - Name: "mytask9", - TaskRef: &v1.TaskRef{Name: "taskHasParentWithRunAfter"}, - RunAfter: []string{"mytask8"}, -}, { - Name: "mytask10", - TaskRef: &v1.TaskRef{Name: "taskWithWhenExpressions"}, - When: []v1.WhenExpression{{ - Input: "foo", - Operator: selection.In, - Values: []string{"foo", "bar"}, - }}, -}, { - Name: "mytask11", - TaskRef: &v1.TaskRef{Name: "taskWithWhenExpressions"}, - When: []v1.WhenExpression{{ - Input: "foo", - Operator: selection.NotIn, - Values: []string{"foo", "bar"}, - }}, -}, { - Name: "mytask12", - TaskRef: &v1.TaskRef{Name: "taskWithWhenExpressions"}, - When: []v1.WhenExpression{{ - Input: "foo", - Operator: selection.In, - Values: []string{"foo", "bar"}, - }}, - RunAfter: []string{"mytask1"}, -}, { - Name: "mytask13", - TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, -}, { - Name: "mytask14", - TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, -}, { - Name: "mytask15", - TaskRef: &v1.TaskRef{Name: "taskWithReferenceToTaskResult"}, - Params: v1.Params{{Name: "param1", Value: *v1.NewStructuredValues("$(tasks.mytask1.results.result1)")}}, -}, { - Name: "mytask16", - Matrix: &v1.Matrix{ - Params: v1.Params{{ - Name: "browser", - Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, - }}, - }, -}, { - Name: "mytask17", - Matrix: &v1.Matrix{ - Params: v1.Params{{ - Name: "browser", - Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, - }}, - }, -}, { - Name: "mytask18", - TaskRef: &v1.TaskRef{Name: "task"}, - Retries: 1, - Matrix: &v1.Matrix{ - Params: v1.Params{{ - Name: "browser", - Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, - }}, - }, -}, { - Name: "mytask19", - TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, - Matrix: &v1.Matrix{ - Params: v1.Params{{ - Name: "browser", - Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, - }}, - }, -}, { - Name: "mytask20", - TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, - Matrix: &v1.Matrix{ - Params: v1.Params{{ - Name: "browser", - Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, - }}, - }, -}, { - Name: "mytask21", - TaskRef: &v1.TaskRef{Name: "task"}, - Retries: 2, - Matrix: &v1.Matrix{ - Params: v1.Params{{ - Name: "browser", - Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, - }}, - }, -}} - -var p = &v1.Pipeline{ - ObjectMeta: metav1.ObjectMeta{ - Namespace: "namespace", - Name: "pipeline", - }, - Spec: v1.PipelineSpec{ - Tasks: pts, - }, -} - -var task = &v1.Task{ - ObjectMeta: metav1.ObjectMeta{ - Name: "task", - }, - Spec: v1.TaskSpec{ - Steps: []v1.Step{{ - Name: "step1", - }}, - }, -} - -var trs = []v1.TaskRun{{ - ObjectMeta: metav1.ObjectMeta{ - Namespace: "namespace", - Name: "pipelinerun-mytask1", - }, - Spec: v1.TaskRunSpec{}, -}, { - ObjectMeta: metav1.ObjectMeta{ - Namespace: "namespace", - Name: "pipelinerun-mytask2", - }, - Spec: v1.TaskRunSpec{}, -}, { - ObjectMeta: metav1.ObjectMeta{ - Namespace: "namespace", - Name: "pipelinerun-mytask4", - }, - Spec: v1.TaskRunSpec{}, -}} +// TODO: Remove this +// var pts = []v1.PipelineTask{{ +// Name: "mytask1", +// TaskRef: &v1.TaskRef{Name: "task"}, +// }, { +// Name: "mytask2", +// TaskRef: &v1.TaskRef{Name: "task"}, +// }, { +// Name: "mytask3", +// TaskRef: &v1.TaskRef{Name: "task"}, +// }, { +// Name: "mytask4", +// TaskRef: &v1.TaskRef{Name: "task"}, +// Retries: 1, +// }, { +// Name: "mytask5", +// TaskRef: &v1.TaskRef{Name: "cancelledTask"}, +// Retries: 2, +// }, { +// Name: "mytask6", +// TaskRef: &v1.TaskRef{Name: "task"}, +// }, { +// Name: "mytask7", +// TaskRef: &v1.TaskRef{Name: "taskWithOneParent"}, +// RunAfter: []string{"mytask6"}, +// }, { +// Name: "mytask8", +// TaskRef: &v1.TaskRef{Name: "taskWithTwoParents"}, +// RunAfter: []string{"mytask1", "mytask6"}, +// }, { +// Name: "mytask9", +// TaskRef: &v1.TaskRef{Name: "taskHasParentWithRunAfter"}, +// RunAfter: []string{"mytask8"}, +// }, { +// Name: "mytask10", +// TaskRef: &v1.TaskRef{Name: "taskWithWhenExpressions"}, +// When: []v1.WhenExpression{{ +// Input: "foo", +// Operator: selection.In, +// Values: []string{"foo", "bar"}, +// }}, +// }, { +// Name: "mytask11", +// TaskRef: &v1.TaskRef{Name: "taskWithWhenExpressions"}, +// When: []v1.WhenExpression{{ +// Input: "foo", +// Operator: selection.NotIn, +// Values: []string{"foo", "bar"}, +// }}, +// }, { +// Name: "mytask12", +// TaskRef: &v1.TaskRef{Name: "taskWithWhenExpressions"}, +// When: []v1.WhenExpression{{ +// Input: "foo", +// Operator: selection.In, +// Values: []string{"foo", "bar"}, +// }}, +// RunAfter: []string{"mytask1"}, +// }, { +// Name: "mytask13", +// TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, +// }, { +// Name: "mytask14", +// TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, +// }, { +// Name: "mytask15", +// TaskRef: &v1.TaskRef{Name: "taskWithReferenceToTaskResult"}, +// Params: v1.Params{{Name: "param1", Value: *v1.NewStructuredValues("$(tasks.mytask1.results.result1)")}}, +// }, { +// Name: "mytask16", +// Matrix: &v1.Matrix{ +// Params: v1.Params{{ +// Name: "browser", +// Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, +// }}, +// }, +// }, { +// Name: "mytask17", +// Matrix: &v1.Matrix{ +// Params: v1.Params{{ +// Name: "browser", +// Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, +// }}, +// }, +// }, { +// Name: "mytask18", +// TaskRef: &v1.TaskRef{Name: "task"}, +// Retries: 1, +// Matrix: &v1.Matrix{ +// Params: v1.Params{{ +// Name: "browser", +// Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, +// }}, +// }, +// }, { +// Name: "mytask19", +// TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, +// Matrix: &v1.Matrix{ +// Params: v1.Params{{ +// Name: "browser", +// Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, +// }}, +// }, +// }, { +// Name: "mytask20", +// TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, +// Matrix: &v1.Matrix{ +// Params: v1.Params{{ +// Name: "browser", +// Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, +// }}, +// }, +// }, { +// Name: "mytask21", +// TaskRef: &v1.TaskRef{Name: "task"}, +// Retries: 2, +// Matrix: &v1.Matrix{ +// Params: v1.Params{{ +// Name: "browser", +// Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, +// }}, +// }, +// }} + +// TODO: Remove this +// var p = &v1.Pipeline{ +// ObjectMeta: metav1.ObjectMeta{ +// Namespace: "namespace", +// Name: "pipeline", +// }, +// Spec: v1.PipelineSpec{ +// Tasks: testhelpers.PipelineTasks, +// }, +// } + +// TODO: Remove this +// var task = &v1.Task{ +// ObjectMeta: metav1.ObjectMeta{ +// Name: "task", +// }, +// Spec: v1.TaskSpec{ +// Steps: []v1.Step{{ +// Name: "step1", +// }}, +// }, +// } + +// TODO: Remove this +// var trs = []v1.TaskRun{{ +// ObjectMeta: metav1.ObjectMeta{ +// Namespace: "namespace", +// Name: "pipelinerun-mytask1", +// }, +// Spec: v1.TaskRunSpec{}, +// }, { +// ObjectMeta: metav1.ObjectMeta{ +// Namespace: "namespace", +// Name: "pipelinerun-mytask2", +// }, +// Spec: v1.TaskRunSpec{}, +// }, { +// ObjectMeta: metav1.ObjectMeta{ +// Namespace: "namespace", +// Name: "pipelinerun-mytask4", +// }, +// Spec: v1.TaskRunSpec{}, +// }} var customRuns = []v1beta1.CustomRun{{ ObjectMeta: metav1.ObjectMeta{ @@ -414,302 +419,302 @@ func newCustomRun(run v1beta1.CustomRun) *v1beta1.CustomRun { } var noneStartedState = PipelineRunState{{ - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask1"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[1], + PipelineTask: &testhelpers.PipelineTasks[1], TaskRunNames: []string{"pipelinerun-mytask2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var oneStartedState = PipelineRunState{{ - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[1], + PipelineTask: &testhelpers.PipelineTasks[1], TaskRunNames: []string{"pipelinerun-mytask2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var oneFinishedState = PipelineRunState{{ - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[1], + PipelineTask: &testhelpers.PipelineTasks[1], TaskRunNames: []string{"pipelinerun-mytask2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var oneFailedState = PipelineRunState{{ - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[1], + PipelineTask: &testhelpers.PipelineTasks[1], TaskRunNames: []string{"pipelinerun-mytask2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var finalScheduledState = PipelineRunState{{ - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[1], + PipelineTask: &testhelpers.PipelineTasks[1], TaskRunNames: []string{"pipelinerun-mytask2"}, - TaskRuns: []*v1.TaskRun{makeScheduled(trs[1])}, + TaskRuns: []*v1.TaskRun{makeScheduled(testhelpers.ExampleTaskRuns[1])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var allFinishedState = PipelineRunState{{ - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[1], + PipelineTask: &testhelpers.PipelineTasks[1], TaskRunNames: []string{"pipelinerun-mytask2"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var noCustomRunStartedState = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: nil, }, { - PipelineTask: &pts[13], + PipelineTask: &testhelpers.PipelineTasks[13], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask14"}, CustomRuns: nil, }} var oneCustomRunStartedState = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunStarted(customRuns[0])}, }, { - PipelineTask: &pts[13], + PipelineTask: &testhelpers.PipelineTasks[13], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask14"}, CustomRuns: nil, }} var oneCustomRunFinishedState = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunSucceeded(customRuns[0])}, }, { - PipelineTask: &pts[13], + PipelineTask: &testhelpers.PipelineTasks[13], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask14"}, CustomRuns: nil, }} var oneCustomRunFailedState = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunFailed(customRuns[0])}, }, { - PipelineTask: &pts[13], + PipelineTask: &testhelpers.PipelineTasks[13], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask14"}, CustomRuns: nil, }} var taskCancelled = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var customRunCancelled = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: []*v1beta1.CustomRun{withCustomRunCancelled(newCustomRun(customRuns[0]))}, }} var noneStartedStateMatrix = PipelineRunState{{ - PipelineTask: &pts[15], + PipelineTask: &testhelpers.PipelineTasks[15], TaskRunNames: []string{"pipelinerun-mytask1"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[16], + PipelineTask: &testhelpers.PipelineTasks[16], TaskRunNames: []string{"pipelinerun-mytask3"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var oneStartedStateMatrix = PipelineRunState{{ - PipelineTask: &pts[15], + PipelineTask: &testhelpers.PipelineTasks[15], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[16], + PipelineTask: &testhelpers.PipelineTasks[16], TaskRunNames: []string{"pipelinerun-mytask2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var oneFinishedStateMatrix = PipelineRunState{{ - PipelineTask: &pts[15], + PipelineTask: &testhelpers.PipelineTasks[15], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[16], + PipelineTask: &testhelpers.PipelineTasks[16], TaskRunNames: []string{"pipelinerun-mytask2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var oneFailedStateMatrix = PipelineRunState{{ - PipelineTask: &pts[15], + PipelineTask: &testhelpers.PipelineTasks[15], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[16], + PipelineTask: &testhelpers.PipelineTasks[16], TaskRunNames: []string{"pipelinerun-mytask2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var finalScheduledStateMatrix = PipelineRunState{{ - PipelineTask: &pts[15], + PipelineTask: &testhelpers.PipelineTasks[15], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[16], + PipelineTask: &testhelpers.PipelineTasks[16], TaskRunNames: []string{"pipelinerun-mytask2"}, - TaskRuns: []*v1.TaskRun{makeScheduled(trs[1])}, + TaskRuns: []*v1.TaskRun{makeScheduled(testhelpers.ExampleTaskRuns[1])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var allFinishedStateMatrix = PipelineRunState{{ - PipelineTask: &pts[15], + PipelineTask: &testhelpers.PipelineTasks[15], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[16], + PipelineTask: &testhelpers.PipelineTasks[16], TaskRunNames: []string{"pipelinerun-mytask2"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var noCustomRunStartedStateMatrix = PipelineRunState{{ - PipelineTask: &pts[18], + PipelineTask: &testhelpers.PipelineTasks[18], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: nil, }, { - PipelineTask: &pts[19], + PipelineTask: &testhelpers.PipelineTasks[19], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: nil, }} var oneCustomRunStartedStateMatrix = PipelineRunState{{ - PipelineTask: &pts[18], + PipelineTask: &testhelpers.PipelineTasks[18], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunStarted(customRuns[0])}, }, { - PipelineTask: &pts[19], + PipelineTask: &testhelpers.PipelineTasks[19], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask14"}, CustomRuns: nil, }} var oneCustomRunFailedStateMatrix = PipelineRunState{{ - PipelineTask: &pts[18], + PipelineTask: &testhelpers.PipelineTasks[18], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunFailed(customRuns[0])}, }, { - PipelineTask: &pts[19], + PipelineTask: &testhelpers.PipelineTasks[19], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask14"}, CustomRuns: nil, }} var taskCancelledMatrix = PipelineRunState{{ - PipelineTask: &pts[20], + PipelineTask: &testhelpers.PipelineTasks[20], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} @@ -757,18 +762,18 @@ func TestIsSkipped(t *testing.T) { }, { name: "tasks-parent-failed", state: PipelineRunState{{ - PipelineTask: &pts[5], + PipelineTask: &testhelpers.PipelineTasks[5], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[6], // mytask7 runAfter mytask6 + PipelineTask: &testhelpers.PipelineTasks[6], // mytask7 runAfter mytask6 TaskRunNames: []string{"pipelinerun-mytask2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -777,18 +782,18 @@ func TestIsSkipped(t *testing.T) { }, { name: "tasks-parent-cancelled", state: PipelineRunState{{ - PipelineTask: &pts[5], + PipelineTask: &testhelpers.PipelineTasks[5], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[6], // mytask7 runAfter mytask6 + PipelineTask: &testhelpers.PipelineTasks[6], // mytask7 runAfter mytask6 TaskRunNames: []string{"pipelinerun-mytask2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -797,18 +802,18 @@ func TestIsSkipped(t *testing.T) { }, { name: "tasks-grandparent-failed", state: PipelineRunState{{ - PipelineTask: &pts[5], + PipelineTask: &testhelpers.PipelineTasks[5], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[6], // mytask7 runAfter mytask6 + PipelineTask: &testhelpers.PipelineTasks[6], // mytask7 runAfter mytask6 TaskRunNames: []string{"pipelinerun-mytask2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { PipelineTask: &v1.PipelineTask{ @@ -819,7 +824,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-mytask3"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -828,25 +833,25 @@ func TestIsSkipped(t *testing.T) { }, { name: "tasks-parents-failed-passed", state: PipelineRunState{{ - PipelineTask: &pts[5], + PipelineTask: &testhelpers.PipelineTasks[5], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask2"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[7], // mytask8 runAfter mytask1, mytask6 + PipelineTask: &testhelpers.PipelineTasks[7], // mytask8 runAfter mytask1, mytask6 TaskRunNames: []string{"pipelinerun-mytask3"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -855,25 +860,25 @@ func TestIsSkipped(t *testing.T) { }, { name: "task-failed-pipeline-stopping", state: PipelineRunState{{ - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[5], + PipelineTask: &testhelpers.PipelineTasks[5], TaskRunNames: []string{"pipelinerun-mytask2"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[1])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[6], // mytask7 runAfter mytask6 + PipelineTask: &testhelpers.PipelineTasks[6], // mytask7 runAfter mytask6 TaskRunNames: []string{"pipelinerun-mytask3"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -882,11 +887,11 @@ func TestIsSkipped(t *testing.T) { }, { name: "tasks-when-expressions-passed", state: PipelineRunState{{ - PipelineTask: &pts[9], + PipelineTask: &testhelpers.PipelineTasks[9], TaskRunNames: []string{"pipelinerun-guardedtask"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -895,11 +900,11 @@ func TestIsSkipped(t *testing.T) { }, { name: "tasks-when-expression-failed", state: PipelineRunState{{ - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], TaskRunNames: []string{"pipelinerun-guardedtask"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -908,16 +913,16 @@ func TestIsSkipped(t *testing.T) { }, { name: "when-expression-task-but-without-parent-done", state: PipelineRunState{{ - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[11], + PipelineTask: &testhelpers.PipelineTasks[11], TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -939,11 +944,11 @@ func TestIsSkipped(t *testing.T) { name: "tasks-when-expressions", state: PipelineRunState{{ // skipped because when expressions evaluate to false - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], TaskRunNames: []string{"pipelinerun-guardedtask"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // not skipped regardless of its parent task being skipped because when expressions are scoped to task @@ -955,7 +960,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-ordering-dependent-task-1"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -966,11 +971,11 @@ func TestIsSkipped(t *testing.T) { name: "tasks-when-expressions-run-multiple-dependent-tasks", state: PipelineRunState{{ // skipped because when expressions evaluate to false - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], TaskRunNames: []string{"pipelinerun-guardedtask"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // not skipped regardless of its parent task being skipped because when expressions are scoped to task @@ -982,7 +987,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-ordering-dependent-task-1"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // not skipped regardless of its grandparent task being skipped because when expressions are scoped to task @@ -994,7 +999,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-ordering-dependent-task-2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -1006,11 +1011,11 @@ func TestIsSkipped(t *testing.T) { name: "tasks-when-expressions-run-multiple-ordering-and-resource-dependent-tasks", state: PipelineRunState{{ // skipped because when expressions evaluate to false - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], TaskRunNames: []string{"pipelinerun-guardedtask"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // not skipped regardless of its parent task mytask11 being skipped because when expressions are scoped to task @@ -1022,7 +1027,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-ordering-dependent-task-1"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // not skipped regardless of its grandparent task mytask11 being skipped because when expressions are scoped to task @@ -1034,7 +1039,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-ordering-dependent-task-2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // attempted but skipped because of missing result in params from parent task mytask11 which was skipped @@ -1049,7 +1054,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-resource-dependent-task-1"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // skipped because of parent task mytask20 was skipped because of missing result from grandparent task @@ -1062,7 +1067,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-ordering-dependent-task-3"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // attempted but skipped because of missing result from parent task mytask11 which was skipped in when expressions @@ -1078,7 +1083,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-resource-dependent-task-2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // not skipped because of parent task mytask22 was skipping because when condition @@ -1090,7 +1095,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-ordering-dependent-task-4"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -1158,7 +1163,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-matrix-empty-params"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // skipped empty ArrayVal exist in matrix param @@ -1178,7 +1183,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-matrix-empty-params"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // skipped empty ArrayVal exist in matrix param @@ -1204,7 +1209,7 @@ func TestIsSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-matrix-empty-params"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -1273,7 +1278,7 @@ func TestIsFailure(t *testing.T) { name: "taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, }, want: false, }, { @@ -1288,7 +1293,7 @@ func TestIsFailure(t *testing.T) { name: "taskrun succeeded", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, }, want: false, }, { @@ -1303,7 +1308,7 @@ func TestIsFailure(t *testing.T) { name: "taskrun failed", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }, want: true, }, { @@ -1326,7 +1331,7 @@ func TestIsFailure(t *testing.T) { name: "taskrun failed - Retried", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task", Retries: 1}, - TaskRuns: []*v1.TaskRun{withRetries(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: true, }, { @@ -1341,21 +1346,21 @@ func TestIsFailure(t *testing.T) { name: "taskrun cancelled", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: true, }, { name: "taskrun cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "taskrun cancelled for timeout", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: true, }, { @@ -1386,7 +1391,7 @@ func TestIsFailure(t *testing.T) { name: "taskrun cancelled: retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task", Retries: 1}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: true, }, { @@ -1401,7 +1406,7 @@ func TestIsFailure(t *testing.T) { name: "taskrun cancelled: retried", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task", Retries: 1}, - TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(trs[0])))}, + TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[0])))}, }, want: true, }, { @@ -1429,7 +1434,7 @@ func TestIsFailure(t *testing.T) { name: "matrixed taskruns running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -1444,7 +1449,7 @@ func TestIsFailure(t *testing.T) { name: "one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0]), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0]), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -1459,14 +1464,14 @@ func TestIsFailure(t *testing.T) { name: "matrixed taskruns succeeded", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0]), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0]), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { name: "one matrixed taskrun succeeded", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -1481,7 +1486,7 @@ func TestIsFailure(t *testing.T) { name: "matrixed taskruns failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0]), makeFailed(trs[1])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0]), makeFailed(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -1496,7 +1501,7 @@ func TestIsFailure(t *testing.T) { name: "one matrixed taskrun failed, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -1511,7 +1516,7 @@ func TestIsFailure(t *testing.T) { name: "matrixed taskruns failed: retried", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withRetries(makeFailed(trs[0])), withRetries(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeFailed(testhelpers.ExampleTaskRuns[0])), withRetries(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: true, }, { @@ -1526,7 +1531,7 @@ func TestIsFailure(t *testing.T) { name: "matrixed taskruns failed: one taskrun with retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(trs[0])), withRetries(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(testhelpers.ExampleTaskRuns[0])), withRetries(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: false, }, { @@ -1549,7 +1554,7 @@ func TestIsFailure(t *testing.T) { name: "matrixed taskruns cancelled", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), withCancelled(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), withCancelled(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: true, }, { @@ -1564,7 +1569,7 @@ func TestIsFailure(t *testing.T) { name: "one matrixed taskrun cancelled, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -1579,7 +1584,7 @@ func TestIsFailure(t *testing.T) { name: "matrixed taskruns cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0])), withCancelled(newTaskRun(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0])), withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[1]))}, }, want: false, }, { @@ -1594,7 +1599,7 @@ func TestIsFailure(t *testing.T) { name: "one matrixed taskrun cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -1609,7 +1614,7 @@ func TestIsFailure(t *testing.T) { name: "matrixed taskruns cancelled: retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), withCancelled(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), withCancelled(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: true, }, { @@ -1624,7 +1629,7 @@ func TestIsFailure(t *testing.T) { name: "one matrixed taskrun cancelled: retries remaining, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -1639,7 +1644,7 @@ func TestIsFailure(t *testing.T) { name: "matrixed taskruns cancelled: retried", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(trs[0]))), withCancelled(withRetries(makeFailed(trs[1])))}, + TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[0]))), withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[1])))}, }, want: true, }, { @@ -1654,7 +1659,7 @@ func TestIsFailure(t *testing.T) { name: "one matrixed taskrun cancelled: retried, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(trs[0]))), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[0]))), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -1688,43 +1693,43 @@ func TestIsCancelled(t *testing.T) { }, { name: "taskrun not done", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, }, want: false, }, { name: "taskrun succeeded but not cancelled", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{(makeSucceeded(trs[0]))}, + TaskRuns: []*v1.TaskRun{(makeSucceeded(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "taskrun failed but not cancelled", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "taskrun cancelled and failed", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: true, }, { name: "taskrun cancelled but still running", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{withCancelled(makeStarted(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeStarted(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "one taskrun cancelled, one not done", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { name: "one taskrun cancelled, one done but not cancelled", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -1807,49 +1812,49 @@ func TestIsCancelledForTimeout(t *testing.T) { }, { name: "taskrun not done", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, }, want: false, }, { name: "taskrun succeeded but not cancelled", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{(makeSucceeded(trs[0]))}, + TaskRuns: []*v1.TaskRun{(makeSucceeded(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "taskrun failed but not cancelled", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "taskrun cancelled by spec and failed", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{withCancelledBySpec(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelledBySpec(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "taskrun cancelled for timeout and failed", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: true, }, { name: "taskrun cancelled for timeout but still running", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeStarted(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeStarted(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "one taskrun cancelled for timeout, one not done", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { name: "one taskrun cancelled for timeout, one done but not cancelled", rpt: ResolvedPipelineTask{ - TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(trs[0])), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(testhelpers.ExampleTaskRuns[0])), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -2088,42 +2093,42 @@ func TestHaveAnyTaskRunsFailed(t *testing.T) { name: "taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, }, want: false, }, { name: "taskrun succeeded", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, }, want: false, }, { name: "taskrun failed", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }, want: true, }, { name: "taskrun cancelled", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: true, }, { name: "taskrun cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "taskrun cancelled for timeout", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: true, }, { @@ -2136,70 +2141,70 @@ func TestHaveAnyTaskRunsFailed(t *testing.T) { name: "matrixed taskruns running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { name: "one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0]), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0]), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { name: "matrixed taskruns succeeded", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0]), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0]), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { name: "one matrixed taskrun succeeded", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { name: "matrixed taskruns failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0]), makeFailed(trs[1])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0]), makeFailed(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { name: "one matrixed taskrun failed, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { name: "matrixed taskruns cancelled", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), withCancelled(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), withCancelled(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: true, }, { name: "one matrixed taskrun cancelled, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { name: "matrixed taskruns cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0])), withCancelled(newTaskRun(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0])), withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[1]))}, }, want: false, }, { name: "one matrixed taskrun cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }} { @@ -2220,17 +2225,17 @@ func TestSkipBecauseParentTaskWasSkipped(t *testing.T) { name: "when-expression-task-but-without-parent-done", state: PipelineRunState{{ // parent task has when expressions but is not yet done - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // child task not skipped because parent is not yet done - PipelineTask: &pts[11], + PipelineTask: &testhelpers.PipelineTasks[11], TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -2240,11 +2245,11 @@ func TestSkipBecauseParentTaskWasSkipped(t *testing.T) { name: "tasks-when-expressions", state: PipelineRunState{{ // parent task is skipped because when expressions evaluate to false, not because of its parent tasks - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], TaskRunNames: []string{"pipelinerun-guardedtask"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // child task is not skipped regardless of its parent task being skipped due to when expressions evaluating @@ -2257,7 +2262,7 @@ func TestSkipBecauseParentTaskWasSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-ordering-dependent-task-1"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -2268,11 +2273,11 @@ func TestSkipBecauseParentTaskWasSkipped(t *testing.T) { name: "tasks-when-expressions-run-multiple-dependent-tasks", state: PipelineRunState{{ // parent task is skipped because when expressions evaluate to false, not because of its parent tasks - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], TaskRunNames: []string{"pipelinerun-guardedtask"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // child task is not skipped regardless of its parent task being skipped due to when expressions evaluating @@ -2285,7 +2290,7 @@ func TestSkipBecauseParentTaskWasSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-ordering-dependent-task-1"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { // child task is not skipped regardless of its parent task being skipped due to when expressions evaluating @@ -2298,7 +2303,7 @@ func TestSkipBecauseParentTaskWasSkipped(t *testing.T) { TaskRunNames: []string{"pipelinerun-ordering-dependent-task-2"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, expected: map[string]bool{ @@ -2423,9 +2428,9 @@ func TestResolvePipelineRun_PipelineTaskHasNoResources(t *testing.T) { }} getTask := func(ctx context.Context, name string) (*v1.Task, *v1.RefSource, *trustedresources.VerificationResult, error) { - return task, nil, nil, nil + return testhelpers.ExampleTask, nil, nil, nil } - getTaskRun := func(name string) (*v1.TaskRun, error) { return &trs[0], nil } + getTaskRun := func(name string) (*v1.TaskRun, error) { return &testhelpers.ExampleTaskRuns[0], nil } pr := v1.PipelineRun{ ObjectMeta: metav1.ObjectMeta{ Name: "pipelinerun", @@ -2435,7 +2440,7 @@ func TestResolvePipelineRun_PipelineTaskHasNoResources(t *testing.T) { for _, task := range pts { ps, err := ResolvePipelineTask(t.Context(), pr, getTask, getTaskRun, nopGetCustomRun, task, nil) if err != nil { - t.Errorf("Error getting tasks for fake pipeline %s: %s", p.ObjectMeta.Name, err) + t.Errorf("Error getting tasks for fake pipeline %s: %s", testhelpers.ExamplePipeline.ObjectMeta.Name, err) } pipelineState = append(pipelineState, ps) } @@ -2443,8 +2448,8 @@ func TestResolvePipelineRun_PipelineTaskHasNoResources(t *testing.T) { t.Fatalf("Expected only 2 resolved PipelineTasks but got %d", len(pipelineState)) } expectedTask := &resources.ResolvedTask{ - TaskName: task.Name, - TaskSpec: &task.Spec, + TaskName: testhelpers.ExampleTask.Name, + TaskSpec: &testhelpers.ExampleTask.Spec, } if d := cmp.Diff(expectedTask, pipelineState[0].ResolvedTask, cmpopts.IgnoreUnexported(v1.TaskRunSpec{})); d != "" { t.Fatalf("Expected resources where only Tasks were resolved but actual differed %s", diff.PrintWantGot(d)) @@ -2461,9 +2466,9 @@ func TestResolvePipelineRun_PipelineTaskHasPipelineRef(t *testing.T) { } getTask := func(ctx context.Context, name string) (*v1.Task, *v1.RefSource, *trustedresources.VerificationResult, error) { - return task, nil, nil, nil + return testhelpers.ExampleTask, nil, nil, nil } - getTaskRun := func(name string) (*v1.TaskRun, error) { return &trs[0], nil } + getTaskRun := func(name string) (*v1.TaskRun, error) { return &testhelpers.ExampleTaskRuns[0], nil } pr := v1.PipelineRun{ ObjectMeta: metav1.ObjectMeta{ Name: "pipelinerun", @@ -2472,10 +2477,10 @@ func TestResolvePipelineRun_PipelineTaskHasPipelineRef(t *testing.T) { _, err := ResolvePipelineTask(t.Context(), pr, getTask, getTaskRun, nopGetCustomRun, pt, nil) if err == nil { - t.Errorf("Error getting tasks for fake pipeline %s, expected an error but got nil.", p.ObjectMeta.Name) + t.Errorf("Error getting tasks for fake pipeline %s, expected an error but got nil.", testhelpers.ExamplePipeline.ObjectMeta.Name) } if !strings.Contains(err.Error(), "does not support PipelineRef or PipelineSpec") { - t.Errorf("Error getting tasks for fake pipeline %s: expected contains keyword but got %s", p.ObjectMeta.Name, err) + t.Errorf("Error getting tasks for fake pipeline %s: expected contains keyword but got %s", testhelpers.ExamplePipeline.ObjectMeta.Name, err) } } @@ -2526,14 +2531,14 @@ func TestResolvePipelineRun_TaskDoesntExist(t *testing.T) { var tnf *TaskNotFoundError switch { case err == nil: - t.Fatalf("Pipeline %s: want error, got nil", p.Name) + t.Fatalf("Pipeline %s: want error, got nil", testhelpers.ExamplePipeline.Name) case errors.As(err, &tnf): // expected error if len(tnf.Name) == 0 { - t.Fatalf("Pipeline %s: TaskNotFoundError did not have name set: %s", p.Name, tnf.Error()) + t.Fatalf("Pipeline %s: TaskNotFoundError did not have name set: %s", testhelpers.ExamplePipeline.Name, tnf.Error()) } default: - t.Fatalf("Pipeline %s: Want %T, got %s of type %T", p.Name, tnf, err, err) + t.Fatalf("Pipeline %s: Want %T, got %s of type %T", testhelpers.ExamplePipeline.Name, tnf, err, err) } } } @@ -2557,7 +2562,7 @@ func TestResolvePipelineRun_VerificationFailed(t *testing.T) { }} verificationResult := &trustedresources.VerificationResult{VerificationResultType: trustedresources.VerificationError, Err: trustedresources.ErrResourceVerificationFailed} getTask := func(ctx context.Context, name string) (*v1.Task, *v1.RefSource, *trustedresources.VerificationResult, error) { - return task, nil, verificationResult, nil + return testhelpers.ExampleTask, nil, verificationResult, nil } getTaskRun := func(name string) (*v1.TaskRun, error) { return nil, nil } //nolint:nilnil pr := v1.PipelineRun{ @@ -2580,7 +2585,7 @@ func TestResolvePipelineRun_TransientError(t *testing.T) { } getTask := func(ctx context.Context, name string) (*v1.Task, *v1.RefSource, *trustedresources.VerificationResult, error) { - return task, nil, nil, apierrors.NewTimeoutError("some dang ol' timeout", 5) + return testhelpers.ExampleTask, nil, nil, apierrors.NewTimeoutError("some dang ol' timeout", 5) } getTaskRun := func(name string) (*v1.TaskRun, error) { return nil, nil } //nolint:nilnil pr := v1.PipelineRun{ @@ -2812,7 +2817,7 @@ func TestResolvePipeline_WhenExpressions(t *testing.T) { } getTask := func(_ context.Context, name string) (*v1.Task, *v1.RefSource, *trustedresources.VerificationResult, error) { - return task, nil, nil, nil + return testhelpers.ExampleTask, nil, nil, nil } pr := v1.PipelineRun{ ObjectMeta: metav1.ObjectMeta{ @@ -2825,7 +2830,7 @@ func TestResolvePipeline_WhenExpressions(t *testing.T) { case "pipelinerun-mytask1-always-true-0": return t1, nil case "pipelinerun-mytask1": - return &trs[0], nil + return &testhelpers.ExampleTaskRuns[0], nil } return nil, fmt.Errorf("getTaskRun called with unexpected name %s", name) } @@ -2845,7 +2850,7 @@ func TestIsCustomTask(t *testing.T) { }, } getTask := func(ctx context.Context, name string) (*v1.Task, *v1.RefSource, *trustedresources.VerificationResult, error) { - return task, nil, nil, nil + return testhelpers.ExampleTask, nil, nil, nil } getTaskRun := func(name string) (*v1.TaskRun, error) { return nil, nil } //nolint:nilnil getRun := func(name string) (*v1beta1.CustomRun, error) { return nil, nil } //nolint:nilnil @@ -3615,9 +3620,9 @@ func TestIsMatrixed(t *testing.T) { }, } getTask := func(ctx context.Context, name string) (*v1.Task, *v1.RefSource, *trustedresources.VerificationResult, error) { - return task, nil, nil, nil + return testhelpers.ExampleTask, nil, nil, nil } - getTaskRun := func(name string) (*v1.TaskRun, error) { return &trs[0], nil } + getTaskRun := func(name string) (*v1.TaskRun, error) { return &testhelpers.ExampleTaskRuns[0], nil } getRun := func(name string) (*v1beta1.CustomRun, error) { return &customRuns[0], nil } for _, tc := range []struct { @@ -3791,7 +3796,7 @@ func TestResolvePipelineRunTask_WithMatrix(t *testing.T) { }} getTask := func(ctx context.Context, name string) (*v1.Task, *v1.RefSource, *trustedresources.VerificationResult, error) { - return task, nil, nil, nil + return testhelpers.ExampleTask, nil, nil, nil } getTaskRun := func(name string) (*v1.TaskRun, error) { return taskRunsMap[name], nil } getRun := func(name string) (*v1beta1.CustomRun, error) { return &customRuns[0], nil } @@ -3943,9 +3948,9 @@ func TestResolvePipelineRunTask_WithMatrixedCustomTask(t *testing.T) { }} getTask := func(ctx context.Context, name string) (*v1.Task, *v1.RefSource, *trustedresources.VerificationResult, error) { - return task, nil, nil, nil + return testhelpers.ExampleTask, nil, nil, nil } - getTaskRun := func(name string) (*v1.TaskRun, error) { return &trs[0], nil } + getTaskRun := func(name string) (*v1.TaskRun, error) { return &testhelpers.ExampleTaskRuns[0], nil } getRun := func(name string) (*v1beta1.CustomRun, error) { return runsMap[name], nil } for _, tc := range []struct { @@ -4041,7 +4046,7 @@ func TestIsSuccessful(t *testing.T) { name: "taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, }, want: false, }, { @@ -4056,7 +4061,7 @@ func TestIsSuccessful(t *testing.T) { name: "taskrun succeeded", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, }, want: true, }, { @@ -4071,7 +4076,7 @@ func TestIsSuccessful(t *testing.T) { name: "taskrun failed", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }, want: false, }, { @@ -4086,7 +4091,7 @@ func TestIsSuccessful(t *testing.T) { name: "taskrun failed: retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task", Retries: 1}, - TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { @@ -4109,14 +4114,14 @@ func TestIsSuccessful(t *testing.T) { name: "taskrun cancelled", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "taskrun cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { @@ -4139,7 +4144,7 @@ func TestIsSuccessful(t *testing.T) { name: "taskrun cancelled: retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task", Retries: 1}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { @@ -4154,7 +4159,7 @@ func TestIsSuccessful(t *testing.T) { name: "taskrun cancelled: retried", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task", Retries: 1}, - TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(trs[0])))}, + TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[0])))}, }, want: false, }, { @@ -4182,7 +4187,7 @@ func TestIsSuccessful(t *testing.T) { name: "matrixed taskruns running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4197,7 +4202,7 @@ func TestIsSuccessful(t *testing.T) { name: "one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0]), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0]), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4212,7 +4217,7 @@ func TestIsSuccessful(t *testing.T) { name: "matrixed taskruns succeeded", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0]), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0]), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -4227,7 +4232,7 @@ func TestIsSuccessful(t *testing.T) { name: "one matrixed taskrun succeeded", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4242,7 +4247,7 @@ func TestIsSuccessful(t *testing.T) { name: "matrixed taskruns failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0]), makeFailed(trs[1])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0]), makeFailed(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4257,7 +4262,7 @@ func TestIsSuccessful(t *testing.T) { name: "one matrixed taskrun failed, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4272,7 +4277,7 @@ func TestIsSuccessful(t *testing.T) { name: "matrixed taskruns failed: retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(trs[0])), withRetries(makeToBeRetried(trs[1]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(testhelpers.ExampleTaskRuns[0])), withRetries(makeToBeRetried(testhelpers.ExampleTaskRuns[1]))}, }, want: false, }, { @@ -4287,7 +4292,7 @@ func TestIsSuccessful(t *testing.T) { name: "matrixed taskruns failed: one taskrun with retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(trs[0])), withRetries(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(testhelpers.ExampleTaskRuns[0])), withRetries(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: false, }, { @@ -4310,7 +4315,7 @@ func TestIsSuccessful(t *testing.T) { name: "matrixed taskruns cancelled", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), withCancelled(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), withCancelled(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: false, }, { @@ -4325,7 +4330,7 @@ func TestIsSuccessful(t *testing.T) { name: "one matrixed taskrun cancelled, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4340,7 +4345,7 @@ func TestIsSuccessful(t *testing.T) { name: "matrixed taskruns cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0])), withCancelled(newTaskRun(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0])), withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[1]))}, }, want: false, }, { @@ -4355,7 +4360,7 @@ func TestIsSuccessful(t *testing.T) { name: "one matrixed taskrun cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4370,7 +4375,7 @@ func TestIsSuccessful(t *testing.T) { name: "matrixed taskruns cancelled: retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), withCancelled(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), withCancelled(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: false, }, { @@ -4385,7 +4390,7 @@ func TestIsSuccessful(t *testing.T) { name: "one matrixed taskrun cancelled: retries remaining, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4400,7 +4405,7 @@ func TestIsSuccessful(t *testing.T) { name: "matrixed taskruns cancelled: retried", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(trs[0]))), withCancelled(withRetries(makeFailed(trs[1])))}, + TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[0]))), withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[1])))}, }, want: false, }, { @@ -4415,7 +4420,7 @@ func TestIsSuccessful(t *testing.T) { name: "one matrixed taskrun cancelled: retried, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(trs[0]))), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[0]))), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4457,7 +4462,7 @@ func TestIsRunning(t *testing.T) { name: "taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, }, want: true, }, { @@ -4472,7 +4477,7 @@ func TestIsRunning(t *testing.T) { name: "taskrun succeeded", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, }, want: false, }, { @@ -4487,7 +4492,7 @@ func TestIsRunning(t *testing.T) { name: "taskrun failed", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }, want: false, }, { @@ -4502,7 +4507,7 @@ func TestIsRunning(t *testing.T) { name: "taskrun failed: retried", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task", Retries: 1}, - TaskRuns: []*v1.TaskRun{withRetries(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { @@ -4525,14 +4530,14 @@ func TestIsRunning(t *testing.T) { name: "taskrun cancelled", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { name: "taskrun cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0]))}, }, want: true, }, { @@ -4555,7 +4560,7 @@ func TestIsRunning(t *testing.T) { name: "taskrun cancelled: retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task", Retries: 1}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: false, }, { @@ -4570,7 +4575,7 @@ func TestIsRunning(t *testing.T) { name: "taskrun cancelled: retried", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task", Retries: 1}, - TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(trs[0])))}, + TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[0])))}, }, want: false, }, { @@ -4598,7 +4603,7 @@ func TestIsRunning(t *testing.T) { name: "matrixed taskruns running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -4613,7 +4618,7 @@ func TestIsRunning(t *testing.T) { name: "one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0]), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0]), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -4628,7 +4633,7 @@ func TestIsRunning(t *testing.T) { name: "matrixed taskruns succeeded", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0]), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0]), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4643,7 +4648,7 @@ func TestIsRunning(t *testing.T) { name: "matrixed taskruns failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0]), makeFailed(trs[1])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0]), makeFailed(testhelpers.ExampleTaskRuns[1])}, }, want: false, }, { @@ -4658,7 +4663,7 @@ func TestIsRunning(t *testing.T) { name: "one matrixed taskrun failed, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0]), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0]), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -4673,7 +4678,7 @@ func TestIsRunning(t *testing.T) { name: "matrixed taskruns failed: retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(trs[0])), withRetries(makeToBeRetried(trs[1]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(testhelpers.ExampleTaskRuns[0])), withRetries(makeToBeRetried(testhelpers.ExampleTaskRuns[1]))}, }, want: true, }, { @@ -4688,7 +4693,7 @@ func TestIsRunning(t *testing.T) { name: "matrixed taskruns failed: one taskrun with retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(trs[0])), withRetries(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(testhelpers.ExampleTaskRuns[0])), withRetries(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: true, }, { @@ -4711,7 +4716,7 @@ func TestIsRunning(t *testing.T) { name: "matrixed taskruns cancelled", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), withCancelled(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), withCancelled(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: false, }, { @@ -4726,7 +4731,7 @@ func TestIsRunning(t *testing.T) { name: "one matrixed taskrun cancelled, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -4741,7 +4746,7 @@ func TestIsRunning(t *testing.T) { name: "matrixed taskruns cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0])), withCancelled(newTaskRun(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0])), withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[1]))}, }, want: true, }, { @@ -4756,7 +4761,7 @@ func TestIsRunning(t *testing.T) { name: "one matrixed taskrun cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -4771,7 +4776,7 @@ func TestIsRunning(t *testing.T) { name: "matrixed taskruns cancelled: retries remaining", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), withCancelled(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), withCancelled(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: false, }, { @@ -4786,7 +4791,7 @@ func TestIsRunning(t *testing.T) { name: "one matrixed taskrun cancelled: retries remaining, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -4801,7 +4806,7 @@ func TestIsRunning(t *testing.T) { name: "matrixed taskruns cancelled: retried", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(trs[0]))), withCancelled(withRetries(makeFailed(trs[1])))}, + TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[0]))), withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[1])))}, }, want: false, }, { @@ -4816,7 +4821,7 @@ func TestIsRunning(t *testing.T) { name: "one matrixed taskrun cancelled: retried, one matrixed taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: withPipelineTaskRetries(*matrixedPipelineTask, 1), - TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(trs[0]))), makeStarted(trs[1])}, + TaskRuns: []*v1.TaskRun{withCancelled(withRetries(makeFailed(testhelpers.ExampleTaskRuns[0]))), makeStarted(testhelpers.ExampleTaskRuns[1])}, }, want: true, }, { @@ -4871,7 +4876,7 @@ func TestGetReason(t *testing.T) { name: "taskrun running", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, }, }, { @@ -4886,7 +4891,7 @@ func TestGetReason(t *testing.T) { name: "taskrun succeeded", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, }, want: "Succeeded", }, @@ -4903,7 +4908,7 @@ func TestGetReason(t *testing.T) { name: "taskrun failed", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }, want: "Failed", }, @@ -4920,7 +4925,7 @@ func TestGetReason(t *testing.T) { name: "taskrun failed: retried", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task", Retries: 1}, - TaskRuns: []*v1.TaskRun{withRetries(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: "Failed", }, @@ -4937,7 +4942,7 @@ func TestGetReason(t *testing.T) { name: "taskrun cancelled", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }, want: v1.TaskRunReasonCancelled.String(), }, @@ -4945,7 +4950,7 @@ func TestGetReason(t *testing.T) { name: "taskrun cancelled but not failed", rpt: ResolvedPipelineTask{ PipelineTask: &v1.PipelineTask{Name: "task"}, - TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(newTaskRun(testhelpers.ExampleTaskRuns[0]))}, }, want: v1.TaskRunReasonCancelled.String(), }, @@ -4971,7 +4976,7 @@ func TestGetReason(t *testing.T) { name: "matrixed taskruns succeeded", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0]), makeSucceeded(trs[1])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0]), makeSucceeded(testhelpers.ExampleTaskRuns[1])}, }, want: "Succeeded", }, @@ -4988,7 +4993,7 @@ func TestGetReason(t *testing.T) { name: "matrixed taskruns failed", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0]), makeFailed(trs[1])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0]), makeFailed(testhelpers.ExampleTaskRuns[1])}, }, want: "Failed", }, @@ -5005,7 +5010,7 @@ func TestGetReason(t *testing.T) { name: "matrixed taskruns cancelled", rpt: ResolvedPipelineTask{ PipelineTask: matrixedPipelineTask, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0])), withCancelled(makeFailed(trs[1]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0])), withCancelled(makeFailed(testhelpers.ExampleTaskRuns[1]))}, }, want: v1.TaskRunReasonCancelled.String(), }, diff --git a/pkg/reconciler/pipelinerun/resources/pipelinerunstate_test.go b/pkg/reconciler/pipelinerun/resources/pipelinerunstate_test.go index 491658b62d9..455c3d5822f 100644 --- a/pkg/reconciler/pipelinerun/resources/pipelinerunstate_test.go +++ b/pkg/reconciler/pipelinerun/resources/pipelinerunstate_test.go @@ -27,6 +27,7 @@ import ( "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" "github.com/tektoncd/pipeline/pkg/reconciler/pipeline/dag" "github.com/tektoncd/pipeline/pkg/reconciler/taskrun/resources" + testhelpers "github.com/tektoncd/pipeline/pkg/reconciler/testing" "github.com/tektoncd/pipeline/test/diff" "go.uber.org/zap" corev1 "k8s.io/api/core/v1" @@ -45,95 +46,95 @@ var testClock = clock.NewFakePassiveClock(now) func TestPipelineRunFacts_CheckDAGTasksDoneDone(t *testing.T) { var taskCancelledByStatusState = PipelineRunState{{ - PipelineTask: &pts[4], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[4], // 2 retries needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskCancelledBySpecState = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelledBySpec(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelledBySpec(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskRunningState = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskSucceededState = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskRetriedState = PipelineRunState{{ - PipelineTask: &pts[3], // 1 retry needed + PipelineTask: &testhelpers.PipelineTasks[3], // 1 retry needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskExpectedState = PipelineRunState{{ - PipelineTask: &pts[4], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[4], // 2 retries needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withRetries(makeToBeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var noTaskRunState = PipelineRunState{{ - PipelineTask: &pts[4], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[4], // 2 retries needed TaskRunNames: []string{"pipelinerun-mytask1"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var customRunRunningState = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunStarted(customRuns[0])}, }} var customRunSucceededState = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunSucceeded(customRuns[0])}, }} var customRunFailedState = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunFailed(customRuns[0])}, }} var taskCancelledFailedWithRetries = PipelineRunState{{ - PipelineTask: &pts[4], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[4], // 2 retries needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} @@ -580,182 +581,182 @@ func TestGetNextTasks(t *testing.T) { func TestGetNextTaskWithRetries(t *testing.T) { var taskCancelledByStatusState = PipelineRunState{{ - PipelineTask: &pts[4], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[4], // 2 retries needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskCancelledBySpecState = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelledBySpec(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelledBySpec(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskRunningState = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskSucceededState = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskRetriedState = PipelineRunState{{ - PipelineTask: &pts[3], // 1 retry needed + PipelineTask: &testhelpers.PipelineTasks[3], // 1 retry needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var customRunCancelledByStatusState = PipelineRunState{{ - PipelineTask: &pts[4], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[4], // 2 retries needed CustomRunNames: []string{"pipelinerun-mytask1"}, CustomRuns: []*v1beta1.CustomRun{withCustomRunCancelled(withCustomRunRetries(newCustomRun(customRuns[0])))}, CustomTask: true, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var customRunCancelledBySpecState = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], CustomRunNames: []string{"pipelinerun-mytask1"}, CustomRuns: []*v1beta1.CustomRun{withCustomRunCancelledBySpec(withCustomRunRetries(newCustomRun(customRuns[0])))}, CustomTask: true, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var customRunRunningState = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], CustomRunNames: []string{"pipelinerun-mytask1"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunStarted(customRuns[0])}, CustomTask: true, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var customRunSucceededState = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], CustomRunNames: []string{"pipelinerun-mytask1"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunSucceeded(customRuns[0])}, CustomTask: true, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskCancelledByStatusStateMatrix = PipelineRunState{{ - PipelineTask: &pts[20], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[20], // 2 retries needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskCancelledBySpecStateMatrix = PipelineRunState{{ - PipelineTask: &pts[20], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[20], // 2 retries needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelledBySpec(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelledBySpec(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskRunningStateMatrix = PipelineRunState{{ - PipelineTask: &pts[20], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[20], // 2 retries needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskSucceededStateMatrix = PipelineRunState{{ - PipelineTask: &pts[20], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[20], // 2 retries needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskRetriedStateMatrix = PipelineRunState{{ - PipelineTask: &pts[17], // 1 retry needed + PipelineTask: &testhelpers.PipelineTasks[17], // 1 retry needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var runCancelledByStatusStateMatrix = PipelineRunState{{ - PipelineTask: &pts[20], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[20], // 2 retries needed CustomRunNames: []string{"pipelinerun-mytask1"}, CustomRuns: []*v1beta1.CustomRun{withCustomRunCancelled(withCustomRunRetries(newCustomRun(customRuns[0])))}, CustomTask: true, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var runCancelledBySpecStateMatrix = PipelineRunState{{ - PipelineTask: &pts[20], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[20], // 2 retries needed CustomRunNames: []string{"pipelinerun-mytask1"}, CustomRuns: []*v1beta1.CustomRun{withCustomRunCancelledBySpec(withCustomRunRetries(newCustomRun(customRuns[0])))}, CustomTask: true, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var runRunningStateMatrix = PipelineRunState{{ - PipelineTask: &pts[20], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[20], // 2 retries needed CustomRunNames: []string{"pipelinerun-mytask1"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunStarted(customRuns[0])}, CustomTask: true, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var customRunSucceededStateMatrix = PipelineRunState{{ - PipelineTask: &pts[20], // 2 retries needed + PipelineTask: &testhelpers.PipelineTasks[20], // 2 retries needed CustomRunNames: []string{"pipelinerun-mytask1"}, CustomRuns: []*v1beta1.CustomRun{makeCustomRunSucceeded(customRuns[0])}, CustomTask: true, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var customRunRetriedStateMatrix = PipelineRunState{{ - PipelineTask: &pts[17], // 1 retry needed + PipelineTask: &testhelpers.PipelineTasks[17], // 1 retry needed CustomRunNames: []string{"pipelinerun-mytask1"}, CustomRuns: []*v1beta1.CustomRun{withCustomRunCancelled(withCustomRunRetries(newCustomRun(customRuns[0])))}, CustomTask: true, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} @@ -884,7 +885,7 @@ func TestDAGExecutionQueue(t *testing.T) { }, TaskRunNames: []string{"createdtask"}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, } createdRun := ResolvedPipelineTask{ @@ -901,9 +902,9 @@ func TestDAGExecutionQueue(t *testing.T) { TaskRef: &v1.TaskRef{Name: "task"}, }, TaskRunNames: []string{"runningtask"}, - TaskRuns: []*v1.TaskRun{newTaskRun(trs[0])}, + TaskRuns: []*v1.TaskRun{newTaskRun(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, } runningRun := ResolvedPipelineTask{ @@ -921,9 +922,9 @@ func TestDAGExecutionQueue(t *testing.T) { TaskRef: &v1.TaskRef{Name: "task"}, }, TaskRunNames: []string{"successfultask"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, } successfulRun := ResolvedPipelineTask{ @@ -941,9 +942,9 @@ func TestDAGExecutionQueue(t *testing.T) { TaskRef: &v1.TaskRef{Name: "task"}, }, TaskRunNames: []string{"failedtask"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, } failedCustomRun := ResolvedPipelineTask{ @@ -1038,26 +1039,26 @@ func TestDAGExecutionQueueSequentialTasks(t *testing.T) { wantFirst: true, }, { name: "first task running", - firstTaskRun: newTaskRun(trs[0]), + firstTaskRun: newTaskRun(testhelpers.ExampleTaskRuns[0]), }, { name: "first task succeeded", - firstTaskRun: makeSucceeded(trs[0]), + firstTaskRun: makeSucceeded(testhelpers.ExampleTaskRuns[0]), wantSecond: true, }, { name: "first task failed", - firstTaskRun: makeFailed(trs[0]), + firstTaskRun: makeFailed(testhelpers.ExampleTaskRuns[0]), }, { name: "first task succeeded, second task running", - firstTaskRun: makeSucceeded(trs[0]), - secondTaskRun: newTaskRun(trs[1]), + firstTaskRun: makeSucceeded(testhelpers.ExampleTaskRuns[0]), + secondTaskRun: newTaskRun(testhelpers.ExampleTaskRuns[1]), }, { name: "first task succeeded, second task succeeded", - firstTaskRun: makeSucceeded(trs[0]), - secondTaskRun: makeSucceeded(trs[1]), + firstTaskRun: makeSucceeded(testhelpers.ExampleTaskRuns[0]), + secondTaskRun: makeSucceeded(testhelpers.ExampleTaskRuns[1]), }, { name: "first task succeeded, second task failed", - firstTaskRun: makeSucceeded(trs[0]), - secondTaskRun: makeFailed(trs[1]), + firstTaskRun: makeSucceeded(testhelpers.ExampleTaskRuns[0]), + secondTaskRun: makeFailed(testhelpers.ExampleTaskRuns[1]), }} for _, tc := range tcs { t.Run(tc.name, func(t *testing.T) { @@ -1068,7 +1069,7 @@ func TestDAGExecutionQueueSequentialTasks(t *testing.T) { }, TaskRunNames: []string{"task-1"}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, } secondTask := ResolvedPipelineTask{ @@ -1079,7 +1080,7 @@ func TestDAGExecutionQueueSequentialTasks(t *testing.T) { }, TaskRunNames: []string{"task-2"}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, } if tc.firstTaskRun != nil { @@ -1228,7 +1229,7 @@ func TestPipelineRunState_CompletedOrSkippedDAGTasks(t *testing.T) { name: "no-tasks-started-run-cancelled-gracefully", state: noneStartedState, specStatus: v1.PipelineRunSpecStatusCancelledRunFinally, - expectedNames: []string{pts[0].Name, pts[1].Name}, + expectedNames: []string{testhelpers.PipelineTasks[0].Name, testhelpers.PipelineTasks[1].Name}, }, { name: "one-task-started", state: oneStartedState, @@ -1237,24 +1238,24 @@ func TestPipelineRunState_CompletedOrSkippedDAGTasks(t *testing.T) { name: "one-task-started-run-stopped-gracefully", state: oneStartedState, specStatus: v1.PipelineRunSpecStatusStoppedRunFinally, - expectedNames: []string{pts[1].Name}, + expectedNames: []string{testhelpers.PipelineTasks[1].Name}, }, { name: "one-task-finished", state: oneFinishedState, - expectedNames: []string{pts[0].Name}, + expectedNames: []string{testhelpers.PipelineTasks[0].Name}, }, { name: "one-task-finished-run-cancelled-forcefully", state: oneFinishedState, specStatus: v1.PipelineRunSpecStatusCancelled, - expectedNames: []string{pts[0].Name}, + expectedNames: []string{testhelpers.PipelineTasks[0].Name}, }, { name: "one-task-failed", state: oneFailedState, - expectedNames: []string{pts[0].Name, pts[1].Name}, + expectedNames: []string{testhelpers.PipelineTasks[0].Name, testhelpers.PipelineTasks[1].Name}, }, { name: "all-finished", state: allFinishedState, - expectedNames: []string{pts[0].Name, pts[1].Name}, + expectedNames: []string{testhelpers.PipelineTasks[0].Name, testhelpers.PipelineTasks[1].Name}, }, { name: "large deps, not started", state: largePipelineState, @@ -1274,11 +1275,11 @@ func TestPipelineRunState_CompletedOrSkippedDAGTasks(t *testing.T) { }, { name: "one-run-finished", state: oneCustomRunFinishedState, - expectedNames: []string{pts[12].Name}, + expectedNames: []string{testhelpers.PipelineTasks[12].Name}, }, { name: "one-run-failed", state: oneCustomRunFailedState, - expectedNames: []string{pts[12].Name, pts[13].Name}, + expectedNames: []string{testhelpers.PipelineTasks[12].Name, testhelpers.PipelineTasks[13].Name}, }} for _, tc := range tcs { t.Run(tc.name, func(t *testing.T) { @@ -1447,66 +1448,66 @@ func TestPipelineRunState_GetFinalTasksAndNames(t *testing.T) { desc: "DAG tasks (mytask1 and mytask2) finished successfully -" + " do not schedule final tasks since pipeline didnt have any", state: oneStartedState, - DAGTasks: []v1.PipelineTask{pts[0], pts[1]}, + DAGTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, finalTasks: []v1.PipelineTask{}, expectedFinalTasks: PipelineRunState{}, expectedFinalNames: nil, - expectedTaskNames: sets.NewString(pts[0].Name, pts[1].Name), + expectedTaskNames: sets.NewString(testhelpers.PipelineTasks[0].Name, testhelpers.PipelineTasks[1].Name), }, { // tasks: [ mytask1] // finally: [mytask2] name: "02 - DAG task not started, no final tasks", desc: "DAG tasks (mytask1) not started yet - do not schedule final tasks (mytask2)", state: noneStartedState, - DAGTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + DAGTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedFinalTasks: PipelineRunState{}, - expectedFinalNames: sets.NewString(pts[1].Name), - expectedTaskNames: sets.NewString(pts[0].Name), + expectedFinalNames: sets.NewString(testhelpers.PipelineTasks[1].Name), + expectedTaskNames: sets.NewString(testhelpers.PipelineTasks[0].Name), }, { // tasks: [ mytask1] // finally: [mytask2] name: "03 - DAG task not finished, no final tasks", desc: "DAG tasks (mytask1) started but not finished - do not schedule final tasks (mytask2)", state: oneStartedState, - DAGTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + DAGTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedFinalTasks: PipelineRunState{}, - expectedFinalNames: sets.NewString(pts[1].Name), - expectedTaskNames: sets.NewString(pts[0].Name), + expectedFinalNames: sets.NewString(testhelpers.PipelineTasks[1].Name), + expectedTaskNames: sets.NewString(testhelpers.PipelineTasks[0].Name), }, { // tasks: [ mytask1] // finally: [mytask2] name: "04 - DAG task done, return final tasks", desc: "DAG tasks (mytask1) done - schedule final tasks (mytask2)", state: oneFinishedState, - DAGTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + DAGTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedFinalTasks: PipelineRunState{oneFinishedState[1]}, - expectedFinalNames: sets.NewString(pts[1].Name), - expectedTaskNames: sets.NewString(pts[0].Name), + expectedFinalNames: sets.NewString(testhelpers.PipelineTasks[1].Name), + expectedTaskNames: sets.NewString(testhelpers.PipelineTasks[0].Name), }, { // tasks: [ mytask1] // finally: [mytask2] name: "05 - DAG task failed, return final tasks", desc: "DAG task (mytask1) failed - schedule final tasks (mytask2)", state: oneFailedState, - DAGTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + DAGTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedFinalTasks: PipelineRunState{oneFinishedState[1]}, - expectedFinalNames: sets.NewString(pts[1].Name), - expectedTaskNames: sets.NewString(pts[0].Name), + expectedFinalNames: sets.NewString(testhelpers.PipelineTasks[1].Name), + expectedTaskNames: sets.NewString(testhelpers.PipelineTasks[0].Name), }, { // tasks: [ mytask1] // finally: [mytask2] name: "06 - DAG tasks succeeded, final tasks scheduled - no final tasks", desc: "DAG task (mytask1) finished successfully - final task (mytask2) scheduled - no final tasks", state: finalScheduledState, - DAGTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + DAGTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedFinalTasks: PipelineRunState{}, - expectedFinalNames: sets.NewString(pts[1].Name), - expectedTaskNames: sets.NewString(pts[0].Name), + expectedFinalNames: sets.NewString(testhelpers.PipelineTasks[1].Name), + expectedTaskNames: sets.NewString(testhelpers.PipelineTasks[0].Name), }} for _, tc := range tcs { dagGraph, err := dag.Build(v1.PipelineTaskList(tc.DAGTasks), v1.PipelineTaskList(tc.DAGTasks).Deps()) @@ -1558,8 +1559,8 @@ func TestPipelineRunState_IsFinalTaskStarted(t *testing.T) { name: "01 - DAG task started, final task not created", desc: "DAG tasks (mytask1) started yet - do not schedule final tasks (mytask2)", state: oneStartedState, - DAGTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + DAGTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedFinalTaskStarted: false, }, { // tasks: [ mytask1(done)] @@ -1567,8 +1568,8 @@ func TestPipelineRunState_IsFinalTaskStarted(t *testing.T) { name: "02 - DAG task succeeded, final task not created", desc: "DAG tasks (mytask1) finished successfully - do not schedule final tasks (mytask2)", state: oneFinishedState, - DAGTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + DAGTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedFinalTaskStarted: false, }, { // tasks: [ mytask1(done)] @@ -1576,7 +1577,7 @@ func TestPipelineRunState_IsFinalTaskStarted(t *testing.T) { name: "03 - DAG task succeeded, no final tasks", desc: "DAG tasks (mytask1) finished successfully - no final tasks", state: oneStartedState, - DAGTasks: []v1.PipelineTask{pts[0]}, + DAGTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, finalTasks: []v1.PipelineTask{}, expectedFinalTaskStarted: false, }, { @@ -1585,8 +1586,8 @@ func TestPipelineRunState_IsFinalTaskStarted(t *testing.T) { name: "04 - DAG task succeeded, final tasks (mytask2) succeeded", desc: "DAG tasks (mytask1) finished successfully - final tasks (mytask2) finished successfully", state: allFinishedState, - DAGTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + DAGTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedFinalTaskStarted: true, }} for _, tc := range tcs { @@ -1617,28 +1618,28 @@ func TestPipelineRunState_IsFinalTaskStarted(t *testing.T) { func TestGetPipelineConditionStatus(t *testing.T) { var taskRetriedState = PipelineRunState{{ - PipelineTask: &pts[3], // 1 retry needed + PipelineTask: &testhelpers.PipelineTasks[3], // 1 retry needed TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeRetried(testhelpers.ExampleTaskRuns[0]))}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var taskCancelledFailed = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelled(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }} var taskCancelledFailedTimedOut = PipelineRunState{{ - PipelineTask: &pts[4], + PipelineTask: &testhelpers.PipelineTasks[4], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(trs[0]))}, + TaskRuns: []*v1.TaskRun{withCancelledForTimeout(makeFailed(testhelpers.ExampleTaskRuns[0]))}, }} var cancelledTask = PipelineRunState{{ - PipelineTask: &pts[3], // 1 retry needed + PipelineTask: &testhelpers.PipelineTasks[3], // 1 retry needed TaskRunNames: []string{"pipelinerun-mytask1"}, TaskRuns: []*v1.TaskRun{{ Status: v1.TaskRunStatus{ @@ -1650,12 +1651,12 @@ func TestGetPipelineConditionStatus(t *testing.T) { }, }}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} var cancelledRun = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask13"}, CustomRuns: []*v1beta1.CustomRun{ @@ -1671,7 +1672,7 @@ func TestGetPipelineConditionStatus(t *testing.T) { }} var timedOutRun = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask14"}, CustomRuns: []*v1beta1.CustomRun{ @@ -1690,7 +1691,7 @@ func TestGetPipelineConditionStatus(t *testing.T) { }} var notRunningRun = PipelineRunState{{ - PipelineTask: &pts[12], + PipelineTask: &testhelpers.PipelineTasks[12], CustomTask: true, CustomRunNames: []string{"pipelinerun-mytask14"}, }} @@ -1701,16 +1702,16 @@ func TestGetPipelineConditionStatus(t *testing.T) { // 1 runAfter the failed one, which is marked as incomplete var taskMultipleFailuresSkipRunning = PipelineRunState{{ TaskRunNames: []string{"task0taskrun"}, - PipelineTask: &pts[5], - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[5], + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, }, { TaskRunNames: []string{"runningTaskRun"}, // this is running - PipelineTask: &pts[6], - TaskRuns: []*v1.TaskRun{makeStarted(trs[1])}, + PipelineTask: &testhelpers.PipelineTasks[6], + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[1])}, }, { TaskRunNames: []string{"failedTaskRun"}, // this failed - PipelineTask: &pts[0], - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[0], + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }} var taskMultipleFailuresOneCancel = taskMultipleFailuresSkipRunning @@ -1718,16 +1719,16 @@ func TestGetPipelineConditionStatus(t *testing.T) { var taskNotRunningWithSuccesfulParentsOneFailed = PipelineRunState{{ TaskRunNames: []string{"task0taskrun"}, - PipelineTask: &pts[5], - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[5], + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, }, { - TaskRunNames: []string{"notRunningTaskRun"}, // runAfter pts[5], not started yet - PipelineTask: &pts[6], + TaskRunNames: []string{"notRunningTaskRun"}, // runAfter testhelpers.PipelineTasks[5], not started yet + PipelineTask: &testhelpers.PipelineTasks[6], TaskRuns: nil, }, { TaskRunNames: []string{"failedTaskRun"}, // this failed - PipelineTask: &pts[0], - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[0], + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }} tenMinutesAgo := now.Add(-10 * time.Minute) @@ -1934,43 +1935,43 @@ func TestGetPipelineConditionStatus_WithFinalTasks(t *testing.T) { // pipeline state with one DAG successful, one final task failed dagSucceededFinalFailed := PipelineRunState{{ TaskRunNames: []string{"task0taskrun"}, - PipelineTask: &pts[0], - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[0], + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, }, { TaskRunNames: []string{"failedTaskRun"}, - PipelineTask: &pts[1], - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[1], + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }} // pipeline state with one DAG failed, no final started dagFailedFinalNotStarted := PipelineRunState{{ TaskRunNames: []string{"task0taskrun"}, - PipelineTask: &pts[0], - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[0], + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }, { TaskRunNames: []string{"notRunningTaskRun"}, - PipelineTask: &pts[1], + PipelineTask: &testhelpers.PipelineTasks[1], TaskRuns: nil, }} // pipeline state with one DAG failed, one final task failed dagFailedFinalFailed := PipelineRunState{{ TaskRunNames: []string{"task0taskrun"}, - PipelineTask: &pts[0], - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[0], + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }, { TaskRunNames: []string{"failedTaskRun"}, - PipelineTask: &pts[1], - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[1], + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }} // pipeline state with one DAG failed, one final task skipped dagFailedFinalSkipped := PipelineRunState{{ TaskRunNames: []string{"task0taskrun"}, - PipelineTask: &pts[0], - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[0], + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }, { - PipelineTask: &pts[14], + PipelineTask: &testhelpers.PipelineTasks[14], }} tcs := []struct { @@ -1988,8 +1989,8 @@ func TestGetPipelineConditionStatus_WithFinalTasks(t *testing.T) { }{{ name: "pipeline with one successful DAG task and failed final task", state: dagSucceededFinalFailed, - dagTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedStatus: corev1.ConditionFalse, expectedReason: v1.PipelineRunReasonFailed.String(), expectedSucceeded: 1, @@ -2000,8 +2001,8 @@ func TestGetPipelineConditionStatus_WithFinalTasks(t *testing.T) { }, { name: "pipeline with one failed DAG task and not started final task", state: dagFailedFinalNotStarted, - dagTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedStatus: corev1.ConditionUnknown, expectedReason: v1.PipelineRunReasonRunning.String(), expectedSucceeded: 0, @@ -2012,8 +2013,8 @@ func TestGetPipelineConditionStatus_WithFinalTasks(t *testing.T) { }, { name: "pipeline with one failed DAG task and failed final task", state: dagFailedFinalFailed, - dagTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[1]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[1]}, expectedStatus: corev1.ConditionFalse, expectedReason: v1.PipelineRunReasonFailed.String(), expectedSucceeded: 0, @@ -2024,8 +2025,8 @@ func TestGetPipelineConditionStatus_WithFinalTasks(t *testing.T) { }, { name: "pipeline with one failed DAG task and skipped final task", state: dagFailedFinalSkipped, - dagTasks: []v1.PipelineTask{pts[0]}, - finalTasks: []v1.PipelineTask{pts[14]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[14]}, expectedStatus: corev1.ConditionFalse, expectedReason: v1.PipelineRunReasonFailed.String(), expectedSucceeded: 0, @@ -2181,16 +2182,16 @@ func TestGetPipelineConditionStatus_OnError(t *testing.T) { OnError: v1.PipelineTaskContinue, }, TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask2"}, - TaskRuns: []*v1.TaskRun{makeSucceeded(trs[0])}, + TaskRuns: []*v1.TaskRun{makeSucceeded(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }} d, err := dagFromState(oneFailedStateOnError) @@ -2380,144 +2381,144 @@ func TestPipelineRunFacts_GetPipelineTaskStatus(t *testing.T) { }{{ name: "no-tasks-started", state: noneStartedState, - dagTasks: []v1.PipelineTask{pts[0], pts[1]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskReasonSuffix: "", - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskReasonSuffix: "", - v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskReasonSuffix: "", + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskReasonSuffix: "", + v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, }, }, { name: "one-task-started", state: oneStartedState, - dagTasks: []v1.PipelineTask{pts[0], pts[1]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskReasonSuffix: "", - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskReasonSuffix: "", - v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskReasonSuffix: "", + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskReasonSuffix: "", + v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, }, }, { name: "one-task-finished", state: oneFinishedState, - dagTasks: []v1.PipelineTask{pts[0], pts[1]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskReasonSuffix: "Succeeded", - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskReasonSuffix: "", - v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskReasonSuffix: "Succeeded", + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskReasonSuffix: "", + v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, }, }, { name: "one-task-failed", state: oneFailedState, - dagTasks: []v1.PipelineTask{pts[0], pts[1]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonFailed.String(), - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskReasonSuffix: "Failed", - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskReasonSuffix: "", - v1.PipelineTasksAggregateStatus: v1.PipelineRunReasonFailed.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonFailed.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskReasonSuffix: "Failed", + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskReasonSuffix: "", + v1.PipelineTasksAggregateStatus: v1.PipelineRunReasonFailed.String(), }, }, { name: "all-finished", state: allFinishedState, - dagTasks: []v1.PipelineTask{pts[0], pts[1]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskReasonSuffix: "Succeeded", - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskReasonSuffix: "Succeeded", - v1.PipelineTasksAggregateStatus: v1.PipelineRunReasonSuccessful.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskReasonSuffix: "Succeeded", + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskReasonSuffix: "Succeeded", + v1.PipelineTasksAggregateStatus: v1.PipelineRunReasonSuccessful.String(), }, }, { name: "task-with-when-expressions-passed", state: PipelineRunState{{ - PipelineTask: &pts[9], + PipelineTask: &testhelpers.PipelineTasks[9], TaskRunNames: []string{"pr-guard-succeeded-task-not-started"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, - dagTasks: []v1.PipelineTask{pts[9]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[9]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[9].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[9].Name + PipelineTaskReasonSuffix: "", - v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[9].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[9].Name + PipelineTaskReasonSuffix: "", + v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, }, }, { name: "tasks-when-expression-failed-and-task-skipped", state: PipelineRunState{{ - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], TaskRunNames: []string{"pr-guardedtask-skipped"}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, - dagTasks: []v1.PipelineTask{pts[10]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[10]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[10].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[10].Name + PipelineTaskReasonSuffix: "", - v1.PipelineTasksAggregateStatus: v1.PipelineRunReasonCompleted.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[10].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[10].Name + PipelineTaskReasonSuffix: "", + v1.PipelineTasksAggregateStatus: v1.PipelineRunReasonCompleted.String(), }, }, { name: "when-expression-task-with-parent-started", state: PipelineRunState{{ - PipelineTask: &pts[0], - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[0], + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[11], + PipelineTask: &testhelpers.PipelineTasks[11], TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, - dagTasks: []v1.PipelineTask{pts[0], pts[11]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[11]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskReasonSuffix: "", - PipelineTaskStatusPrefix + pts[11].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[11].Name + PipelineTaskReasonSuffix: "", - v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskReasonSuffix: "", + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[11].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[11].Name + PipelineTaskReasonSuffix: "", + v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, }, }, { name: "task-cancelled", state: taskCancelled, - dagTasks: []v1.PipelineTask{pts[4]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[4]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[4].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[4].Name + PipelineTaskReasonSuffix: v1.TaskRunReasonCancelled.String(), - v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[4].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[4].Name + PipelineTaskReasonSuffix: v1.TaskRunReasonCancelled.String(), + v1.PipelineTasksAggregateStatus: PipelineTaskStateNone, }, }, { name: "one-skipped-one-failed-aggregate-status-must-be-failed", state: PipelineRunState{{ - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], TaskRunNames: []string{"pr-guardedtask-skipped"}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, - dagTasks: []v1.PipelineTask{pts[0], pts[10]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[10]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: v1.PipelineRunReasonFailed.String(), - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskReasonSuffix: v1.PipelineRunReasonFailed.String(), - PipelineTaskStatusPrefix + pts[10].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[10].Name + PipelineTaskReasonSuffix: "", - v1.PipelineTasksAggregateStatus: v1.PipelineRunReasonFailed.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: v1.PipelineRunReasonFailed.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskReasonSuffix: v1.PipelineRunReasonFailed.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[10].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[10].Name + PipelineTaskReasonSuffix: "", + v1.PipelineTasksAggregateStatus: v1.PipelineRunReasonFailed.String(), }, }} for _, tc := range tcs { @@ -2551,117 +2552,117 @@ func TestPipelineRunFacts_GetPipelineFinalTaskStatus(t *testing.T) { }{{ name: "no-tasks-started", state: noneStartedState, - finalTasks: []v1.PipelineTask{pts[0], pts[1]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, }, }, { name: "one-task-started", state: oneStartedState, - finalTasks: []v1.PipelineTask{pts[0], pts[1]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, }, }, { name: "one-task-finished", state: oneFinishedState, - finalTasks: []v1.PipelineTask{pts[0], pts[1]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, }, }, { name: "one-task-failed", state: oneFailedState, - finalTasks: []v1.PipelineTask{pts[0], pts[1]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonFailed.String(), - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonFailed.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, }, }, { name: "all-finished", state: allFinishedState, - finalTasks: []v1.PipelineTask{pts[0], pts[1]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[1]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), - PipelineTaskStatusPrefix + pts[1].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[1].Name + PipelineTaskStatusSuffix: v1.TaskRunReasonSuccessful.String(), }, }, { name: "task-with-when-expressions-passed", state: PipelineRunState{{ - PipelineTask: &pts[9], + PipelineTask: &testhelpers.PipelineTasks[9], TaskRunNames: []string{"pr-guard-succeeded-task-not-started"}, TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, - finalTasks: []v1.PipelineTask{pts[9]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[9]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[9].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[9].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, }, }, { name: "tasks-when-expression-failed-and-task-skipped", state: PipelineRunState{{ - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], TaskRunNames: []string{"pr-guardedtask-skipped"}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, - finalTasks: []v1.PipelineTask{pts[10]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[10]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[10].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[10].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, }, }, { name: "when-expression-task-with-parent-started", state: PipelineRunState{{ - PipelineTask: &pts[0], - TaskRuns: []*v1.TaskRun{makeStarted(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[0], + TaskRuns: []*v1.TaskRun{makeStarted(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[11], + PipelineTask: &testhelpers.PipelineTasks[11], TaskRuns: nil, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, - finalTasks: []v1.PipelineTask{pts[0], pts[11]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[11]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, - PipelineTaskStatusPrefix + pts[11].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[11].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, }, }, { name: "task-cancelled", state: taskCancelled, - finalTasks: []v1.PipelineTask{pts[4]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[4]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[4].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[4].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, }, }, { name: "one-skipped-one-failed-aggregate-status-must-be-failed", state: PipelineRunState{{ - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], TaskRunNames: []string{"pr-guardedtask-skipped"}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }, { - PipelineTask: &pts[0], + PipelineTask: &testhelpers.PipelineTasks[0], TaskRunNames: []string{"pipelinerun-mytask1"}, - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, ResolvedTask: &resources.ResolvedTask{ - TaskSpec: &task.Spec, + TaskSpec: &testhelpers.ExampleTask.Spec, }, }}, - finalTasks: []v1.PipelineTask{pts[0], pts[10]}, + finalTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[10]}, expectedStatus: map[string]string{ - PipelineTaskStatusPrefix + pts[0].Name + PipelineTaskStatusSuffix: v1.PipelineRunReasonFailed.String(), - PipelineTaskStatusPrefix + pts[10].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[0].Name + PipelineTaskStatusSuffix: v1.PipelineRunReasonFailed.String(), + PipelineTaskStatusPrefix + testhelpers.PipelineTasks[10].Name + PipelineTaskStatusSuffix: PipelineTaskStateNone, }, }} for _, tc := range tcs { @@ -2695,39 +2696,39 @@ func TestPipelineRunFacts_GetSkippedTasks(t *testing.T) { }{{ name: "stopping-skip-taskruns", state: PipelineRunState{{ - PipelineTask: &pts[0], - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[0], + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }, { - PipelineTask: &pts[14], + PipelineTask: &testhelpers.PipelineTasks[14], }}, - dagTasks: []v1.PipelineTask{pts[0], pts[14]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0], testhelpers.PipelineTasks[14]}, expectedSkippedTasks: []v1.SkippedTask{{ - Name: pts[14].Name, + Name: testhelpers.PipelineTasks[14].Name, Reason: v1.StoppingSkip, }}, }, { name: "missing-results-skip-finally", state: PipelineRunState{{ TaskRunNames: []string{"task0taskrun"}, - PipelineTask: &pts[0], - TaskRuns: []*v1.TaskRun{makeFailed(trs[0])}, + PipelineTask: &testhelpers.PipelineTasks[0], + TaskRuns: []*v1.TaskRun{makeFailed(testhelpers.ExampleTaskRuns[0])}, }, { - PipelineTask: &pts[14], + PipelineTask: &testhelpers.PipelineTasks[14], }}, - dagTasks: []v1.PipelineTask{pts[0]}, - finallyTasks: []v1.PipelineTask{pts[14]}, + dagTasks: []v1.PipelineTask{testhelpers.PipelineTasks[0]}, + finallyTasks: []v1.PipelineTask{testhelpers.PipelineTasks[14]}, expectedSkippedTasks: []v1.SkippedTask{{ - Name: pts[14].Name, + Name: testhelpers.PipelineTasks[14].Name, Reason: v1.MissingResultsSkip, }}, }, { name: "when-expressions-skip-finally", state: PipelineRunState{{ - PipelineTask: &pts[10], + PipelineTask: &testhelpers.PipelineTasks[10], }}, - finallyTasks: []v1.PipelineTask{pts[10]}, + finallyTasks: []v1.PipelineTask{testhelpers.PipelineTasks[10]}, expectedSkippedTasks: []v1.SkippedTask{{ - Name: pts[10].Name, + Name: testhelpers.PipelineTasks[10].Name, Reason: v1.WhenExpressionsSkip, WhenExpressions: []v1.WhenExpression{{ Input: "foo", @@ -2739,11 +2740,11 @@ func TestPipelineRunFacts_GetSkippedTasks(t *testing.T) { t.Run(tc.name, func(t *testing.T) { d, err := dag.Build(v1.PipelineTaskList(tc.dagTasks), v1.PipelineTaskList(tc.dagTasks).Deps()) if err != nil { - t.Fatalf("Unexpected error while building graph for DAG tasks %v: %v", v1.PipelineTaskList{pts[0]}, err) + t.Fatalf("Unexpected error while building graph for DAG tasks %v: %v", v1.PipelineTaskList{testhelpers.PipelineTasks[0]}, err) } df, err := dag.Build(v1.PipelineTaskList(tc.finallyTasks), map[string][]string{}) if err != nil { - t.Fatalf("Unexpected error while building graph for final tasks %v: %v", v1.PipelineTaskList{pts[14]}, err) + t.Fatalf("Unexpected error while building graph for final tasks %v: %v", v1.PipelineTaskList{testhelpers.PipelineTasks[14]}, err) } facts := PipelineRunFacts{ State: tc.state, diff --git a/pkg/reconciler/testing/factory.go b/pkg/reconciler/testing/factory.go new file mode 100644 index 00000000000..c57e456f925 --- /dev/null +++ b/pkg/reconciler/testing/factory.go @@ -0,0 +1,250 @@ +// Package testing provides test helpers for the reconciler. +package testing + +import ( + v1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1" + v1beta1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/selection" +) + +// PipelineTasks is a set of example PipelineTasks for testing. +var PipelineTasks = []v1.PipelineTask{{ + Name: "mytask1", + TaskRef: &v1.TaskRef{Name: "task"}, +}, { + Name: "mytask2", + TaskRef: &v1.TaskRef{Name: "task"}, +}, { + Name: "mytask3", + TaskRef: &v1.TaskRef{Name: "task"}, +}, { + Name: "mytask4", + TaskRef: &v1.TaskRef{Name: "task"}, + Retries: 1, +}, { + Name: "mytask5", + TaskRef: &v1.TaskRef{Name: "cancelledTask"}, + Retries: 2, +}, { + Name: "mytask6", + TaskRef: &v1.TaskRef{Name: "task"}, +}, { + Name: "mytask7", + TaskRef: &v1.TaskRef{Name: "taskWithOneParent"}, + RunAfter: []string{"mytask6"}, +}, { + Name: "mytask8", + TaskRef: &v1.TaskRef{Name: "taskWithTwoParents"}, + RunAfter: []string{"mytask1", "mytask6"}, +}, { + Name: "mytask9", + TaskRef: &v1.TaskRef{Name: "taskHasParentWithRunAfter"}, + RunAfter: []string{"mytask8"}, +}, { + Name: "mytask10", + TaskRef: &v1.TaskRef{Name: "taskWithWhenExpressions"}, + When: []v1.WhenExpression{{ + Input: "foo", + Operator: selection.In, + Values: []string{"foo", "bar"}, + }}, +}, { + Name: "mytask11", + TaskRef: &v1.TaskRef{Name: "taskWithWhenExpressions"}, + When: []v1.WhenExpression{{ + Input: "foo", + Operator: selection.NotIn, + Values: []string{"foo", "bar"}, + }}, +}, { + Name: "mytask12", + TaskRef: &v1.TaskRef{Name: "taskWithWhenExpressions"}, + When: []v1.WhenExpression{{ + Input: "foo", + Operator: selection.In, + Values: []string{"foo", "bar"}, + }}, + RunAfter: []string{"mytask1"}, +}, { + Name: "mytask13", + TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, +}, { + Name: "mytask14", + TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, +}, { + Name: "mytask15", + TaskRef: &v1.TaskRef{Name: "taskWithReferenceToTaskResult"}, + Params: v1.Params{{Name: "param1", Value: *v1.NewStructuredValues("$(tasks.mytask1.results.result1)")}}, +}, { + Name: "mytask16", + Matrix: &v1.Matrix{ + Params: v1.Params{{ + Name: "browser", + Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, + }}, + }, +}, { + Name: "mytask17", + Matrix: &v1.Matrix{ + Params: v1.Params{{ + Name: "browser", + Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, + }}, + }, +}, { + Name: "mytask18", + TaskRef: &v1.TaskRef{Name: "task"}, + Retries: 1, + Matrix: &v1.Matrix{ + Params: v1.Params{{ + Name: "browser", + Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, + }}, + }, +}, { + Name: "mytask19", + TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, + Matrix: &v1.Matrix{ + Params: v1.Params{{ + Name: "browser", + Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, + }}, + }, +}, { + Name: "mytask20", + TaskRef: &v1.TaskRef{APIVersion: "example.dev/v0", Kind: "Example", Name: "customtask"}, + Matrix: &v1.Matrix{ + Params: v1.Params{{ + Name: "browser", + Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, + }}, + }, +}, { + Name: "mytask21", + TaskRef: &v1.TaskRef{Name: "task"}, + Retries: 2, + Matrix: &v1.Matrix{ + Params: v1.Params{{ + Name: "browser", + Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, + }}, + }, +}} + +// ExamplePipeline is a sample Pipeline for testing. +var ExamplePipeline = &v1.Pipeline{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "namespace", + Name: "pipeline", + }, + Spec: v1.PipelineSpec{ + Tasks: PipelineTasks, + }, +} + +// ExampleTask is a sample Task for testing. +var ExampleTask = &v1.Task{ + ObjectMeta: metav1.ObjectMeta{ + Name: "task", + }, + Spec: v1.TaskSpec{ + Steps: []v1.Step{{ + Name: "step1", + }}, + }, +} + +// ExampleTaskRuns is a set of TaskRuns for testing. +/* ...copy from trs, renamed... */ +var ExampleTaskRuns = []v1.TaskRun{{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "namespace", + Name: "pipelinerun-mytask1", + }, + Spec: v1.TaskRunSpec{}, +}, { + ObjectMeta: metav1.ObjectMeta{ + Namespace: "namespace", + Name: "pipelinerun-mytask2", + }, + Spec: v1.TaskRunSpec{}, +}, { + ObjectMeta: metav1.ObjectMeta{ + Namespace: "namespace", + Name: "pipelinerun-mytask4", + }, + Spec: v1.TaskRunSpec{}, +}} + +// ExampleCustomRuns is a set of CustomRuns for testing. +/* ...copy from customRuns, renamed... */ +var ExampleCustomRuns = []v1beta1.CustomRun{{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: "namespace", + Name: "pipelinerun-mytask13", + }, + Spec: v1beta1.CustomRunSpec{}, +}, { + ObjectMeta: metav1.ObjectMeta{ + Namespace: "namespace", + Name: "pipelinerun-mytask14", + }, + Spec: v1beta1.CustomRunSpec{}, +}} + +// ExampleMatrixedPipelineTask is a sample matrixed PipelineTask for testing. +/* ...copy from matrixedPipelineTask, renamed... */ +var ExampleMatrixedPipelineTask = &v1.PipelineTask{ + Name: "task", + TaskSpec: &v1.EmbeddedTask{ + TaskSpec: v1.TaskSpec{ + Params: []v1.ParamSpec{{ + Name: "browser", + Type: v1.ParamTypeString, + }}, + Results: []v1.TaskResult{{ + Name: "BROWSER", + }}, + Steps: []v1.Step{{ + Name: "produce-results", + Image: "bash:latest", + Script: `#!/usr/bin/env bash\necho -n "$(params.browser)" | sha256sum | tee $(results.BROWSER.path)"`, + }}, + }, + }, + Matrix: &v1.Matrix{ + Params: v1.Params{{ + Name: "browser", + Value: v1.ParamValue{ArrayVal: []string{"safari", "chrome"}}, + }}, + }, +} + +// NewTaskRun returns a new TaskRun for testing. +func NewTaskRun(tr v1.TaskRun) *v1.TaskRun { + return &v1.TaskRun{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: tr.Namespace, + Name: tr.Name, + }, + Spec: tr.Spec, + Status: v1.TaskRunStatus{ + Status: v1.TaskRunStatus{}.Status, + }, + } +} + +// NewCustomRun returns a new CustomRun for testing. +func NewCustomRun(run v1beta1.CustomRun) *v1beta1.CustomRun { + return &v1beta1.CustomRun{ + ObjectMeta: metav1.ObjectMeta{ + Namespace: run.Namespace, + Name: run.Name, + }, + Spec: run.Spec, + Status: v1beta1.CustomRunStatus{ + Status: v1beta1.CustomRunStatus{}.Status, + }, + } +} diff --git a/pkg/reconciler/testing/selectors.go b/pkg/reconciler/testing/selectors.go new file mode 100644 index 00000000000..b1d74d7402b --- /dev/null +++ b/pkg/reconciler/testing/selectors.go @@ -0,0 +1,23 @@ +package testing + +import ( + "errors" + + v1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1" + v1beta1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" +) + +// NopGetCustomRun returns an error for CustomRun lookup (used in tests where CustomRun should not be called) +func NopGetCustomRun(string) (*v1beta1.CustomRun, error) { + return nil, errors.New("GetCustomRun should not be called") +} + +// NopGetTask returns an error for Task lookup (used in tests where Task should not be called) +func NopGetTask(string) (*v1.Task, error) { + return nil, errors.New("GetTask should not be called") +} + +// NopGetPipeline returns an error for Pipeline lookup (used in tests where Pipeline should not be called) +func NopGetPipeline(string) (*v1.Pipeline, error) { + return nil, errors.New("GetPipeline should not be called") +} diff --git a/pkg/reconciler/testing/status_transformers.go b/pkg/reconciler/testing/status_transformers.go new file mode 100644 index 00000000000..9cfe7b126d9 --- /dev/null +++ b/pkg/reconciler/testing/status_transformers.go @@ -0,0 +1,125 @@ +package testing + +import ( + v1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1" + v1beta1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" + corev1 "k8s.io/api/core/v1" + apis "knative.dev/pkg/apis" + duckv1 "knative.dev/pkg/apis/duck/v1" +) + +// Status transformer helpers for testing +func MakeScheduled(taskRun v1.TaskRun, newTaskRun func(v1.TaskRun) *v1.TaskRun) *v1.TaskRun { + tr := newTaskRun(taskRun) + tr.Status = v1.TaskRunStatus{} + return tr +} + +func MakeStarted(taskRun v1.TaskRun, newTaskRun func(v1.TaskRun) *v1.TaskRun) *v1.TaskRun { + tr := newTaskRun(taskRun) + tr.Status.Conditions[0].Status = corev1.ConditionUnknown + return tr +} + +func MakeSucceeded(taskRun v1.TaskRun, newTaskRun func(v1.TaskRun) *v1.TaskRun) *v1.TaskRun { + tr := newTaskRun(taskRun) + tr.Status.Conditions[0].Status = corev1.ConditionTrue + tr.Status.Conditions[0].Reason = "Succeeded" + return tr +} + +func MakeFailed(taskRun v1.TaskRun, newTaskRun func(v1.TaskRun) *v1.TaskRun) *v1.TaskRun { + tr := newTaskRun(taskRun) + tr.Status.Conditions[0].Status = corev1.ConditionFalse + tr.Status.Conditions[0].Reason = "Failed" + return tr +} + +func MakeToBeRetried(taskRun v1.TaskRun, newTaskRun func(v1.TaskRun) *v1.TaskRun) *v1.TaskRun { + tr := newTaskRun(taskRun) + tr.Status.Conditions[0].Status = corev1.ConditionUnknown + tr.Status.Conditions[0].Reason = v1.TaskRunReasonToBeRetried.String() + return tr +} + +func MakeRetried(taskRun v1.TaskRun, newTaskRun func(v1.TaskRun) *v1.TaskRun, withRetries func(*v1.TaskRun) *v1.TaskRun) *v1.TaskRun { + tr := newTaskRun(taskRun) + return withRetries(tr) +} + +func WithRetries(taskRun *v1.TaskRun) *v1.TaskRun { + taskRun.Status.RetriesStatus = []v1.TaskRunStatus{{ + Status: duckv1.Status{ + Conditions: []apis.Condition{{ + Type: apis.ConditionSucceeded, + Status: corev1.ConditionFalse, + }}, + }, + }} + return taskRun +} + +func WithCancelled(taskRun *v1.TaskRun) *v1.TaskRun { + taskRun.Status.Conditions[0].Reason = v1.TaskRunSpecStatusCancelled + return taskRun +} + +func WithCancelledForTimeout(taskRun *v1.TaskRun) *v1.TaskRun { + taskRun.Spec.StatusMessage = v1.TaskRunCancelledByPipelineTimeoutMsg + taskRun.Status.Conditions[0].Reason = v1.TaskRunSpecStatusCancelled + return taskRun +} + +func WithCancelledBySpec(taskRun *v1.TaskRun) *v1.TaskRun { + taskRun.Spec.Status = v1.TaskRunSpecStatusCancelled + return taskRun +} + +// CustomRun status helpers +func MakeCustomRunStarted(customRun v1beta1.CustomRun, newCustomRun func(v1beta1.CustomRun) *v1beta1.CustomRun) *v1beta1.CustomRun { + run := newCustomRun(customRun) + run.Status.Conditions[0].Status = corev1.ConditionUnknown + return run +} + +func MakeCustomRunSucceeded(customRun v1beta1.CustomRun, newCustomRun func(v1beta1.CustomRun) *v1beta1.CustomRun) *v1beta1.CustomRun { + run := newCustomRun(customRun) + run.Status.Conditions[0].Status = corev1.ConditionTrue + run.Status.Conditions[0].Reason = "Succeeded" + return run +} + +func MakeCustomRunFailed(customRun v1beta1.CustomRun, newCustomRun func(v1beta1.CustomRun) *v1beta1.CustomRun) *v1beta1.CustomRun { + run := newCustomRun(customRun) + run.Status.Conditions[0].Status = corev1.ConditionFalse + run.Status.Conditions[0].Reason = "Failed" + return run +} + +func WithCustomRunRetries(customRun *v1beta1.CustomRun) *v1beta1.CustomRun { + customRun.Status.RetriesStatus = []v1beta1.CustomRunStatus{{ + Status: duckv1.Status{ + Conditions: []apis.Condition{{ + Type: apis.ConditionSucceeded, + Status: corev1.ConditionFalse, + }}, + }, + }} + return customRun +} + +func WithCustomRunCancelled(customRun *v1beta1.CustomRun) *v1beta1.CustomRun { + customRun.Status.Conditions[0].Reason = v1beta1.CustomRunReasonCancelled.String() + return customRun +} + +func WithCustomRunCancelledForTimeout(customRun *v1beta1.CustomRun) *v1beta1.CustomRun { + customRun.Spec.StatusMessage = v1beta1.CustomRunCancelledByPipelineTimeoutMsg + customRun.Status.Conditions[0].Reason = v1beta1.CustomRunReasonCancelled.String() + return customRun +} + +func WithCustomRunCancelledBySpec(customRun *v1beta1.CustomRun) *v1beta1.CustomRun { + customRun.Spec.Status = v1beta1.CustomRunSpecStatusCancelled + return customRun +}