test: add annotations/label propagation tests

Tests depend on previous commit containing new `factory.go` etc.

- `TestReconcile_PropagateLabelsAndAnnotationsToChild`
- `TestReconcile_ChildPipelineRunHasDefaultLabels``

Signed-off-by: Stanislav Jakuschevskij <stas@two-giants.com>

Author: twoGiants

pkg/reconciler/pipelinerun/pipelinerun_pinp_test.go

@@ -2,6 +2,7 @@ package pipelinerun
 
 import (
 	"context"
+	"fmt"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -12,7 +13,14 @@ import (
 	"github.com/tektoncd/pipeline/test/diff"
 	"github.com/tektoncd/pipeline/test/names"
 	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	ktesting "k8s.io/client-go/testing"
+	"knative.dev/pkg/apis"
+	"knative.dev/pkg/controller"
 )
 
 // TestReconcile_ChildPipelineRunPipelineSpec verifies the reconciliation logic for PipelineRuns that create child
@@ -278,3 +286,138 @@ func TestReconcile_NestedChildPipelineRuns(t *testing.T) {
 		[]*v1.PipelineRun{expectedGrandchildPipelineRun},
 	)
 }
+
+func TestReconcile_PropagateLabelsAndAnnotationsToChild(t *testing.T) {
+	names.TestingSeed()
+	// GIVEN
+	namespace := "foo"
+	parentPipeline,
+		parentPipelineRun,
+		expectedChildPipelineRun := th.OnePipelineInPipeline(t, namespace, "parent-pipeline-run")
+	expectedChildPipelineRun = th.WithAnnotationAndLabel(expectedChildPipelineRun, false)
+	testData := test.Data{
+		PipelineRuns: []*v1.PipelineRun{th.WithAnnotationAndLabel(parentPipelineRun, true)},
+		Pipelines:    []*v1.Pipeline{parentPipeline},
+		ConfigMaps:   []*corev1.ConfigMap{withEnabledAlphaAPIFields(newFeatureFlagsConfigMap())},
+	}
+
+	// WHEN
+	reconciledRun, childPipelineRuns := reconcileOncePinP(
+		t,
+		testData,
+		namespace,
+		parentPipelineRun.Name,
+		[]string{},
+	)
+
+	// THEN
+	validatePinP(
+		t,
+		reconciledRun.Status,
+		reconciledRun.Name,
+		childPipelineRuns,
+		[]*v1.PipelineRun{expectedChildPipelineRun},
+	)
+}
+
+func TestReconcile_ChildPipelineRunHasDefaultLabels(t *testing.T) {
+	names.TestingSeed()
+	// GIVEN
+	namespace := "foo"
+	parentPipeline,
+		parentPipelineRun,
+		expectedChildPipelineRun := th.OnePipelineInPipeline(t, namespace, "parent-pipeline-run")
+	expectedLabels := map[string]string{
+		pipeline.PipelineRunLabelKey:    parentPipelineRun.Name,
+		pipeline.PipelineLabelKey:       parentPipelineRun.Spec.PipelineRef.Name,
+		pipeline.PipelineRunUIDLabelKey: string(parentPipelineRun.UID),
+		pipeline.PipelineTaskLabelKey:   parentPipeline.Spec.Tasks[0].Name,
+		pipeline.MemberOfLabelKey:       v1.PipelineTasks,
+	}
+	testData := test.Data{
+		PipelineRuns: []*v1.PipelineRun{parentPipelineRun},
+		Pipelines:    []*v1.Pipeline{parentPipeline},
+		ConfigMaps:   []*corev1.ConfigMap{withEnabledAlphaAPIFields(newFeatureFlagsConfigMap())},
+	}
+
+	// WHEN
+	_, childPipelineRuns := reconcileOncePinP(
+		t,
+		testData,
+		namespace,
+		parentPipelineRun.Name,
+		[]string{},
+	)
+
+	// THEN
+	validateChildPipelineRunCount(t, childPipelineRuns, 1)
+
+	child := childPipelineRuns[expectedChildPipelineRun.Name]
+	for k, v := range expectedLabels {
+		if childPipelineRuns[expectedChildPipelineRun.Name].Labels[k] != v {
+			t.Errorf("Expected label %q=%q on child PipelineRun, got %q", k, v, child.Labels[k])
+		}
+	}
+}
+
+func TestReconcile_ChildPipelineRunCreationError(t *testing.T) {
+	names.TestingSeed()
+	// GIVEN
+	namespace := "foo"
+	parentPipeline,
+		parentPipelineRun,
+		expectedChildPipelineRun := th.OnePipelineInPipeline(t, namespace, "parent-pipeline-run")
+
+	testCases := []struct {
+		name        string
+		creationErr error
+	}{
+		{
+			name: "invalid",
+			creationErr: apierrors.NewInvalid(
+				schema.GroupKind{},
+				expectedChildPipelineRun.Name,
+				field.ErrorList{}),
+		},
+		{
+			name:        "bad request",
+			creationErr: apierrors.NewBadRequest("bad request"),
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			testData := test.Data{
+				PipelineRuns: []*v1.PipelineRun{parentPipelineRun},
+				Pipelines:    []*v1.Pipeline{parentPipeline},
+				ConfigMaps:   []*corev1.ConfigMap{withEnabledAlphaAPIFields(newFeatureFlagsConfigMap())},
+			}
+			prt := newPipelineRunTest(t, testData)
+			defer prt.Cancel()
+
+			clients := prt.TestAssets.Clients
+
+			// Simulate error when creating child PipelineRun's TaskRun
+			clients.Pipeline.PrependReactor("create", "pipelineruns", func(action ktesting.Action) (bool, runtime.Object, error) {
+				return true, nil, tc.creationErr
+			})
+
+			err := prt.TestAssets.Controller.Reconciler.Reconcile(prt.TestAssets.Ctx, fmt.Sprintf("%s/%s", namespace, parentPipelineRun.Name))
+			if !controller.IsPermanentError(err) {
+				t.Errorf("expected permanent error but got %s", err)
+			}
+			reconciledRun, err := clients.Pipeline.TektonV1().PipelineRuns(namespace).Get(prt.TestAssets.Ctx, parentPipelineRun.Name, metav1.GetOptions{})
+			if err != nil {
+				t.Fatalf("Somehow had error getting reconciled run out of fake client: %s", err)
+			}
+
+			if reconciledRun.Status.CompletionTime == nil {
+				t.Errorf("Expected a CompletionTime on invalid PipelineRun but was nil")
+			}
+
+			if reconciledRun.Status.GetCondition(apis.ConditionSucceeded).Reason != "CreateRunFailed" {
+				t.Errorf("Expected PipelineRun to be create run failed, but condition reason is %s", reconciledRun.Status.GetCondition(apis.ConditionSucceeded))
+			}
+		})
+	}
+}

pkg/reconciler/testing/factory.go

@@ -169,6 +169,24 @@ spec:
 	return parentPipeline, parentPipelineRun, expectedChildPipelineRun
 }
 
+func WithAnnotationAndLabel(pr *v1.PipelineRun, withUnused bool) *v1.PipelineRun {
+	if pr.Annotations == nil {
+		pr.Annotations = map[string]string{}
+	}
+	pr.Annotations["tekton.test/annotation"] = "test-annotation-value"
+
+	if pr.Labels == nil {
+		pr.Labels = map[string]string{}
+	}
+	pr.Labels["tekton.test/label"] = "test-label-value"
+
+	if withUnused {
+		pr.Labels["tekton.dev/pipeline"] = "will-not-be-used"
+	}
+
+	return pr
+}
+
 func childPipelineRunWithObjectMeta(
 	childPipelineRunName,
 	ns,