From f97f6b5901a0c058943003c4da0e240bfb3233fe Mon Sep 17 00:00:00 2001 From: Jason Hall Date: Wed, 9 Sep 2020 08:45:50 -0400 Subject: [PATCH] Remove tb.ArrayOrString This was redundant with v1beta1.NewArrayOrString Also clean up some tests for brevity/readability --- internal/builder/v1alpha1/param.go | 23 +- internal/builder/v1alpha1/pipeline.go | 8 +- internal/builder/v1alpha1/task.go | 6 +- internal/builder/v1beta1/param.go | 19 +- internal/builder/v1beta1/param_test.go | 44 - internal/builder/v1beta1/pipeline.go | 8 +- internal/builder/v1beta1/pipeline_test.go | 25 +- internal/builder/v1beta1/task.go | 3 +- internal/builder/v1beta1/task_test.go | 8 +- .../v1alpha1/pipeline_conversion_test.go | 2 +- .../v1alpha1/pipelinerun_conversion_test.go | 4 +- pkg/apis/pipeline/v1alpha1/run_types_test.go | 18 +- .../pipeline/v1alpha1/run_validation_test.go | 8 +- .../v1alpha1/taskrun_conversion_test.go | 18 +- pkg/apis/pipeline/v1beta1/param_types.go | 9 +- pkg/apis/pipeline/v1beta1/param_types_test.go | 41 +- pkg/apis/pipeline/v1beta1/resultref_test.go | 889 +++++++----------- .../pipeline/v1beta1/task_validation_test.go | 57 +- .../v1beta1/taskrun_validation_test.go | 7 +- pkg/reconciler/pipeline/dag/dag_test.go | 55 +- .../pipeline/dag/dagv1beta1_test.go | 62 +- .../pipelinerun/resources/apply_test.go | 465 ++++----- .../resources/pipelinerunresolution_test.go | 12 +- .../resources/resultrefresolution.go | 10 +- .../resources/resultrefresolution_test.go | 744 ++++++--------- .../resources/validate_params_test.go | 12 +- .../taskrun/resources/apply_test.go | 80 +- .../taskrun/validate_resources_test.go | 10 +- test/dag_test.go | 10 +- test/helm_task_test.go | 10 +- test/pipelinerun_test.go | 8 +- 31 files changed, 1029 insertions(+), 1646 deletions(-) delete mode 100644 internal/builder/v1beta1/param_test.go diff --git a/internal/builder/v1alpha1/param.go b/internal/builder/v1alpha1/param.go index b9a84276680..0b7e745e465 100644 --- a/internal/builder/v1alpha1/param.go +++ b/internal/builder/v1alpha1/param.go @@ -13,27 +13,14 @@ limitations under the License. package builder -import "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1" +import ( + "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1" + "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" +) // ParamSpecOp is an operation which modify a ParamSpec struct. type ParamSpecOp func(*v1alpha1.ParamSpec) -// arrayOrString creates an ArrayOrString of type ParamTypeString or ParamTypeArray, based on -// how many inputs are given (>1 input will create an array, not string). -func arrayOrString(value string, additionalValues ...string) *v1alpha1.ArrayOrString { - if len(additionalValues) > 0 { - additionalValues = append([]string{value}, additionalValues...) - return &v1alpha1.ArrayOrString{ - Type: v1alpha1.ParamTypeArray, - ArrayVal: additionalValues, - } - } - return &v1alpha1.ArrayOrString{ - Type: v1alpha1.ParamTypeString, - StringVal: value, - } -} - // ParamSpecDescription sets the description of a ParamSpec. func ParamSpecDescription(desc string) ParamSpecOp { return func(ps *v1alpha1.ParamSpec) { @@ -43,7 +30,7 @@ func ParamSpecDescription(desc string) ParamSpecOp { // ParamSpecDefault sets the default value of a ParamSpec. func ParamSpecDefault(value string, additionalValues ...string) ParamSpecOp { - arrayOrString := arrayOrString(value, additionalValues...) + arrayOrString := v1beta1.NewArrayOrString(value, additionalValues...) return func(ps *v1alpha1.ParamSpec) { ps.Default = arrayOrString } diff --git a/internal/builder/v1alpha1/pipeline.go b/internal/builder/v1alpha1/pipeline.go index ce567a4055a..9c72df3a35d 100644 --- a/internal/builder/v1alpha1/pipeline.go +++ b/internal/builder/v1alpha1/pipeline.go @@ -213,11 +213,10 @@ func PipelineTaskRefKind(kind v1alpha1.TaskKind) PipelineTaskOp { // PipelineTaskParam adds a ResourceParam, with specified name and value, to the PipelineTask. func PipelineTaskParam(name string, value string, additionalValues ...string) PipelineTaskOp { - arrayOrString := arrayOrString(value, additionalValues...) return func(pt *v1alpha1.PipelineTask) { pt.Params = append(pt.Params, v1alpha1.Param{ Name: name, - Value: *arrayOrString, + Value: *v1beta1.NewArrayOrString(value, additionalValues...), }) } } @@ -287,7 +286,7 @@ func PipelineTaskConditionParam(name, val string) PipelineTaskConditionOp { } condition.Params = append(condition.Params, v1alpha1.Param{ Name: name, - Value: *arrayOrString(val), + Value: *v1beta1.NewArrayOrString(val), }) } } @@ -436,11 +435,10 @@ func PipelineRunServiceAccountNameTask(taskName, sa string) PipelineRunSpecOp { // PipelineRunParam add a param, with specified name and value, to the PipelineRunSpec. func PipelineRunParam(name string, value string, additionalValues ...string) PipelineRunSpecOp { - arrayOrString := arrayOrString(value, additionalValues...) return func(prs *v1alpha1.PipelineRunSpec) { prs.Params = append(prs.Params, v1alpha1.Param{ Name: name, - Value: *arrayOrString, + Value: *v1beta1.NewArrayOrString(value, additionalValues...), }) } } diff --git a/internal/builder/v1alpha1/task.go b/internal/builder/v1alpha1/task.go index be77e5133f1..42314b000c6 100644 --- a/internal/builder/v1alpha1/task.go +++ b/internal/builder/v1alpha1/task.go @@ -757,11 +757,10 @@ func TaskRunServiceAccountName(sa string) TaskRunSpecOp { // TaskRunParam sets the Params to the TaskSpec func TaskRunParam(name, value string, additionalValues ...string) TaskRunSpecOp { - arrayOrString := arrayOrString(value, additionalValues...) return func(spec *v1alpha1.TaskRunSpec) { spec.Params = append(spec.Params, v1alpha1.Param{ Name: name, - Value: *arrayOrString, + Value: *v1beta1.NewArrayOrString(value, additionalValues...), }) } } @@ -822,11 +821,10 @@ func TaskRunInputs(ops ...TaskRunInputsOp) TaskRunSpecOp { // TaskRunInputsParam add a param, with specified name and value, to the TaskRunInputs. func TaskRunInputsParam(name, value string, additionalValues ...string) TaskRunInputsOp { - arrayOrString := arrayOrString(value, additionalValues...) return func(i *v1alpha1.TaskRunInputs) { i.Params = append(i.Params, v1alpha1.Param{ Name: name, - Value: *arrayOrString, + Value: *v1beta1.NewArrayOrString(value, additionalValues...), }) } } diff --git a/internal/builder/v1beta1/param.go b/internal/builder/v1beta1/param.go index 3957a1b399e..682792c3504 100644 --- a/internal/builder/v1beta1/param.go +++ b/internal/builder/v1beta1/param.go @@ -18,22 +18,6 @@ import "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" // ParamSpecOp is an operation which modify a ParamSpec struct. type ParamSpecOp func(*v1beta1.ParamSpec) -// ArrayOrString creates an ArrayOrString of type ParamTypeString or ParamTypeArray, based on -// how many inputs are given (>1 input will create an array, not string). -func ArrayOrString(value string, additionalValues ...string) *v1beta1.ArrayOrString { - if len(additionalValues) > 0 { - additionalValues = append([]string{value}, additionalValues...) - return &v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeArray, - ArrayVal: additionalValues, - } - } - return &v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: value, - } -} - // ParamSpecDescription sets the description of a ParamSpec. func ParamSpecDescription(desc string) ParamSpecOp { return func(ps *v1beta1.ParamSpec) { @@ -43,8 +27,7 @@ func ParamSpecDescription(desc string) ParamSpecOp { // ParamSpecDefault sets the default value of a ParamSpec. func ParamSpecDefault(value string, additionalValues ...string) ParamSpecOp { - arrayOrString := ArrayOrString(value, additionalValues...) return func(ps *v1beta1.ParamSpec) { - ps.Default = arrayOrString + ps.Default = v1beta1.NewArrayOrString(value, additionalValues...) } } diff --git a/internal/builder/v1beta1/param_test.go b/internal/builder/v1beta1/param_test.go deleted file mode 100644 index 1661fef0c0b..00000000000 --- a/internal/builder/v1beta1/param_test.go +++ /dev/null @@ -1,44 +0,0 @@ -/* -Copyright 2019 The Tekton Authors -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - http://www.apache.org/licenses/LICENSE-2.0 -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package builder_test - -import ( - "testing" - - "github.com/google/go-cmp/cmp" - tb "github.com/tektoncd/pipeline/internal/builder/v1beta1" - "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" -) - -func TestGenerateString(t *testing.T) { - value := tb.ArrayOrString("somestring") - expectedValue := &v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "somestring", - } - if d := cmp.Diff(expectedValue, value); d != "" { - t.Fatalf("ArrayOrString diff -want, +got: %v", d) - } -} - -func TestGenerateArray(t *testing.T) { - value := tb.ArrayOrString("some", "array", "elements") - expectedValue := &v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeArray, - ArrayVal: []string{"some", "array", "elements"}, - } - if d := cmp.Diff(expectedValue, value); d != "" { - t.Fatalf("ArrayOrString diff -want, +got: %v", d) - } -} diff --git a/internal/builder/v1beta1/pipeline.go b/internal/builder/v1beta1/pipeline.go index 4cfe6bde60c..27e869e51ab 100644 --- a/internal/builder/v1beta1/pipeline.go +++ b/internal/builder/v1beta1/pipeline.go @@ -240,11 +240,10 @@ func PipelineTaskRefKind(kind v1beta1.TaskKind) PipelineTaskOp { // PipelineTaskParam adds a ResourceParam, with specified name and value, to the PipelineTask. func PipelineTaskParam(name string, value string, additionalValues ...string) PipelineTaskOp { - arrayOrString := ArrayOrString(value, additionalValues...) return func(pt *v1beta1.PipelineTask) { pt.Params = append(pt.Params, v1beta1.Param{ Name: name, - Value: *arrayOrString, + Value: *v1beta1.NewArrayOrString(value, additionalValues...), }) } } @@ -314,7 +313,7 @@ func PipelineTaskConditionParam(name, val string) PipelineTaskConditionOp { } condition.Params = append(condition.Params, v1beta1.Param{ Name: name, - Value: *ArrayOrString(val), + Value: *v1beta1.NewArrayOrString(val), }) } } @@ -489,11 +488,10 @@ func PipelineTaskRunSpecs(taskRunSpecs []v1beta1.PipelineTaskRunSpec) PipelineRu // PipelineRunParam add a param, with specified name and value, to the PipelineRunSpec. func PipelineRunParam(name string, value string, additionalValues ...string) PipelineRunSpecOp { - arrayOrString := ArrayOrString(value, additionalValues...) return func(prs *v1beta1.PipelineRunSpec) { prs.Params = append(prs.Params, v1beta1.Param{ Name: name, - Value: *arrayOrString, + Value: *v1beta1.NewArrayOrString(value, additionalValues...), }) } } diff --git a/internal/builder/v1beta1/pipeline_test.go b/internal/builder/v1beta1/pipeline_test.go index 3647ec36ad6..c21914fe6f9 100644 --- a/internal/builder/v1beta1/pipeline_test.go +++ b/internal/builder/v1beta1/pipeline_test.go @@ -21,15 +21,14 @@ import ( "time" "github.com/google/go-cmp/cmp" + tb "github.com/tektoncd/pipeline/internal/builder/v1beta1" + "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" + resource "github.com/tektoncd/pipeline/pkg/apis/resource/v1alpha1" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/selection" "knative.dev/pkg/apis" duckv1beta1 "knative.dev/pkg/apis/duck/v1beta1" - - tb "github.com/tektoncd/pipeline/internal/builder/v1beta1" - "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" - resource "github.com/tektoncd/pipeline/pkg/apis/resource/v1alpha1" ) func TestPipeline(t *testing.T) { @@ -88,7 +87,7 @@ func TestPipeline(t *testing.T) { Params: []v1beta1.ParamSpec{{ Name: "first-param", Type: v1beta1.ParamTypeString, - Default: tb.ArrayOrString("default-value"), + Default: v1beta1.NewArrayOrString("default-value"), Description: "default description", }}, Tasks: []v1beta1.PipelineTask{{ @@ -96,10 +95,10 @@ func TestPipeline(t *testing.T) { TaskRef: &v1beta1.TaskRef{Name: "banana"}, Params: []v1beta1.Param{{ Name: "stringparam", - Value: *tb.ArrayOrString("value"), + Value: *v1beta1.NewArrayOrString("value"), }, { Name: "arrayparam", - Value: *tb.ArrayOrString("array", "value"), + Value: *v1beta1.NewArrayOrString("array", "value"), }}, Conditions: []v1beta1.PipelineTaskCondition{{ ConditionRef: "some-condition-ref", @@ -198,10 +197,10 @@ func TestPipelineRun(t *testing.T) { ServiceAccountNames: []v1beta1.PipelineRunSpecServiceAccountName{{TaskName: "foo", ServiceAccountName: "sa-2"}}, Params: []v1beta1.Param{{ Name: "first-param-string", - Value: *tb.ArrayOrString("first-value"), + Value: *v1beta1.NewArrayOrString("first-value"), }, { Name: "second-param-array", - Value: *tb.ArrayOrString("some", "array"), + Value: *v1beta1.NewArrayOrString("some", "array"), }}, Timeout: &metav1.Duration{Duration: 1 * time.Hour}, Resources: []v1beta1.PipelineResourceBinding{{ @@ -265,10 +264,10 @@ func TestPipelineRunWithPodTemplate(t *testing.T) { ServiceAccountNames: []v1beta1.PipelineRunSpecServiceAccountName{{TaskName: "foo", ServiceAccountName: "sa-2"}}, Params: []v1beta1.Param{{ Name: "first-param-string", - Value: *tb.ArrayOrString("first-value"), + Value: *v1beta1.NewArrayOrString("first-value"), }, { Name: "second-param-array", - Value: *tb.ArrayOrString("some", "array"), + Value: *v1beta1.NewArrayOrString("some", "array"), }}, Timeout: &metav1.Duration{Duration: 1 * time.Hour}, Resources: []v1beta1.PipelineResourceBinding{{ @@ -340,10 +339,10 @@ func TestPipelineRunWithResourceSpec(t *testing.T) { ServiceAccountNames: []v1beta1.PipelineRunSpecServiceAccountName{{TaskName: "foo", ServiceAccountName: "sa-2"}}, Params: []v1beta1.Param{{ Name: "first-param-string", - Value: *tb.ArrayOrString("first-value"), + Value: *v1beta1.NewArrayOrString("first-value"), }, { Name: "second-param-array", - Value: *tb.ArrayOrString("some", "array"), + Value: *v1beta1.NewArrayOrString("some", "array"), }}, Timeout: &metav1.Duration{Duration: 1 * time.Hour}, Resources: []v1beta1.PipelineResourceBinding{{ diff --git a/internal/builder/v1beta1/task.go b/internal/builder/v1beta1/task.go index f5605f1259a..59cf340d906 100644 --- a/internal/builder/v1beta1/task.go +++ b/internal/builder/v1beta1/task.go @@ -680,11 +680,10 @@ func TaskRunServiceAccountName(sa string) TaskRunSpecOp { // TaskRunParam sets the Params to the TaskSpec func TaskRunParam(name, value string, additionalValues ...string) TaskRunSpecOp { - arrayOrString := ArrayOrString(value, additionalValues...) return func(spec *v1beta1.TaskRunSpec) { spec.Params = append(spec.Params, v1beta1.Param{ Name: name, - Value: *arrayOrString, + Value: *v1beta1.NewArrayOrString(value, additionalValues...), }) } } diff --git a/internal/builder/v1beta1/task_test.go b/internal/builder/v1beta1/task_test.go index 28ef7c2e13f..7f466fa7037 100644 --- a/internal/builder/v1beta1/task_test.go +++ b/internal/builder/v1beta1/task_test.go @@ -101,12 +101,12 @@ func TestTask(t *testing.T) { Name: "param", Type: v1beta1.ParamTypeString, Description: "mydesc", - Default: tb.ArrayOrString("default"), + Default: v1beta1.NewArrayOrString("default"), }, { Name: "array-param", Type: v1beta1.ParamTypeString, Description: "desc", - Default: tb.ArrayOrString("array", "values"), + Default: v1beta1.NewArrayOrString("array", "values"), }}, Resources: &v1beta1.TaskResources{ Inputs: []v1beta1.TaskResource{{ @@ -240,10 +240,10 @@ func TestTaskRunWithTaskRef(t *testing.T) { Spec: v1beta1.TaskRunSpec{ Params: []v1beta1.Param{{ Name: "iparam", - Value: *tb.ArrayOrString("ivalue"), + Value: *v1beta1.NewArrayOrString("ivalue"), }, { Name: "arrayparam", - Value: *tb.ArrayOrString("array", "values"), + Value: *v1beta1.NewArrayOrString("array", "values"), }}, Resources: &v1beta1.TaskRunResources{ Inputs: []v1beta1.TaskResourceBinding{{ diff --git a/pkg/apis/pipeline/v1alpha1/pipeline_conversion_test.go b/pkg/apis/pipeline/v1alpha1/pipeline_conversion_test.go index ab78a966927..6585cf87309 100644 --- a/pkg/apis/pipeline/v1alpha1/pipeline_conversion_test.go +++ b/pkg/apis/pipeline/v1alpha1/pipeline_conversion_test.go @@ -95,7 +95,7 @@ func TestPipelineConversion_Success(t *testing.T) { }, Params: []Param{{ Name: "param1", - Value: v1beta1.ArrayOrString{StringVal: "str", Type: v1beta1.ParamTypeString}, + Value: *v1beta1.NewArrayOrString("str"), }}, Workspaces: []WorkspacePipelineTaskBinding{{ Name: "w1", diff --git a/pkg/apis/pipeline/v1alpha1/pipelinerun_conversion_test.go b/pkg/apis/pipeline/v1alpha1/pipelinerun_conversion_test.go index 0737dcab82c..baa9dccb86f 100644 --- a/pkg/apis/pipeline/v1alpha1/pipelinerun_conversion_test.go +++ b/pkg/apis/pipeline/v1alpha1/pipelinerun_conversion_test.go @@ -76,7 +76,7 @@ func TestPipelineRunConversion(t *testing.T) { }}, Params: []Param{{ Name: "p1", - Value: v1beta1.ArrayOrString{StringVal: "baz"}, + Value: *v1beta1.NewArrayOrString("baz"), }}, Resources: []PipelineResourceBinding{{ Name: "i1", @@ -136,7 +136,7 @@ func TestPipelineRunConversion(t *testing.T) { }}, Params: []Param{{ Name: "p1", - Value: v1beta1.ArrayOrString{StringVal: "baz"}, + Value: *v1beta1.NewArrayOrString("baz"), }}, Resources: []PipelineResourceBinding{{ Name: "i1", diff --git a/pkg/apis/pipeline/v1alpha1/run_types_test.go b/pkg/apis/pipeline/v1alpha1/run_types_test.go index b90c4741cff..93eb368d03d 100644 --- a/pkg/apis/pipeline/v1alpha1/run_types_test.go +++ b/pkg/apis/pipeline/v1alpha1/run_types_test.go @@ -46,26 +46,26 @@ func TestGetParams(t *testing.T) { spec: v1alpha1.RunSpec{ Params: []v1beta1.Param{{ Name: "first", - Value: v1beta1.NewArrayOrString("blah"), + Value: *v1beta1.NewArrayOrString("blah"), }, { Name: "foo", - Value: v1beta1.NewArrayOrString("bar"), + Value: *v1beta1.NewArrayOrString("bar"), }}, }, name: "foo", want: &v1beta1.Param{ Name: "foo", - Value: v1beta1.NewArrayOrString("bar"), + Value: *v1beta1.NewArrayOrString("bar"), }, }, { desc: "not found", spec: v1alpha1.RunSpec{ Params: []v1beta1.Param{{ Name: "first", - Value: v1beta1.NewArrayOrString("blah"), + Value: *v1beta1.NewArrayOrString("blah"), }, { Name: "foo", - Value: v1beta1.NewArrayOrString("bar"), + Value: *v1beta1.NewArrayOrString("bar"), }}, }, name: "bar", @@ -78,19 +78,19 @@ func TestGetParams(t *testing.T) { spec: v1alpha1.RunSpec{ Params: []v1beta1.Param{{ Name: "first", - Value: v1beta1.NewArrayOrString("blah"), + Value: *v1beta1.NewArrayOrString("blah"), }, { Name: "foo", - Value: v1beta1.NewArrayOrString("bar"), + Value: *v1beta1.NewArrayOrString("bar"), }, { Name: "foo", - Value: v1beta1.NewArrayOrString("second bar"), + Value: *v1beta1.NewArrayOrString("second bar"), }}, }, name: "foo", want: &v1beta1.Param{ Name: "foo", - Value: v1beta1.NewArrayOrString("bar"), + Value: *v1beta1.NewArrayOrString("bar"), }, }} { t.Run(c.desc, func(t *testing.T) { diff --git a/pkg/apis/pipeline/v1alpha1/run_validation_test.go b/pkg/apis/pipeline/v1alpha1/run_validation_test.go index a03151627dc..645b481739f 100644 --- a/pkg/apis/pipeline/v1alpha1/run_validation_test.go +++ b/pkg/apis/pipeline/v1alpha1/run_validation_test.go @@ -85,10 +85,10 @@ func TestRun_Invalid(t *testing.T) { }, Params: []v1beta1.Param{{ Name: "foo", - Value: v1beta1.NewArrayOrString("foo"), + Value: *v1beta1.NewArrayOrString("foo"), }, { Name: "foo", - Value: v1beta1.NewArrayOrString("foo"), + Value: *v1beta1.NewArrayOrString("foo"), }}, }, }, @@ -138,10 +138,10 @@ func TestRun_Valid(t *testing.T) { }, Params: []v1beta1.Param{{ Name: "foo", - Value: v1beta1.NewArrayOrString("foo"), + Value: *v1beta1.NewArrayOrString("foo"), }, { Name: "bar", - Value: v1beta1.NewArrayOrString("bar"), + Value: *v1beta1.NewArrayOrString("bar"), }}, }, }, diff --git a/pkg/apis/pipeline/v1alpha1/taskrun_conversion_test.go b/pkg/apis/pipeline/v1alpha1/taskrun_conversion_test.go index a42d7edffbc..4708b02368e 100644 --- a/pkg/apis/pipeline/v1alpha1/taskrun_conversion_test.go +++ b/pkg/apis/pipeline/v1alpha1/taskrun_conversion_test.go @@ -72,7 +72,7 @@ func TestTaskRunConversion(t *testing.T) { }}, Params: []Param{{ Name: "p1", - Value: v1beta1.ArrayOrString{StringVal: "baz"}, + Value: *v1beta1.NewArrayOrString("baz"), }}, Resources: &v1beta1.TaskRunResources{ Inputs: []v1beta1.TaskResourceBinding{{ @@ -127,7 +127,7 @@ func TestTaskRunConversion(t *testing.T) { }}, Params: []Param{{ Name: "p1", - Value: v1beta1.ArrayOrString{StringVal: "baz"}, + Value: *v1beta1.NewArrayOrString("baz"), }}, Resources: &v1beta1.TaskRunResources{ Inputs: []v1beta1.TaskResourceBinding{{ @@ -172,13 +172,13 @@ func TestTaskRunConversion(t *testing.T) { }}, Params: []Param{{ Name: "p1", - Value: v1beta1.ArrayOrString{StringVal: "baz"}, + Value: *v1beta1.NewArrayOrString("baz"), }}, Inputs: &TaskRunInputs{ Params: []Param{{ Name: "p2", - Value: v1beta1.ArrayOrString{StringVal: "bar"}}, - }, + Value: *v1beta1.NewArrayOrString("bar"), + }}, }, }, }, @@ -318,8 +318,8 @@ func TestTaskRunConversionFromDeprecated(t *testing.T) { Inputs: &TaskRunInputs{ Params: []Param{{ Name: "p2", - Value: v1beta1.ArrayOrString{StringVal: "bar"}}, - }, + Value: *v1beta1.NewArrayOrString("bar"), + }}, }, }, }, @@ -332,8 +332,8 @@ func TestTaskRunConversionFromDeprecated(t *testing.T) { Spec: TaskRunSpec{ Params: []Param{{ Name: "p2", - Value: v1beta1.ArrayOrString{StringVal: "bar"}}, - }, + Value: *v1beta1.NewArrayOrString("bar"), + }}, }, }, }, { diff --git a/pkg/apis/pipeline/v1beta1/param_types.go b/pkg/apis/pipeline/v1beta1/param_types.go index 875815ca760..09c18d954d9 100644 --- a/pkg/apis/pipeline/v1beta1/param_types.go +++ b/pkg/apis/pipeline/v1beta1/param_types.go @@ -132,15 +132,14 @@ func (arrayOrString *ArrayOrString) ApplyReplacements(stringReplacements map[str // NewArrayOrString creates an ArrayOrString of type ParamTypeString or ParamTypeArray, based on // how many inputs are given (>1 input will create an array, not string). -func NewArrayOrString(value string, values ...string) ArrayOrString { +func NewArrayOrString(value string, values ...string) *ArrayOrString { if len(values) > 0 { - values = append([]string{value}, values...) - return ArrayOrString{ + return &ArrayOrString{ Type: ParamTypeArray, - ArrayVal: values, + ArrayVal: append([]string{value}, values...), } } - return ArrayOrString{ + return &ArrayOrString{ Type: ParamTypeString, StringVal: value, } diff --git a/pkg/apis/pipeline/v1beta1/param_types_test.go b/pkg/apis/pipeline/v1beta1/param_types_test.go index 816ac1431f7..ba931bdb6e6 100644 --- a/pkg/apis/pipeline/v1beta1/param_types_test.go +++ b/pkg/apis/pipeline/v1beta1/param_types_test.go @@ -23,7 +23,6 @@ import ( "testing" "github.com/google/go-cmp/cmp" - tb "github.com/tektoncd/pipeline/internal/builder/v1beta1" "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" "github.com/tektoncd/pipeline/test/diff" ) @@ -46,12 +45,12 @@ func TestParamSpec_SetDefaults(t *testing.T) { name: "inferred type from default value", before: &v1beta1.ParamSpec{ Name: "parametername", - Default: tb.ArrayOrString("an", "array"), + Default: v1beta1.NewArrayOrString("an", "array"), }, defaultsApplied: &v1beta1.ParamSpec{ Name: "parametername", Type: v1beta1.ParamTypeArray, - Default: tb.ArrayOrString("an", "array"), + Default: v1beta1.NewArrayOrString("an", "array"), }, }, { name: "fully defined ParamSpec", @@ -59,13 +58,13 @@ func TestParamSpec_SetDefaults(t *testing.T) { Name: "parametername", Type: v1beta1.ParamTypeArray, Description: "a description", - Default: tb.ArrayOrString("an", "array"), + Default: v1beta1.NewArrayOrString("an", "array"), }, defaultsApplied: &v1beta1.ParamSpec{ Name: "parametername", Type: v1beta1.ParamTypeArray, Description: "a description", - Default: tb.ArrayOrString("an", "array"), + Default: v1beta1.NewArrayOrString("an", "array"), }, }} for _, tc := range tests { @@ -92,43 +91,43 @@ func TestArrayOrString_ApplyReplacements(t *testing.T) { }{{ name: "no replacements on array", args: args{ - input: tb.ArrayOrString("an", "array"), + input: v1beta1.NewArrayOrString("an", "array"), stringReplacements: map[string]string{"some": "value", "anotherkey": "value"}, arrayReplacements: map[string][]string{"arraykey": {"array", "value"}, "sdfdf": {"sdf", "sdfsd"}}, }, - expectedOutput: tb.ArrayOrString("an", "array"), + expectedOutput: v1beta1.NewArrayOrString("an", "array"), }, { name: "string replacements on string", args: args{ - input: tb.ArrayOrString("astring$(some) asdf $(anotherkey)"), + input: v1beta1.NewArrayOrString("astring$(some) asdf $(anotherkey)"), stringReplacements: map[string]string{"some": "value", "anotherkey": "value"}, arrayReplacements: map[string][]string{"arraykey": {"array", "value"}, "sdfdf": {"asdf", "sdfsd"}}, }, - expectedOutput: tb.ArrayOrString("astringvalue asdf value"), + expectedOutput: v1beta1.NewArrayOrString("astringvalue asdf value"), }, { name: "single array replacement", args: args{ - input: tb.ArrayOrString("firstvalue", "$(arraykey)", "lastvalue"), + input: v1beta1.NewArrayOrString("firstvalue", "$(arraykey)", "lastvalue"), stringReplacements: map[string]string{"some": "value", "anotherkey": "value"}, arrayReplacements: map[string][]string{"arraykey": {"array", "value"}, "sdfdf": {"asdf", "sdfsd"}}, }, - expectedOutput: tb.ArrayOrString("firstvalue", "array", "value", "lastvalue"), + expectedOutput: v1beta1.NewArrayOrString("firstvalue", "array", "value", "lastvalue"), }, { name: "multiple array replacement", args: args{ - input: tb.ArrayOrString("firstvalue", "$(arraykey)", "lastvalue", "$(sdfdf)"), + input: v1beta1.NewArrayOrString("firstvalue", "$(arraykey)", "lastvalue", "$(sdfdf)"), stringReplacements: map[string]string{"some": "value", "anotherkey": "value"}, arrayReplacements: map[string][]string{"arraykey": {"array", "value"}, "sdfdf": {"asdf", "sdfsd"}}, }, - expectedOutput: tb.ArrayOrString("firstvalue", "array", "value", "lastvalue", "asdf", "sdfsd"), + expectedOutput: v1beta1.NewArrayOrString("firstvalue", "array", "value", "lastvalue", "asdf", "sdfsd"), }, { name: "empty array replacement", args: args{ - input: tb.ArrayOrString("firstvalue", "$(arraykey)", "lastvalue"), + input: v1beta1.NewArrayOrString("firstvalue", "$(arraykey)", "lastvalue"), stringReplacements: map[string]string{"some": "value", "anotherkey": "value"}, arrayReplacements: map[string][]string{"arraykey": {}}, }, - expectedOutput: tb.ArrayOrString("firstvalue", "lastvalue"), + expectedOutput: v1beta1.NewArrayOrString("firstvalue", "lastvalue"), }} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -149,11 +148,11 @@ func TestArrayOrString_UnmarshalJSON(t *testing.T) { input string result v1beta1.ArrayOrString }{ - {"{\"val\": \"123\"}", *tb.ArrayOrString("123")}, - {"{\"val\": \"\"}", *tb.ArrayOrString("")}, + {"{\"val\": \"123\"}", *v1beta1.NewArrayOrString("123")}, + {"{\"val\": \"\"}", *v1beta1.NewArrayOrString("")}, {"{\"val\":[]}", v1beta1.ArrayOrString{Type: v1beta1.ParamTypeArray, ArrayVal: []string{}}}, {"{\"val\":[\"oneelement\"]}", v1beta1.ArrayOrString{Type: v1beta1.ParamTypeArray, ArrayVal: []string{"oneelement"}}}, - {"{\"val\":[\"multiple\", \"elements\"]}", v1beta1.ArrayOrString{Type: v1beta1.ParamTypeArray, ArrayVal: []string{"multiple", "elements"}}}, + {"{\"val\":[\"multiple\", \"elements\"]}", *v1beta1.NewArrayOrString("multiple", "elements")}, } for _, c := range cases { @@ -172,9 +171,9 @@ func TestArrayOrString_MarshalJSON(t *testing.T) { input v1beta1.ArrayOrString result string }{ - {*tb.ArrayOrString("123"), "{\"val\":\"123\"}"}, - {*tb.ArrayOrString("123", "1234"), "{\"val\":[\"123\",\"1234\"]}"}, - {*tb.ArrayOrString("a", "a", "a"), "{\"val\":[\"a\",\"a\",\"a\"]}"}, + {*v1beta1.NewArrayOrString("123"), "{\"val\":\"123\"}"}, + {*v1beta1.NewArrayOrString("123", "1234"), "{\"val\":[\"123\",\"1234\"]}"}, + {*v1beta1.NewArrayOrString("a", "a", "a"), "{\"val\":[\"a\",\"a\",\"a\"]}"}, } for _, c := range cases { diff --git a/pkg/apis/pipeline/v1beta1/resultref_test.go b/pkg/apis/pipeline/v1beta1/resultref_test.go index ba279188c02..d5e3b66909c 100644 --- a/pkg/apis/pipeline/v1beta1/resultref_test.go +++ b/pkg/apis/pipeline/v1beta1/resultref_test.go @@ -27,146 +27,90 @@ import ( ) func TestNewResultReference(t *testing.T) { - type args struct { + for _, tt := range []struct { + name string param v1beta1.Param - } - tests := []struct { - name string - args args - want []*v1beta1.ResultRef - }{ - { - name: "Test valid expression", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.sumTask.results.sumResult)", - }, - }, - }, - want: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask", - Result: "sumResult", - }, - }, - }, { - name: "substitution within string", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "sum-will-go-here -> $(tasks.sumTask.results.sumResult)", - }, - }, - }, - want: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask", - Result: "sumResult", - }, - }, - }, { - name: "multiple substitution", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.sumTask1.results.sumResult) and another $(tasks.sumTask2.results.sumResult)", - }, - }, - }, - want: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask1", - Result: "sumResult", - }, { - PipelineTask: "sumTask2", - Result: "sumResult", - }, - }, - }, { - name: "multiple substitution with param", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(params.param) $(tasks.sumTask1.results.sumResult) and another $(tasks.sumTask2.results.sumResult)", - }, - }, - }, - want: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask1", - Result: "sumResult", - }, { - PipelineTask: "sumTask2", - Result: "sumResult", - }, - }, - }, { - name: "first separator typo", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(task.sumTasks.results.sumResult)", - }, - }, - }, - want: nil, - }, { - name: "third separator typo", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.sumTasks.result.sumResult)", - }, - }, - }, - want: nil, - }, { - name: "param substitution shouldn't be considered result ref", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(params.paramName)", - }, - }, - }, - want: nil, - }, { - name: "One bad and good result substitution", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "good -> $(tasks.sumTask1.results.sumResult) bad-> $(task.sumTask2.results.sumResult)", - }, - }, - }, - want: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask1", - Result: "sumResult", - }, - }, + want []*v1beta1.ResultRef + }{{ + name: "Test valid expression", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sumTask.results.sumResult)"), }, - } - for _, tt := range tests { + want: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask", + Result: "sumResult", + }}, + }, { + name: "substitution within string", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("sum-will-go-here -> $(tasks.sumTask.results.sumResult)"), + }, + want: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask", + Result: "sumResult", + }}, + }, { + name: "multiple substitution", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sumTask1.results.sumResult) and another $(tasks.sumTask2.results.sumResult)"), + }, + want: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask1", + Result: "sumResult", + }, { + PipelineTask: "sumTask2", + Result: "sumResult", + }}, + }, { + name: "multiple substitution with param", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(params.param) $(tasks.sumTask1.results.sumResult) and another $(tasks.sumTask2.results.sumResult)"), + }, + want: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask1", + Result: "sumResult", + }, { + PipelineTask: "sumTask2", + Result: "sumResult", + }}, + }, { + name: "first separator typo", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(task.sumTasks.results.sumResult)"), + }, + want: nil, + }, { + name: "third separator typo", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sumTasks.result.sumResult)"), + }, + want: nil, + }, { + name: "param substitution shouldn't be considered result ref", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(params.paramName)"), + }, + want: nil, + }, { + name: "One bad and good result substitution", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("good -> $(tasks.sumTask1.results.sumResult) bad-> $(task.sumTask2.results.sumResult)"), + }, + want: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask1", + Result: "sumResult", + }}, + }} { t.Run(tt.name, func(t *testing.T) { - expressions, ok := v1beta1.GetVarSubstitutionExpressionsForParam(tt.args.param) + expressions, ok := v1beta1.GetVarSubstitutionExpressionsForParam(tt.param) if !ok && tt.want != nil { t.Fatalf("expected to find expressions but didn't find any") } else { @@ -180,120 +124,73 @@ func TestNewResultReference(t *testing.T) { } func TestHasResultReference(t *testing.T) { - type args struct { - param v1beta1.Param - } - tests := []struct { + for _, tt := range []struct { name string - args args + param v1beta1.Param wantRef []*v1beta1.ResultRef - }{ - { - name: "Test valid expression", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.sumTask.results.sumResult)", - }, - }, - }, - wantRef: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask", - Result: "sumResult", - }, - }, - }, { - name: "Test valid expression with dashes", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.sum-task.results.sum-result)", - }, - }, - }, - wantRef: []*v1beta1.ResultRef{ - { - PipelineTask: "sum-task", - Result: "sum-result", - }, - }, - }, { - name: "Test valid expression with underscores", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.sum-task.results.sum_result)", - }, - }, - }, - wantRef: []*v1beta1.ResultRef{ - { - PipelineTask: "sum-task", - Result: "sum_result", - }, - }, - }, { - name: "Test invalid expression: param substitution shouldn't be considered result ref", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(params.paramName)", - }, - }, - }, - wantRef: nil, - }, { - name: "Test valid expression in array", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeArray, - ArrayVal: []string{"$(tasks.sumTask.results.sumResult)", "$(tasks.sumTask2.results.sumResult2)"}, - }, - }, - }, - wantRef: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask", - Result: "sumResult", - }, - { - PipelineTask: "sumTask2", - Result: "sumResult2", - }, - }, - }, { - name: "Test valid expression in array - no ref in first element", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeArray, - ArrayVal: []string{"1", "$(tasks.sumTask2.results.sumResult2)"}, - }, - }, - }, - wantRef: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask2", - Result: "sumResult2", - }, - }, + }{{ + name: "Test valid expression", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sumTask.results.sumResult)"), }, - } - for _, tt := range tests { + wantRef: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask", + Result: "sumResult", + }}, + }, { + name: "Test valid expression with dashes", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sum-task.results.sum-result)"), + }, + wantRef: []*v1beta1.ResultRef{{ + PipelineTask: "sum-task", + Result: "sum-result", + }}, + }, { + name: "Test valid expression with underscores", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sum-task.results.sum_result)"), + }, + wantRef: []*v1beta1.ResultRef{{ + PipelineTask: "sum-task", + Result: "sum_result", + }}, + }, { + name: "Test invalid expression: param substitution shouldn't be considered result ref", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(params.paramName)"), + }, + wantRef: nil, + }, { + name: "Test valid expression in array", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sumTask.results.sumResult)", "$(tasks.sumTask2.results.sumResult2)"), + }, + wantRef: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask", + Result: "sumResult", + }, { + PipelineTask: "sumTask2", + Result: "sumResult2", + }}, + }, { + name: "Test valid expression in array - no ref in first element", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("1", "$(tasks.sumTask2.results.sumResult2)"), + }, + wantRef: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask2", + Result: "sumResult2", + }}, + }} { t.Run(tt.name, func(t *testing.T) { - expressions, ok := v1beta1.GetVarSubstitutionExpressionsForParam(tt.args.param) + expressions, ok := v1beta1.GetVarSubstitutionExpressionsForParam(tt.param) if !ok { t.Fatalf("expected to find expressions but didn't find any") } @@ -315,115 +212,69 @@ func TestHasResultReference(t *testing.T) { } func TestLooksLikeResultRef(t *testing.T) { - type args struct { + for _, tt := range []struct { + name string param v1beta1.Param - } - tests := []struct { - name string - args args - want bool - }{ - { - name: "test expression that is a result ref", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.sumTasks.results.sumResult)", - }, - }, - }, - want: true, - }, { - name: "test expression: looks like result ref, but typo in 'task' separator", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(task.sumTasks.results.sumResult)", - }, - }, - }, - want: true, - }, { - name: "test expression: looks like result ref, but typo in 'results' separator", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.sumTasks.result.sumResult)", - }, - }, - }, - want: true, - }, { - name: "test expression: missing 'task' separator", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(sumTasks.results.sumResult)", - }, - }, - }, - want: false, - }, { - name: "test expression: missing variable substitution", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "tasks.sumTasks.results.sumResult", - }, - }, - }, - want: false, - }, { - name: "test expression: param substitution shouldn't be considered result ref", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(params.someParam)", - }, - }, - }, - want: false, - }, { - name: "test expression: one good ref, one bad one should return true", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.sumTasks.results.sumResult) $(task.sumTasks.results.sumResult)", - }, - }, - }, - want: true, - }, { - name: "test expression: inside array parameter", - args: args{ - param: v1beta1.Param{ - Name: "param", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeArray, - ArrayVal: []string{"$(tasks.sumTask.results.sumResult)", "$(tasks.sumTask2.results.sumResult2)"}, - }, - }, - }, - want: true, + want bool + }{{ + name: "test expression that is a result ref", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sumTasks.results.sumResult)"), }, - } - for _, tt := range tests { + want: true, + }, { + name: "test expression: looks like result ref, but typo in 'task' separator", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(task.sumTasks.results.sumResult)"), + }, + want: true, + }, { + name: "test expression: looks like result ref, but typo in 'results' separator", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sumTasks.result.sumResult)"), + }, + want: true, + }, { + name: "test expression: missing 'task' separator", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(sumTasks.results.sumResult)"), + }, + want: false, + }, { + name: "test expression: missing variable substitution", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("tasks.sumTasks.results.sumResult"), + }, + want: false, + }, { + name: "test expression: param substitution shouldn't be considered result ref", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(params.someParam)"), + }, + want: false, + }, { + name: "test expression: one good ref, one bad one should return true", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sumTasks.results.sumResult) $(task.sumTasks.results.sumResult)"), + }, + want: true, + }, { + name: "test expression: inside array parameter", + param: v1beta1.Param{ + Name: "param", + Value: *v1beta1.NewArrayOrString("$(tasks.sumTask.results.sumResult)", "$(tasks.sumTask2.results.sumResult2)"), + }, + want: true, + }} { t.Run(tt.name, func(t *testing.T) { - expressions, ok := v1beta1.GetVarSubstitutionExpressionsForParam(tt.args.param) + expressions, ok := v1beta1.GetVarSubstitutionExpressionsForParam(tt.param) if ok { if got := v1beta1.LooksLikeContainsResultRefs(expressions); got != tt.want { t.Errorf("LooksLikeContainsResultRefs() = %v, want %v", got, tt.want) @@ -436,130 +287,98 @@ func TestLooksLikeResultRef(t *testing.T) { } func TestNewResultReferenceWhenExpressions(t *testing.T) { - type args struct { - whenExpression v1beta1.WhenExpression - } - tests := []struct { + for _, tt := range []struct { name string - args args + we v1beta1.WhenExpression want []*v1beta1.ResultRef - }{ - { - name: "Test valid expression", - args: args{ - whenExpression: v1beta1.WhenExpression{ - Input: "$(tasks.sumTask.results.sumResult)", - Operator: selection.In, - Values: []string{"foo"}, - }, - }, - want: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask", - Result: "sumResult", - }, - }, - }, { - name: "substitution within string", - args: args{ - whenExpression: v1beta1.WhenExpression{ - Input: "sum-will-go-here -> $(tasks.sumTask.results.sumResult)", - Operator: selection.In, - Values: []string{"foo"}, - }, - }, - want: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask", - Result: "sumResult", - }, - }, - }, { - name: "multiple substitution", - args: args{ - whenExpression: v1beta1.WhenExpression{ - Input: "$(tasks.sumTask1.results.sumResult) and another $(tasks.sumTask2.results.sumResult)", - Operator: selection.In, - Values: []string{"foo"}, - }, - }, - want: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask1", - Result: "sumResult", - }, { - PipelineTask: "sumTask2", - Result: "sumResult", - }, - }, - }, { - name: "multiple substitution with param", - args: args{ - whenExpression: v1beta1.WhenExpression{ - Input: "$(params.param) $(tasks.sumTask1.results.sumResult) and another $(tasks.sumTask2.results.sumResult)", - Operator: selection.In, - Values: []string{"foo"}, - }, - }, - want: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask1", - Result: "sumResult", - }, { - PipelineTask: "sumTask2", - Result: "sumResult", - }, - }, - }, { - name: "first separator typo", - args: args{ - whenExpression: v1beta1.WhenExpression{ - Input: "$(task.sumTasks.results.sumResult)", - Operator: selection.In, - Values: []string{"foo"}, - }, - }, - want: nil, - }, { - name: "third separator typo", - args: args{ - whenExpression: v1beta1.WhenExpression{ - Input: "$(tasks.sumTasks.result.sumResult)", - Operator: selection.In, - Values: []string{"foo"}, - }, - }, - want: nil, - }, { - name: "param substitution shouldn't be considered result ref", - args: args{ - whenExpression: v1beta1.WhenExpression{ - Input: "$(params.paramName)", - Operator: selection.In, - Values: []string{"foo"}, - }, - }, - want: nil, - }, { - name: "One bad and good result substitution", - args: args{ - whenExpression: v1beta1.WhenExpression{ - Input: "good -> $(tasks.sumTask1.results.sumResult) bad-> $(task.sumTask2.results.sumResult)", - Operator: selection.In, - Values: []string{"foo"}, - }, - }, - want: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask1", - Result: "sumResult", - }, - }, + }{{ + name: "Test valid expression", + we: v1beta1.WhenExpression{ + Input: "$(tasks.sumTask.results.sumResult)", + Operator: selection.In, + Values: []string{"foo"}, }, - } - for _, tt := range tests { + want: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask", + Result: "sumResult", + }}, + }, { + name: "substitution within string", + we: v1beta1.WhenExpression{ + Input: "sum-will-go-here -> $(tasks.sumTask.results.sumResult)", + Operator: selection.In, + Values: []string{"foo"}, + }, + want: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask", + Result: "sumResult", + }}, + }, { + name: "multiple substitution", + we: v1beta1.WhenExpression{ + Input: "$(tasks.sumTask1.results.sumResult) and another $(tasks.sumTask2.results.sumResult)", + Operator: selection.In, + Values: []string{"foo"}, + }, + want: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask1", + Result: "sumResult", + }, { + PipelineTask: "sumTask2", + Result: "sumResult", + }}, + }, { + name: "multiple substitution with param", + we: v1beta1.WhenExpression{ + Input: "$(params.param) $(tasks.sumTask1.results.sumResult) and another $(tasks.sumTask2.results.sumResult)", + Operator: selection.In, + Values: []string{"foo"}, + }, + want: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask1", + Result: "sumResult", + }, { + PipelineTask: "sumTask2", + Result: "sumResult", + }}, + }, { + name: "first separator typo", + we: v1beta1.WhenExpression{ + Input: "$(task.sumTasks.results.sumResult)", + Operator: selection.In, + Values: []string{"foo"}, + }, + want: nil, + }, { + name: "third separator typo", + we: v1beta1.WhenExpression{ + Input: "$(tasks.sumTasks.result.sumResult)", + Operator: selection.In, + Values: []string{"foo"}, + }, + want: nil, + }, { + name: "param substitution shouldn't be considered result ref", + we: v1beta1.WhenExpression{ + Input: "$(params.paramName)", + Operator: selection.In, + Values: []string{"foo"}, + }, + want: nil, + }, { + name: "One bad and good result substitution", + we: v1beta1.WhenExpression{ + Input: "good -> $(tasks.sumTask1.results.sumResult) bad-> $(task.sumTask2.results.sumResult)", + Operator: selection.In, + Values: []string{"foo"}, + }, + want: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask1", + Result: "sumResult", + }}, + }} { t.Run(tt.name, func(t *testing.T) { - expressions, ok := tt.args.whenExpression.GetVarSubstitutionExpressions() + expressions, ok := tt.we.GetVarSubstitutionExpressions() if !ok { t.Fatalf("expected to find expressions but didn't find any") } else { @@ -573,78 +392,66 @@ func TestNewResultReferenceWhenExpressions(t *testing.T) { } func TestHasResultReferenceWhenExpression(t *testing.T) { - tests := []struct { + for _, tt := range []struct { name string we v1beta1.WhenExpression wantRef []*v1beta1.ResultRef - }{ - { - name: "Test valid expression", - we: v1beta1.WhenExpression{ - Input: "sumResult", - Operator: selection.In, - Values: []string{"$(tasks.sumTask.results.sumResult)"}, - }, - wantRef: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask", - Result: "sumResult", - }, - }, - }, { - name: "Test valid expression with dashes", - we: v1beta1.WhenExpression{ - Input: "$(tasks.sum-task.results.sum-result)", - Operator: selection.In, - Values: []string{"sum-result"}, - }, - wantRef: []*v1beta1.ResultRef{ - { - PipelineTask: "sum-task", - Result: "sum-result", - }, - }, - }, { - name: "Test valid expression with underscores", - we: v1beta1.WhenExpression{ - Input: "$(tasks.sum-task.results.sum_result)", - Operator: selection.In, - Values: []string{"sum-result"}, - }, - wantRef: []*v1beta1.ResultRef{ - { - PipelineTask: "sum-task", - Result: "sum_result", - }, - }, - }, { - name: "Test invalid expression: param substitution shouldn't be considered result ref", - we: v1beta1.WhenExpression{ - Input: "$(params.paramName)", - Operator: selection.In, - Values: []string{"sum-result"}, - }, - wantRef: nil, - }, { - name: "Test valid expression in array", - we: v1beta1.WhenExpression{ - Input: "$sumResult", - Operator: selection.In, - Values: []string{"$(tasks.sumTask.results.sumResult)", "$(tasks.sumTask2.results.sumResult2)"}, - }, - wantRef: []*v1beta1.ResultRef{ - { - PipelineTask: "sumTask", - Result: "sumResult", - }, - { - PipelineTask: "sumTask2", - Result: "sumResult2", - }, - }, + }{{ + name: "Test valid expression", + we: v1beta1.WhenExpression{ + Input: "sumResult", + Operator: selection.In, + Values: []string{"$(tasks.sumTask.results.sumResult)"}, }, - } - for _, tt := range tests { + wantRef: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask", + Result: "sumResult", + }}, + }, { + name: "Test valid expression with dashes", + we: v1beta1.WhenExpression{ + Input: "$(tasks.sum-task.results.sum-result)", + Operator: selection.In, + Values: []string{"sum-result"}, + }, + wantRef: []*v1beta1.ResultRef{{ + PipelineTask: "sum-task", + Result: "sum-result", + }}, + }, { + name: "Test valid expression with underscores", + we: v1beta1.WhenExpression{ + Input: "$(tasks.sum-task.results.sum_result)", + Operator: selection.In, + Values: []string{"sum-result"}, + }, + wantRef: []*v1beta1.ResultRef{{ + PipelineTask: "sum-task", + Result: "sum_result", + }}, + }, { + name: "Test invalid expression: param substitution shouldn't be considered result ref", + we: v1beta1.WhenExpression{ + Input: "$(params.paramName)", + Operator: selection.In, + Values: []string{"sum-result"}, + }, + wantRef: nil, + }, { + name: "Test valid expression in array", + we: v1beta1.WhenExpression{ + Input: "$sumResult", + Operator: selection.In, + Values: []string{"$(tasks.sumTask.results.sumResult)", "$(tasks.sumTask2.results.sumResult2)"}, + }, + wantRef: []*v1beta1.ResultRef{{ + PipelineTask: "sumTask", + Result: "sumResult", + }, { + PipelineTask: "sumTask2", + Result: "sumResult2", + }}, + }} { t.Run(tt.name, func(t *testing.T) { expressions, ok := tt.we.GetVarSubstitutionExpressions() if !ok { diff --git a/pkg/apis/pipeline/v1beta1/task_validation_test.go b/pkg/apis/pipeline/v1beta1/task_validation_test.go index 37bbbad2849..f567854fea9 100644 --- a/pkg/apis/pipeline/v1beta1/task_validation_test.go +++ b/pkg/apis/pipeline/v1beta1/task_validation_test.go @@ -22,7 +22,6 @@ import ( "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" - tb "github.com/tektoncd/pipeline/internal/builder/v1beta1" "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" "github.com/tektoncd/pipeline/test/diff" corev1 "k8s.io/api/core/v1" @@ -96,7 +95,7 @@ func TestTaskSpecValidate(t *testing.T) { Params: []v1beta1.ParamSpec{{ Name: "task", Description: "param", - Default: tb.ArrayOrString("default"), + Default: v1beta1.NewArrayOrString("default"), }}, Steps: validSteps, }, @@ -107,7 +106,7 @@ func TestTaskSpecValidate(t *testing.T) { Name: "task", Type: v1beta1.ParamTypeString, Description: "param", - Default: tb.ArrayOrString("default"), + Default: v1beta1.NewArrayOrString("default"), }}, Steps: validSteps, }, @@ -364,7 +363,7 @@ func TestTaskSpecValidateError(t *testing.T) { Name: "validparam", Type: v1beta1.ParamTypeString, Description: "parameter", - Default: tb.ArrayOrString("default"), + Default: v1beta1.NewArrayOrString("default"), }}, }, expectedError: apis.FieldError{ @@ -452,12 +451,12 @@ func TestTaskSpecValidateError(t *testing.T) { Name: "validparam", Type: v1beta1.ParamTypeString, Description: "parameter", - Default: tb.ArrayOrString("default"), + Default: v1beta1.NewArrayOrString("default"), }, { Name: "param-with-invalid-type", Type: "invalidtype", Description: "invalidtypedesc", - Default: tb.ArrayOrString("default"), + Default: v1beta1.NewArrayOrString("default"), }}, Steps: validSteps, }, @@ -472,7 +471,7 @@ func TestTaskSpecValidateError(t *testing.T) { Name: "task", Type: v1beta1.ParamTypeArray, Description: "param", - Default: tb.ArrayOrString("default"), + Default: v1beta1.NewArrayOrString("default"), }}, Steps: validSteps, }, @@ -487,7 +486,7 @@ func TestTaskSpecValidateError(t *testing.T) { Name: "task", Type: v1beta1.ParamTypeString, Description: "param", - Default: tb.ArrayOrString("default", "array"), + Default: v1beta1.NewArrayOrString("default", "array"), }}, Steps: validSteps, }, @@ -502,7 +501,7 @@ func TestTaskSpecValidateError(t *testing.T) { Name: "validparam", Type: v1beta1.ParamTypeString, Description: "parameter", - Default: tb.ArrayOrString("default"), + Default: v1beta1.NewArrayOrString("default"), }}, Steps: []v1beta1.Step{}, }, @@ -649,17 +648,11 @@ func TestTaskSpecValidateError(t *testing.T) { name: "inferred array not properly isolated", fields: fields{ Params: []v1beta1.ParamSpec{{ - Name: "baz", - Default: &v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeArray, - ArrayVal: []string{"implied", "array", "type"}, - }, + Name: "baz", + Default: v1beta1.NewArrayOrString("implied", "array", "type"), }, { - Name: "foo-is-baz", - Default: &v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeArray, - ArrayVal: []string{"implied", "array", "type"}, - }, + Name: "foo-is-baz", + Default: v1beta1.NewArrayOrString("implied", "array", "type"), }}, Steps: []v1beta1.Step{{Container: corev1.Container{ Name: "mystep", @@ -677,17 +670,11 @@ func TestTaskSpecValidateError(t *testing.T) { name: "inferred array star not properly isolated", fields: fields{ Params: []v1beta1.ParamSpec{{ - Name: "baz", - Default: &v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeArray, - ArrayVal: []string{"implied", "array", "type"}, - }, + Name: "baz", + Default: v1beta1.NewArrayOrString("implied", "array", "type"), }, { - Name: "foo-is-baz", - Default: &v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeArray, - ArrayVal: []string{"implied", "array", "type"}, - }, + Name: "foo-is-baz", + Default: v1beta1.NewArrayOrString("implied", "array", "type"), }}, Steps: []v1beta1.Step{{Container: corev1.Container{ Name: "mystep", @@ -704,13 +691,11 @@ func TestTaskSpecValidateError(t *testing.T) { }, { name: "Inexistent param variable with existing", fields: fields{ - Params: []v1beta1.ParamSpec{ - { - Name: "foo", - Description: "param", - Default: tb.ArrayOrString("default"), - }, - }, + Params: []v1beta1.ParamSpec{{ + Name: "foo", + Description: "param", + Default: v1beta1.NewArrayOrString("default"), + }}, Steps: []v1beta1.Step{{Container: corev1.Container{ Name: "mystep", Image: "myimage", diff --git a/pkg/apis/pipeline/v1beta1/taskrun_validation_test.go b/pkg/apis/pipeline/v1beta1/taskrun_validation_test.go index c0c4b66cf96..c65fb52b818 100644 --- a/pkg/apis/pipeline/v1beta1/taskrun_validation_test.go +++ b/pkg/apis/pipeline/v1beta1/taskrun_validation_test.go @@ -22,7 +22,6 @@ import ( "time" "github.com/google/go-cmp/cmp" - tb "github.com/tektoncd/pipeline/internal/builder/v1beta1" "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1" "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" resource "github.com/tektoncd/pipeline/pkg/apis/resource/v1alpha1" @@ -192,10 +191,10 @@ func TestTaskRunSpec_Invalidate(t *testing.T) { spec: v1beta1.TaskRunSpec{ Params: []v1alpha1.Param{{ Name: "name", - Value: *tb.ArrayOrString("value"), + Value: *v1beta1.NewArrayOrString("value"), }, { Name: "name", - Value: *tb.ArrayOrString("value"), + Value: *v1beta1.NewArrayOrString("value"), }}, TaskRef: &v1beta1.TaskRef{Name: "mytask"}, }, @@ -242,7 +241,7 @@ func TestTaskRunSpec_Validate(t *testing.T) { Timeout: &metav1.Duration{Duration: 0}, Params: []v1beta1.Param{{ Name: "name", - Value: *tb.ArrayOrString("value"), + Value: *v1beta1.NewArrayOrString("value"), }}, TaskSpec: &v1beta1.TaskSpec{ Steps: []v1beta1.Step{{Container: corev1.Container{ diff --git a/pkg/reconciler/pipeline/dag/dag_test.go b/pkg/reconciler/pipeline/dag/dag_test.go index 79ea11111f8..74ab1a54737 100644 --- a/pkg/reconciler/pipeline/dag/dag_test.go +++ b/pkg/reconciler/pipeline/dag/dag_test.go @@ -564,40 +564,25 @@ func TestBuild_TaskParamsFromTaskResults(t *testing.T) { e := v1alpha1.PipelineTask{Name: "e"} xDependsOnA := v1alpha1.PipelineTask{ Name: "x", - Params: []v1alpha1.Param{ - { - Name: "paramX", - Value: v1beta1.ArrayOrString{ - Type: v1alpha1.ParamTypeString, - StringVal: "$(tasks.a.results.resultA)", - }, - }, - }, + Params: []v1alpha1.Param{{ + Name: "paramX", + Value: *v1beta1.NewArrayOrString("$(tasks.a.results.resultA)"), + }}, } yDependsOnBRunsAfterC := v1alpha1.PipelineTask{ Name: "y", RunAfter: []string{"c"}, - Params: []v1alpha1.Param{ - { - Name: "paramB", - Value: v1beta1.ArrayOrString{ - Type: v1alpha1.ParamTypeString, - StringVal: "$(tasks.b.results.resultB)", - }, - }, - }, + Params: []v1alpha1.Param{{ + Name: "paramB", + Value: *v1beta1.NewArrayOrString("$(tasks.b.results.resultB)"), + }}, } zDependsOnDAndE := v1alpha1.PipelineTask{ Name: "z", - Params: []v1alpha1.Param{ - { - Name: "paramZ", - Value: v1beta1.ArrayOrString{ - Type: v1alpha1.ParamTypeString, - StringVal: "$(tasks.d.results.resultD) $(tasks.e.results.resultE)", - }, - }, - }, + Params: []v1alpha1.Param{{ + Name: "paramZ", + Value: *v1beta1.NewArrayOrString("$(tasks.d.results.resultD) $(tasks.e.results.resultE)"), + }}, } // a b c d e @@ -652,17 +637,11 @@ func TestBuild_ConditionsParamsFromTaskResults(t *testing.T) { Name: "x", Conditions: []v1beta1.PipelineTaskCondition{{ ConditionRef: "cond", - Params: []v1alpha1.Param{ - { - Name: "paramX", - Value: v1beta1.ArrayOrString{ - Type: v1alpha1.ParamTypeString, - StringVal: "$(tasks.a.results.resultA)", - }, - }, - }, - }, - }, + Params: []v1alpha1.Param{{ + Name: "paramX", + Value: *v1beta1.NewArrayOrString("$(tasks.a.results.resultA)"), + }}, + }}, } // a diff --git a/pkg/reconciler/pipeline/dag/dagv1beta1_test.go b/pkg/reconciler/pipeline/dag/dagv1beta1_test.go index 0b04a65a46c..de2509934cd 100644 --- a/pkg/reconciler/pipeline/dag/dagv1beta1_test.go +++ b/pkg/reconciler/pipeline/dag/dagv1beta1_test.go @@ -49,11 +49,8 @@ func testGraphv1beta1(t *testing.T) *dag.Graph { }, { Name: "w", Params: []v1beta1.Param{{ - Name: "foo", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.y.results.bar)", - }, + Name: "foo", + Value: *v1beta1.NewArrayOrString("$(tasks.y.results.bar)"), }}, RunAfter: []string{"b"}, }, { @@ -522,40 +519,25 @@ func TestBuild_TaskParamsFromTaskResults_v1beta1(t *testing.T) { e := v1beta1.PipelineTask{Name: "e"} xDependsOnA := v1beta1.PipelineTask{ Name: "x", - Params: []v1beta1.Param{ - { - Name: "paramX", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.a.results.resultA)", - }, - }, - }, + Params: []v1beta1.Param{{ + Name: "paramX", + Value: *v1beta1.NewArrayOrString("$(tasks.a.results.resultA)"), + }}, } yDependsOnBRunsAfterC := v1beta1.PipelineTask{ Name: "y", RunAfter: []string{"c"}, - Params: []v1beta1.Param{ - { - Name: "paramB", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.b.results.resultB)", - }, - }, - }, + Params: []v1beta1.Param{{ + Name: "paramB", + Value: *v1beta1.NewArrayOrString("$(tasks.b.results.resultB)"), + }}, } zDependsOnDAndE := v1beta1.PipelineTask{ Name: "z", - Params: []v1beta1.Param{ - { - Name: "paramZ", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.d.results.resultD) $(tasks.e.results.resultE)", - }, - }, - }, + Params: []v1beta1.Param{{ + Name: "paramZ", + Value: *v1beta1.NewArrayOrString("$(tasks.d.results.resultD) $(tasks.e.results.resultE)"), + }}, } // a b c d e @@ -610,17 +592,11 @@ func TestBuild_ConditionsParamsFromTaskResults_v1beta1(t *testing.T) { Name: "x", Conditions: []v1beta1.PipelineTaskCondition{{ ConditionRef: "cond", - Params: []v1beta1.Param{ - { - Name: "paramX", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.a.results.resultA)", - }, - }, - }, - }, - }, + Params: []v1beta1.Param{{ + Name: "paramX", + Value: *v1beta1.NewArrayOrString("$(tasks.a.results.resultA)"), + }}, + }}, } // a diff --git a/pkg/reconciler/pipelinerun/resources/apply_test.go b/pkg/reconciler/pipelinerun/resources/apply_test.go index eb1a6a36226..d73aef29ef7 100644 --- a/pkg/reconciler/pipelinerun/resources/apply_test.go +++ b/pkg/reconciler/pipelinerun/resources/apply_test.go @@ -21,14 +21,13 @@ import ( "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/selection" - tb "github.com/tektoncd/pipeline/internal/builder/v1beta1" "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1" "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" resourcev1alpha1 "github.com/tektoncd/pipeline/pkg/apis/resource/v1alpha1" "github.com/tektoncd/pipeline/test/diff" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/selection" ) func TestApplyParameters(t *testing.T) { @@ -187,119 +186,77 @@ func TestApplyParameters(t *testing.T) { } func TestApplyTaskResults_MinimalExpression(t *testing.T) { - type args struct { + for _, tt := range []struct { + name string targets PipelineRunState resolvedResultRefs ResolvedResultRefs - } - tests := []struct { - name string - args args - want PipelineRunState - }{ - { - name: "Test result substitution on minimal variable substitution expression - params", - args: args{ - resolvedResultRefs: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, - }, - targets: PipelineRunState{ - { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - Params: []v1beta1.Param{ - { - Name: "bParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.aTask.results.aResult)", - }, - }, - }, - }, - }, - }, + want PipelineRunState + }{{ + name: "Test result substitution on minimal variable substitution expression - params", + resolvedResultRefs: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", }, - want: PipelineRunState{ - { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - Params: []v1beta1.Param{ - { - Name: "bParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - }, - }, - }, - }, + FromTaskRun: "aTaskRun", + }}, + targets: PipelineRunState{{ + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + Params: []v1beta1.Param{{ + Name: "bParam", + Value: *v1beta1.NewArrayOrString("$(tasks.aTask.results.aResult)"), + }}, }, - }, { - name: "Test result substitution on minimal variable substitution expression - when expressions", - args: args{ - resolvedResultRefs: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, - }, - targets: PipelineRunState{ - { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - WhenExpressions: []v1beta1.WhenExpression{ - { - Input: "$(tasks.aTask.results.aResult)", - Operator: selection.In, - Values: []string{"$(tasks.aTask.results.aResult)"}, - }, - }, - }, - }, - }, + }}, + want: PipelineRunState{{ + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + Params: []v1beta1.Param{{ + Name: "bParam", + Value: *v1beta1.NewArrayOrString("aResultValue"), + }}, }, - want: PipelineRunState{ - { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - WhenExpressions: []v1beta1.WhenExpression{ - { - Input: "aResultValue", - Operator: selection.In, - Values: []string{"aResultValue"}, - }, - }, - }, - }, + }}, + }, { + name: "Test result substitution on minimal variable substitution expression - when expressions", + resolvedResultRefs: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", }, - }, - } - for _, tt := range tests { + FromTaskRun: "aTaskRun", + }}, + targets: PipelineRunState{{ + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + WhenExpressions: []v1beta1.WhenExpression{{ + Input: "$(tasks.aTask.results.aResult)", + Operator: selection.In, + Values: []string{"$(tasks.aTask.results.aResult)"}, + }}, + }, + }}, + want: PipelineRunState{{ + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + WhenExpressions: []v1beta1.WhenExpression{{ + Input: "aResultValue", + Operator: selection.In, + Values: []string{"aResultValue"}, + }}, + }, + }}, + }} { t.Run(tt.name, func(t *testing.T) { - ApplyTaskResults(tt.args.targets, tt.args.resolvedResultRefs) - if d := cmp.Diff(tt.want, tt.args.targets); d != "" { + ApplyTaskResults(tt.targets, tt.resolvedResultRefs) + if d := cmp.Diff(tt.want, tt.targets); d != "" { t.Fatalf("ApplyTaskResults() %s", diff.PrintWantGot(d)) } }) @@ -307,119 +264,79 @@ func TestApplyTaskResults_MinimalExpression(t *testing.T) { } func TestApplyTaskResults_EmbeddedExpression(t *testing.T) { - type args struct { + for _, tt := range []struct { + name string targets PipelineRunState resolvedResultRefs ResolvedResultRefs - } - tests := []struct { - name string - args args - want PipelineRunState - }{ - { - name: "Test result substitution on embedded variable substitution expression - params", - args: args{ - resolvedResultRefs: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, - }, - targets: PipelineRunState{ - { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - Params: []v1beta1.Param{ - { - Name: "bParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "Result value --> $(tasks.aTask.results.aResult)", - }, - }, - }, - }, - }, - }, + want PipelineRunState + }{{ + name: "Test result substitution on embedded variable substitution expression - params", + resolvedResultRefs: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", }, - want: PipelineRunState{ - { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - Params: []v1beta1.Param{ - { - Name: "bParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "Result value --> aResultValue", - }, - }, - }, - }, - }, + FromTaskRun: "aTaskRun", + }}, + targets: PipelineRunState{{ + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + Params: []v1beta1.Param{{ + Name: "bParam", + Value: *v1beta1.NewArrayOrString("Result value --> $(tasks.aTask.results.aResult)"), + }}, }, - }, { - name: "Test result substitution on embedded variable substitution expression - when expressions", - args: args{ - resolvedResultRefs: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, - }, - targets: PipelineRunState{ + }}, + want: PipelineRunState{{ + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + Params: []v1beta1.Param{{ + Name: "bParam", + Value: *v1beta1.NewArrayOrString("Result value --> aResultValue"), + }}, + }, + }}, + }, { + name: "Test result substitution on embedded variable substitution expression - when expressions", + resolvedResultRefs: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", + }, + FromTaskRun: "aTaskRun", + }}, + targets: PipelineRunState{{ + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + WhenExpressions: []v1beta1.WhenExpression{ { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - WhenExpressions: []v1beta1.WhenExpression{ - { - Input: "Result value --> $(tasks.aTask.results.aResult)", - Operator: selection.In, - Values: []string{"Result value --> $(tasks.aTask.results.aResult)"}, - }, - }, - }, + Input: "Result value --> $(tasks.aTask.results.aResult)", + Operator: selection.In, + Values: []string{"Result value --> $(tasks.aTask.results.aResult)"}, }, }, }, - want: PipelineRunState{ - { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - WhenExpressions: []v1beta1.WhenExpression{ - { - Input: "Result value --> aResultValue", - Operator: selection.In, - Values: []string{"Result value --> aResultValue"}, - }, - }, - }, - }, + }}, + want: PipelineRunState{{ + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + WhenExpressions: []v1beta1.WhenExpression{{ + Input: "Result value --> aResultValue", + Operator: selection.In, + Values: []string{"Result value --> aResultValue"}, + }}, }, - }, - } - for _, tt := range tests { + }}, + }} { t.Run(tt.name, func(t *testing.T) { - ApplyTaskResults(tt.args.targets, tt.args.resolvedResultRefs) - if d := cmp.Diff(tt.want, tt.args.targets); d != "" { + ApplyTaskResults(tt.targets, tt.resolvedResultRefs) + if d := cmp.Diff(tt.want, tt.targets); d != "" { t.Fatalf("ApplyTaskResults() %s", diff.PrintWantGot(d)) } }) @@ -427,93 +344,65 @@ func TestApplyTaskResults_EmbeddedExpression(t *testing.T) { } func TestApplyTaskResults_Conditions(t *testing.T) { - type args struct { + for _, tt := range []struct { + name string targets PipelineRunState resolvedResultRefs ResolvedResultRefs - } - tests := []struct { - name string - args args - want PipelineRunState + want PipelineRunState }{{ name: "Test result substitution in condition parameter", - args: args{ - resolvedResultRefs: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, + resolvedResultRefs: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", }, - targets: PipelineRunState{ - { - ResolvedConditionChecks: TaskConditionCheckState{{ - ConditionRegisterName: "always-true-0", - ConditionCheckName: "test", - Condition: &v1alpha1.Condition{ - ObjectMeta: metav1.ObjectMeta{ - Name: "always-true", - }, - Spec: v1alpha1.ConditionSpec{ - Check: v1beta1.Step{}, - }}, - ResolvedResources: map[string]*resourcev1alpha1.PipelineResource{}, - PipelineTaskCondition: &v1beta1.PipelineTaskCondition{ - Params: []v1beta1.Param{ - { - Name: "cParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "Result value --> $(tasks.aTask.results.aResult)", - }, - }, - }, - }, + FromTaskRun: "aTaskRun", + }}, + targets: PipelineRunState{{ + ResolvedConditionChecks: TaskConditionCheckState{{ + ConditionRegisterName: "always-true-0", + ConditionCheckName: "test", + Condition: &v1alpha1.Condition{ + ObjectMeta: metav1.ObjectMeta{ + Name: "always-true", }, + Spec: v1alpha1.ConditionSpec{ + Check: v1beta1.Step{}, }, }, - }, - }, - want: PipelineRunState{ - { - ResolvedConditionChecks: TaskConditionCheckState{{ - ConditionRegisterName: "always-true-0", - ConditionCheckName: "test", - Condition: &v1alpha1.Condition{ - ObjectMeta: metav1.ObjectMeta{ - Name: "always-true", - }, - Spec: v1alpha1.ConditionSpec{ - Check: v1beta1.Step{}, - }}, - ResolvedResources: map[string]*resourcev1alpha1.PipelineResource{}, - PipelineTaskCondition: &v1beta1.PipelineTaskCondition{ - Params: []v1beta1.Param{ - { - Name: "cParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "Result value --> aResultValue", - }, - }, - }, - }, + ResolvedResources: map[string]*resourcev1alpha1.PipelineResource{}, + PipelineTaskCondition: &v1beta1.PipelineTaskCondition{ + Params: []v1beta1.Param{{ + Name: "cParam", + Value: *v1beta1.NewArrayOrString("Result value --> $(tasks.aTask.results.aResult)"), + }}, }, + }}, + }}, + want: PipelineRunState{{ + ResolvedConditionChecks: TaskConditionCheckState{{ + ConditionRegisterName: "always-true-0", + ConditionCheckName: "test", + Condition: &v1alpha1.Condition{ + ObjectMeta: metav1.ObjectMeta{ + Name: "always-true", + }, + Spec: v1alpha1.ConditionSpec{ + Check: v1beta1.Step{}, + }, }, - }, - }, - }, - } - for _, tt := range tests { + ResolvedResources: map[string]*resourcev1alpha1.PipelineResource{}, + PipelineTaskCondition: &v1beta1.PipelineTaskCondition{Params: []v1beta1.Param{{ + Name: "cParam", + Value: *v1beta1.NewArrayOrString("Result value --> aResultValue"), + }}}, + }}, + }}, + }} { t.Run(tt.name, func(t *testing.T) { - ApplyTaskResults(tt.args.targets, tt.args.resolvedResultRefs) - if d := cmp.Diff(tt.want[0].ResolvedConditionChecks, tt.args.targets[0].ResolvedConditionChecks, cmpopts.IgnoreUnexported(v1beta1.TaskRunSpec{}, ResolvedConditionCheck{})); d != "" { + ApplyTaskResults(tt.targets, tt.resolvedResultRefs) + if d := cmp.Diff(tt.want[0].ResolvedConditionChecks, tt.targets[0].ResolvedConditionChecks, cmpopts.IgnoreUnexported(v1beta1.TaskRunSpec{}, ResolvedConditionCheck{})); d != "" { t.Fatalf("ApplyTaskResults() %s", diff.PrintWantGot(d)) } }) diff --git a/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go b/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go index 588351a5482..4a54459bc67 100644 --- a/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go +++ b/pkg/reconciler/pipelinerun/resources/pipelinerunresolution_test.go @@ -2183,12 +2183,20 @@ func TestResolveConditionChecks_MultipleConditions(t *testing.T) { ptc1 := v1beta1.PipelineTaskCondition{ ConditionRef: "always-true", - Params: []v1beta1.Param{{Name: "path", Value: *tb.ArrayOrString("$(params.path)")}, {Name: "image", Value: *tb.ArrayOrString("$(params.image)")}}, + Params: []v1beta1.Param{{ + Name: "path", Value: *v1beta1.NewArrayOrString("$(params.path)"), + }, { + Name: "image", Value: *v1beta1.NewArrayOrString("$(params.image)"), + }}, } ptc2 := v1beta1.PipelineTaskCondition{ ConditionRef: "always-true", - Params: []v1beta1.Param{{Name: "path", Value: *tb.ArrayOrString("$(params.path-test)")}, {Name: "image", Value: *tb.ArrayOrString("$(params.image-test)")}}, + Params: []v1beta1.Param{{ + Name: "path", Value: *v1beta1.NewArrayOrString("$(params.path-test)"), + }, { + Name: "image", Value: *v1beta1.NewArrayOrString("$(params.image-test)"), + }}, } pts := []v1beta1.PipelineTask{{ diff --git a/pkg/reconciler/pipelinerun/resources/resultrefresolution.go b/pkg/reconciler/pipelinerun/resources/resultrefresolution.go index c86a2214849..2830b175c14 100644 --- a/pkg/reconciler/pipelinerun/resources/resultrefresolution.go +++ b/pkg/reconciler/pipelinerun/resources/resultrefresolution.go @@ -215,10 +215,7 @@ func resolveResultRef(pipelineState PipelineRunState, resultRef *v1beta1.ResultR return nil, err } return &ResolvedResultRef{ - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: result.Value, - }, + Value: *v1beta1.NewArrayOrString(result.Value), FromTaskRun: referencedTaskRun.Name, ResultReference: *resultRef, }, nil @@ -235,10 +232,7 @@ func resolveResultRefForPipelineResult(pipelineStatus v1beta1.PipelineRunStatus, return nil, err } return &ResolvedResultRef{ - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: result.Value, - }, + Value: *v1beta1.NewArrayOrString(result.Value), FromTaskRun: taskRunName, ResultReference: *resultRef, }, nil diff --git a/pkg/reconciler/pipelinerun/resources/resultrefresolution_test.go b/pkg/reconciler/pipelinerun/resources/resultrefresolution_test.go index c06ea87b1f7..bf191744bf0 100644 --- a/pkg/reconciler/pipelinerun/resources/resultrefresolution_test.go +++ b/pkg/reconciler/pipelinerun/resources/resultrefresolution_test.go @@ -17,251 +17,162 @@ import ( ) func TestTaskParamResolver_ResolveResultRefs(t *testing.T) { - type fields struct { + for _, tt := range []struct { + name string pipelineRunState PipelineRunState - } - type args struct { - param v1beta1.Param - } - tests := []struct { - name string - fields fields - args args - want ResolvedResultRefs - wantErr bool - }{ - { - name: "successful resolution: param not using result reference", - fields: fields{ - pipelineRunState: PipelineRunState{ - { - TaskRunName: "aTaskRun", - TaskRun: tb.TaskRun("aTaskRun"), - PipelineTask: &v1beta1.PipelineTask{ - Name: "aTask", - TaskRef: &v1beta1.TaskRef{Name: "aTask"}, - }, - }, - }, - }, - args: args{ - param: v1beta1.Param{ - Name: "targetParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "explicitValueNoResultReference", - }, - }, + param v1beta1.Param + want ResolvedResultRefs + wantErr bool + }{{ + name: "successful resolution: param not using result reference", + pipelineRunState: PipelineRunState{{ + TaskRunName: "aTaskRun", + TaskRun: tb.TaskRun("aTaskRun"), + PipelineTask: &v1beta1.PipelineTask{ + Name: "aTask", + TaskRef: &v1beta1.TaskRef{Name: "aTask"}, }, - want: nil, - wantErr: false, + }}, + param: v1beta1.Param{ + Name: "targetParam", + Value: *v1beta1.NewArrayOrString("explicitValueNoResultReference"), }, - { - name: "successful resolution: using result reference", - fields: fields{ - pipelineRunState: PipelineRunState{ - { - TaskRunName: "aTaskRun", - TaskRun: tb.TaskRun("aTaskRun", tb.TaskRunStatus( - tb.TaskRunResult("aResult", "aResultValue"), - )), - PipelineTask: &v1beta1.PipelineTask{ - Name: "aTask", - TaskRef: &v1beta1.TaskRef{Name: "aTask"}, - }, - }, - }, - }, - args: args{ - param: v1beta1.Param{ - Name: "targetParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.aTask.results.aResult)", - }, - }, - }, - want: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, - }, - wantErr: false, - }, { - name: "successful resolution: using multiple result reference", - fields: fields{ - pipelineRunState: PipelineRunState{ - { - TaskRunName: "aTaskRun", - TaskRun: tb.TaskRun("aTaskRun", tb.TaskRunStatus( - tb.TaskRunResult("aResult", "aResultValue"), - )), - PipelineTask: &v1beta1.PipelineTask{ - Name: "aTask", - TaskRef: &v1beta1.TaskRef{Name: "aTask"}, - }, - }, { - TaskRunName: "bTaskRun", - TaskRun: tb.TaskRun("bTaskRun", tb.TaskRunStatus( - tb.TaskRunResult("bResult", "bResultValue"), - )), - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - }, - }, - }, - }, - args: args{ - param: v1beta1.Param{ - Name: "targetParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.aTask.results.aResult) $(tasks.bTask.results.bResult)", - }, - }, - }, - want: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "bResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "bTask", - Result: "bResult", - }, - FromTaskRun: "bTaskRun", - }, - }, - wantErr: false, - }, { - name: "successful resolution: duplicate result references", - fields: fields{ - pipelineRunState: PipelineRunState{ - { - TaskRunName: "aTaskRun", - TaskRun: tb.TaskRun("aTaskRun", tb.TaskRunStatus( - tb.TaskRunResult("aResult", "aResultValue"), - )), - PipelineTask: &v1beta1.PipelineTask{ - Name: "aTask", - TaskRef: &v1beta1.TaskRef{Name: "aTask"}, - }, - }, - }, - }, - args: args{ - param: v1beta1.Param{ - Name: "targetParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.aTask.results.aResult) $(tasks.aTask.results.aResult)", - }, - }, + want: nil, + wantErr: false, + }, { + name: "successful resolution: using result reference", + pipelineRunState: PipelineRunState{{ + TaskRunName: "aTaskRun", + TaskRun: tb.TaskRun("aTaskRun", tb.TaskRunStatus( + tb.TaskRunResult("aResult", "aResultValue"), + )), + PipelineTask: &v1beta1.PipelineTask{ + Name: "aTask", + TaskRef: &v1beta1.TaskRef{Name: "aTask"}, }, - want: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, + }}, + param: v1beta1.Param{ + Name: "targetParam", + Value: *v1beta1.NewArrayOrString("$(tasks.aTask.results.aResult)"), + }, + want: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", + }, + FromTaskRun: "aTaskRun", + }}, + wantErr: false, + }, { + name: "successful resolution: using multiple result reference", + pipelineRunState: PipelineRunState{{ + TaskRunName: "aTaskRun", + TaskRun: tb.TaskRun("aTaskRun", tb.TaskRunStatus( + tb.TaskRunResult("aResult", "aResultValue"), + )), + PipelineTask: &v1beta1.PipelineTask{ + Name: "aTask", + TaskRef: &v1beta1.TaskRef{Name: "aTask"}, }, - wantErr: false, }, { - name: "unsuccessful resolution: referenced result doesn't exist in referenced task", - fields: fields{ - pipelineRunState: PipelineRunState{ - { - TaskRunName: "aTaskRun", - TaskRun: tb.TaskRun("aTaskRun"), - PipelineTask: &v1beta1.PipelineTask{ - Name: "aTask", - TaskRef: &v1beta1.TaskRef{Name: "aTask"}, - }, - }, - }, + TaskRunName: "bTaskRun", + TaskRun: tb.TaskRun("bTaskRun", tb.TaskRunStatus( + tb.TaskRunResult("bResult", "bResultValue"), + )), + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, }, - args: args{ - param: v1beta1.Param{ - Name: "targetParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.aTask.results.aResult)", - }, - }, + }}, + param: v1beta1.Param{ + Name: "targetParam", + Value: *v1beta1.NewArrayOrString("$(tasks.aTask.results.aResult) $(tasks.bTask.results.bResult)"), + }, + want: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", }, - want: nil, - wantErr: true, + FromTaskRun: "aTaskRun", }, { - name: "unsuccessful resolution: pipeline task missing", - fields: fields{ - pipelineRunState: PipelineRunState{}, - }, - args: args{ - param: v1beta1.Param{ - Name: "targetParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.aTask.results.aResult)", - }, - }, + Value: *v1beta1.NewArrayOrString("bResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "bTask", + Result: "bResult", + }, + FromTaskRun: "bTaskRun", + }}, + wantErr: false, + }, { + name: "successful resolution: duplicate result references", + pipelineRunState: PipelineRunState{{ + TaskRunName: "aTaskRun", + TaskRun: tb.TaskRun("aTaskRun", tb.TaskRunStatus( + tb.TaskRunResult("aResult", "aResultValue"), + )), + PipelineTask: &v1beta1.PipelineTask{ + Name: "aTask", + TaskRef: &v1beta1.TaskRef{Name: "aTask"}, }, - want: nil, - wantErr: true, - }, { - name: "unsuccessful resolution: task run missing", - fields: fields{ - pipelineRunState: PipelineRunState{ - { - PipelineTask: &v1beta1.PipelineTask{ - Name: "aTask", - TaskRef: &v1beta1.TaskRef{Name: "aTask"}, - }, - }, - }, + }}, + param: v1beta1.Param{ + Name: "targetParam", + Value: *v1beta1.NewArrayOrString("$(tasks.aTask.results.aResult) $(tasks.aTask.results.aResult)"), + }, + want: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", + }, + FromTaskRun: "aTaskRun", + }}, + wantErr: false, + }, { + name: "unsuccessful resolution: referenced result doesn't exist in referenced task", + pipelineRunState: PipelineRunState{{ + TaskRunName: "aTaskRun", + TaskRun: tb.TaskRun("aTaskRun"), + PipelineTask: &v1beta1.PipelineTask{ + Name: "aTask", + TaskRef: &v1beta1.TaskRef{Name: "aTask"}, }, - args: args{ - param: v1beta1.Param{ - Name: "targetParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.aTask.results.aResult)", - }, - }, + }}, + param: v1beta1.Param{ + Name: "targetParam", + Value: *v1beta1.NewArrayOrString("$(tasks.aTask.results.aResult)"), + }, + want: nil, + wantErr: true, + }, { + name: "unsuccessful resolution: pipeline task missing", + pipelineRunState: PipelineRunState{}, + param: v1beta1.Param{ + Name: "targetParam", + Value: *v1beta1.NewArrayOrString("$(tasks.aTask.results.aResult)"), + }, + want: nil, + wantErr: true, + }, { + name: "unsuccessful resolution: task run missing", + pipelineRunState: PipelineRunState{{ + PipelineTask: &v1beta1.PipelineTask{ + Name: "aTask", + TaskRef: &v1beta1.TaskRef{Name: "aTask"}, }, - want: nil, - wantErr: true, + }}, + param: v1beta1.Param{ + Name: "targetParam", + Value: *v1beta1.NewArrayOrString("$(tasks.aTask.results.aResult)"), }, - } - for _, tt := range tests { + want: nil, + wantErr: true, + }} { t.Run(tt.name, func(t *testing.T) { t.Logf("test name: %s\n", tt.name) - got, err := extractResultRefsForParam(tt.fields.pipelineRunState, tt.args.param) + got, err := extractResultRefsForParam(tt.pipelineRunState, tt.param) // sort result ref based on task name to guarantee an certain order sort.SliceStable(got, func(i, j int) bool { return strings.Compare(got[i].FromTaskRun, got[j].FromTaskRun) < 0 @@ -296,160 +207,118 @@ func resolvedSliceAsString(rs []*ResolvedResultRef) string { } func TestResolveResultRefs(t *testing.T) { - type args struct { + pipelineRunState := PipelineRunState{{ + TaskRunName: "aTaskRun", + TaskRun: tb.TaskRun("aTaskRun", tb.TaskRunStatus( + tb.TaskRunResult("aResult", "aResultValue"), + )), + PipelineTask: &v1beta1.PipelineTask{ + Name: "aTask", + TaskRef: &v1beta1.TaskRef{Name: "aTask"}, + }, + }, { + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + Params: []v1beta1.Param{{ + Name: "bParam", + Value: *v1beta1.NewArrayOrString("$(tasks.aTask.results.aResult)"), + }}, + }, + }, { + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + WhenExpressions: []v1beta1.WhenExpression{{ + Input: "$(tasks.aTask.results.aResult)", + Operator: selection.In, + Values: []string{"$(tasks.aTask.results.aResult)"}, + }}, + }, + }, { + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + WhenExpressions: []v1beta1.WhenExpression{{ + Input: "$(tasks.aTask.results.missingResult)", + Operator: selection.In, + Values: []string{"$(tasks.aTask.results.missingResult)"}, + }}, + }, + }, { + PipelineTask: &v1beta1.PipelineTask{ + Name: "bTask", + TaskRef: &v1beta1.TaskRef{Name: "bTask"}, + Params: []v1beta1.Param{{ + Name: "bParam", + Value: *v1beta1.NewArrayOrString("$(tasks.aTask.results.missingResult)"), + }}, + }, + }} + + for _, tt := range []struct { + name string pipelineRunState PipelineRunState targets PipelineRunState - } - pipelineRunState := PipelineRunState{ - { - TaskRunName: "aTaskRun", - TaskRun: tb.TaskRun("aTaskRun", tb.TaskRunStatus( - tb.TaskRunResult("aResult", "aResultValue"), - )), - PipelineTask: &v1beta1.PipelineTask{ - Name: "aTask", - TaskRef: &v1beta1.TaskRef{Name: "aTask"}, - }, - }, { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - Params: []v1beta1.Param{ - { - Name: "bParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.aTask.results.aResult)", - }, - }, - }, - }, - }, { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - WhenExpressions: []v1beta1.WhenExpression{ - { - Input: "$(tasks.aTask.results.aResult)", - Operator: selection.In, - Values: []string{"$(tasks.aTask.results.aResult)"}, - }, - }, - }, - }, { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - WhenExpressions: []v1beta1.WhenExpression{ - { - Input: "$(tasks.aTask.results.missingResult)", - Operator: selection.In, - Values: []string{"$(tasks.aTask.results.missingResult)"}, - }, - }, - }, - }, { - PipelineTask: &v1beta1.PipelineTask{ - Name: "bTask", - TaskRef: &v1beta1.TaskRef{Name: "bTask"}, - Params: []v1beta1.Param{ - { - Name: "bParam", - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "$(tasks.aTask.results.missingResult)", - }, - }, - }, - }, + want ResolvedResultRefs + wantErr bool + }{{ + name: "Test successful result references resolution - params", + pipelineRunState: pipelineRunState, + targets: PipelineRunState{ + pipelineRunState[1], }, - } - - tests := []struct { - name string - args args - want ResolvedResultRefs - wantErr bool - }{ - { - name: "Test successful result references resolution - params", - args: args{ - pipelineRunState: pipelineRunState, - targets: PipelineRunState{ - pipelineRunState[1], - }, - }, - want: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, - }, - wantErr: false, - }, { - name: "Test successful result references resolution - when expressions", - args: args{ - pipelineRunState: pipelineRunState, - targets: PipelineRunState{ - pipelineRunState[2], - }, - }, - want: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, - }, - wantErr: false, - }, { - name: "Test successful result references resolution non result references", - args: args{ - pipelineRunState: pipelineRunState, - targets: PipelineRunState{ - pipelineRunState[0], - }, - }, - want: nil, - wantErr: false, - }, { - name: "Test unsuccessful result references resolution - when expression", - args: args{ - pipelineRunState: pipelineRunState, - targets: PipelineRunState{ - pipelineRunState[3], - }, - }, - want: nil, - wantErr: true, - }, { - name: "Test unsuccessful result references resolution - params", - args: args{ - pipelineRunState: pipelineRunState, - targets: PipelineRunState{ - pipelineRunState[4], - }, - }, - want: nil, - wantErr: true, + want: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", + }, + FromTaskRun: "aTaskRun", + }}, + wantErr: false, + }, { + name: "Test successful result references resolution - when expressions", + pipelineRunState: pipelineRunState, + targets: PipelineRunState{ + pipelineRunState[2], }, - } - for _, tt := range tests { + want: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", + }, + FromTaskRun: "aTaskRun", + }}, + wantErr: false, + }, { + name: "Test successful result references resolution non result references", + pipelineRunState: pipelineRunState, + targets: PipelineRunState{ + pipelineRunState[0], + }, + want: nil, + wantErr: false, + }, { + name: "Test unsuccessful result references resolution - when expression", + pipelineRunState: pipelineRunState, + targets: PipelineRunState{ + pipelineRunState[3], + }, + want: nil, + wantErr: true, + }, { + name: "Test unsuccessful result references resolution - params", + pipelineRunState: pipelineRunState, + targets: PipelineRunState{ + pipelineRunState[4], + }, + want: nil, + wantErr: true, + }} { t.Run(tt.name, func(t *testing.T) { - got, err := ResolveResultRefs(tt.args.pipelineRunState, tt.args.targets) + got, err := ResolveResultRefs(tt.pipelineRunState, tt.targets) sort.SliceStable(got, func(i, j int) bool { return strings.Compare(got[i].FromTaskRun, got[j].FromTaskRun) < 0 }) @@ -465,10 +334,6 @@ func TestResolveResultRefs(t *testing.T) { } func TestResolvePipelineResultRefs(t *testing.T) { - type args struct { - status v1beta1.PipelineRunStatus - pipelineResults []v1beta1.PipelineResult - } taskrunStatus := map[string]*v1beta1.PipelineRunTaskRunStatus{} taskrunStatus["aTaskRun"] = &v1beta1.PipelineRunTaskRunStatus{ PipelineTaskName: "aTask", @@ -518,76 +383,55 @@ func TestResolvePipelineResultRefs(t *testing.T) { } tests := []struct { - name string - args args - want ResolvedResultRefs - }{ - { - name: "Test pipeline result from a successful task", - args: args{ - status: status, - pipelineResults: []v1beta1.PipelineResult{ - { - Name: "from-a", - Value: "$(tasks.aTask.results.aResult)", - Description: "a result from a", - }, - }, - }, - want: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, - }, - }, - { - name: "Test results from a task that did not run and one and failed", - args: args{ - status: status, - pipelineResults: []v1beta1.PipelineResult{ - { - Name: "from-a", - Value: "$(tasks.aTask.results.aResult)", - Description: "a result from a", - }, - { - Name: "from-b", - Value: "$(tasks.bTask.results.bResult)", - Description: "a result from b", - }, - { - Name: "from-c", - Value: "$(tasks.cTask.results.cResult)", - Description: "a result from c", - }, - }, - }, - want: ResolvedResultRefs{ - { - Value: v1beta1.ArrayOrString{ - Type: v1beta1.ParamTypeString, - StringVal: "aResultValue", - }, - ResultReference: v1beta1.ResultRef{ - PipelineTask: "aTask", - Result: "aResult", - }, - FromTaskRun: "aTaskRun", - }, - }, - }, + name string + status v1beta1.PipelineRunStatus + pipelineResults []v1beta1.PipelineResult + want ResolvedResultRefs + }{{ + name: "Test pipeline result from a successful task", + status: status, + pipelineResults: []v1beta1.PipelineResult{{ + Name: "from-a", + Value: "$(tasks.aTask.results.aResult)", + Description: "a result from a", + }}, + want: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", + }, + FromTaskRun: "aTaskRun", + }}, + }, { + name: "Test results from a task that did not run and one and failed", + status: status, + pipelineResults: []v1beta1.PipelineResult{{ + Name: "from-a", + Value: "$(tasks.aTask.results.aResult)", + Description: "a result from a", + }, { + Name: "from-b", + Value: "$(tasks.bTask.results.bResult)", + Description: "a result from b", + }, { + Name: "from-c", + Value: "$(tasks.cTask.results.cResult)", + Description: "a result from c", + }}, + want: ResolvedResultRefs{{ + Value: *v1beta1.NewArrayOrString("aResultValue"), + ResultReference: v1beta1.ResultRef{ + PipelineTask: "aTask", + Result: "aResult", + }, + FromTaskRun: "aTaskRun", + }}, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - got := ResolvePipelineResultRefs(tt.args.status, tt.args.pipelineResults) + got := ResolvePipelineResultRefs(tt.status, tt.pipelineResults) sort.SliceStable(got, func(i, j int) bool { return strings.Compare(got[i].FromTaskRun, got[j].FromTaskRun) < 0 }) diff --git a/pkg/reconciler/pipelinerun/resources/validate_params_test.go b/pkg/reconciler/pipelinerun/resources/validate_params_test.go index e9960984000..18bf45e8842 100644 --- a/pkg/reconciler/pipelinerun/resources/validate_params_test.go +++ b/pkg/reconciler/pipelinerun/resources/validate_params_test.go @@ -138,7 +138,7 @@ func TestValidateRequiredParametersProvided_Valid(t *testing.T) { prp: []v1beta1.Param{ { Name: "required-string-param", - Value: *tb.ArrayOrString("somestring"), + Value: *v1beta1.NewArrayOrString("somestring"), }, }, }, { @@ -152,7 +152,7 @@ func TestValidateRequiredParametersProvided_Valid(t *testing.T) { prp: []v1beta1.Param{ { Name: "required-array-param", - Value: *tb.ArrayOrString("another", "array"), + Value: *v1beta1.NewArrayOrString("another", "array"), }, }, }, { @@ -161,13 +161,13 @@ func TestValidateRequiredParametersProvided_Valid(t *testing.T) { { Name: "string-param", Type: v1beta1.ParamTypeString, - Default: tb.ArrayOrString("somedefault"), + Default: v1beta1.NewArrayOrString("somedefault"), }, }, prp: []v1beta1.Param{ { Name: "another-string-param", - Value: *tb.ArrayOrString("somestring"), + Value: *v1beta1.NewArrayOrString("somestring"), }, }, }} @@ -196,7 +196,7 @@ func TestValidateRequiredParametersProvided_Invalid(t *testing.T) { prp: []v1beta1.Param{ { Name: "another-string-param", - Value: *tb.ArrayOrString("anotherstring"), + Value: *v1beta1.NewArrayOrString("anotherstring"), }, }, }, { @@ -210,7 +210,7 @@ func TestValidateRequiredParametersProvided_Invalid(t *testing.T) { prp: []v1beta1.Param{ { Name: "another-array-param", - Value: *tb.ArrayOrString("anotherstring"), + Value: *v1beta1.NewArrayOrString("anotherstring"), }, }, }} diff --git a/pkg/reconciler/taskrun/resources/apply_test.go b/pkg/reconciler/taskrun/resources/apply_test.go index 14a2062d4a7..b6f096ea265 100644 --- a/pkg/reconciler/taskrun/resources/apply_test.go +++ b/pkg/reconciler/taskrun/resources/apply_test.go @@ -20,7 +20,6 @@ import ( "testing" "github.com/google/go-cmp/cmp" - tb "github.com/tektoncd/pipeline/internal/builder/v1beta1" "github.com/tektoncd/pipeline/pkg/apis/pipeline" "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1" "github.com/tektoncd/pipeline/pkg/apis/resource" @@ -300,7 +299,7 @@ var ( Spec: v1beta1.TaskRunSpec{ Params: []v1beta1.Param{{ Name: "array-param", - Value: *tb.ArrayOrString("foo"), + Value: *v1beta1.NewArrayOrString("foo"), }}, }, } @@ -309,7 +308,7 @@ var ( Spec: v1beta1.TaskRunSpec{ Params: []v1beta1.Param{{ Name: "array-param", - Value: *tb.ArrayOrString("foo", "bar", "third"), + Value: *v1beta1.NewArrayOrString("foo", "bar", "third"), }}, }, } @@ -318,10 +317,10 @@ var ( Spec: v1beta1.TaskRunSpec{ Params: []v1beta1.Param{{ Name: "array-param", - Value: *tb.ArrayOrString("foo", "bar", "third"), + Value: *v1beta1.NewArrayOrString("foo", "bar", "third"), }, { Name: "another-array-param", - Value: *tb.ArrayOrString("part1", "part2"), + Value: *v1beta1.NewArrayOrString("part1", "part2"), }}, }, } @@ -330,10 +329,10 @@ var ( Spec: v1beta1.TaskRunSpec{ Params: []v1beta1.Param{{ Name: "array-param", - Value: *tb.ArrayOrString("middlefirst", "middlesecond"), + Value: *v1beta1.NewArrayOrString("middlefirst", "middlesecond"), }, { Name: "normal-param", - Value: *tb.ArrayOrString("foo"), + Value: *v1beta1.NewArrayOrString("foo"), }}, }, } @@ -342,16 +341,16 @@ var ( Spec: v1beta1.TaskRunSpec{ Params: []v1beta1.Param{{ Name: "array-param1", - Value: *tb.ArrayOrString("1-param1", "2-param1", "3-param1", "4-param1"), + Value: *v1beta1.NewArrayOrString("1-param1", "2-param1", "3-param1", "4-param1"), }, { Name: "array-param2", - Value: *tb.ArrayOrString("1-param2", "2-param2", "2-param3"), + Value: *v1beta1.NewArrayOrString("1-param2", "2-param2", "2-param3"), }, { Name: "string-param1", - Value: *tb.ArrayOrString("foo"), + Value: *v1beta1.NewArrayOrString("foo"), }, { Name: "string-param2", - Value: *tb.ArrayOrString("bar"), + Value: *v1beta1.NewArrayOrString("bar"), }}, }, } @@ -486,12 +485,10 @@ func TestApplyArrayParameters(t *testing.T) { args: args{ ts: arrayParamTaskSpec, tr: &v1beta1.TaskRun{}, - dp: []v1beta1.ParamSpec{ - { - Name: "array-param", - Default: tb.ArrayOrString("defaulted", "value!"), - }, - }, + dp: []v1beta1.ParamSpec{{ + Name: "array-param", + Default: v1beta1.NewArrayOrString("defaulted", "value!"), + }}, }, want: applyMutation(arrayParamTaskSpec, func(spec *v1beta1.TaskSpec) { spec.Steps[1].Args = []string{"first", "second", "defaulted", "value!", "last"} @@ -512,19 +509,19 @@ func TestApplyParameters(t *testing.T) { Spec: v1beta1.TaskRunSpec{ Params: []v1beta1.Param{{ Name: "myimage", - Value: *tb.ArrayOrString("bar"), + Value: *v1beta1.NewArrayOrString("bar"), }, { Name: "FOO", - Value: *tb.ArrayOrString("world"), + Value: *v1beta1.NewArrayOrString("world"), }}, }, } dp := []v1beta1.ParamSpec{{ Name: "something", - Default: tb.ArrayOrString("mydefault"), + Default: v1beta1.NewArrayOrString("mydefault"), }, { Name: "somethingelse", - Default: tb.ArrayOrString(""), + Default: v1beta1.NewArrayOrString(""), }} want := applyMutation(simpleTaskSpec, func(spec *v1beta1.TaskSpec) { spec.StepTemplate.Env[0].Value = "world" @@ -576,22 +573,17 @@ func TestApplyParameters(t *testing.T) { } func TestApplyResources(t *testing.T) { - type args struct { + tests := []struct { + name string ts *v1beta1.TaskSpec r map[string]v1beta1.PipelineResourceInterface rStr string - } - tests := []struct { - name string - args args want *v1beta1.TaskSpec }{{ name: "no replacements specified", - args: args{ - ts: simpleTaskSpec, - r: make(map[string]v1beta1.PipelineResourceInterface), - rStr: "inputs", - }, + ts: simpleTaskSpec, + r: make(map[string]v1beta1.PipelineResourceInterface), + rStr: "inputs", want: applyMutation(simpleTaskSpec, func(spec *v1beta1.TaskSpec) { spec.Steps[1].WorkingDir = "/workspace/workspace" spec.Steps[4].WorkingDir = "/workspace/workspace" @@ -600,11 +592,9 @@ func TestApplyResources(t *testing.T) { }), }, { name: "input resource specified", - args: args{ - ts: simpleTaskSpec, - r: inputs, - rStr: "inputs", - }, + ts: simpleTaskSpec, + r: inputs, + rStr: "inputs", want: applyMutation(simpleTaskSpec, func(spec *v1beta1.TaskSpec) { spec.Steps[1].WorkingDir = "/workspace/workspace" spec.Steps[1].Args = []string{"https://git-repo"} @@ -615,11 +605,9 @@ func TestApplyResources(t *testing.T) { }), }, { name: "output resource specified", - args: args{ - ts: simpleTaskSpec, - r: outputs, - rStr: "outputs", - }, + ts: simpleTaskSpec, + r: outputs, + rStr: "outputs", want: applyMutation(simpleTaskSpec, func(spec *v1beta1.TaskSpec) { spec.Steps[1].WorkingDir = "/workspace/workspace" spec.Steps[2].Args = []string{"gcr.io/hans/sandwiches"} @@ -630,18 +618,16 @@ func TestApplyResources(t *testing.T) { }), }, { name: "output resource specified with path replacement", - args: args{ - ts: gcsTaskSpec, - r: outputs, - rStr: "outputs", - }, + ts: gcsTaskSpec, + r: outputs, + rStr: "outputs", want: applyMutation(gcsTaskSpec, func(spec *v1beta1.TaskSpec) { spec.Steps[0].Args = []string{"/workspace/output/bucket"} }), }} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - got := resources.ApplyResources(tt.args.ts, tt.args.r, tt.args.rStr) + got := resources.ApplyResources(tt.ts, tt.r, tt.rStr) if d := cmp.Diff(tt.want, got); d != "" { t.Errorf("ApplyResources() %s", diff.PrintWantGot(d)) } diff --git a/pkg/reconciler/taskrun/validate_resources_test.go b/pkg/reconciler/taskrun/validate_resources_test.go index 75eb02e549e..2ca9a917202 100644 --- a/pkg/reconciler/taskrun/validate_resources_test.go +++ b/pkg/reconciler/taskrun/validate_resources_test.go @@ -71,10 +71,10 @@ func TestValidateResolvedTaskResources_ValidParams(t *testing.T) { } p := []v1beta1.Param{{ Name: "foo", - Value: *tb.ArrayOrString("somethinggood"), + Value: *v1beta1.NewArrayOrString("somethinggood"), }, { Name: "bar", - Value: *tb.ArrayOrString("somethinggood"), + Value: *v1beta1.NewArrayOrString("somethinggood"), }} if err := taskrun.ValidateResolvedTaskResources(p, rtr); err != nil { t.Fatalf("Did not expect to see error when validating TaskRun with correct params but saw %v", err) @@ -97,7 +97,7 @@ func TestValidateResolvedTaskResources_InvalidParams(t *testing.T) { }, params: []v1beta1.Param{{ Name: "foobar", - Value: *tb.ArrayOrString("somethingfun"), + Value: *v1beta1.NewArrayOrString("somethingfun"), }}, }, { name: "missing-params", @@ -106,10 +106,10 @@ func TestValidateResolvedTaskResources_InvalidParams(t *testing.T) { }, params: []v1beta1.Param{{ Name: "foo", - Value: *tb.ArrayOrString("i am a real param"), + Value: *v1beta1.NewArrayOrString("i am a real param"), }, { Name: "extra", - Value: *tb.ArrayOrString("i am an extra param"), + Value: *v1beta1.NewArrayOrString("i am an extra param"), }}, }} for _, tc := range tcs { diff --git a/test/dag_test.go b/test/dag_test.go index 5fd16aded6d..2b8593f8d33 100644 --- a/test/dag_test.go +++ b/test/dag_test.go @@ -102,7 +102,7 @@ func TestDAGPipelineRun(t *testing.T) { Name: "pipeline-task-3", TaskRef: &v1beta1.TaskRef{Name: "echo-task"}, Params: []v1beta1.Param{{ - Name: "text", Value: v1beta1.NewArrayOrString("wow"), + Name: "text", Value: *v1beta1.NewArrayOrString("wow"), }}, Resources: &v1beta1.PipelineTaskResources{ Inputs: []v1beta1.PipelineTaskInputResource{{ @@ -117,7 +117,7 @@ func TestDAGPipelineRun(t *testing.T) { Name: "pipeline-task-2-parallel-2", TaskRef: &v1beta1.TaskRef{Name: "echo-task"}, Params: []v1beta1.Param{{ - Name: "text", Value: v1beta1.NewArrayOrString("such parallel"), + Name: "text", Value: *v1beta1.NewArrayOrString("such parallel"), }}, Resources: &v1beta1.PipelineTaskResources{ Inputs: []v1beta1.PipelineTaskInputResource{{ @@ -132,7 +132,7 @@ func TestDAGPipelineRun(t *testing.T) { Name: "pipeline-task-4", TaskRef: &v1beta1.TaskRef{Name: "echo-task"}, Params: []v1beta1.Param{{ - Name: "text", Value: v1beta1.NewArrayOrString("very cloud native"), + Name: "text", Value: *v1beta1.NewArrayOrString("very cloud native"), }}, Resources: &v1beta1.PipelineTaskResources{ Inputs: []v1beta1.PipelineTaskInputResource{{ @@ -147,7 +147,7 @@ func TestDAGPipelineRun(t *testing.T) { Name: "pipeline-task-2-parallel-1", TaskRef: &v1beta1.TaskRef{Name: "echo-task"}, Params: []v1beta1.Param{{ - Name: "text", Value: v1beta1.NewArrayOrString("much graph"), + Name: "text", Value: *v1beta1.NewArrayOrString("much graph"), }}, Resources: &v1beta1.PipelineTaskResources{ Inputs: []v1beta1.PipelineTaskInputResource{{ @@ -162,7 +162,7 @@ func TestDAGPipelineRun(t *testing.T) { Name: "pipeline-task-1", TaskRef: &v1beta1.TaskRef{Name: "echo-task"}, Params: []v1beta1.Param{{ - Name: "text", Value: v1beta1.NewArrayOrString("how to ci/cd?"), + Name: "text", Value: *v1beta1.NewArrayOrString("how to ci/cd?"), }}, Resources: &v1beta1.PipelineTaskResources{ Inputs: []v1beta1.PipelineTaskInputResource{{ diff --git a/test/helm_task_test.go b/test/helm_task_test.go index 2d1e17a2684..036b3072201 100644 --- a/test/helm_task_test.go +++ b/test/helm_task_test.go @@ -146,7 +146,7 @@ func getCreateImageTask(namespace string) *v1beta1.Task { } func getHelmDeployTask(namespace string) *v1beta1.Task { - empty := v1beta1.NewArrayOrString("") + empty := *v1beta1.NewArrayOrString("") return &v1beta1.Task{ ObjectMeta: metav1.ObjectMeta{Name: helmDeployTaskName, Namespace: namespace}, Spec: v1beta1.TaskSpec{ @@ -246,15 +246,15 @@ func getHelmDeployPipeline(namespace string) *v1beta1.Pipeline { }}, }, Params: []v1beta1.Param{{ - Name: "pathToHelmCharts", Value: v1beta1.NewArrayOrString("/workspace/gitsource/test/gohelloworld/gohelloworld-chart"), + Name: "pathToHelmCharts", Value: *v1beta1.NewArrayOrString("/workspace/gitsource/test/gohelloworld/gohelloworld-chart"), }, { - Name: "chartname", Value: v1beta1.NewArrayOrString("$(params.chartname)"), + Name: "chartname", Value: *v1beta1.NewArrayOrString("$(params.chartname)"), }}, }, { Name: "check-service", TaskRef: &v1beta1.TaskRef{Name: checkServiceTaskName}, Params: []v1beta1.Param{{ - Name: "serviceUrl", Value: v1beta1.NewArrayOrString(fmt.Sprintf("http://%s:8080", helmDeployServiceName)), + Name: "serviceUrl", Value: *v1beta1.NewArrayOrString(fmt.Sprintf("http://%s:8080", helmDeployServiceName)), }}, RunAfter: []string{"helm-deploy"}, }}, @@ -268,7 +268,7 @@ func getHelmDeployPipelineRun(namespace string) *v1beta1.PipelineRun { Spec: v1beta1.PipelineRunSpec{ PipelineRef: &v1beta1.PipelineRef{Name: helmDeployPipelineName}, Params: []v1beta1.Param{{ - Name: "chartname", Value: v1beta1.NewArrayOrString("gohelloworld"), + Name: "chartname", Value: *v1beta1.NewArrayOrString("gohelloworld"), }}, Resources: []v1beta1.PipelineResourceBinding{{ Name: "git-repo", ResourceRef: &v1beta1.PipelineResourceRef{Name: sourceResourceName}, diff --git a/test/pipelinerun_test.go b/test/pipelinerun_test.go index cdc1d66e862..bd795d93621 100644 --- a/test/pipelinerun_test.go +++ b/test/pipelinerun_test.go @@ -313,9 +313,9 @@ func getHelloWorldPipelineWithSingularTask(suffix int, namespace string) *v1beta Name: task1Name, TaskRef: &v1beta1.TaskRef{Name: getName(taskName, suffix)}, Params: []v1beta1.Param{{ - Name: "path", Value: v1beta1.NewArrayOrString("$(params.path)"), + Name: "path", Value: *v1beta1.NewArrayOrString("$(params.path)"), }, { - Name: "dest", Value: v1beta1.NewArrayOrString("$(params.dest)"), + Name: "dest", Value: *v1beta1.NewArrayOrString("$(params.dest)"), }}, }}, }, @@ -539,10 +539,10 @@ func getHelloWorldPipelineRun(suffix int, namespace string) *v1beta1.PipelineRun PipelineRef: &v1beta1.PipelineRef{Name: getName(pipelineName, suffix)}, Params: []v1beta1.Param{{ Name: "path", - Value: v1beta1.NewArrayOrString("docker://gcr.io/build-crd-testing/secret-sauce"), + Value: *v1beta1.NewArrayOrString("docker://gcr.io/build-crd-testing/secret-sauce"), }, { Name: "dest", - Value: v1beta1.NewArrayOrString("dir:///tmp/"), + Value: *v1beta1.NewArrayOrString("dir:///tmp/"), }}, ServiceAccountName: fmt.Sprintf("%s%d", saName, suffix), },