TEP-0114: Custom Task E2E Test with A Controller Installed

test/custom_task_test.go

@@ -22,16 +22,18 @@ package test
 import (
 	"context"
 	"fmt"
+	"os/exec"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/tektoncd/pipeline/pkg/apis/config"
 
 	"github.com/tektoncd/pipeline/test/parse"
 
-	"github.com/google/go-cmp/cmp"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
 	"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1"
 	"github.com/tektoncd/pipeline/test/diff"
@@ -45,8 +47,8 @@ import (
 )
 
 const (
-	apiVersion = "example.dev/v0"
-	kind       = "Example"
+	apiVersion = "wait.testing.tekton.dev/v1alpha1"
+	kind       = "Wait"
 )
 
 var supportedFeatureGates = map[string]string{
@@ -401,3 +403,130 @@ spec:
 		t.Fatalf("Failed to get PipelineRun `%s`: %s", pipelineRun.Name, err)
 	}
 }
+
+func applyController(t *testing.T) {
+	t.Log("Creating Wait Custom Task Controller...")
+	cmd := exec.Command("ko", "apply", "-f", "./config/controller.yaml")
+	cmd.Dir = "./wait-task"
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("Failed to create Wait Custom Task Controller: %s, Output: %s", err, out)
+	}
+}
+
+func cleanUpController(t *testing.T) {
+	t.Log("Tearing down Wait Custom Task Controller...")
+	cmd := exec.Command("ko", "delete", "-f", "./config/controller.yaml")
+	cmd.Dir = "./wait-task"
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("Failed to tear down Wait Custom Task Controller: %s, Output: %s", err, out)
+	}
+}
+
+func TestWaitCustomTask(t *testing.T) {
+	ctx := context.Background()
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	c, namespace := setup(ctx, t, requireAnyGate(supportedFeatureGates))
+	knativetest.CleanupOnInterrupt(func() { tearDown(ctx, t, c, namespace) }, t.Logf)
+	defer tearDown(ctx, t, c, namespace)
+
+	// Create a custom task controller
+	applyController(t)
+	// Cleanup the controller after finishing the test
+	defer cleanUpController(t)
+
+	for _, tc := range []struct {
+		name                string
+		duration            string
+		conditionAccessorFn func(string) ConditionAccessorFn
+		wantConditionType   apis.ConditionType
+		wantConditionStatus corev1.ConditionStatus
+		wantConditionReason string
+	}{{
+		name:                "Wait Task Has Passed",
+		duration:            "1s",
+		conditionAccessorFn: Succeed,
+		wantConditionType:   apis.ConditionSucceeded,
+		wantConditionStatus: corev1.ConditionTrue,
+		wantConditionReason: "DurationElapsed",
+	}, {
+		name:                "Wait Task Is Running",
+		duration:            "2s",
+		conditionAccessorFn: Running,
+		wantConditionType:   apis.ConditionSucceeded,
+		wantConditionStatus: corev1.ConditionUnknown,
+		wantConditionReason: "Running",
+	}} {
+		t.Run(tc.name, func(t *testing.T) {
+			runName := helpers.ObjectNameForTest(t)
+			run := parse.MustParseRun(t, fmt.Sprintf(`
+metadata:
+  name: %s
+spec:
+  ref:
+    apiVersion: %s
+    kind: %s
+  params:
+  - name: duration
+    value: %s
+`, runName, apiVersion, kind, tc.duration))
+			if _, err := c.RunClient.Create(ctx, run, metav1.CreateOptions{}); err != nil {
+				t.Fatalf("Failed to create TaskRun %q: %v", runName, err)
+			}
+
+			// Wait for the Run.
+			if err := WaitForRunState(ctx, c, runName, time.Minute, tc.conditionAccessorFn(runName), tc.wantConditionReason); err != nil {
+				t.Fatalf("Waiting for Run to finish running: %v", err)
+			}
+
+			// Get the actual Run
+			gotRun, err := c.RunClient.Get(ctx, runName, metav1.GetOptions{})
+			if err != nil {
+				t.Fatalf("%v", err)
+			}
+
+			gotCondition := gotRun.GetStatus().GetCondition(apis.ConditionSucceeded)
+			if gotCondition == nil {
+				t.Fatal("The Run failed to succeed")
+			}
+
+			// Compose the expected Run
+			runYAML := fmt.Sprintf(`
+metadata:
+  name: %s
+  namespace: %s
+spec:
+  ref:
+    apiVersion: %s
+    kind: %s
+  params:
+  - name: duration
+    value: %s
+  serviceAccountName: default
+status:
+  conditions:
+  - reason: %s
+    status: %q
+    type: %s
+  observedGeneration: 1
+  `, runName, namespace, apiVersion, kind, tc.duration, tc.wantConditionReason, tc.wantConditionStatus, tc.wantConditionType)
+			wantRun := parse.MustParseRun(t, runYAML)
+			var (
+				filterTypeMeta   = cmpopts.IgnoreFields(v1alpha1.Run{}, "TypeMeta")
+				filterObjectMeta = cmpopts.IgnoreFields(metav1.ObjectMeta{}, "ResourceVersion", "UID", "CreationTimestamp", "Generation", "ManagedFields")
+				filterCondition  = cmpopts.IgnoreFields(apis.Condition{}, "LastTransitionTime.Inner.Time", "Message")
+				filterRunStatus  = cmpopts.IgnoreFields(v1alpha1.RunStatusFields{}, "StartTime", "CompletionTime")
+			)
+			if d := cmp.Diff(wantRun, gotRun,
+				filterTypeMeta,
+				filterObjectMeta,
+				filterCondition,
+				filterRunStatus,
+			); d != "" {
+				t.Errorf("-got +want: %v", d)
+			}
+		})
+	}
+}

