Custom Task E2E Test with A Controller Installed

This cl introduces a `wait-task` controller into test/ folder to
better support Custom Task e2e testing.

Previously we update the Run object to mimic the behavior of a custom
task controller. This cl introduces a real controller to reconcile
the custom task run.

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"
@@ -46,7 +48,7 @@ import (
 
 const (
 	apiVersion = "example.dev/v0"
-	kind       = "Example"
+	kind       = "Wait"
 )
 
 var supportedFeatureGates = map[string]string{
@@ -401,3 +403,76 @@ 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 TestCustomTask_NoCRD(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)
+	defer cleanUpController(t)
+
+	// metadataLabel := map[string]string{"test-label": "test"}
+	runName := helpers.ObjectNameForTest(t)
+	run := parse.MustParseRun(t, fmt.Sprintf(`
+metadata:
+  name: %s
+spec:
+  ref:
+    apiVersion: %s
+    kind: %s
+  params:
+  - name: duration
+    value: 1s
+`, runName, apiVersion, kind))
+	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 to Finish.
+	if err := WaitForRunState(ctx, c, runName, time.Minute, Succeed(runName), "RunFinished"); 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)
+	}
+
+	// Expect the succeeded condition
+	wantCondition := &apis.Condition{
+		Type:    apis.ConditionSucceeded,
+		Status:  corev1.ConditionTrue,
+		Reason:  "DurationElapsed",
+		Message: "The wait duration has elapsed",
+	}
+
+	if d := cmp.Diff(wantCondition, gotRun.GetStatus().GetCondition(wantCondition.Type), cmpopts.IgnoreFields(apis.Condition{}, "LastTransitionTime")); d != "" {
+		t.Errorf("diff: %v", d)
+	}
+}

test/wait-task/README.md

@@ -0,0 +1,10 @@
+# Wait Custom Task for Tekton
+
+This folder is simply copied from [experimental/wait-task](https://github.com/tektoncd/experimental/tree/main/wait-task)
+for the testing purpose, with resources used build and release 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/experimental/wait-task/cmd/controller"
+
+import (
+	"context"
+
+	"github.com/tektoncd/experimental/wait-task/pkg/reconciler"
+	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"
+	"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("example.dev/v0", "Wait"),
+		Handler:    controller.HandleAll(impl.Enqueue),
+	})
+
+	return impl
+}