test/wait-task/README.md

@@ -0,0 +1,10 @@
+# Wait Custom Task for Tekton
+
+This folder is largely copied from [experimental/wait-task](https://github.com/tektoncd/experimental/tree/main/wait-task)
+for the testing purpose, with resources used for building and releasing the
+wait custom task removed.
+
+It provides a [Tekton Custom
+Task](https://tekton.dev/docs/pipelines/runs/) that, when run, simply waits a
+given amount of time before succeeding, specified by an input parameter named
+`duration`.

test/wait-task/cmd/controller/main.go

@@ -0,0 +1,52 @@
+/*
+Copyright 2021 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 main // import "github.com/tektoncd/pipeline/test/wait-task/cmd/controller"
+
+import (
+	"context"
+
+	runinformer "github.com/tektoncd/pipeline/pkg/client/injection/informers/pipeline/v1alpha1/run"
+	runreconciler "github.com/tektoncd/pipeline/pkg/client/injection/reconciler/pipeline/v1alpha1/run"
+	tkncontroller "github.com/tektoncd/pipeline/pkg/controller"
+	"github.com/tektoncd/pipeline/test/wait-task/pkg/reconciler"
+	"k8s.io/client-go/tools/cache"
+	"knative.dev/pkg/configmap"
+	"knative.dev/pkg/controller"
+	"knative.dev/pkg/injection/sharedmain"
+)
+
+const controllerName = "wait-task-controller"
+
+func main() {
+	sharedmain.Main(controllerName, newController)
+}
+
+func newController(ctx context.Context, cmw configmap.Watcher) *controller.Impl {
+	c := &reconciler.Reconciler{}
+	impl := runreconciler.NewImpl(ctx, c, func(impl *controller.Impl) controller.Options {
+		return controller.Options{
+			AgentName: controllerName,
+		}
+	})
+
+	runinformer.Get(ctx).Informer().AddEventHandler(cache.FilteringResourceEventHandler{
+		FilterFunc: tkncontroller.FilterRunRef("wait.testing.tekton.dev/v1alpha1", "Wait"),
+		Handler:    controller.HandleAll(impl.Enqueue),
+	})
+
+	return impl
+}